from mitmproxy import http
from mitmproxy.http import HTTPFlow
from ._base import HttpEvent


@dataclass
class RequestHeaders(HttpEvent):
    request: http.Request

            

Reported by Pylint.

              from dataclasses import dataclass
from typing import Optional

from mitmproxy import http
from mitmproxy.http import HTTPFlow
from ._base import HttpEvent


@dataclass

            

Reported by Pylint.

              

@dataclass
class RequestHeaders(HttpEvent):
    request: http.Request
    end_stream: bool
    """
    If True, we already know at this point that there is no message body. This is useful for HTTP/2, where it allows
    us to set END_STREAM on headers already (and some servers - Akamai - implicitly expect that).

            

Reported by Pylint.

                  request: http.Request
    end_stream: bool
    """
    If True, we already know at this point that there is no message body. This is useful for HTTP/2, where it allows
    us to set END_STREAM on headers already (and some servers - Akamai - implicitly expect that).
    In either case, this event will nonetheless be followed by RequestEndOfMessage.
    """
    replay_flow: Optional[HTTPFlow] = None
    """If set, the current request headers belong to a replayed flow, which should be reused."""

            

Reported by Pylint.

              

@dataclass
class ResponseHeaders(HttpEvent):
    response: http.Response
    end_stream: bool = False


# explicit constructors below to facilitate type checking in _http1/_http2

            

Reported by Pylint.

              # explicit constructors below to facilitate type checking in _http1/_http2

@dataclass
class RequestData(HttpEvent):
    data: bytes

    def __init__(self, stream_id: int, data: bytes):
        self.stream_id = stream_id
        self.data = data

            

Reported by Pylint.

              

@dataclass
class ResponseData(HttpEvent):
    data: bytes

    def __init__(self, stream_id: int, data: bytes):
        self.stream_id = stream_id
        self.data = data

            

Reported by Pylint.

              

@dataclass
class RequestTrailers(HttpEvent):
    trailers: http.Headers

    def __init__(self, stream_id: int, trailers: http.Headers):
        self.stream_id = stream_id
        self.trailers = trailers

            

Reported by Pylint.

              

@dataclass
class ResponseTrailers(HttpEvent):
    trailers: http.Headers

    def __init__(self, stream_id: int, trailers: http.Headers):
        self.stream_id = stream_id
        self.trailers = trailers

            

Reported by Pylint.

              

@dataclass
class RequestEndOfMessage(HttpEvent):
    def __init__(self, stream_id: int):
        self.stream_id = stream_id


@dataclass

            

Reported by Pylint.

              from mitmproxy.contentviews import urlencoded
from mitmproxy.net.http import url
from . import full_eval


def test_view_urlencoded():
    v = full_eval(urlencoded.ViewURLEncoded())

    d = url.encode([("one", "two"), ("three", "four")]).encode()

            

Reported by Pylint.

              from mitmproxy.contentviews import urlencoded
from mitmproxy.net.http import url
from . import full_eval


def test_view_urlencoded():
    v = full_eval(urlencoded.ViewURLEncoded())

    d = url.encode([("one", "two"), ("three", "four")]).encode()

            

Reported by Pylint.

              from . import full_eval


def test_view_urlencoded():
    v = full_eval(urlencoded.ViewURLEncoded())

    d = url.encode([("one", "two"), ("three", "four")]).encode()
    assert v(d)


            

Reported by Pylint.

              

def test_view_urlencoded():
    v = full_eval(urlencoded.ViewURLEncoded())

    d = url.encode([("one", "two"), ("three", "four")]).encode()
    assert v(d)

    d = url.encode([("adsfa", "")]).encode()

            

Reported by Pylint.

              def test_view_urlencoded():
    v = full_eval(urlencoded.ViewURLEncoded())

    d = url.encode([("one", "two"), ("three", "four")]).encode()
    assert v(d)

    d = url.encode([("adsfa", "")]).encode()
    assert v(d)


            

Reported by Pylint.

                  v = full_eval(urlencoded.ViewURLEncoded())

    d = url.encode([("one", "two"), ("three", "four")]).encode()
    assert v(d)

    d = url.encode([("adsfa", "")]).encode()
    assert v(d)

    assert not v(b"\xFF\x00")

            

Reported by Bandit.

                  d = url.encode([("one", "two"), ("three", "four")]).encode()
    assert v(d)

    d = url.encode([("adsfa", "")]).encode()
    assert v(d)

    assert not v(b"\xFF\x00")



            

Reported by Pylint.

                  assert v(d)

    d = url.encode([("adsfa", "")]).encode()
    assert v(d)

    assert not v(b"\xFF\x00")


def test_render_priority():

            

Reported by Bandit.

                  d = url.encode([("adsfa", "")]).encode()
    assert v(d)

    assert not v(b"\xFF\x00")


def test_render_priority():
    v = urlencoded.ViewURLEncoded()
    assert v.render_priority(b"", content_type="application/x-www-form-urlencoded")

            

Reported by Bandit.

                  assert not v(b"\xFF\x00")


def test_render_priority():
    v = urlencoded.ViewURLEncoded()
    assert v.render_priority(b"", content_type="application/x-www-form-urlencoded")
    assert not v.render_priority(b"", content_type="text/plain")

            

Reported by Pylint.

              from pathlib import Path
from typing import List, Type

import mitmproxy.addons.next_layer  # noqa
from mitmproxy import hooks, log, addonmanager
from mitmproxy.proxy import server_hooks, layer
from mitmproxy.proxy.layers import http, tcp, tls, websocket

known = set()

            

Reported by Pylint.

              from typing import List, Type

import mitmproxy.addons.next_layer  # noqa
from mitmproxy import hooks, log, addonmanager
from mitmproxy.proxy import server_hooks, layer
from mitmproxy.proxy.layers import http, tcp, tls, websocket

known = set()


            

Reported by Pylint.

              
import mitmproxy.addons.next_layer  # noqa
from mitmproxy import hooks, log, addonmanager
from mitmproxy.proxy import server_hooks, layer
from mitmproxy.proxy.layers import http, tcp, tls, websocket

known = set()



            

Reported by Pylint.

              import mitmproxy.addons.next_layer  # noqa
from mitmproxy import hooks, log, addonmanager
from mitmproxy.proxy import server_hooks, layer
from mitmproxy.proxy.layers import http, tcp, tls, websocket

known = set()


def category(name: str, desc: str, hooks: List[Type[hooks.Hook]]) -> None:

            

Reported by Pylint.

              from pathlib import Path
from typing import List, Type

import mitmproxy.addons.next_layer  # noqa
from mitmproxy import hooks, log, addonmanager
from mitmproxy.proxy import server_hooks, layer
from mitmproxy.proxy.layers import http, tcp, tls, websocket

known = set()

            

Reported by Pylint.

              known = set()


def category(name: str, desc: str, hooks: List[Type[hooks.Hook]]) -> None:
    all_params = [
        list(inspect.signature(hook.__init__).parameters.values())[1:]
        for hook in hooks
    ]


            

Reported by Pylint.

                              if mod == "typing":
                    # this is ugly, but can be removed once we are on Python 3.9+ only
                    imports.add(inspect.getmodule(param.annotation.__args__[0]).__name__)
                    types.add(param.annotation._name)
                else:
                    imports.add(mod)
            except AttributeError:
                raise ValueError(f"Missing type annotation: {params}")
    imports.discard("builtins")

            

Reported by Pylint.

                              else:
                    imports.add(mod)
            except AttributeError:
                raise ValueError(f"Missing type annotation: {params}")
    imports.discard("builtins")
    if types:
        print(f"from typing import {', '.join(sorted(types))}")
    print("from mitmproxy import ctx")
    for imp in sorted(imports):

            

Reported by Pylint.

              #!/usr/bin/env python3
import contextlib
import inspect
import textwrap
from pathlib import Path
from typing import List, Type

import mitmproxy.addons.next_layer  # noqa
from mitmproxy import hooks, log, addonmanager

            

Reported by Pylint.

              #!/usr/bin/env python3
import contextlib
import inspect
import textwrap
from pathlib import Path
from typing import List, Type

import mitmproxy.addons.next_layer  # noqa
from mitmproxy import hooks, log, addonmanager

            

Reported by Pylint.

                      rel_matcher = re.compile(pattern, flags=re.IGNORECASE)
        rel_matches = rel_matcher.finditer(pageText)
        map_dict = {}
        for match_num, match in enumerate(rel_matches):
            (delimiter, rel_link) = match.group("delimiter", "link")
            abs_link = urljoin(pageUrl, rel_link)
            map_dict["{0}{1}{0}".format(delimiter, rel_link)] = "{0}{1}{0}".format(delimiter, abs_link)
        for map in map_dict.items():
            pageText = pageText.replace(*map)

            

Reported by Pylint.

                          (delimiter, rel_link) = match.group("delimiter", "link")
            abs_link = urljoin(pageUrl, rel_link)
            map_dict["{0}{1}{0}".format(delimiter, rel_link)] = "{0}{1}{0}".format(delimiter, abs_link)
        for map in map_dict.items():
            pageText = pageText.replace(*map)
            # Uncomment the following to print the expansion mapping
            # print("{0} -> {1}".format(*map))
        flow.response.text = pageText
            

Reported by Pylint.

              # This script determines if request is an HTML webpage and if so seeks out
# relative links (<a href="./about.html">) and expands them to absolute links
# In practice this can be used to front an indexing spider that may not have the capability to expand relative page links.
# Usage: mitmdump -s link_expander.py or mitmproxy -s link_expander.py

import re
from urllib.parse import urljoin



            

Reported by Pylint.

              # This script determines if request is an HTML webpage and if so seeks out
# relative links (<a href="./about.html">) and expands them to absolute links
# In practice this can be used to front an indexing spider that may not have the capability to expand relative page links.
# Usage: mitmdump -s link_expander.py or mitmproxy -s link_expander.py

import re
from urllib.parse import urljoin



            

Reported by Pylint.

              from urllib.parse import urljoin


def response(flow):

    if "Content-Type" in flow.response.headers and flow.response.headers["Content-Type"].find("text/html") != -1:
        pageUrl = flow.request.url
        pageText = flow.response.text
        pattern = (r"<a\s+(?:[^>]*?\s+)?href=(?P<delimiter>[\"'])"

            

Reported by Pylint.

              
def response(flow):

    if "Content-Type" in flow.response.headers and flow.response.headers["Content-Type"].find("text/html") != -1:
        pageUrl = flow.request.url
        pageText = flow.response.text
        pattern = (r"<a\s+(?:[^>]*?\s+)?href=(?P<delimiter>[\"'])"
                   r"(?P<link>(?!https?:\/\/|ftps?:\/\/|\/\/|#|javascript:|mailto:).*?)(?P=delimiter)")
        rel_matcher = re.compile(pattern, flags=re.IGNORECASE)

            

Reported by Pylint.

              def response(flow):

    if "Content-Type" in flow.response.headers and flow.response.headers["Content-Type"].find("text/html") != -1:
        pageUrl = flow.request.url
        pageText = flow.response.text
        pattern = (r"<a\s+(?:[^>]*?\s+)?href=(?P<delimiter>[\"'])"
                   r"(?P<link>(?!https?:\/\/|ftps?:\/\/|\/\/|#|javascript:|mailto:).*?)(?P=delimiter)")
        rel_matcher = re.compile(pattern, flags=re.IGNORECASE)
        rel_matches = rel_matcher.finditer(pageText)

            

Reported by Pylint.

              
    if "Content-Type" in flow.response.headers and flow.response.headers["Content-Type"].find("text/html") != -1:
        pageUrl = flow.request.url
        pageText = flow.response.text
        pattern = (r"<a\s+(?:[^>]*?\s+)?href=(?P<delimiter>[\"'])"
                   r"(?P<link>(?!https?:\/\/|ftps?:\/\/|\/\/|#|javascript:|mailto:).*?)(?P=delimiter)")
        rel_matcher = re.compile(pattern, flags=re.IGNORECASE)
        rel_matches = rel_matcher.finditer(pageText)
        map_dict = {}

            

Reported by Pylint.

                      pageUrl = flow.request.url
        pageText = flow.response.text
        pattern = (r"<a\s+(?:[^>]*?\s+)?href=(?P<delimiter>[\"'])"
                   r"(?P<link>(?!https?:\/\/|ftps?:\/\/|\/\/|#|javascript:|mailto:).*?)(?P=delimiter)")
        rel_matcher = re.compile(pattern, flags=re.IGNORECASE)
        rel_matches = rel_matcher.finditer(pageText)
        map_dict = {}
        for match_num, match in enumerate(rel_matches):
            (delimiter, rel_link) = match.group("delimiter", "link")

            

Reported by Pylint.

                      for match_num, match in enumerate(rel_matches):
            (delimiter, rel_link) = match.group("delimiter", "link")
            abs_link = urljoin(pageUrl, rel_link)
            map_dict["{0}{1}{0}".format(delimiter, rel_link)] = "{0}{1}{0}".format(delimiter, abs_link)
        for map in map_dict.items():
            pageText = pageText.replace(*map)
            # Uncomment the following to print the expansion mapping
            # print("{0} -> {1}".format(*map))
        flow.response.text = pageText
            

Reported by Pylint.

              from mitmproxy.contentviews import multipart
from . import full_eval


def test_view_multipart():
    view = full_eval(multipart.ViewMultipart())
    v = b"""
