Merge pull request #2264 from cortesi/options

Change the way addons handle options
author: Aldo Cortesi <aldo@corte.si> 2017-04-26 11:23:48 +1200
committer: GitHub <noreply@github.com> 2017-04-26 11:23:48 +1200
commit: 1daf0b3f0ae80e1e2dce823204547611e28d6ee9 (patch)
tree: 57b4153fa4980e2af1aff7aae9c84ae507a463fb /test
parent: 02c82b1b602b7d5ab03c1e25d7d89f44c593174a (diff)
parent: b72f1390937e9799f588fd9a1564056131fb1aa7 (diff)
download: mitmproxy-1daf0b3f0ae80e1e2dce823204547611e28d6ee9.tar.gz
mitmproxy-1daf0b3f0ae80e1e2dce823204547611e28d6ee9.tar.bz2
mitmproxy-1daf0b3f0ae80e1e2dce823204547611e28d6ee9.zip
12 files changed, 243 insertions, 275 deletions
diff --git a/test/examples/test_examples.py b/test/examples/test_examples.py
index 4b691df2..4c1631ce 100644
--- a/test/examples/test_examples.py
+++ b/test/examples/test_examples.py
@@ -1,9 +1,4 @@
-from mitmproxy import options
 from mitmproxy import contentviews
-from mitmproxy import proxy
-from mitmproxy import master
-from mitmproxy.addons import script
-
 from mitmproxy.test import tflow
 from mitmproxy.test import tutils
 from mitmproxy.test import taddons
@@ -14,37 +9,20 @@ from ..mitmproxy import tservers
 example_dir = tutils.test_data.push("../examples")
 
 
-class ScriptError(Exception):
-    pass
-
-
-class RaiseMaster(master.Master):
-    def add_log(self, e, level):
-        if level in ("warn", "error"):
-            raise ScriptError(e)
-
-
-def tscript(cmd, args=""):
-    o = options.Options()
-    cmd = example_dir.path(cmd)
-    m = RaiseMaster(o, proxy.DummyServer())
-    sc = script.Script(cmd)
-    m.addons.add(sc)
-    return m, sc
-
-
 class TestScripts(tservers.MasterTest):
     def test_add_header(self):
-        m, _ = tscript("simple/add_header.py")
-        f = tflow.tflow(resp=tutils.tresp())
-        m.addons.handle_lifecycle("response", f)
-        assert f.response.headers["newheader"] == "foo"
+        with taddons.context() as tctx:
+            a = tctx.script(example_dir.path("simple/add_header.py"))
+            f = tflow.tflow(resp=tutils.tresp())
+            a.response(f)
+            assert f.response.headers["newheader"] == "foo"
 
     def test_custom_contentviews(self):
-        m, sc = tscript("simple/custom_contentview.py")
-        swapcase = contentviews.get("swapcase")
-        _, fmt = swapcase(b"<html>Test!</html>")
-        assert any(b'tEST!' in val[0][1] for val in fmt)
+        with taddons.context() as tctx:
+            tctx.script(example_dir.path("simple/custom_contentview.py"))
+            swapcase = contentviews.get("swapcase")
+            _, fmt = swapcase(b"<html>Test!</html>")
+            assert any(b'tEST!' in val[0][1] for val in fmt)
 
     def test_iframe_injector(self):
         with taddons.context() as tctx:
@@ -61,57 +39,63 @@ class TestScripts(tservers.MasterTest):
             assert b'iframe' in content and b'evil_iframe' in content
 
     def test_modify_form(self):
-        m, sc = tscript("simple/modify_form.py")
+        with taddons.context() as tctx:
+            sc = tctx.script(example_dir.path("simple/modify_form.py"))
 
-        form_header = Headers(content_type="application/x-www-form-urlencoded")
-        f = tflow.tflow(req=tutils.treq(headers=form_header))
-        m.addons.handle_lifecycle("request", f)
+            form_header = Headers(content_type="application/x-www-form-urlencoded")
+            f = tflow.tflow(req=tutils.treq(headers=form_header))
+            sc.request(f)
 
-        assert f.request.urlencoded_form["mitmproxy"] == "rocks"
+            assert f.request.urlencoded_form["mitmproxy"] == "rocks"
 
