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"