--AaB03x
Content-Disposition: form-data; name="submit-name"

            

Reported by Pylint.

              from mitmproxy.contentviews import multipart
from . import full_eval


def test_view_multipart():
    view = full_eval(multipart.ViewMultipart())
    v = b"""
--AaB03x
Content-Disposition: form-data; name="submit-name"

            

Reported by Pylint.

              from . import full_eval


def test_view_multipart():
    view = full_eval(multipart.ViewMultipart())
    v = b"""
--AaB03x
Content-Disposition: form-data; name="submit-name"


            

Reported by Pylint.

              
def test_view_multipart():
    view = full_eval(multipart.ViewMultipart())
    v = b"""
--AaB03x
Content-Disposition: form-data; name="submit-name"

Larry
--AaB03x

            

Reported by Pylint.

              Larry
--AaB03x
        """.strip()
    assert view(v, content_type="multipart/form-data; boundary=AaB03x")

    assert not view(v)

    assert not view(v, content_type="multipart/form-data")


            

Reported by Bandit.

                      """.strip()
    assert view(v, content_type="multipart/form-data; boundary=AaB03x")

    assert not view(v)

    assert not view(v, content_type="multipart/form-data")

    assert not view(v, content_type="unparseable")


            

Reported by Bandit.

              
    assert not view(v)

    assert not view(v, content_type="multipart/form-data")

    assert not view(v, content_type="unparseable")


def test_render_priority():

            

Reported by Bandit.

              
    assert not view(v, content_type="multipart/form-data")

    assert not view(v, content_type="unparseable")


def test_render_priority():
    v = multipart.ViewMultipart()
    assert v.render_priority(b"", content_type="multipart/form-data")

            

Reported by Bandit.

                  assert not view(v, content_type="unparseable")


def test_render_priority():
    v = multipart.ViewMultipart()
    assert v.render_priority(b"", content_type="multipart/form-data")
    assert not v.render_priority(b"", content_type="text/plain")

            

Reported by Pylint.

              

def test_render_priority():
    v = multipart.ViewMultipart()
    assert v.render_priority(b"", content_type="multipart/form-data")
    assert not v.render_priority(b"", content_type="text/plain")

            

Reported by Pylint.

                  try:
        re.compile(spec.subject)
    except re.error as e:
        raise ValueError(f"Invalid regular expression {spec.subject!r} ({e})")

    return spec


class MapRemote:

            

Reported by Pylint.

              import re
import typing

from mitmproxy import ctx, exceptions, flowfilter, http
from mitmproxy.utils.spec import parse_spec


class MapRemoteSpec(typing.NamedTuple):
    matches: flowfilter.TFilter

            

Reported by Pylint.

              from mitmproxy.utils.spec import parse_spec


class MapRemoteSpec(typing.NamedTuple):
    matches: flowfilter.TFilter
    subject: str
    replacement: str



            

Reported by Pylint.

                  replacement: str


def parse_map_remote_spec(option: str) -> MapRemoteSpec:
    spec = MapRemoteSpec(*parse_spec(option))

    try:
        re.compile(spec.subject)
    except re.error as e:

            

Reported by Pylint.

              
    try:
        re.compile(spec.subject)
    except re.error as e:
        raise ValueError(f"Invalid regular expression {spec.subject!r} ({e})")

    return spec



            

Reported by Pylint.

                  return spec


class MapRemote:
    def __init__(self):
        self.replacements: typing.List[MapRemoteSpec] = []

    def load(self, loader):
        loader.add_option(

            

Reported by Pylint.

                  def __init__(self):
        self.replacements: typing.List[MapRemoteSpec] = []

    def load(self, loader):
        loader.add_option(
            "map_remote", typing.Sequence[str], [],
            """
            Map remote resources to another remote URL using a pattern of the form
            "[/flow-filter]/url-regex/replacement", where the separator can

            

