def __init__(self, *args, **kwargs):
self.tp = ThreadPool(maxthreads=20)
self.tp.start()
self.resource = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
self.nameSpace = TestNameSpace()
self.nameSpace.async_thing_complete = Queue()
return super(NoGoStatusCodes, self).__init__(*args, **kwargs)
class NoGoStatusCodes(TestCase):
def __init__(self, *args, **kwargs):
self.tp = ThreadPool(maxthreads=20)
self.tp.start()
self.resource = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
self.nameSpace = TestNameSpace()
self.nameSpace.async_thing_complete = Queue()
return super(NoGoStatusCodes, self).__init__(*args, **kwargs)
def setUp(self, *args, **kwargs):
self.addCleanup(self.tp.stop)
super(NoGoStatusCodes, self).setUp(*args, **kwargs)
def wsgi_thing(self, environ, start_response):
start_response('404 NOT FOUND', [('Content-type', 'text/plain')])
@crosstown_traffic(no_go_status_codes=self.no_go_status_codes,
same_thread=True)
def long_thing_on_same_thread():
self.nameSpace.async_task_was_run = True
log.debug("No bad status codes; went ahead with async thing.")
return [b"Nothing."]
def test_bad_status_codes_cause_no_go_in_wsgi_response(self):
self.no_go_status_codes = [404, '6xx']
request = DummyRequest([b'r1'])
request.isSecure = lambda: False
request.content = "llamas"
request.client = IPv4Address("TCP", b"50.0.50.0", 5000)
finished = request.notifyFinish()
self.resource.render(request)
# This must wait until the WSGI response is closed.
finished.addCallback(
lambda _: self.assertFalse(self.nameSpace.async_task_was_run))
return finished
def test_bad_status_codes_cause_no_go_flag(self):
through_to_you = crosstown_traffic(no_go_status_codes=[418])
through_to_you.status_code = 418
through_to_you.check_status_code_against_no_go_list()
self.assertTrue(through_to_you.no_go)
def test_no_bad_status_codes_are_cool(self):
through_to_you = crosstown_traffic(no_go_status_codes=[418])
through_to_you.status_code = 404
through_to_you.check_status_code_against_no_go_list()
self.assertFalse(through_to_you.no_go)
def request_same_or_different_thread_thread(self):
hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
request1 = DummyRequest('r1')
request1.isSecure = lambda: False
request1.content = "llamas"
d = deferToThreadPool(reactor, self.tp, hr.render, request1)
return d
def request_same_or_different_thread_thread(self):
hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
request1 = DummyRequest([b'r1'])
request1.isSecure = lambda: False
request1.content = b"llamas"
request1.client = IPv4Address("TCP", b"50.0.50.0", 5000)
d = deferToThreadPool(reactor, self.tp, hr.render, request1)
d.addCallback(lambda _: request1.notifyFinish())
return d
def test_contemporaneous_requests(self):
'''
We're going to create two request-response cycles here:
Cycle 1 will begin.
Cycle 2 will begin.
Cycle 2 will return.
Cycle 1 will return.
This way, we can prove that the crosstown_traffic created
by cycle 1 is not resolved by the return of cycle 2.
'''
tp = ThreadPool(maxthreads=20)
tp.start()
self.addCleanup(tp.stop)
log.debug("\n\nStarting the two stream stuff.")
request1 = DummyRequest([b'r1'])
request1.isSecure = lambda: False
request1.content = "Nothing really here."
request1.requestHeaders.addRawHeader('llamas', 'dingo')
request1.client = IPv4Address("TCP", b"50.0.50.0", 5000)
nameSpace.test_case = self
hr = HendrixWSGIResource(reactor, tp, wsgi_application)
d1 = deferToThreadPool(reactor, tp, hr.render, request1)
request2 = DummyRequest([b'r2'])
request2.isSecure = lambda: False
request2.content = b"Nothing really here."
request2.requestHeaders.addRawHeader('llamas', 'dingo')
request2.client = IPv4Address("TCP", b"100.0.50.0", 5000)
d2 = deferToThreadPool(reactor, tp, hr.render, request2)
def woah_stop(failure):
nameSpace.async_task_was_done.put_nowait(False)
nameSpace.second_cycle_complete.put_nowait(False)
nameSpace.ready_to_proceed_with_second_cycle.put_nowait(False)
d1.addErrback(woah_stop)
d2.addErrback(woah_stop)
combo_deferred = gatherResults([d1, d2])
def wait_for_queue_resolution():
nameSpace.async_task_was_done.get(True, 3)
combo_deferred.addCallback(lambda _: deferToThreadPool(
reactor, tp, wait_for_queue_resolution))
combo_deferred.addCallback(
lambda _: self.assertTrue(nameSpace.async_task_was_run))
return combo_deferred
def __init__(self, *args, **kwargs):
self.tp = ThreadPool(maxthreads=20)
self.tp.start()
self.resource = HendrixWSGIResource(reactor,
self.tp,
self.wsgi_thing)
self.nameSpace = TestNameSpace()
self.nameSpace.async_thing_complete = Queue()
return super(NoGoStatusCodes, self).__init__(*args, **kwargs)
class NoGoStatusCodes(TestCase):
def __init__(self, *args, **kwargs):
self.tp = ThreadPool(maxthreads=20)
self.tp.start()
self.resource = HendrixWSGIResource(reactor,
self.tp,
self.wsgi_thing)
self.nameSpace = TestNameSpace()
self.nameSpace.async_thing_complete = Queue()
return super(NoGoStatusCodes, self).__init__(*args, **kwargs)
def setUp(self, *args, **kwargs):
self.addCleanup(self.tp.stop)
super(NoGoStatusCodes, self).setUp(*args, **kwargs)
def wsgi_thing(self, environ, start_response):
start_response('404 NOT FOUND', [('Content-type', 'text/plain')])
@crosstown_traffic(
no_go_status_codes=self.no_go_status_codes,
same_thread=True
)
def long_thing_on_same_thread():
self.nameSpace.async_task_was_run = True
log.debug("No bad status codes; went ahead with async thing.")
return [b"Nothing."]
def test_bad_status_codes_cause_no_go_in_wsgi_response(self):
self.no_go_status_codes = [404, '6xx']
request = DummyRequest([b'r1'])
request.isSecure = lambda: False
request.content = "llamas"
request.client = IPv4Address("TCP", b"50.0.50.0", 5000)
finished = request.notifyFinish()
self.resource.render(request)
# This must wait until the WSGI response is closed.
finished.addCallback(
lambda _: self.assertFalse(
self.nameSpace.async_task_was_run
)
)
return finished
def test_bad_status_codes_cause_no_go_flag(self):
through_to_you = crosstown_traffic(
no_go_status_codes=[418]
)
through_to_you.status_code = 418
through_to_you.check_status_code_against_no_go_list()
self.assertTrue(through_to_you.no_go)
def test_no_bad_status_codes_are_cool(self):
through_to_you = crosstown_traffic(
no_go_status_codes=[418]
)
through_to_you.status_code = 404
through_to_you.check_status_code_against_no_go_list()
self.assertFalse(through_to_you.no_go)
