Esempio n. 1
0
    def test_ignore_content(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(replay_ignore_content=False), [])

        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)

        r.request.content = b"foo"
        r2.request.content = b"foo"
        assert s._hash(r) == s._hash(r2)
        r2.request.content = b"bar"
        assert not s._hash(r) == s._hash(r2)

        s.configure(options.Options(replay_ignore_content=True), [])
        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)
        r.request.content = b"foo"
        r2.request.content = b"foo"
        assert s._hash(r) == s._hash(r2)
        r2.request.content = b"bar"
        assert s._hash(r) == s._hash(r2)
        r2.request.content = b""
        assert s._hash(r) == s._hash(r2)
        r2.request.content = None
        assert s._hash(r) == s._hash(r2)
Esempio n. 2
0
    def test_ignore_payload_params(self):
        s = serverplayback.ServerPlayback()
        s.configure(
            options.Options(
                server_replay_ignore_payload_params=["param1", "param2"]
            ),
            []
        )

        r = tutils.tflow(resp=True)
        r.request.headers["Content-Type"] = "application/x-www-form-urlencoded"
        r.request.content = b"paramx=x&param1=1"
        r2 = tutils.tflow(resp=True)
        r2.request.headers["Content-Type"] = "application/x-www-form-urlencoded"
        r2.request.content = b"paramx=x&param1=1"
        # same parameters
        assert s._hash(r) == s._hash(r2)
        # ignored parameters !=
        r2.request.content = b"paramx=x&param1=2"
        assert s._hash(r) == s._hash(r2)
        # missing parameter
        r2.request.content = b"paramx=x"
        assert s._hash(r) == s._hash(r2)
        # ignorable parameter added
        r2.request.content = b"paramx=x&param1=2"
        assert s._hash(r) == s._hash(r2)
        # not ignorable parameter changed
        r2.request.content = b"paramx=y&param1=1"
        assert not s._hash(r) == s._hash(r2)
        # not ignorable parameter missing
        r2.request.content = b"param1=1"
        assert not s._hash(r) == s._hash(r2)
Esempio n. 3
0
    def test_ignore_payload_params(self):
        s = serverplayback.ServerPlayback()
        s.configure(
            options.Options(replay_ignore_payload_params=["param1", "param2"]),
            [])

        r = tutils.tflow(resp=True)
        r.request.headers["Content-Type"] = "application/x-www-form-urlencoded"
        r.request.content = b"paramx=x&param1=1"
        r2 = tutils.tflow(resp=True)
        r2.request.headers[
            "Content-Type"] = "application/x-www-form-urlencoded"
        r2.request.content = b"paramx=x&param1=1"
        # same parameters
        assert s._hash(r) == s._hash(r2)
        # ignored parameters !=
        r2.request.content = b"paramx=x&param1=2"
        assert s._hash(r) == s._hash(r2)
        # missing parameter
        r2.request.content = b"paramx=x"
        assert s._hash(r) == s._hash(r2)
        # ignorable parameter added
        r2.request.content = b"paramx=x&param1=2"
        assert s._hash(r) == s._hash(r2)
        # not ignorable parameter changed
        r2.request.content = b"paramx=y&param1=1"
        assert not s._hash(r) == s._hash(r2)
        # not ignorable parameter missing
        r2.request.content = b"param1=1"
        assert not s._hash(r) == s._hash(r2)
Esempio n. 4
0
    def test_ignore_content(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(server_replay_ignore_content=False), [])

        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)

        r.request.content = b"foo"
        r2.request.content = b"foo"
        assert s._hash(r) == s._hash(r2)
        r2.request.content = b"bar"
        assert not s._hash(r) == s._hash(r2)

        s.configure(options.Options(server_replay_ignore_content=True), [])
        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)
        r.request.content = b"foo"
        r2.request.content = b"foo"
        assert s._hash(r) == s._hash(r2)
        r2.request.content = b"bar"
        assert s._hash(r) == s._hash(r2)
        r2.request.content = b""
        assert s._hash(r) == s._hash(r2)
        r2.request.content = None
        assert s._hash(r) == s._hash(r2)