-        f.request.headers["content-type"] = ""
-        m.addons.handle_lifecycle("request", f)
-        assert list(f.request.urlencoded_form.items()) == [("foo", "bar")]
+            f.request.headers["content-type"] = ""
+            sc.request(f)
+            assert list(f.request.urlencoded_form.items()) == [("foo", "bar")]
 
     def test_modify_querystring(self):
-        m, sc = tscript("simple/modify_querystring.py")
-        f = tflow.tflow(req=tutils.treq(path="/search?q=term"))
+        with taddons.context() as tctx:
+            sc = tctx.script(example_dir.path("simple/modify_querystring.py"))
+            f = tflow.tflow(req=tutils.treq(path="/search?q=term"))
 
-        m.addons.handle_lifecycle("request", f)
-        assert f.request.query["mitmproxy"] == "rocks"
+            sc.request(f)
+            assert f.request.query["mitmproxy"] == "rocks"
 
-        f.request.path = "/"
-        m.addons.handle_lifecycle("request", f)
-        assert f.request.query["mitmproxy"] == "rocks"
+            f.request.path = "/"
+            sc.request(f)
+            assert f.request.query["mitmproxy"] == "rocks"
 
     def test_redirect_requests(self):
-        m, sc = tscript("simple/redirect_requests.py")
-        f = tflow.tflow(req=tutils.treq(host="example.org"))
-        m.addons.handle_lifecycle("request", f)
-        assert f.request.host == "mitmproxy.org"
+        with taddons.context() as tctx:
+            sc = tctx.script(example_dir.path("simple/redirect_requests.py"))
+            f = tflow.tflow(req=tutils.treq(host="example.org"))
+            sc.request(f)
+            assert f.request.host == "mitmproxy.org"
 
     def test_send_reply_from_proxy(self):
-        m, sc = tscript("simple/send_reply_from_proxy.py")
-        f = tflow.tflow(req=tutils.treq(host="example.com", port=80))
-        m.addons.handle_lifecycle("request", f)
-        assert f.response.content == b"Hello World"
+        with taddons.context() as tctx:
+            sc = tctx.script(example_dir.path("simple/send_reply_from_proxy.py"))
+            f = tflow.tflow(req=tutils.treq(host="example.com", port=80))
+            sc.request(f)
+            assert f.response.content == b"Hello World"
 
     def test_dns_spoofing(self):
-        m, sc = tscript("complex/dns_spoofing.py")
-        original_host = "example.com"
+        with taddons.context() as tctx:
+            sc = tctx.script(example_dir.path("complex/dns_spoofing.py"))
+
+            original_host = "example.com"
 
-        host_header = Headers(host=original_host)
-        f = tflow.tflow(req=tutils.treq(headers=host_header, port=80))
+            host_header = Headers(host=original_host)
+            f = tflow.tflow(req=tutils.treq(headers=host_header, port=80))
 
-        m.addons.handle_lifecycle("requestheaders", f)
+            tctx.master.addons.invoke_addon(sc, "requestheaders", f)
 
-        # Rewrite by reverse proxy mode
-        f.request.scheme = "https"
-        f.request.port = 443
+            # Rewrite by reverse proxy mode
+            f.request.scheme = "https"
+            f.request.port = 443
 
-        m.addons.handle_lifecycle("request", f)
+            tctx.master.addons.invoke_addon(sc, "request", f)
 
-        assert f.request.scheme == "http"
-        assert f.request.port == 80
+            assert f.request.scheme == "http"
+            assert f.request.port == 80
 
-        assert f.request.headers["Host"] == original_host
+            assert f.request.headers["Host"] == original_host
diff --git a/test/mitmproxy/addons/test_onboarding.py b/test/mitmproxy/addons/test_onboarding.py
index 63125c23..42a3b574 100644
--- a/test/mitmproxy/addons/test_onboarding.py
+++ b/test/mitmproxy/addons/test_onboarding.py
@@ -1,4 +1,5 @@
 from mitmproxy.addons import onboarding
+from mitmproxy.test import taddons
 from .. import tservers
 
 
@@ -7,10 +8,14 @@ class TestApp(tservers.HTTPProxyTest):
         return [onboarding.Onboarding()]
 
     def test_basic(self):
-        assert self.app("/").status_code == 200
+        with taddons.context() as tctx:
+            tctx.configure(self.addons()[0])
+            assert self.app("/").status_code == 200
 
     def test_cert(self):