Reported by Pylint.

                  def __init__(self):
        self.replacements: typing.List[MapRemoteSpec] = []

    def load(self, loader):
        loader.add_option(
            "map_remote", typing.Sequence[str], [],
            """
            Map remote resources to another remote URL using a pattern of the form
            "[/flow-filter]/url-regex/replacement", where the separator can

            

Reported by Pylint.

                          """
        )

    def configure(self, updated):
        if "map_remote" in updated:
            self.replacements = []
            for option in ctx.options.map_remote:
                try:
                    spec = parse_map_remote_spec(option)

            

Reported by Pylint.

                          for option in ctx.options.map_remote:
                try:
                    spec = parse_map_remote_spec(option)
                except ValueError as e:
                    raise exceptions.OptionsError(f"Cannot parse map_remote option {option}: {e}") from e

                self.replacements.append(spec)

    def request(self, flow: http.HTTPFlow) -> None:

            

Reported by Pylint.

                  here = pathlib.Path(__file__).absolute().parent
    version_file = here / ".." / ".." / "mitmproxy" / "version.py"
    runpy.run_path(str(version_file), run_name='__main__')
    stdout, stderr = capsys.readouterr()
    assert len(stdout) > 0
    assert stdout.strip() == version.VERSION


def test_get_version():

            