Esempio n. 5
0
    def test_server_playback_full(self):
        state = flow.State()
        s = serverplayback.ServerPlayback()
        o = options.Options(refresh_server_playback=True, keepserving=False)
        m = mastertest.RecordingMaster(o, None, state)
        m.addons.add(o, s)

        f = tutils.tflow()
        f.response = netlib.tutils.tresp(content=f.request.content)
        s.load([f, f])

        tf = tutils.tflow()
        assert not tf.response
        m.request(tf)
        assert tf.response == f.response

        tf = tutils.tflow()
        tf.request.content = b"gibble"
        assert not tf.response
        m.request(tf)
        assert not tf.response

        assert not s.stop
        s.tick()
        assert not s.stop

        tf = tutils.tflow()
        m.request(tutils.tflow())
        assert s.stop
Esempio n. 6
0
    def test_server_playback_full(self):
        state = flow.State()
        s = serverplayback.ServerPlayback()
        o = options.Options(refresh_server_playback = True, keepserving=False)
        m = mastertest.RecordingMaster(o, None, state)
        m.addons.add(s)

        f = tutils.tflow()
        f.response = netlib.tutils.tresp(content=f.request.content)
        s.load([f, f])

        tf = tutils.tflow()
        assert not tf.response
        m.request(tf)
        assert tf.response == f.response

        tf = tutils.tflow()
        tf.request.content = b"gibble"
        assert not tf.response
        m.request(tf)
        assert not tf.response

        assert not s.stop
        s.tick()
        assert not s.stop

        tf = tutils.tflow()
        m.request(tutils.tflow())
        assert s.stop
Esempio n. 7
0
 def test_intercept(self):
     """regression test for https://github.com/mitmproxy/mitmproxy/issues/1605"""
     m = self.mkmaster(intercept="~b bar")
     f = tutils.tflow(req=netlib.tutils.treq(content=b"foo"))
     m.request(f)
     assert not m.state.flows[0].intercepted
     f = tutils.tflow(req=netlib.tutils.treq(content=b"bar"))
     m.request(f)
     assert m.state.flows[1].intercepted
     f = tutils.tflow(resp=netlib.tutils.tresp(content=b"bar"))
     m.request(f)
     assert m.state.flows[2].intercepted
Esempio n. 8
0
    def test_ignore_host(self):
        sp = serverplayback.ServerPlayback()
        sp.configure(options.Options(server_replay_ignore_host=True), [])

        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)

        r.request.host = "address"
        r2.request.host = "address"
        assert sp._hash(r) == sp._hash(r2)
        r2.request.host = "wrong_address"
        assert sp._hash(r) == sp._hash(r2)
Esempio n. 9
0
    def test_ignore_host(self):
        sp = serverplayback.ServerPlayback()
        sp.configure(options.Options(replay_ignore_host=True), [])

        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)

        r.request.host = "address"
        r2.request.host = "address"
        assert sp._hash(r) == sp._hash(r2)
        r2.request.host = "wrong_address"
        assert sp._hash(r) == sp._hash(r2)
Esempio n. 10
0
    def test_server_playback_kill(self):
        state = flow.State()
        s = serverplayback.ServerPlayback()
        o = options.Options(refresh_server_playback=True, kill=True)
        m = mastertest.RecordingMaster(o, None, state)
        m.addons.add(o, s)

        f = tutils.tflow()
        f.response = netlib.tutils.tresp(content=f.request.content)
        s.load([f])

        f = tutils.tflow()
        f.request.host = "nonexistent"
        m.request(f)
        assert f.reply.value == exceptions.Kill
Esempio n. 11
0
    def test_load_with_nopop(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(nopop=True), [])

        r = tutils.tflow(resp=True)
        r.request.headers["key"] = "one"

        r2 = tutils.tflow(resp=True)
        r2.request.headers["key"] = "two"

        s.load([r, r2])

        assert s.count() == 2
        s.next_flow(r)
        assert s.count() == 2