-        for ext in ["pem", "p12"]:
-            resp = self.app("/cert/%s" % ext)
-            assert resp.status_code == 200
-            assert resp.content
+        with taddons.context() as tctx:
+            tctx.configure(self.addons()[0])
+            for ext in ["pem", "p12"]:
+                resp = self.app("/cert/%s" % ext)
+                assert resp.status_code == 200
+                assert resp.content
diff --git a/test/mitmproxy/addons/test_proxyauth.py b/test/mitmproxy/addons/test_proxyauth.py
index 513f3f08..86621709 100644
--- a/test/mitmproxy/addons/test_proxyauth.py
+++ b/test/mitmproxy/addons/test_proxyauth.py
@@ -66,9 +66,6 @@ def test_configure():
         with pytest.raises(exceptions.OptionsError):
             ctx.configure(up, proxyauth="any", mode="socks5")
 
-        ctx.configure(up, mode="regular")
-        assert up.mode == "regular"
-
 
 def test_check():
     up = proxyauth.ProxyAuth()
diff --git a/test/mitmproxy/addons/test_script.py b/test/mitmproxy/addons/test_script.py
index 4a86fad2..859d99f9 100644
--- a/test/mitmproxy/addons/test_script.py
+++ b/test/mitmproxy/addons/test_script.py
@@ -1,7 +1,6 @@
 import traceback
 import sys
 import time
-import watchdog.events
 import pytest
 
 from unittest import mock
@@ -16,34 +15,6 @@ from mitmproxy import master
 from mitmproxy.addons import script
 
 
-class Called:
-    def __init__(self):
-        self.called = False
-
-    def __call__(self, *args, **kwargs):
-        self.called = True
-
-
-def test_reloadhandler():
-    rh = script.ReloadHandler(Called())
-    assert not rh.filter(watchdog.events.DirCreatedEvent("path"))
-    assert not rh.filter(watchdog.events.FileModifiedEvent("/foo/.bar"))
-    assert not rh.filter(watchdog.events.FileModifiedEvent("/foo/bar"))
-    assert rh.filter(watchdog.events.FileModifiedEvent("/foo/bar.py"))
-
-    assert not rh.callback.called
-    rh.on_modified(watchdog.events.FileModifiedEvent("/foo/bar"))
-    assert not rh.callback.called
-    rh.on_modified(watchdog.events.FileModifiedEvent("/foo/bar.py"))
-    assert rh.callback.called
-    rh.callback.called = False
-
-    rh.on_created(watchdog.events.FileCreatedEvent("foo"))
-    assert not rh.callback.called
-    rh.on_created(watchdog.events.FileCreatedEvent("foo.py"))
-    assert rh.callback.called
-
-
 def test_load_script():
     with taddons.context() as tctx:
         ns = script.load_script(
@@ -89,6 +60,8 @@ class TestScript:
                 )
             )
             tctx.master.addons.add(sc)
+            tctx.configure(sc)
+            sc.tick()
 
             rec = tctx.master.addons.get("recorder")
 
@@ -107,10 +80,12 @@ class TestScript:
             f.write("\n")
             sc = script.Script(str(f))
             tctx.configure(sc)
-            for _ in range(5):
-                sc.reload()
+            sc.tick()
+            for _ in range(3):
+                sc.last_load, sc.last_mtime = 0, 0
                 sc.tick()
                 time.sleep(0.1)
+            tctx.master.has_log("Loading")
 
     def test_exception(self):
         with taddons.context() as tctx:
@@ -118,10 +93,12 @@ class TestScript:
                 tutils.test_data.path("mitmproxy/data/addonscripts/error.py")
             )
             tctx.master.addons.add(sc)
+            tctx.configure(sc)
+            sc.tick()
+
             f = tflow.tflow(resp=True)
             tctx.master.addons.trigger("request", f)
 
-            assert tctx.master.logs[0].level == "error"
             tctx.master.has_log("ValueError: Error!")
             tctx.master.has_log("error.py")
 
@@ -133,8 +110,10 @@ class TestScript:
                 )
             )
             tctx.master.addons.add(sc)
+            tctx.configure(sc)
+            sc.tick()
             assert sc.ns.event_log == [
-                'scriptload', 'addonload'
+                'scriptload', 'addonload', 'scriptconfigure', 'addonconfigure'
             ]
 
 
@@ -207,21 +186,23 @@ class TestScriptLoader:
                     "%s/c.py" % rec,
                 ]
             )