Reported by Pylint.

              import pathlib
import runpy
import subprocess
import sys
from unittest import mock

from mitmproxy import version



            

Reported by Pylint.

              import pathlib
import runpy
import subprocess
import sys
from unittest import mock

from mitmproxy import version



            

Reported by Bandit.

              from mitmproxy import version


def test_version(capsys):
    here = pathlib.Path(__file__).absolute().parent
    version_file = here / ".." / ".." / "mitmproxy" / "version.py"
    runpy.run_path(str(version_file), run_name='__main__')
    stdout, stderr = capsys.readouterr()
    assert len(stdout) > 0

            

Reported by Pylint.

                  version_file = here / ".." / ".." / "mitmproxy" / "version.py"
    runpy.run_path(str(version_file), run_name='__main__')
    stdout, stderr = capsys.readouterr()
    assert len(stdout) > 0
    assert stdout.strip() == version.VERSION


def test_get_version():
    version.VERSION = "3.0.0rc2"

            

Reported by Bandit.

                  runpy.run_path(str(version_file), run_name='__main__')
    stdout, stderr = capsys.readouterr()
    assert len(stdout) > 0
    assert stdout.strip() == version.VERSION


def test_get_version():
    version.VERSION = "3.0.0rc2"


            

Reported by Bandit.

                  assert stdout.strip() == version.VERSION