Esempio n. 12
0
    def test_server_playback_kill(self):
        state = flow.State()
        s = serverplayback.ServerPlayback()
        o = options.Options(refresh_server_playback = True, replay_kill_extra=True)
        m = mastertest.RecordingMaster(o, None, state)
        m.addons.add(s)

        f = tutils.tflow()
        f.response = netlib.tutils.tresp(content=f.request.content)
        s.load([f])

        f = tutils.tflow()
        f.request.host = "nonexistent"
        m.request(f)
        assert f.reply.value == exceptions.Kill
Esempio n. 13
0
    def test_load_with_server_replay_nopop(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(server_replay_nopop=True), [])

        r = tutils.tflow(resp=True)
        r.request.headers["key"] = "one"

        r2 = tutils.tflow(resp=True)
        r2.request.headers["key"] = "two"

        s.load([r, r2])

        assert s.count() == 2
        s.next_flow(r)
        assert s.count() == 2
Esempio n. 14
0
    def test_server_playback_kill(self):
        s = serverplayback.ServerPlayback()
        o = options.Options(refresh_server_playback=True,
                            replay_kill_extra=True)
        m = mastertest.RecordingMaster(o, proxy.DummyServer())
        m.addons.add(s)

        f = tutils.tflow()
        f.response = netlib.tutils.tresp(content=f.request.content)
        s.load([f])

        f = tutils.tflow()
        f.request.host = "nonexistent"
        m.request(f)
        assert f.reply.value == exceptions.Kill
Esempio n. 15
0
    def test_patch(self):
        flow = tutils.tflow(req=req_patch)
        result = '    ' + """
    @task()
    def path(self):
        url = self.locust.host + '/path'
        
        headers = {
            'header': 'qvalue',
            'content-length': '7',
        }

        params = {
            'query': 'param',
        }

        data = '''content'''

        self.response = self.client.request(
            method='PATCH',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )
        """.strip() + '\n'

        assert flow_export.locust_task(flow) == result
Esempio n. 16
0
    def test_ignore_params(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(replay_ignore_params=["param1", "param2"]),
                    [])

        r = tutils.tflow(resp=True)
        r.request.path = "/test?param1=1"
        r2 = tutils.tflow(resp=True)
        r2.request.path = "/test"
        assert s._hash(r) == s._hash(r2)
        r2.request.path = "/test?param1=2"
        assert s._hash(r) == s._hash(r2)
        r2.request.path = "/test?param2=1"
        assert s._hash(r) == s._hash(r2)
        r2.request.path = "/test?param3=2"
        assert not s._hash(r) == s._hash(r2)
Esempio n. 17
0
    def test_headers(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(rheaders=["foo"]), [])

        r = tutils.tflow(resp=True)
        r.request.headers["foo"] = "bar"
        r2 = tutils.tflow(resp=True)
        assert not s._hash(r) == s._hash(r2)
        r2.request.headers["foo"] = "bar"
        assert s._hash(r) == s._hash(r2)
        r2.request.headers["oink"] = "bar"
        assert s._hash(r) == s._hash(r2)

        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)
        assert s._hash(r) == s._hash(r2)
Esempio n. 18
0
    def test_post_json(self):
        req_post.content = '{"name": "example", "email": "*****@*****.**"}'
        req_post.headers = Headers(content_type="application/json")
        flow = tutils.tflow(req=req_post)
        result = dedent("""
            import requests

            url = 'http://address/path'

            headers = {
                'content-type': 'application/json',
            }

            json = {
                "name": "example",
                "email": "*****@*****.**"
            }

            response = requests.request(
                method='POST',
                url=url,
                headers=headers,
                json=json,
            )

            print(response.text)
        """).strip()
        assert flow_export.python_code(flow) == result