-
+            tctx.master.addons.invoke_addon(sc, "tick")
             debug = [i.msg for i in tctx.master.logs if i.level == "debug"]
             assert debug == [
                 'a load',
                 'a running',
+                'a configure',
+                'a tick',
 
                 'b load',
                 'b running',
+                'b configure',
+                'b tick',
 
                 'c load',
                 'c running',
-
-                'a configure',
-                'b configure',
                 'c configure',
+                'c tick',
             ]
 
             tctx.master.logs = []
@@ -233,6 +214,7 @@ class TestScriptLoader:
                     "%s/b.py" % rec,
                 ]
             )
+
             debug = [i.msg for i in tctx.master.logs if i.level == "debug"]
             assert debug == [
                 'c configure',
@@ -248,13 +230,16 @@ class TestScriptLoader:
                     "%s/a.py" % rec,
                 ]
             )
+            tctx.master.addons.invoke_addon(sc, "tick")
 
             debug = [i.msg for i in tctx.master.logs if i.level == "debug"]
             assert debug == [
                 'c done',
                 'b done',
+                'a configure',
                 'e load',
                 'e running',
                 'e configure',
-                'a configure',
+                'e tick',
+                'a tick',
             ]
diff --git a/test/mitmproxy/addons/test_serverplayback.py b/test/mitmproxy/addons/test_serverplayback.py
index 7078b66e..29de48a0 100644
--- a/test/mitmproxy/addons/test_serverplayback.py
+++ b/test/mitmproxy/addons/test_serverplayback.py
@@ -6,7 +6,6 @@ from mitmproxy.test import tflow
 
 import mitmproxy.test.tutils
 from mitmproxy.addons import serverplayback
-from mitmproxy import options
 from mitmproxy import exceptions
 from mitmproxy import io
 
@@ -39,86 +38,88 @@ def test_tick():
 
 def test_server_playback():
     sp = serverplayback.ServerPlayback()
-    sp.configure(options.Options(), [])
-    f = tflow.tflow(resp=True)
+    with taddons.context() as tctx:
+        tctx.configure(sp)
+        f = tflow.tflow(resp=True)
 
-    assert not sp.flowmap
+        assert not sp.flowmap
 
-    sp.load_flows([f])
-    assert sp.flowmap
-    assert sp.next_flow(f)
-    assert not sp.flowmap
+        sp.load_flows([f])
+        assert sp.flowmap
+        assert sp.next_flow(f)
+        assert not sp.flowmap
 
-    sp.load_flows([f])
-    assert sp.flowmap
-    sp.clear()
-    assert not sp.flowmap
+        sp.load_flows([f])
+        assert sp.flowmap
+        sp.clear()
+        assert not sp.flowmap
 
 
 def test_ignore_host():
     sp = serverplayback.ServerPlayback()
-    sp.configure(options.Options(server_replay_ignore_host=True), [])
+    with taddons.context() as tctx:
+        tctx.configure(sp, server_replay_ignore_host=True)
 
-    r = tflow.tflow(resp=True)
-    r2 = tflow.tflow(resp=True)
+        r = tflow.tflow(resp=True)
+        r2 = tflow.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)
+        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)
 
 
 def test_ignore_content():
     s = serverplayback.ServerPlayback()
-    s.configure(options.Options(server_replay_ignore_content=False), [])
+    with taddons.context() as tctx:
+        tctx.configure(s, server_replay_ignore_content=False)
 
-    r = tflow.tflow(resp=True)
-    r2 = tflow.tflow(resp=True)
+        r = tflow.tflow(resp=True)
+        r2 = tflow.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)
+        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 = tflow.tflow(resp=True)
-    r2 = tflow.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)
+        tctx.configure(s, server_replay_ignore_content=True)
+        r = tflow.tflow(resp=True)
+        r2 = tflow.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)
 
 
 def test_ignore_content_wins_over_params():
     s = serverplayback.ServerPlayback()
-    s.configure(
-        options.Options(
+    with taddons.context() as tctx:
+        tctx.configure(
+            s,
             server_replay_ignore_content=True,
             server_replay_ignore_payload_params=[
                 "param1", "param2"
             ]
-        ),
-        []
-    )
-    # NOTE: parameters are mutually exclusive in options
+        )
 
