def tresp(req=None):
if not req:
req = treq()
headers = flow.ODictCaseless()
headers["header_response"] = ["svalue"]
cert = certutils.SSLCert.from_der(file(test_data.path("data/dercert"),"rb").read())
resp = flow.Response(req, (1, 1), 200, "message", headers, "content_response", cert)
resp.reply = controller.DummyReply()
return resp
def tclient_conn():
"""
@return: libmproxy.proxy.connection.ClientConnection
"""
c = ClientConnection.from_state(
dict(address=dict(address=("address", 22), use_ipv6=True),
clientcert=None))
c.reply = controller.DummyReply()
return c
def tserver_conn():
"""
@return: libmproxy.proxy.connection.ServerConnection
"""
c = ServerConnection.from_state(
dict(address=dict(address=("address", 22), use_ipv6=True),
state=[],
source_address=dict(address=("address", 22), use_ipv6=True),
cert=None))
c.reply = controller.DummyReply()
return c
def test_script(self):
s = flow.State()
fm = flow.FlowMaster(None, s)
assert not fm.load_script(tutils.test_data.path("scripts/all.py"))
req = tutils.treq()
fm.handle_clientconnect(req.client_conn)
assert fm.script.ns["log"][-1] == "clientconnect"
f = fm.handle_request(req)
assert fm.script.ns["log"][-1] == "request"
resp = tutils.tresp(req)
fm.handle_response(resp)
assert fm.script.ns["log"][-1] == "response"
dc = flow.ClientDisconnect(req.client_conn)
dc.reply = controller.DummyReply()
fm.handle_clientdisconnect(dc)
assert fm.script.ns["log"][-1] == "clientdisconnect"
err = flow.Error(f.request, "msg")
err.reply = controller.DummyReply()
fm.handle_error(err)
assert fm.script.ns["log"][-1] == "error"
def treq(conn=None, content="content"):
if not conn:
conn = tclient_conn()
server_conn = tserver_conn()
headers = flow.ODictCaseless()
headers["header"] = ["qvalue"]
f = http.HTTPFlow(conn, server_conn)
f.request = http.HTTPRequest("relative", "GET", None, None, None, "/path",
(1, 1), headers, content, None, None, None)
f.request.reply = controller.DummyReply()
return f.request
def tclient_conn():
"""
@return: libmproxy.proxy.connection.ClientConnection
"""
c = ClientConnection.from_state(
dict(
address=dict(address=("address", 22), use_ipv6=True),
clientcert=None,
ssl_established=False,
timestamp_start=1,
timestamp_ssl_setup=2,
timestamp_end=3,
))
c.reply = controller.DummyReply()
return c
def tresp(req=None, content="message"):
if not req:
req = treq()
f = req.flow
headers = flow.ODictCaseless()
headers["header_response"] = ["svalue"]
cert = certutils.SSLCert.from_der(
file(test_data.path("data/dercert"), "rb").read())
f.server_conn = ServerConnection._from_state(
dict(address=dict(address=("address", 22), use_ipv6=True),
source_address=None,
cert=cert.to_pem()))
f.response = http.HTTPResponse((1, 1), 200, "OK", headers, content, time(),
time())
f.response.reply = controller.DummyReply()
return f.response
def test_client_playback(self):
s = flow.State()
f = tutils.tflow_full()
pb = [tutils.tflow_full(), f]
fm = flow.FlowMaster(None, s)
assert not fm.start_server_playback(pb, False, [], False, False)
assert not fm.start_client_playback(pb, False)
q = Queue.Queue()
assert not fm.state.flow_count()
fm.tick(q)
assert fm.state.flow_count()
err = flow.Error(f.request, "error")
err.reply = controller.DummyReply()
fm.handle_error(err)
def tserver_conn():
"""
@return: libmproxy.proxy.connection.ServerConnection
"""
c = ServerConnection.from_state(
dict(address=dict(address=("address", 22), use_ipv6=True),
source_address=dict(address=("address", 22), use_ipv6=True),
cert=None,
timestamp_start=1,
timestamp_tcp_setup=2,
timestamp_ssl_setup=3,
timestamp_end=4,
ssl_established=False,
sni="address",
via=None))
c.reply = controller.DummyReply()
return c
def test_all(self):
s = flow.State()
fm = flow.FlowMaster(None, s)
fm.anticache = True
fm.anticomp = True
f = tutils.tflow(req=None)
fm.handle_clientconnect(f.client_conn)
f.request = tutils.treq()
fm.handle_request(f)
assert s.flow_count() == 1
f.response = tutils.tresp()
fm.handle_response(f)
assert not fm.handle_response(None)
assert s.flow_count() == 1
fm.handle_clientdisconnect(f.client_conn)
f.error = Error("msg")
f.error.reply = controller.DummyReply()
fm.handle_error(f)
fm.load_script(tutils.test_data.path("scripts/a.py"))
fm.shutdown()
def tflow_err():
r = treq()
f = flow.Flow(r)
f.error = flow.Error(r, "error")
f.error.reply = controller.DummyReply()
return f
def tclient_conn():
c = ClientConnection._from_state(
dict(address=dict(address=("address", 22), use_ipv6=True),
clientcert=None))
c.reply = controller.DummyReply()
return c
def terr(req=None):
if not req:
req = treq()
err = flow.Error(req, "error")
err.reply = controller.DummyReply()
return err