Esempio n. 19
0
    def test_patch(self):
        flow = tutils.tflow(req=req_patch)
        result = dedent("""
            import requests

            url = 'http://address/path'

            headers = {
                'header': 'qvalue',
                'content-length': '7',
            }

            params = {
                'query': 'param',
            }

            data = '''content'''

            response = requests.request(
                method='PATCH',
                url=url,
                headers=headers,
                params=params,
                data=data,
            )

            print(response.text)
        """).strip()
        assert flow_export.python_code(flow) == result
Esempio n. 20
0
 def test_post(self):
     p = req_post()
     p.content = '''content'''
     p.headers = ''
     flow = tutils.tflow(req=p)
     python_equals("test_flow_export/locust_post.py",
                   flow_export.locust_code(flow))
Esempio n. 21
0
    def test_get(self):
        flow = tutils.tflow(req=req_get)
        result = """
from locust import HttpLocust, TaskSet, task

class UserBehavior(TaskSet):
    def on_start(self):
        ''' on_start is called when a Locust start before any task is scheduled '''
        self.path()

    @task()
    def path(self):
        url = self.locust.host + '/path'
        
        headers = {
            'header': 'qvalue',
            'content-length': '7',
        }

        self.response = self.client.request(
            method='GET',
            url=url,
            headers=headers,
        )

    ### Additional tasks can go here ###


class WebsiteUser(HttpLocust):
    task_set = UserBehavior
    min_wait = 1000
    max_wait = 3000
        """.strip()

        assert flow_export.locust_code(flow) == result
Esempio n. 22
0
    def test_post(self):
        req_post.content = '''content'''
        req_post.headers = ''
        flow = tutils.tflow(req=req_post)
        result = """
from locust import HttpLocust, TaskSet, task

class UserBehavior(TaskSet):
    def on_start(self):
        ''' on_start is called when a Locust start before any task is scheduled '''
        self.path()

    @task()
    def path(self):
        url = self.locust.host + '/path'
        
        data = '''content'''

        self.response = self.client.request(
            method='POST',
            url=url,
            data=data,
        )

    ### Additional tasks can go here ###


class WebsiteUser(HttpLocust):
    task_set = UserBehavior
    min_wait = 1000
    max_wait = 3000

        """.strip()

        assert flow_export.locust_code(flow) == result
Esempio n. 23
0
    def test_get(self):
        flow = tutils.tflow(req=req_get)
        result = """
from locust import HttpLocust, TaskSet, task

class UserBehavior(TaskSet):
    def on_start(self):
        ''' on_start is called when a Locust start before any task is scheduled '''
        self.path()

    @task()
    def path(self):
        url = self.locust.host + '/path'
        
        headers = {
            'header': 'qvalue',
            'content-length': '7',
        }

        self.response = self.client.request(
            method='GET',
            url=url,
            headers=headers,
        )

    ### Additional tasks can go here ###


class WebsiteUser(HttpLocust):
    task_set = UserBehavior
    min_wait = 1000
    max_wait = 3000
        """.strip()

        assert flow_export.locust_code(flow) == result
Esempio n. 24
0
    def test_patch(self):
        flow = tutils.tflow(req=req_patch)
        result = '    ' + """
    @task()
    def path(self):
        url = self.locust.host + '/path'
        
        headers = {
            'header': 'qvalue',
            'content-length': '7',
        }

        params = {
            'query': 'param',
        }

        data = '''content'''

        self.response = self.client.request(
            method='PATCH',
            url=url,
            headers=headers,
            params=params,
            data=data,
        )
        """.strip() + '\n'

        assert flow_export.locust_task(flow) == result
Esempio n. 25
0
    def test_post(self):
        req_post.content = '''content'''
        req_post.headers = ''
        flow = tutils.tflow(req=req_post)
        result = """
from locust import HttpLocust, TaskSet, task

class UserBehavior(TaskSet):
    def on_start(self):
        ''' on_start is called when a Locust start before any task is scheduled '''
        self.path()

    @task()
    def path(self):
        url = self.locust.host + '/path'
        
        data = '''content'''

        self.response = self.client.request(
            method='POST',
            url=url,
            data=data,
        )

    ### Additional tasks can go here ###


class WebsiteUser(HttpLocust):
    task_set = UserBehavior
    min_wait = 1000
    max_wait = 3000

        """.strip()

        assert flow_export.locust_code(flow) == result