-    r = tflow.tflow(resp=True)
-    r.request.headers["Content-Type"] = "application/x-www-form-urlencoded"
-    r.request.content = b"paramx=y"
+        # NOTE: parameters are mutually exclusive in options
+        r = tflow.tflow(resp=True)
+        r.request.headers["Content-Type"] = "application/x-www-form-urlencoded"
+        r.request.content = b"paramx=y"
 
-    r2 = tflow.tflow(resp=True)
-    r2.request.headers["Content-Type"] = "application/x-www-form-urlencoded"
-    r2.request.content = b"paramx=x"
+        r2 = tflow.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)
+        # same parameters
+        assert s._hash(r) == s._hash(r2)
 
 
 def test_ignore_payload_params_other_content_type():
@@ -147,136 +148,139 @@ def test_ignore_payload_params_other_content_type():
 
 def test_hash():
     s = serverplayback.ServerPlayback()
-    s.configure(options.Options(), [])
+    with taddons.context() as tctx:
+        tctx.configure(s)
 
-    r = tflow.tflow()
-    r2 = tflow.tflow()
+        r = tflow.tflow()
+        r2 = tflow.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)
+        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)
+        r.request.path = "path?blank_value"
+        r2.request.path = "path?"
+        assert s._hash(r) != s._hash(r2)
 
 
 def test_headers():
     s = serverplayback.ServerPlayback()
-    s.configure(options.Options(server_replay_use_headers=["foo"]), [])
+    with taddons.context() as tctx:
+        tctx.configure(s, server_replay_use_headers=["foo"])
 
-    r = tflow.tflow(resp=True)
-    r.request.headers["foo"] = "bar"
-    r2 = tflow.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 = tflow.tflow(resp=True)
+        r.request.headers["foo"] = "bar"
+        r2 = tflow.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 = tflow.tflow(resp=True)
-    r2 = tflow.tflow(resp=True)
-    assert s._hash(r) == s._hash(r2)
+        r = tflow.tflow(resp=True)
+        r2 = tflow.tflow(resp=True)
+        assert s._hash(r) == s._hash(r2)
 
 
 def test_load():
     s = serverplayback.ServerPlayback()
-    s.configure(options.Options(), [])
+    with taddons.context() as tctx:
+        tctx.configure(s)
 
-    r = tflow.tflow(resp=True)
-    r.request.headers["key"] = "one"
+        r = tflow.tflow(resp=True)
+        r.request.headers["key"] = "one"
 
-    r2 = tflow.tflow(resp=True)
-    r2.request.headers["key"] = "two"
+        r2 = tflow.tflow(resp=True)
+        r2.request.headers["key"] = "two"
 
-    s.load_flows([r, r2])
+        s.load_flows([r, r2])
 
-    assert s.count() == 2
+        assert s.count() == 2
 
-    n = s.next_flow(r)
-    assert n.request.headers["key"] == "one"
-    assert s.count() == 1
+        n = s.next_flow(r)
+        assert n.request.headers["key"] == "one"
+        assert s.count() == 1
 
-    n = s.next_flow(r)
-    assert n.request.headers["key"] == "two"
-    assert not s.flowmap
-    assert s.count() == 0
+        n = s.next_flow(r)
+        assert n.request.headers["key"] == "two"
+        assert not s.flowmap
+        assert s.count() == 0
 
-    assert not s.next_flow(r)
+        assert not s.next_flow(r)
 
 
 def test_load_with_server_replay_nopop():
     s = serverplayback.ServerPlayback()
-    s.configure(options.Options(server_replay_nopop=True), [])
+    with taddons.context() as tctx:
+        tctx.configure(s, server_replay_nopop=True)
 
-    r = tflow.tflow(resp=True)
-    r.request.headers["key"] = "one"
+        r = tflow.tflow(resp=True)
+        r.request.headers["key"] = "one"
 
-    r2 = tflow.tflow(resp=True)
-    r2.request.headers["key"] = "two"
+        r2 = tflow.tflow(resp=True)
+        r2.request.headers["key"] = "two"
 
-    s.load_flows([r, r2])
+        s.load_flows([r, r2])
 
-    assert s.count() == 2
-    s.next_flow(r)
-    assert s.count() == 2
+        assert s.count() == 2
+        s.next_flow(r)
+        assert s.count() == 2
 
 
 def test_ignore_params():
     s = serverplayback.ServerPlayback()
