def test_simple(): o = options.Options() m = master.Master(o, proxy.DummyServer(o)) a = addonmanager.AddonManager(m) with pytest.raises(exceptions.AddonError): a.invoke_addon(TAddon("one"), "done") assert len(a) == 0 a.add(TAddon("one")) assert a.get("one") assert not a.get("two") assert len(a) == 1 a.clear() assert len(a) == 0 assert not a.chain a.add(TAddon("one")) a.trigger("done") with pytest.raises(exceptions.AddonError): a.trigger("tick") a.remove(a.get("one")) assert not a.get("one") ta = TAddon("one") a.add(ta) a.trigger("custom") assert ta.custom_called
def test_load_flows(self): r = self._treader() s = tservers.TestState() fm = master.Master(None, DummyServer()) fm.addons.add(s) fm.load_flows(r) assert len(s.flows) == 6
def test_stream(self): with tutils.tmpdir() as tdir: p = os.path.join(tdir, "foo") def r(): r = io.FlowReader(open(p, "rb")) return list(r.stream()) o = options.Options(outfile=(p, "wb")) m = master.Master(o, proxy.DummyServer()) sa = filestreamer.FileStreamer() m.addons.add(sa) f = tutils.tflow(resp=True) m.request(f) m.response(f) m.addons.remove(sa) assert r()[0].response m.options.outfile = (p, "ab") m.addons.add(sa) f = tutils.tflow() m.request(f) m.addons.remove(sa) assert not r()[1].response
def test_all(self): s = tservers.TestState() fm = master.Master(None) fm.addons.add(s) f = tflow.tflow(req=None) fm.addons.handle_lifecycle("clientconnect", f.client_conn) f.request = http.HTTPRequest.wrap(mitmproxy.test.tutils.treq()) fm.addons.handle_lifecycle("request", f) assert len(s.flows) == 1 f.response = http.HTTPResponse.wrap(mitmproxy.test.tutils.tresp()) fm.addons.handle_lifecycle("response", f) assert len(s.flows) == 1 fm.addons.handle_lifecycle("clientdisconnect", f.client_conn) f.error = flow.Error("msg") fm.addons.handle_lifecycle("error", f) # FIXME: This no longer works, because we consume on the main loop. # fm.tell("foo", f) # with pytest.raises(ControlException): # fm.addons.trigger("unknown") fm.shutdown()
def test_replay(self): opts = options.Options() fm = master.Master(opts) f = tflow.tflow(resp=True) f.request.content = None with pytest.raises(ReplayException, match="missing"): fm.replay_request(f) f.request = None with pytest.raises(ReplayException, match="request"): fm.replay_request(f) f.intercepted = True with pytest.raises(ReplayException, match="intercepted"): fm.replay_request(f) f.live = True with pytest.raises(ReplayException, match="live"): fm.replay_request(f) req = tutils.treq(headers=net_http.Headers(((b":authority", b"foo"), (b"header", b"qvalue"), (b"content-length", b"7")))) f = tflow.tflow(req=req) f.request.http_version = "HTTP/2.0" with mock.patch('mitmproxy.proxy.protocol.http_replay.RequestReplayThread.run'): rt = fm.replay_request(f) assert rt.f.request.http_version == "HTTP/1.1" assert ":authority" not in rt.f.request.headers
def test_server_simple(self): m = master.Master(None) m.server = proxy.DummyServer() m.start() m.shutdown() m.start() m.shutdown()
def test_nesting(): o = options.Options() m = master.Master(o) a = addonmanager.AddonManager(m) a.add( TAddon( "one", addons=[TAddon("two"), TAddon("three", addons=[TAddon("four")])])) assert len(a.chain) == 1 assert a.get("one") assert a.get("two") assert a.get("three") assert a.get("four") a.trigger("custom") assert a.get("one").custom_called assert a.get("two").custom_called assert a.get("three").custom_called assert a.get("four").custom_called a.remove(a.get("three")) assert not a.get("three") assert not a.get("four")
def test_loadchain(): o = options.Options() m = master.Master(o, proxy.DummyServer(o)) a = addonmanager.AddonManager(m) a.add(AChain("one", None)) assert a.get("one") a.clear() a.add(AChain("one", AChain("two", None))) assert not a.get("one") assert a.get("two") a.clear() a.add(AChain("one", AChain("two", AChain("three", None)))) assert not a.get("one") assert not a.get("two") assert a.get("three") a.clear() a.add(AChain("one", AChain("two", AChain("three", AChain("four", None))))) assert not a.get("one") assert not a.get("two") assert not a.get("three") assert a.get("four") a.clear()
def test_addon(self): o = options.Options() m = master.Master(o, proxy.DummyServer()) sc = script.Script(tutils.test_data.path("data/addonscripts/addon.py")) m.addons.add(sc) assert sc.ns.event_log == [ 'scriptstart', 'addonstart', 'addonconfigure' ]
def test_load_flow_reverse(self): s = tservers.TestState() opts = options.Options(mode="reverse:https://use-this-domain") fm = master.Master(opts) fm.addons.add(s) f = tflow.tflow(resp=True) fm.load_flow(f) assert s.flows[0].request.host == "use-this-domain"
def test_load_flows_reverse(self): r = self._treader() s = tservers.TestState() opts = options.Options(mode="reverse:https://use-this-domain") conf = ProxyConfig(opts) fm = master.Master(opts, DummyServer(conf)) fm.addons.add(s) fm.load_flows(r) assert s.flows[0].request.host == "use-this-domain"
def test_simple(): o = options.Options() m = master.Master(o, proxy.DummyServer(o)) a = addonmanager.AddonManager(m) a.add(TAddon("one")) assert a.get("one") assert not a.get("two") a.clear() assert not a.chain
def test_lifecycle(): o = options.Options() m = master.Master(o, proxy.DummyServer(o)) a = addonmanager.AddonManager(m) a.add(TAddon("one")) f = tflow.tflow() a.handle_lifecycle("request", f) a.configure_all(o, o.keys())
def test_replay(self): fm = master.Master(None, DummyServer()) f = tflow.tflow(resp=True) f.request.content = None tutils.raises("missing", fm.replay_request, f) f.intercepted = True tutils.raises("intercepted", fm.replay_request, f) f.live = True tutils.raises("live", fm.replay_request, f)
def test_simple(self): o = options.Options(scripts=[]) m = master.Master(o, proxy.DummyServer()) sc = script.ScriptLoader() m.addons.add(sc) assert len(m.addons) == 1 o.update( scripts=[tutils.test_data.path("data/addonscripts/recorder.py")]) assert len(m.addons) == 2 o.update(scripts=[]) assert len(m.addons) == 1
def __init__(self, proxy_events, listen_port, include_path): self.opts = options.Options() self.opts.listen_port = listen_port self.opts.confdir = include_path self.master = master.Master(self.opts) proxy_events.set_proxy(self) self.master.addons.add(proxy_events) self.master.addons.add(termlog.TermLog()) self.master.addons.add(*addons.default_addons()) self.master.addons.add(keepserving.KeepServing(), readfile.ReadFileStdin())
def test_duplicate_flow(self): s = state.State() fm = master.Master(None, proxy.DummyServer()) fm.addons.add(s) f = tflow.tflow(resp=True) fm.load_flow(f) assert s.flow_count() == 1 f2 = s.duplicate_flow(f) assert f2.response assert s.flow_count() == 2 assert s.index(f2) == 1
def test_load_websocket_flow(self): s = tservers.TestState() opts = options.Options( mode="reverse:https://use-this-domain" ) fm = master.Master(opts) fm.addons.add(s) f = tflow.twebsocketflow() fm.load_flow(f.handshake_flow) fm.load_flow(f) assert s.flows[0].request.host == "use-this-domain" assert s.flows[1].handshake_flow == f.handshake_flow assert len(s.flows[1].messages) == len(f.messages)
def test_call(self): o = options.Options() m = master.Master(o, proxy.DummyServer(o)) cm = command.CommandManager(m) a = TAddon() c = command.Command(cm, "cmd.path", a.cmd1) assert c.call(["foo"]) == "ret foo" assert c.signature_help() == "cmd.path str -> str" c = command.Command(cm, "cmd.two", a.cmd2) with pytest.raises(exceptions.CommandError): c.call(["foo"])
def test_killall(self): srv = DummyServer(None) s = state.State() fm = master.Master(None, srv) fm.addons.add(s) f = tutils.tflow() f.reply.handle() f.intercept(fm) s.killall(fm) for i in s.view: assert "killed" in str(i.error)
def shutdown_proxy(): opts = options.Options( listen_host=PROXY_LISTEN_HOST, listen_port=PROXY_LISTEN_PORT, mode=PROXY_LISTEN_MODE, cadir=PROXY_CACER_DIR, ) config = proxy.ProxyConfig(opts) server = ProxyServer(config) m = master.Master(opts, server) m.shutdown()
def test_concurrent(self): m = master.Master(options.Options(), proxy.DummyServer()) sc = script.Script( tutils.test_data.path("data/addonscripts/concurrent_decorator.py")) m.addons.add(sc) f1, f2 = tutils.tflow(), tutils.tflow() m.request(f1) m.request(f2) start = time.time() while time.time() - start < 5: if f1.reply.state == f2.reply.state == "committed": return raise ValueError("Script never acked")
def test_simple(self): o = options.Options(anticomp = True) m = master.Master(o, proxy.DummyServer()) sa = anticomp.AntiComp() m.addons.add(sa) f = tutils.tflow(resp=True) m.request(f) f = tutils.tflow(resp=True) f.request.headers["Accept-Encoding"] = "foobar" m.request(f) assert f.request.headers["Accept-Encoding"] == "identity"
def test_simple(): o = options.Options() m = master.Master(o, proxy.DummyServer(o)) a = addonmanager.AddonManager(m) a.add(TAddon("one")) assert a.get("one") assert not a.get("two") a.clear() assert not a.chain a.add(TAddon("one")) a("noop") with pytest.raises(exceptions.AddonError): a("noop_member")
def test_replay(self): fm = master.Master(None, DummyServer()) f = tflow.tflow(resp=True) f.request.content = None with pytest.raises(Exception, match="missing"): fm.replay_request(f) f.intercepted = True with pytest.raises(Exception, match="intercepted"): fm.replay_request(f) f.live = True with pytest.raises(Exception, match="live"): fm.replay_request(f)
def test_simple(self): o = options.Options(anticache = True) m = master.Master(o, proxy.DummyServer()) sa = anticache.AntiCache() m.addons.add(sa) f = tflow.tflow(resp=True) m.request(f) f = tflow.tflow(resp=True) f.request.headers["if-modified-since"] = "test" f.request.headers["if-none-match"] = "test" m.request(f) assert "if-modified-since" not in f.request.headers assert "if-none-match" not in f.request.headers
def test_lifecycle(): o = options.Options() m = master.Master(o) a = addonmanager.AddonManager(m) a.add(TAddon("one")) with pytest.raises(exceptions.AddonManagerError): a.add(TAddon("one")) with pytest.raises(exceptions.AddonManagerError): a.remove(TAddon("nonexistent")) f = tflow.tflow() a.handle_lifecycle("request", f) a._configure_all(o, o.keys())
def test_simple(self): o = options.Options(stickyauth=".*") m = master.Master(o, proxy.DummyServer()) sa = stickyauth.StickyAuth() m.addons.add(sa) f = tutils.tflow(resp=True) f.request.headers["authorization"] = "foo" m.request(f) assert "address" in sa.hosts f = tutils.tflow(resp=True) m.request(f) assert f.request.headers["authorization"] == "foo"
def test_halt(): o = options.Options() m = master.Master(o) a = addonmanager.AddonManager(m) halt = THalt() end = TAddon("end") a.add(halt) a.add(end) a.trigger("custom") assert not end.custom_called a.remove(halt) a.trigger("custom") assert end.custom_called
def test_simple(self): o = options.Options() m = master.Master(o, proxy.DummyServer()) sc = script.Script( tutils.test_data.path("data/addonscripts/recorder.py")) m.addons.add(sc) assert sc.ns.call_log == [("solo", "start", (), {}), ("solo", "configure", (o, o.keys()), {})] sc.ns.call_log = [] f = tflow.tflow(resp=True) m.request(f) recf = sc.ns.call_log[0] assert recf[1] == "request"