def test_get_version():
    version.VERSION = "3.0.0rc2"

    with mock.patch('subprocess.check_output') as m:
        m.return_value = b"tag-0-cafecafe"
        assert version.get_dev_version() == "3.0.0rc2"

            

Reported by Pylint.

              def test_get_version():
    version.VERSION = "3.0.0rc2"

    with mock.patch('subprocess.check_output') as m:
        m.return_value = b"tag-0-cafecafe"
        assert version.get_dev_version() == "3.0.0rc2"

        sys.frozen = True
        assert version.get_dev_version() == "3.0.0rc2 binary"

            

Reported by Pylint.

              
    with mock.patch('subprocess.check_output') as m:
        m.return_value = b"tag-0-cafecafe"
        assert version.get_dev_version() == "3.0.0rc2"

        sys.frozen = True
        assert version.get_dev_version() == "3.0.0rc2 binary"
        sys.frozen = False


            

Reported by Bandit.

                      assert version.get_dev_version() == "3.0.0rc2"

        sys.frozen = True
        assert version.get_dev_version() == "3.0.0rc2 binary"
        sys.frozen = False

        m.return_value = b"tag-2-cafecafe"
        assert version.get_dev_version() == "3.0.0rc2 (+2, commit cafecaf)"


            

Reported by Bandit.

                  try:
        status_code = int(status)
    except ValueError:
        raise ValueError(f"Invalid HTTP status code: {status}")
    flow_filter = flowfilter.parse(flow_patt)
    if not flow_filter:
        raise ValueError(f"Invalid filter pattern: {flow_patt}")
    if not RESPONSES.get(status_code):
        raise ValueError(f"Invalid HTTP status code: {status}")

            