-    s.configure(
-        options.Options(
+    with taddons.context() as tctx:
+        tctx.configure(
+            s,
             server_replay_ignore_params=["param1", "param2"]
-        ),
-        []
-    )
+        )
 
-    r = tflow.tflow(resp=True)
-    r.request.path = "/test?param1=1"
-    r2 = tflow.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)
+        r = tflow.tflow(resp=True)
+        r.request.path = "/test?param1=1"
+        r2 = tflow.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)
 
 
 def thash(r, r2, setter):
     s = serverplayback.ServerPlayback()
-    s.configure(
-        options.Options(
+    with taddons.context() as tctx:
+        s = serverplayback.ServerPlayback()
+        tctx.configure(
+            s,
             server_replay_ignore_payload_params=["param1", "param2"]
-        ),
-        []
-    )
-
-    setter(r, paramx="x", param1="1")
-
-    setter(r2, paramx="x", param1="1")
-    # same parameters
-    assert s._hash(r) == s._hash(r2)
-    # ignored parameters !=
-    setter(r2, paramx="x", param1="2")
-    assert s._hash(r) == s._hash(r2)
-    # missing parameter
-    setter(r2, paramx="x")
-    assert s._hash(r) == s._hash(r2)
-    # ignorable parameter added
-    setter(r2, paramx="x", param1="2")
-    assert s._hash(r) == s._hash(r2)
-    # not ignorable parameter changed
-    setter(r2, paramx="y", param1="1")
-    assert not s._hash(r) == s._hash(r2)
-    # not ignorable parameter missing
-    setter(r2, param1="1")
-    r2.request.content = b"param1=1"
-    assert not s._hash(r) == s._hash(r2)
+        )
+
+        setter(r, paramx="x", param1="1")
+
+        setter(r2, paramx="x", param1="1")
+        # same parameters
+        assert s._hash(r) == s._hash(r2)
+        # ignored parameters !=
+        setter(r2, paramx="x", param1="2")
+        assert s._hash(r) == s._hash(r2)
+        # missing parameter
+        setter(r2, paramx="x")
+        assert s._hash(r) == s._hash(r2)
+        # ignorable parameter added
+        setter(r2, paramx="x", param1="2")
+        assert s._hash(r) == s._hash(r2)
+        # not ignorable parameter changed
+        setter(r2, paramx="y", param1="1")
+        assert not s._hash(r) == s._hash(r2)
+        # not ignorable parameter missing
+        setter(r2, param1="1")
+        r2.request.content = b"param1=1"
+        assert not s._hash(r) == s._hash(r2)
 
 
 def test_ignore_payload_params():
diff --git a/test/mitmproxy/addons/test_termstatus.py b/test/mitmproxy/addons/test_termstatus.py
index 7becc857..2debaff5 100644
--- a/test/mitmproxy/addons/test_termstatus.py
+++ b/test/mitmproxy/addons/test_termstatus.py
@@ -5,6 +5,7 @@ from mitmproxy.test import taddons
 def test_configure():
     ts = termstatus.TermStatus()
     with taddons.context() as ctx:
+        ctx.configure(ts, server=False)
         ts.running()
         assert not ctx.master.logs
         ctx.configure(ts, server=True)
diff --git a/test/mitmproxy/data/addonscripts/addon.py b/test/mitmproxy/data/addonscripts/addon.py
index 42e28a93..8c834d82 100644
--- a/test/mitmproxy/data/addonscripts/addon.py
+++ b/test/mitmproxy/data/addonscripts/addon.py
@@ -9,12 +9,12 @@ class Addon:
     def load(self, opts):
         event_log.append("addonload")
 
-    def configure(self, options, updated):
+    def configure(self, updated):
         event_log.append("addonconfigure")
 
 
-def configure(options, updated):
-    event_log.append("addonconfigure")
+def configure(updated):
+    event_log.append("scriptconfigure")
 
 
 def load(l):
diff --git a/test/mitmproxy/data/addonscripts/concurrent_decorator_err.py b/test/mitmproxy/data/addonscripts/concurrent_decorator_err.py
index 7bc28182..4f80e98a 100644
--- a/test/mitmproxy/data/addonscripts/concurrent_decorator_err.py
+++ b/test/mitmproxy/data/addonscripts/concurrent_decorator_err.py
@@ -2,5 +2,5 @@ from mitmproxy.script import concurrent
 
 
 @concurrent
-def start(opts):
+def load(v):
     pass