Esempio n. 26
0
def test_contentview(get_content_view):
    get_content_view.side_effect = ContentViewException(""), ("x", iter([]))

    o = dump.Options(flow_detail=4, verbosity=3)
    m = dump.DumpMaster(None, o, StringIO())
    m.echo_flow(tutils.tflow())
    assert "Content viewer failed" in m.outfile.getvalue()
Esempio n. 27
0
    def test_post_json(self):
        req_post.content = '{"name": "example", "email": "*****@*****.**"}'
        req_post.headers = Headers(content_type="application/json")
        flow = tutils.tflow(req=req_post)
        result = dedent("""
            import requests

            url = 'http://address/path'

            headers = {
                'content-type': 'application/json',
            }

            json = {
                "name": "example",
                "email": "*****@*****.**"
            }

            response = requests.request(
                method='POST',
                url=url,
                headers=headers,
                json=json,
            )

            print(response.text)
        """).strip()
        assert flow_export.python_code(flow) == result
Esempio n. 28
0
    def test_headers(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(server_replay_use_headers=["foo"]), [])

        r = tutils.tflow(resp=True)
        r.request.headers["foo"] = "bar"
        r2 = tutils.tflow(resp=True)
        assert not s._hash(r) == s._hash(r2)
        r2.request.headers["foo"] = "bar"
        assert s._hash(r) == s._hash(r2)
        r2.request.headers["oink"] = "bar"
        assert s._hash(r) == s._hash(r2)

        r = tutils.tflow(resp=True)
        r2 = tutils.tflow(resp=True)
        assert s._hash(r) == s._hash(r2)
Esempio n. 29
0
def test_contentview(get_content_view):
    get_content_view.side_effect = ContentViewException(""), ("x", iter([]))

    o = dump.Options(flow_detail=4, verbosity=3)
    m = dump.DumpMaster(None, o, StringIO())
    m.echo_flow(tutils.tflow())
    assert "Content viewer failed" in m.outfile.getvalue()
Esempio n. 30
0
    def test_patch(self):
        flow = tutils.tflow(req=req_patch)
        result = dedent("""
            import requests

            url = 'http://address/path'

            headers = {
                'header': 'qvalue',
                'content-length': '7',
            }

            params = {
                'query': 'param',
            }

            data = '''content'''

            response = requests.request(
                method='PATCH',
                url=url,
                headers=headers,
                params=params,
                data=data,
            )

            print(response.text)
        """).strip()
        assert flow_export.python_code(flow) == result
Esempio n. 31
0
 def test_post_json(self):
     p = req_post()
     p.content = '{"name": "example", "email": "*****@*****.**"}'
     p.headers = Headers(content_type="application/json")
     flow = tutils.tflow(req=p)
     python_equals("test_flow_export/python_post_json.py",
                   flow_export.python_code(flow))
Esempio n. 32
0
    def test_hash(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(), [])

        r = tutils.tflow()
        r2 = tutils.tflow()

        assert s._hash(r)
        assert s._hash(r) == s._hash(r2)
        r.request.headers["foo"] = "bar"
        assert s._hash(r) == s._hash(r2)
        r.request.path = "voing"
        assert s._hash(r) != s._hash(r2)

        r.request.path = "path?blank_value"
        r2.request.path = "path?"
        assert s._hash(r) != s._hash(r2)
Esempio n. 33
0
    def test_hash(self):
        s = serverplayback.ServerPlayback()
        s.configure(options.Options(), [])

        r = tutils.tflow()
        r2 = tutils.tflow()

        assert s._hash(r)
        assert s._hash(r) == s._hash(r2)
        r.request.headers["foo"] = "bar"
        assert s._hash(r) == s._hash(r2)
        r.request.path = "voing"
        assert s._hash(r) != s._hash(r2)

        r.request.path = "path?blank_value"
        r2.request.path = "path?"
        assert s._hash(r) != s._hash(r2)