Reported by Pylint.

              import typing

from mitmproxy import ctx, exceptions, flowfilter, http, version
from mitmproxy.net.http.status_codes import NO_RESPONSE
from mitmproxy.net.http.status_codes import RESPONSES


class BlockSpec(typing.NamedTuple):
    matches: flowfilter.TFilter

            

Reported by Pylint.

              from mitmproxy.net.http.status_codes import RESPONSES


class BlockSpec(typing.NamedTuple):
    matches: flowfilter.TFilter
    status_code: int


def parse_spec(option: str) -> BlockSpec:

            

Reported by Pylint.

                  return BlockSpec(matches=flow_filter, status_code=status_code)


class BlockList:
    def __init__(self):
        self.items: typing.List[BlockSpec] = []

    def load(self, loader):
        loader.add_option(

            

Reported by Pylint.

                  def __init__(self):
        self.items: typing.List[BlockSpec] = []

    def load(self, loader):
        loader.add_option(
            "block_list", typing.Sequence[str], [],
            """
            Block matching requests and return an empty response with the specified HTTP status.
            Option syntax is "/flow-filter/status-code", where flow-filter describes

            

Reported by Pylint.

                  def __init__(self):
        self.items: typing.List[BlockSpec] = []

    def load(self, loader):
        loader.add_option(
            "block_list", typing.Sequence[str], [],
            """
            Block matching requests and return an empty response with the specified HTTP status.
            Option syntax is "/flow-filter/status-code", where flow-filter describes

            

Reported by Pylint.

                          """
            Block matching requests and return an empty response with the specified HTTP status.
            Option syntax is "/flow-filter/status-code", where flow-filter describes
            which requests this rule should be applied to and status-code is the HTTP status code to return for
            blocked requests. The separator ("/" in the example) can be any character.
            Setting a non-standard status code of 444 will close the connection without sending a response.
            """
        )


            

Reported by Pylint.

                          Option syntax is "/flow-filter/status-code", where flow-filter describes
            which requests this rule should be applied to and status-code is the HTTP status code to return for
            blocked requests. The separator ("/" in the example) can be any character.
            Setting a non-standard status code of 444 will close the connection without sending a response.
            """
        )

    def configure(self, updated):
        if "block_list" in updated:

            

Reported by Pylint.

                          """
        )

    def configure(self, updated):
        if "block_list" in updated:
            self.items = []
            for option in ctx.options.block_list:
                try:
                    spec = parse_spec(option)

            

Reported by Pylint.

                          for option in ctx.options.block_list:
                try:
                    spec = parse_spec(option)
                except ValueError as e:
                    raise exceptions.OptionsError(f"Cannot parse block_list option {option}: {e}") from e
                self.items.append(spec)

    def request(self, flow: http.HTTPFlow) -> None:
        if flow.response or flow.error or (flow.reply and flow.reply.state == "taken"):

            

Reported by Pylint.

              from mitmproxy.contentviews import query
from mitmproxy.test import tutils
from . import full_eval


def test_view_query():
    d = ""
    v = full_eval(query.ViewQuery())
    req = tutils.treq()

            

Reported by Pylint.

              from mitmproxy.contentviews import query
from mitmproxy.test import tutils
from . import full_eval


def test_view_query():
    d = ""
    v = full_eval(query.ViewQuery())
    req = tutils.treq()

            

Reported by Pylint.

              from . import full_eval


def test_view_query():
    d = ""
    v = full_eval(query.ViewQuery())
    req = tutils.treq()
    req.query = [("foo", "bar"), ("foo", "baz")]
    f = v(d, http_message=req)

            

Reported by Pylint.

              

def test_view_query():
    d = ""
    v = full_eval(query.ViewQuery())
    req = tutils.treq()
    req.query = [("foo", "bar"), ("foo", "baz")]
    f = v(d, http_message=req)
    assert f[0] == "Query"

            

Reported by Pylint.

              
def test_view_query():
    d = ""
    v = full_eval(query.ViewQuery())
    req = tutils.treq()
    req.query = [("foo", "bar"), ("foo", "baz")]
    f = v(d, http_message=req)
    assert f[0] == "Query"
    assert f[1] == [[("header", "foo: "), ("text", "bar")], [("header", "foo: "), ("text", "baz")]]

            

