def create_chains(self):
self.ch_enabled = chains.base(uri='/page.html')
self.ch_enabled.server_response = chains.make_response(404,
expected=False)
self.ch_enabled.response = chains.make_response(404)
self.ch_disabled = chains.base()
# Make 200 status expected once for transition purpose.
self.trans_resp = self.ch_disabled.response
self.ch_disabled.response = chains.make_502_expected()
def generate_chain_204(method='GET'):
base = chains.base(method=method)
base.response.status = "204" # it's default, but for explicity
base.response.body = ""
base.server_response.status = "204"
base.server_response.body = ""
return base
def make_chains(self, empty=True):
chain = None
if empty:
chain = deproxy.MessageChain.empty()
else:
chain = chains.base()
return [chain for _ in range(self.requests_n)]
def generate_chain(method='GET', expect_400=False):
base = chains.base(method=method)
chain = tester.BadLengthMessageChain(request=base.request,
expected_responses=[base.response],
forwarded_request=base.fwd_request,
server_response=base.server_response)
if expect_400:
chain.responses.append(chains.response_400(connection='close'))
return chain
def __init__(self, uri='/', max_deadtime=1, timeout=20):
self.uri = uri
self.timeout = timeout
self.max_deadtime = max_deadtime
self.stop_procedures = [self.__stop]
self.client = deproxy.Client()
self.client.set_tester(self)
self.message_chains = [chains.base()]
self.finish_event = multiprocessing.Event()
def create_chains(self):
chain_200 = chains.base(forward=True)
chain_200.request.body = ''.join(
['Arbitrary data ' for _ in range(300)])
chain_200.request.update()
chain_400 = deproxy.MessageChain(
request=deproxy.Request(), expected_response=chains.response_400())
return [chain_200, chain_400]
def __init__(self, *args, **kwargs):
deproxy.Deproxy.__init__(self, *args, **kwargs)
base = chains.base(method='PUT')
base.request.headers['Content-Length'] = 'invalid'
base.request.build_message()
base.response = chains.response_400(connection='close')
base.fwd_request = None
self.message_chains = [base]
self.cookies = []
def generate_chain_200(method='GET', response_body=""):
base = chains.base(method=method)
base.response.status = "200"
base.response.body = response_body
base.response.headers['Content-Length'] = len(response_body)
base.server_response.status = "200"
base.server_response.body = response_body
base.server_response.headers['Content-Length'] = len(response_body)
base.response.update()
base.server_response.update()
return base
def make_chains(self, uri, extra_header=(None, None)):
chain = chains.base(uri=uri)
header, value = extra_header
if not header is None:
for req in [chain.request, chain.fwd_request]:
req.headers.delete_all(header)
req.headers.add(header, value)
req.update()
return [chain for _ in range(self.requests_n)]
def create_chains(self):
chain_200 = chains.base(forward=True)
# Append some garbge to message.
chain_200.request.msg += ''.join(['Arbitrary data ' for _ in range(300)])
# Body is not declared in the request, so the garbage will be treated
# as a new request. 400 response will be sent and client connection
# will be closed.
chain_400 = deproxy.MessageChain(
request = deproxy.Request(),
expected_response = chains.response_400())
return [chain_200, chain_400]
def init_chain(self, params):
uri, header, value, block = params
ch = chains.base(uri=uri)
if block and self.match_rules_test:
ch.request.headers.delete_all(header)
ch.request.headers.add(header, value)
ch.request.update()
ch.fwd_request = None
else:
for request in [ch.request, ch.fwd_request]:
request.headers.delete_all(header)
request.headers.add(header, value)
request.update()
self.chains.append(ch)
def __init__(self, *args, **kwargs):
deproxy.Deproxy.__init__(self, *args, **kwargs)
base = chains.base(method='PUT')
cl = base.request.headers['Content-Length']
base.request.headers.add('Content-Length', cl)
base.request.build_message()
base.fwd_request = deproxy.Request()
base.response = chains.response_400(connection='keep-alive')
self.message_chains = [base]
self.cookies = []
def __init__(self, *args, **kwargs):
deproxy.Deproxy.__init__(self, *args, **kwargs)
base = chains.base(method='PUT')
cl = base.request.headers['Content-Length']
duplicate = self.second_length(cl)
base.request.headers.add('Content-Length', duplicate)
base.request.build_message()
base.response = self.expected_response()
base.fwd_request = None
self.message_chains = [base]
self.cookies = []
def process(self, client, server, chain):
client.make_request(chain.request.msg)
client.wait_for_response()
if chain.fwd_request:
chain.fwd_request.set_expected()
self.assertEqual(server.last_request, chain.fwd_request)
# Check if the connection alive (general case) or
# not (case of 'block' rule matching) after the main
# message processing. Response 404 is enough here.
post_chain = chains.base()
client.make_request(post_chain.request.msg)
if chain.fwd_request:
self.assertTrue(client.wait_for_response())
else:
self.assertFalse(client.wait_for_response())
def chains(self):
uris = [ "/resource-%d" % (i % self.uri_n)
for i in range(self.messages)]
msg_chains = [chains.base(uri=uris[i]) for i in range(self.messages)]
return msg_chains
def sample_rule():
return chains.base()
def __init__(self, *args, **kwargs):
deproxy.Deproxy.__init__(self, *args, **kwargs)
# The first message chain is unique.
self.message_chains = [chains.base()
] + chains.base_repeated(CHAIN_LENGTH)
self.cookie_parsed = False
def chains(self):
chain = chains.base()
return [chain for _ in range(self.messages)]
def create_chains(self):
return [chains.base(forward=True)]