Esempio n. 34
0
 def test_error(self):
     cs = StringIO()
     o = dump.Options(flow_detail=1)
     m = dump.DumpMaster(None, o, outfile=cs)
     f = tutils.tflow(err=True)
     m.handle_request(f)
     assert m.handle_error(f)
     assert "error" in cs.getvalue()
Esempio n. 35
0
 def test_ignore_payload_params_other_content_type(self):
     s = serverplayback.ServerPlayback()
     s.configure(
         options.Options(replay_ignore_content=False,
                         replay_ignore_payload_params=["param1", "param2"]),
         [])
     r = tutils.tflow(resp=True)
     r.request.headers["Content-Type"] = "application/json"
     r.request.content = b'{"param1":"1"}'
     r2 = tutils.tflow(resp=True)
     r2.request.headers["Content-Type"] = "application/json"
     r2.request.content = b'{"param1":"1"}'
     # same content
     assert s._hash(r) == s._hash(r2)
     # distint content (note only x-www-form-urlencoded payload is analysed)
     r2.request.content = b'{"param1":"2"}'
     assert not s._hash(r) == s._hash(r2)
Esempio n. 36
0
 def test_error(self):
     cs = StringIO()
     o = dump.Options(flow_detail=1)
     m = dump.DumpMaster(None, o, outfile=cs)
     f = tutils.tflow(err=True)
     m.handle_request(f)
     assert m.handle_error(f)
     assert "error" in cs.getvalue()
Esempio n. 37
0
 def test_post(self):
     flow = tutils.tflow(req=req_post())
     result = dedent("""
         POST /path HTTP/1.1\r
         host: address:22\r
         \r
         content
     """).strip()
     assert flow_export.raw_request(flow) == result
Esempio n. 38
0
 def test_post(self):
     flow = tutils.tflow(req=req_post)
     result = dedent("""
         POST /path HTTP/1.1\r
         host: address:22\r
         \r
         content
     """).strip()
     assert flow_export.raw_request(flow) == result
Esempio n. 39
0
 def test_get(self):
     flow = tutils.tflow(req=req_get)
     result = dedent("""
         GET /path HTTP/1.1\r
         header: qvalue\r
         content-length: 7\r
         host: address:22\r
         \r
     """).strip(" ").lstrip()
     assert flow_export.raw_request(flow) == result
Esempio n. 40
0
 def test_post(self):
     flow = tutils.tflow(req=req_post)
     result = dedent("""
         POST /path HTTP/1.1\r
         content-type: application/json\r
         host: address:22\r
         \r
         {"name": "example", "email": "*****@*****.**"}
     """).strip()
     assert flow_export.raw_request(flow) == result
Esempio n. 41
0
 def test_get(self):
     flow = tutils.tflow(req=req_get())
     result = dedent("""
         GET /path?a=foo&a=bar&b=baz HTTP/1.1\r
         header: qvalue\r
         content-length: 7\r
         host: address:22\r
         \r
     """).strip(" ").lstrip()
     assert flow_export.raw_request(flow) == result
Esempio n. 42
0
 def test_error(self):
     o = dump.Options(
         tfile=StringIO(),
         flow_detail=1
     )
     m = dump.DumpMaster(None, o)
     f = tutils.tflow(err=True)
     m.request(f)
     assert m.error(f)
     assert "error" in o.tfile.getvalue()
Esempio n. 43
0
    def test_ignore_content_wins_over_params(self):
        s = serverplayback.ServerPlayback()
        s.configure(
            options.Options(replay_ignore_content=True,
                            replay_ignore_payload_params=["param1", "param2"]),
            [])
        # NOTE: parameters are mutually exclusive in options

        r = tutils.tflow(resp=True)
        r.request.headers["Content-Type"] = "application/x-www-form-urlencoded"
        r.request.content = b"paramx=y"

        r2 = tutils.tflow(resp=True)
        r2.request.headers[
            "Content-Type"] = "application/x-www-form-urlencoded"
        r2.request.content = b"paramx=x"

        # same parameters
        assert s._hash(r) == s._hash(r2)