Reported by Pylint.

                  v = full_eval(query.ViewQuery())
    req = tutils.treq()
    req.query = [("foo", "bar"), ("foo", "baz")]
    f = v(d, http_message=req)
    assert f[0] == "Query"
    assert f[1] == [[("header", "foo: "), ("text", "bar")], [("header", "foo: "), ("text", "baz")]]

    assert v(d) == ("Query", [])


            

Reported by Pylint.

                  req = tutils.treq()
    req.query = [("foo", "bar"), ("foo", "baz")]
    f = v(d, http_message=req)
    assert f[0] == "Query"
    assert f[1] == [[("header", "foo: "), ("text", "bar")], [("header", "foo: "), ("text", "baz")]]

    assert v(d) == ("Query", [])



            

Reported by Bandit.

                  req.query = [("foo", "bar"), ("foo", "baz")]
    f = v(d, http_message=req)
    assert f[0] == "Query"
    assert f[1] == [[("header", "foo: "), ("text", "bar")], [("header", "foo: "), ("text", "baz")]]

    assert v(d) == ("Query", [])


def test_render_priority():

            

Reported by Bandit.

                  assert f[0] == "Query"
    assert f[1] == [[("header", "foo: "), ("text", "bar")], [("header", "foo: "), ("text", "baz")]]

    assert v(d) == ("Query", [])


def test_render_priority():
    view = query.ViewQuery()
    req = tutils.treq()

            

Reported by Bandit.

                  assert v(d) == ("Query", [])


def test_render_priority():
    view = query.ViewQuery()
    req = tutils.treq()
    req.query = [("foo", "bar"), ("foo", "baz")]
    assert view.render_priority(b"", http_message=req)
    assert not view.render_priority(b"")

            

Reported by Pylint.

              import urwid

import pytest

from mitmproxy import options, hooks
from mitmproxy.tools import console

from ... import tservers


            

Reported by Pylint.

              import urwid

import pytest

from mitmproxy import options, hooks
from mitmproxy.tools import console

from ... import tservers


            

Reported by Pylint.

              from mitmproxy import options, hooks
from mitmproxy.tools import console

from ... import tservers


@pytest.mark.asyncio
class TestMaster(tservers.MasterTest):
    def mkmaster(self, **opts):

            

Reported by Pylint.

              import urwid

import pytest

from mitmproxy import options, hooks
from mitmproxy.tools import console

from ... import tservers


            

Reported by Pylint.

              

@pytest.mark.asyncio
class TestMaster(tservers.MasterTest):
    def mkmaster(self, **opts):
        o = options.Options(**opts)
        m = console.master.ConsoleMaster(o)
        m.addons.trigger(hooks.ConfigureHook(o.keys()))
        return m

            

Reported by Pylint.

              
@pytest.mark.asyncio
class TestMaster(tservers.MasterTest):
    def mkmaster(self, **opts):
        o = options.Options(**opts)
        m = console.master.ConsoleMaster(o)
        m.addons.trigger(hooks.ConfigureHook(o.keys()))
        return m


            

Reported by Pylint.

              
@pytest.mark.asyncio
class TestMaster(tservers.MasterTest):
    def mkmaster(self, **opts):
        o = options.Options(**opts)
        m = console.master.ConsoleMaster(o)
        m.addons.trigger(hooks.ConfigureHook(o.keys()))
        return m


            

Reported by Pylint.

              @pytest.mark.asyncio
class TestMaster(tservers.MasterTest):
    def mkmaster(self, **opts):
        o = options.Options(**opts)
        m = console.master.ConsoleMaster(o)
        m.addons.trigger(hooks.ConfigureHook(o.keys()))
        return m

    async def test_basic(self):

            

Reported by Pylint.

              class TestMaster(tservers.MasterTest):
    def mkmaster(self, **opts):
        o = options.Options(**opts)
        m = console.master.ConsoleMaster(o)
        m.addons.trigger(hooks.ConfigureHook(o.keys()))
        return m

    async def test_basic(self):
        m = self.mkmaster()

            

Reported by Pylint.

                      m.addons.trigger(hooks.ConfigureHook(o.keys()))
        return m

    async def test_basic(self):
        m = self.mkmaster()
        for i in (1, 2, 3):
            try:
                await self.dummy_cycle(m, 1, b"")
            except urwid.ExitMainLoop:

            

Reported by Pylint.