diff --git a/test/mitmproxy/proxy/test_server.py b/test/mitmproxy/proxy/test_server.py
index b54a764f..b4bb46bb 100644
--- a/test/mitmproxy/proxy/test_server.py
+++ b/test/mitmproxy/proxy/test_server.py
@@ -297,7 +297,7 @@ class TestHTTPAuth(tservers.HTTPProxyTest):
     def test_auth(self):
         self.master.addons.add(proxyauth.ProxyAuth())
         self.master.addons.trigger(
-            "configure", self.master.options, self.master.options.keys()
+            "configure", self.master.options.keys()
         )
         self.master.options.proxyauth = "test:test"
         assert self.pathod("202").status_code == 407
diff --git a/test/mitmproxy/script/test_concurrent.py b/test/mitmproxy/script/test_concurrent.py
index d24f96a2..ceff9fb9 100644
--- a/test/mitmproxy/script/test_concurrent.py
+++ b/test/mitmproxy/script/test_concurrent.py
@@ -2,10 +2,7 @@ from mitmproxy.test import tflow
 from mitmproxy.test import tutils
 from mitmproxy.test import taddons
 
-from mitmproxy import addonmanager
 from mitmproxy import controller
-from mitmproxy.addons import script
-
 import time
 
 from .. import tservers
@@ -36,25 +33,20 @@ class TestConcurrent(tservers.MasterTest):
 
     def test_concurrent_err(self):
         with taddons.context() as tctx:
-            sc = script.Script(
+            tctx.script(
                 tutils.test_data.path(
                     "mitmproxy/data/addonscripts/concurrent_decorator_err.py"
                 )
             )
-            l = addonmanager.Loader(tctx.master)
-            sc.load(l)
             assert tctx.master.has_log("decorator not supported")
 
     def test_concurrent_class(self):
             with taddons.context() as tctx:
-                sc = script.Script(
+                sc = tctx.script(
                     tutils.test_data.path(
                         "mitmproxy/data/addonscripts/concurrent_decorator_class.py"
                     )
                 )
-                l = addonmanager.Loader(tctx.master)
-                sc.load(l)
-
                 f1, f2 = tflow.tflow(), tflow.tflow()
                 tctx.cycle(sc, f1)
                 tctx.cycle(sc, f2)
diff --git a/test/mitmproxy/tools/console/test_master.py b/test/mitmproxy/tools/console/test_master.py
index add8c4d3..c87c9e83 100644
--- a/test/mitmproxy/tools/console/test_master.py
+++ b/test/mitmproxy/tools/console/test_master.py
@@ -30,7 +30,7 @@ class TestMaster(tservers.MasterTest):
             opts["verbosity"] = 1
         o = options.Options(**opts)
         m = console.master.ConsoleMaster(o, proxy.DummyServer())
-        m.addons.trigger("configure", o, o.keys())
+        m.addons.trigger("configure", o.keys())
         return m
 
     def test_basic(self):
diff --git a/test/mitmproxy/tservers.py b/test/mitmproxy/tservers.py
index d8dda5eb..b8005529 100644
--- a/test/mitmproxy/tservers.py
+++ b/test/mitmproxy/tservers.py
@@ -74,7 +74,7 @@ class TestMaster(taddons.RecordingMaster):
         self.state = TestState()
         self.addons.add(self.state)
         self.addons.add(*addons)
-        self.addons.trigger("configure", self.options, self.options.keys())
+        self.addons.trigger("configure", self.options.keys())
         self.addons.trigger("running")
 
     def reset(self, addons):
author	Aldo Cortesi <aldo@corte.si>	2017-04-26 11:23:48 +1200
committer	GitHub <noreply@github.com>	2017-04-26 11:23:48 +1200
commit	1daf0b3f0ae80e1e2dce823204547611e28d6ee9 (patch)
tree	57b4153fa4980e2af1aff7aae9c84ae507a463fb /test
parent	02c82b1b602b7d5ab03c1e25d7d89f44c593174a (diff)
parent	b72f1390937e9799f588fd9a1564056131fb1aa7 (diff)
download	mitmproxy-1daf0b3f0ae80e1e2dce823204547611e28d6ee9.tar.gz mitmproxy-1daf0b3f0ae80e1e2dce823204547611e28d6ee9.tar.bz2 mitmproxy-1daf0b3f0ae80e1e2dce823204547611e28d6ee9.zip