def _huntLeaks(self, test):
self.stream.flush()
repcount = self.repetitions
nwarmup = self.warmup
rc_deltas = [0] * (repcount - nwarmup)
alloc_deltas = [0] * (repcount - nwarmup)
# Preallocate ints likely to be stored in rc_deltas and alloc_deltas,
# to make sys.getallocatedblocks() less flaky.
_int_pool = IntPool()
for i in range(-200, 200):
_int_pool[i]
alloc_before = rc_before = 0
for i in range(repcount):
# Use a pristine, silent result object to avoid recursion
res = result.TestResult()
test.run(res)
# Poorly-written tests may fail when run several times.
# In this case, abort the refleak run and report the failure.
if not res.wasSuccessful():
self.failures.extend(res.failures)
self.errors.extend(res.errors)
raise AssertionError
del res
alloc_after, rc_after = _refleak_cleanup()
if i >= nwarmup:
rc_deltas[i - nwarmup] = _int_pool[rc_after - rc_before]
alloc_deltas[i - nwarmup] = _int_pool[alloc_after -
alloc_before]
alloc_before, rc_before = alloc_after, rc_after
return rc_deltas, alloc_deltas
def generateAmpPages():
if not os.path.exists('amp/generated'):
os.makedirs('amp/generated/')
test = TestEvent()
test.testbed = testbed.Testbed()
test.testbed.activate()
r = result.TestResult()
test.run(r)
if r.errors or r.failures:
logging.error('Error generating amp files:')
for test, error in r.errors:
logging.error('%s: %s', test, error)
for test, fail in r.failures:
logging.error('%s: %s', test, fail)
raise Exception('Errors generating amp files!')
def test_request(self):
"""Run this request if it has not yet run.
If there is a prior test in the sequence, run it first.
"""
if self.has_run:
return
if self.test_data['skip']:
self.skipTest(self.test_data['skip'])
if self.prior and not self.prior.has_run:
# Use a different result so we don't count this test
# in the results.
self.prior.run(result.TestResult())
self._run_test()
def run_testcase(self, request, *args, **kwargs):
instance = self.get_object()
response = {}
try:
result = MyTestSuite(NeoRunner(),
instance)(testresult.TestResult())
print(result)
if result.errors:
response.update(
{'errors': data.errors[-1][-1].split('\n')[-2]})
if result.failures:
response.update(
{'failures': data.failures[-1][-1].split('\n')[-2]})
# name = data.get('name', None)
# api = data.get('api', None)
# request_header = data.get('request_header', None)
# request_body = data.get('request_body', None)
# response_header = data.get('response_header', None)
# response_body = data.get('response_body', None)
# elapsed_time = data.get('elapsed_time', None)
# content_length = data.get('content_length', None)
# result = data.get('result', None)
#
# response = {'name': name, 'api': api, 'request_header': request_header, 'request_body': request_body,
# 'response_header': response_header, 'response_body': response_body,
# 'elapsed_time': elapsed_time,
# 'content_length': content_length, 'result': result}
return Response(response, status=status.HTTP_201_CREATED)
except HttpMethodError:
self.errors = sysvalidate(self, Err_Http_02)
return Response(self.errors,
status=status.HTTP_405_METHOD_NOT_ALLOWED)
except RequestException:
self.errors = sysvalidate(self, Err_Http_01)
return Response(self.errors, status=status.HTTP_400_BAD_REQUEST)
except ValidationError as e:
self.errors = sysvalidate(self, str(e))
return Response(self.errors, status=status.HTTP_400_BAD_REQUEST)
def defaultTestResult(self):
return result.TestResult()
def __init__(self, methodName='runTest'):
self.retry_count = 2
self._result = result.TestResult()
super(RetryTestCase, self).__init__(methodName)
