def test_set_view_filter(self):
c = state.State()
f = tflow.tflow()
assert len(c.view) == 0
c.add_flow(f)
assert len(c.view) == 1
c.set_view_filter("~s")
assert c.filter_txt == "~s"
assert len(c.view) == 0
f.response = http.HTTPResponse.wrap(mitmproxy.test.tutils.tresp())
c.update_flow(f)
assert len(c.view) == 1
c.set_view_filter(None)
assert len(c.view) == 1
f = tflow.tflow()
c.add_flow(f)
assert len(c.view) == 2
c.set_view_filter("~q")
assert len(c.view) == 1
c.set_view_filter("~s")
assert len(c.view) == 1
assert "Invalid" in c.set_view_filter("~")
def test_flow(self):
"""
normal flow:
connect -> request -> response
"""
c = state.State()
f = tflow.tflow()
c.add_flow(f)
assert f
assert c.flow_count() == 1
assert c.active_flow_count() == 1
newf = tflow.tflow()
assert c.add_flow(newf)
assert c.active_flow_count() == 2
f.response = http.HTTPResponse.wrap(mitmproxy.test.tutils.tresp())
assert c.update_flow(f)
assert c.flow_count() == 2
assert c.active_flow_count() == 1
assert not c.update_flow(None)
assert c.active_flow_count() == 1
newf.response = http.HTTPResponse.wrap(mitmproxy.test.tutils.tresp())
assert c.update_flow(newf)
assert c.active_flow_count() == 0
def test_load_flows(self):
r = self._treader()
s = state.State()
fm = master.Master(None, DummyServer())
fm.addons.add(s)
fm.load_flows(r)
assert len(s.flows) == 6
def test_clear(self):
c = state.State()
f = self._add_request(c)
f.intercepted = True
c.clear()
assert c.flow_count() == 0
def test_set_intercept(self):
c = state.State()
assert not c.set_intercept("~q")
assert c.intercept_txt == "~q"
assert "Invalid" in c.set_intercept("~")
assert not c.set_intercept(None)
assert c.intercept_txt is None
def test_load_flows_reverse(self):
r = self._treader()
s = state.State()
opts = options.Options(mode="reverse",
upstream_server="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_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_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 test_dump_flows(self):
c = state.State()
self._add_request(c)
self._add_response(c)
self._add_request(c)
self._add_response(c)
self._add_request(c)
self._add_response(c)
self._add_error(c)
flows = c.view[:]
c.clear()
c.load_flows(flows)
assert isinstance(c.flows[0], flow.Flow)
def test_all(self):
s = state.State()
fm = master.Master(None, DummyServer())
fm.addons.add(s)
f = tutils.tflow(req=None)
fm.clientconnect(f.client_conn)
f.request = http.HTTPRequest.wrap(mitmproxy.test.tutils.treq())
fm.request(f)
assert s.flow_count() == 1
f.response = http.HTTPResponse.wrap(mitmproxy.test.tutils.tresp())
fm.response(f)
assert s.flow_count() == 1
fm.clientdisconnect(f.client_conn)
f.error = flow.Error("msg")
fm.error(f)
fm.shutdown()
def clear_addons(self, addons):
self.addons.clear()
self.state = state.State()
self.addons.add(self.state)
self.addons.add(*addons)
def test_accept_all(self):
c = state.State()
self._add_request(c)
self._add_response(c)
self._add_request(c)
c.accept_all(mock.Mock())
def test_backup(self):
c = state.State()
f = tutils.tflow()
c.add_flow(f)
f.backup()
c.revert(f)