Esempio n. 44
0
 def test_post(self):
     flow = tutils.tflow(req=req_post)
     result = dedent("""
         POST /path HTTP/1.1\r
         content-type: application/json\r
         host: address:22\r
         \r
         {"name": "example", "email": "*****@*****.**"}
     """).strip()
     assert flow_export.raw_request(flow) == result
Esempio n. 45
0
 def test_missing_content(self):
     cs = StringIO()
     o = dump.Options(flow_detail=3)
     m = dump.DumpMaster(None, o, outfile=cs)
     f = tutils.tflow()
     f.request.content = CONTENT_MISSING
     m.handle_request(f)
     f.response = HTTPResponse.wrap(netlib.tutils.tresp())
     f.response.content = CONTENT_MISSING
     m.handle_response(f)
     assert "content missing" in cs.getvalue()
Esempio n. 46
0
def test_response():
    ctx = Context()
    ctx.HARLog = har_extractor._HARLog([])
    ctx.seen_server = set()

    fl = tutils.tflow(req=trequest, resp=tresponse)
    har_extractor.response(ctx, fl)

    with open(tutils.test_data.path("data/har_extractor.har")) as fp:
        test_data = json.load(fp)
        assert json.loads(ctx.HARLog.json()) == test_data["test_response"]
Esempio n. 47
0
    def test_server_playback(self):
        sp = serverplayback.ServerPlayback()
        sp.configure(options.Options(), [])
        f = tutils.tflow(resp=True)

        assert not sp.flowmap

        sp.load([f])
        assert sp.flowmap
        assert sp.next_flow(f)
        assert not sp.flowmap
Esempio n. 48
0
    def test_ignore_params(self):
        s = serverplayback.ServerPlayback()
        s.configure(
            options.Options(
                server_replay_ignore_params=["param1", "param2"]
            ),
            []
        )

        r = tutils.tflow(resp=True)
        r.request.path = "/test?param1=1"
        r2 = tutils.tflow(resp=True)
        r2.request.path = "/test"
        assert s._hash(r) == s._hash(r2)
        r2.request.path = "/test?param1=2"
        assert s._hash(r) == s._hash(r2)
        r2.request.path = "/test?param2=1"
        assert s._hash(r) == s._hash(r2)
        r2.request.path = "/test?param3=2"
        assert not s._hash(r) == s._hash(r2)
Esempio n. 49
0
 def test_patch(self):
     flow = tutils.tflow(req=req_patch())
     result = dedent("""
         PATCH /path?query=param HTTP/1.1\r
         header: qvalue\r
         content-length: 7\r
         host: address:22\r
         \r
         content
     """).strip()
     assert flow_export.raw_request(flow) == result
Esempio n. 50
0
    def test_server_playback(self):
        sp = serverplayback.ServerPlayback()
        sp.configure(options.Options(), [])
        f = tutils.tflow(resp=True)

        assert not sp.flowmap

        sp.load([f])
        assert sp.flowmap
        assert sp.next_flow(f)
        assert not sp.flowmap
Esempio n. 51
0
 def test_missing_content(self):
     cs = StringIO()
     o = dump.Options(flow_detail=3)
     m = dump.DumpMaster(None, o, outfile=cs)
     f = tutils.tflow()
     f.request.content = CONTENT_MISSING
     m.handle_request(f)
     f.response = HTTPResponse.wrap(netlib.tutils.tresp())
     f.response.content = CONTENT_MISSING
     m.handle_response(f)
     assert "content missing" in cs.getvalue()
Esempio n. 52
0
 def cycle(self, master, content):
     f = tutils.tflow(req=netlib.tutils.treq(content=content))
     master.clientconnect(f.client_conn)
     master.serverconnect(f.server_conn)
     master.request(f)
     if not f.error:
         f.response = models.HTTPResponse.wrap(
             netlib.tutils.tresp(content=content))
         master.response(f)
     master.clientdisconnect(f)
     return f
