async def test_rotation_because_of_reaching_limit(self): self.http.rotate_at = 1000 # this id the default responses = [ (Request(method=b'get', url='https://api.github.com/repos/ursa-labs/ursabot', params=mock.ANY, headers=HasHeaders({'Authorization': ['token A']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': f'{i}'}, body=as_json({}))) for i in (1002, 1001, 1000) ] + [(Request(method=b'get', url='https://api.github.com/rate_limit', params=mock.ANY, headers=HasHeaders({'Authorization': ['token B']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '5000'}, body=as_json({'rate': { 'remaining': 5000 }}))), (Request(method=b'get', url='https://api.github.com/repos/ursa-labs/ursabot', params=mock.ANY, headers=HasHeaders({'Authorization': ['token B']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '4999'}, body=as_json({})))] with self.responses(responses): for _ in range(4): await self.http.get('/repos/ursa-labs/ursabot')
async def test_fetching_rate_limit(self): responses = [ (Request(method=b'get', url='https://api.github.com/rate_limit', params=mock.ANY, headers=HasHeaders({'Authorization': ['token A']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '5000'}, body=as_json({'rate': { 'remaining': 5000 }}))), (Request(method=b'get', url='https://api.github.com/rate_limit', params=mock.ANY, headers=HasHeaders({'Authorization': ['token B']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '4000'}, body=as_json({'rate': { 'remaining': 4000 }}))) ] with self.responses(responses): assert await self.http.rate_limit('A') == 5000 assert await self.http.rate_limit('B') == 4000
def test_mismatched_request_causes_failure(self): """ If a request is made that is not expected as the next request, causes a failure. """ sequence = RequestSequence( [(('get', 'https://anything/', {'1': ['2']}, HasHeaders({'1': ['1']}), 'what'), (418, {}, 'body')), (('get', 'http://anything', {}, HasHeaders({'2': ['1']}), 'what'), (202, {}, 'deleted'))], async_failure_reporter=self.async_failures.append) stub = StubTreq(StringStubbingResource(sequence)) get = partial(stub.get, 'https://anything?1=2', data='what', headers={'1': '1'}) resp = self.successResultOf(get()) self.assertEqual(418, resp.code) self.assertEqual('body', self.successResultOf(stub.content(resp))) self.assertEqual([], self.async_failures) resp = self.successResultOf(get()) self.assertEqual(500, resp.code) self.assertEqual(1, len(self.async_failures)) self.assertIn("Expected the next request to be", self.async_failures[0]) self.assertFalse(sequence.consumed())
def test_bytes_encoded_forms(self): """ The :obj:`HasHeaders` equality function compares the bytes-encoded forms of both sets of headers. """ self.assertEqual(HasHeaders({b'a': [b'a']}), {u'a': [u'a']}) self.assertEqual(HasHeaders({u'b': [u'b']}), {b'b': [b'b']})
async def test_rotation_becasue_of_forbidden_access(self): from treq.testing import HasHeaders self.http.rotate_at = 1000 # this id the default responses = [ (Request(method=b'get', url='https://api.github.com/repos/ursa-labs/ursabot', params=mock.ANY, headers=HasHeaders({'Authorization': ['token A']}), data=mock.ANY), Response(code=403, headers={'X-RateLimit-Remaining': '0'}, body=as_json({}))), (Request(method=b'get', url='https://api.github.com/rate_limit', params=mock.ANY, headers=HasHeaders({'Authorization': ['token B']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '900'}, body=as_json({'rate': { 'remaining': 900 }}))), (Request(method=b'get', url='https://api.github.com/rate_limit', params=mock.ANY, headers=HasHeaders({'Authorization': ['token C']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '5000'}, body=as_json({'rate': { 'remaining': 5000 }}))), (Request(method=b'get', url='https://api.github.com/repos/ursa-labs/ursabot', params=mock.ANY, headers=HasHeaders({'Authorization': ['token C']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '4999'}, body=as_json({}))), (Request(method=b'get', url='https://api.github.com/repos/ursa-labs/ursabot', params=mock.ANY, headers=HasHeaders({'Authorization': ['token C']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '4998'}, body=as_json({}))) ] with self.responses(responses): await self.http.get('/repos/ursa-labs/ursabot') await self.http.get('/repos/ursa-labs/ursabot')
def test_equality_and_strict_subsets_succeed(self): """ The :obj:`HasHeaders` returns True if both sets of headers are equivalent, or the first is a strict subset of the second. """ self.assertEqual(HasHeaders({'one': ['two', 'three']}), {'one': ['two', 'three']}, "Equivalent headers do not match.") self.assertEqual(HasHeaders({'one': ['two', 'three']}), {'one': ['two', 'three', 'four'], 'ten': ['six']}, "Strict subset headers do not match")
def test_partial_or_zero_intersection_subsets_fail(self): """ The :obj:`HasHeaders` returns False if both sets of headers overlap but the first is not a strict subset of the second. It also returns False if there is no overlap. """ self.assertNotEqual(HasHeaders({'one': ['two', 'three']}), {'one': ['three', 'four']}, "Partial value overlap matches") self.assertNotEqual(HasHeaders({'one': ['two', 'three']}), {'one': ['two']}, "Missing value matches") self.assertNotEqual(HasHeaders({'one': ['two', 'three']}), {'ten': ['six']}, "Complete inequality matches")
def test_case_insensitive_keys(self): """ The :obj:`HasHeaders` equality function ignores the case of the header keys. """ self.assertEqual(HasHeaders({'A': ['1'], 'b': ['2']}), {'a': ['1'], 'B': ['2']})
def setup_treq(self, code=200, body={}): self.async_failures = [] self.stubs = RequestSequence( [((b"get", "http://server:8989/index", {}, HasHeaders({"Bloc-Session-ID": ["sid"]}), b''), (code, {}, json.dumps(body).encode("utf-8")))], self.async_failures.append) self.client.treq = StubTreq(StringStubbingResource(self.stubs))
def test_repr(self): """ :obj:`HasHeaders` returns a nice string repr. """ self.assertEqual( "HasHeaders({b'a': [b'b']})", repr(HasHeaders({b"A": [b"b"]})), )
def test_repr(self): """ :obj:`HasHeaders` returns a nice string repr. """ if _PY3: reprOutput = "HasHeaders({b'a': [b'b']})" else: reprOutput = "HasHeaders({'a': ['b']})" self.assertEqual(reprOutput, repr(HasHeaders({b'A': [b'b']})))
def _requestSequenceGenerator(self, response, statusCode=http.OK): return RequestSequence( [((b'get', 'https://k8s.wmnet.test:1234/v1/nodes', { b'pretty': [b'false'] }, HasHeaders({ 'Accept': ['application/json'], 'Authorization': ['Bearer token'], }), b''), (statusCode, { b'Content-Type': b'application/json' }, response))], log.error)
def test_200_ok(self): """On a 200 response, return the response's JSON.""" req_seq = RequestSequence([ ((b'get', 'http://an.example/foo', {b'a': [b'b']}, HasHeaders({'Accept': ['application/json']}), b''), (http.OK, {b'Content-Type': b'application/json'}, b'{"status": "ok"}')) ], log.error) treq = StubTreq(StringStubbingResource(req_seq)) with req_seq.consume(self.fail): result = self.successResultOf(make_a_request(treq)) self.assertEqual({"status": "ok"}, result)
async def test_basic(self): responses = [ (Request(method=b'get', url='https://api.github.com/repos/ursa-labs/ursabot', params=mock.ANY, headers=HasHeaders({'Authorization': ['token A']}), data=mock.ANY), Response(code=200, headers={'X-RateLimit-Remaining': '5000'}, body=as_json({}))) ] with self.responses(responses): await self.http.get('/repos/ursa-labs/ursabot')
def test_418_teapot(self): """On an unexpected response code, raise an exception""" req_seq = RequestSequence([ ((b'get', 'http://an.example/foo', {b'a': [b'b']}, HasHeaders({'Accept': ['application/json']}), b''), (418, {b'Content-Type': b'text/plain'}, b"I'm a teapot!")) ], log.error) treq = StubTreq(StringStubbingResource(req_seq)) with req_seq.consume(self.fail): failure = self.failureResultOf(make_a_request(treq)) self.assertEqual(u"Got an error from the server: I'm a teapot!", failure.getErrorMessage())
def test_stopservice_deletes_session(self): """ :func:`stopService` will delete the session and will stop the loop """ self.test_settled() stubs = RequestSequence( [((b"delete", "http://server:8989/session", {}, HasHeaders({"Bloc-Session-ID": ["sid"]}), b''), (200, {}, b''))], self.fail) self.client.treq = StubTreq(StringStubbingResource(stubs)) with stubs.consume(self.fail): d = self.client.stopService() self.assertIsNone(self.successResultOf(d)) # Moving time would fail treq if it tried to heartbeat self.clock.advance(4)
def test_repr(self): """ :obj:`HasHeaders` returns a nice string repr. """ self.assertEqual("HasHeaders({'a': ['b']})", repr(HasHeaders({'A': ['b']})))
def test_case_sensitive_values(self): """ The :obj:`HasHeaders` equality function does care about the case of the header value. """ self.assertNotEqual(HasHeaders({'a': ['a']}), {'a': ['A']})
def get_response_for(_method, _url, _params, _headers, _data): self.assertEqual((method, url, params, data), (_method, _url, _params, _data)) self.assertEqual(HasHeaders(headers), _headers) return response