Esempio n. 53
0
 def test_patch(self):
     flow = tutils.tflow(req=req_patch)
     result = dedent("""
         PATCH /path?query=param HTTP/1.1\r
         header: qvalue\r
         content-length: 7\r
         host: address:22\r
         \r
         content
     """).strip()
     assert flow_export.raw_request(flow) == result
Esempio n. 54
0
 def cycle(self, master, content):
     f = tutils.tflow(req=netlib.tutils.treq(content=content))
     master.clientconnect(f.client_conn)
     master.serverconnect(f.server_conn)
     master.request(f)
     if not f.error:
         f.response = models.HTTPResponse.wrap(
             netlib.tutils.tresp(content=content)
         )
         master.response(f)
     master.clientdisconnect(f)
     return f
Esempio n. 55
0
def test_strfuncs():
    t = HTTPResponse.wrap(netlib.tutils.tresp())
    t.is_replay = True
    dump.str_response(t)

    f = tutils.tflow()
    f.client_conn = None
    f.request.stickycookie = True
    assert "stickycookie" in dump.str_request(f, False)
    assert "stickycookie" in dump.str_request(f, True)
    assert "replay" in dump.str_request(f, False)
    assert "replay" in dump.str_request(f, True)
Esempio n. 56
0
 def _cycle(self, m, content):
     f = tutils.tflow(req=netlib.tutils.treq(body=content))
     l = Log("connect")
     l.reply = mock.MagicMock()
     m.handle_log(l)
     m.handle_clientconnect(f.client_conn)
     m.handle_serverconnect(f.server_conn)
     m.handle_request(f)
     f.response = HTTPResponse.wrap(netlib.tutils.tresp(body=content))
     f = m.handle_response(f)
     m.handle_clientdisconnect(f.client_conn)
     return f
Esempio n. 57
0
def test_strfuncs():
    o = dump.Options()
    m = dump.DumpMaster(None, o)

    m.outfile = StringIO()
    m.o.flow_detail = 0
    m.echo_flow(tutils.tflow())
    assert not m.outfile.getvalue()

    m.o.flow_detail = 4
    m.echo_flow(tutils.tflow())
    assert m.outfile.getvalue()

    m.outfile = StringIO()
    m.echo_flow(tutils.tflow(resp=True))
    assert "<<" in m.outfile.getvalue()

    m.outfile = StringIO()
    m.echo_flow(tutils.tflow(err=True))
    assert "<<" in m.outfile.getvalue()

    flow = tutils.tflow()
    flow.request = netlib.tutils.treq()
    flow.request.stickycookie = True
    flow.client_conn = mock.MagicMock()
    flow.client_conn.address.host = "foo"
    flow.response = netlib.tutils.tresp(content=CONTENT_MISSING)
    flow.response.is_replay = True
    flow.response.status_code = 300
    m.echo_flow(flow)

    flow = tutils.tflow(resp=netlib.tutils.tresp(content="{"))
    flow.response.headers["content-type"] = "application/json"
    flow.response.status_code = 400
    m.echo_flow(flow)
Esempio n. 58
0
 def cycle(self, master, content):
     f = tutils.tflow(req=netlib.tutils.treq(content=content))
     l = proxy.Log("connect")
     l.reply = controller.DummyReply()
     master.log(l)
     master.clientconnect(f.client_conn)
     master.serverconnect(f.server_conn)
     master.request(f)
     if not f.error:
         f.response = models.HTTPResponse.wrap(netlib.tutils.tresp(content=content))
         master.response(f)
     master.clientdisconnect(f)
     return f
Esempio n. 59
0
 def test_missing_content(self):
     o = dump.Options(
         flow_detail=3,
         tfile=StringIO(),
     )
     m = dump.DumpMaster(None, o)
     f = tutils.tflow()
     f.request.content = None
     m.request(f)
     f.response = models.HTTPResponse.wrap(netlib.tutils.tresp())
     f.response.content = None
     m.response(f)
     assert "content missing" in o.tfile.getvalue()