def _location_field(self, *args, **kwargs): name = kwargs.get('name') if name is LOCATION_TYPE_FIELD_NAME: location_field = Mock(spec=HierarchyField) location_field.code = 'l' return location_field geo_code_field = Mock(spec=GeoCodeField) geo_code_field.code = 'g' return geo_code_field
def test_handle_produce_response_on_nonretriable(self, fake_decode, fake_retry): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) m2 = Message('test_driver', {'val': 2}, None, None, 0, 1) response = Mock() response.code = 500 response.error = False response.request = Mock() response.request._batch = [m1, m2] response.request._id = 1 body = { 'offsets': [{}, {}], 'value_schema_id': 1, 'key_schema_id': 2, 'error_code': 50101, 'message': 'Nonretriable' } fake_decode.return_value = body self.producer._handle_produce_response('test_driver', response) calls = [ call('test_driver', m1, 'nonretriable'), call('test_driver', m2, 'nonretriable') ] self.client.mock_for('drop_message').assert_has_calls(calls)
def test_post_with_bad_data(service_client, get_repositories, get_repository): get_repositories.return_value = future_repositories get_repository.return_value = future_repository mock_response = Mock() mock_response.body = '{"errors": [{"source_id_type": "", "message": "not supported asset id type"}]}' mock_response.code = 400 exc = httpclient.HTTPError(400, response=mock_response) service_client.return_value = make_future(MagicMock()) client = yield service_client() endpoint = client.repository.repositories[''].search.offers endpoint.post.side_effect = exc handler = _create_offers_handler() # MUT handler.request.body = ('[{"source_id":' + '"https://openpermissions.org/s0/hub1/asset/exampleco/ExampleCoPictureID/1",' + '"source_id_type":""}]') with pytest.raises(HTTPError) as excinfo: handler.post().result() assert excinfo.value.status_code == mock_response.code assert excinfo.value.errors == json.loads(mock_response.body)
def test_rpc_request_404(self): response = Mock() response.code = 404 response.phrase = "Not found." response.body = escape.json_encode({"result": True}) cyclone.httpclient.fetch.return_value = succeed(response) return self.assertFailure(self.client.foo(), HTTPError)
def test_handle_error_signal(self): if not signals_available: # This test requires the blinker lib to run. print("Can't test signals without signal support") return app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = 400 exception.data = {'foo': 'bar'} recorded = [] def record(sender, exception): recorded.append(exception) got_request_exception.connect(record, app) try: with app.test_request_context("/foo"): api.handle_error(exception) self.assertEquals(len(recorded), 1) self.assertTrue(exception is recorded[0]) finally: got_request_exception.disconnect(record, app)
def test_should_return_expected_success_response_for_registration(self): self.form_submission_mock.is_registration = True response = Response([{NAME_FIELD: "Mr. X"}], None, self.form_submission_mock.saved, self.form_submission_mock.errors, self.form_submission_mock.data_record_id, self.form_submission_mock.short_code, self.form_submission_mock.cleaned_data, self.form_submission_mock.is_registration, ['clinic'], self.form_submission_mock.form_model.form_code) dbm_mock = Mock() form_model_mock = Mock(spec=EntityFormModel) form_model_mock.stringify.return_value = {'name': 'Clinic X', 'q2':'cli001'} short_code_field = Mock() short_code_field.code = 'q2' form_model_mock.entity_questions = [short_code_field] form_model_mock.get_entity_name_question_code.return_value = 'name' form_model_mock.entity_type = ["clinic"] with patch("datawinners.messageprovider.message_handler.get_form_model_by_code") as get_form_model_mock: with patch("datawinners.messageprovider.customized_message.account_wide_customized_message_details") as account_message: get_form_model_mock.return_value = form_model_mock account_message.return_value = [{"code":"reply_success_identification_number_registration", "message":"Thanks {Name of Data Sender}.registered {Identification Number Type} " "{Name of Identification Number} {Submitted Identification Number}", "title": "Succesful register"}] response_text = SMSResponse(response, None).text(dbm_mock) self.assertEqual("Thanks Mr..registered clinic Clinic X cli001", response_text)
def test_handle_smart_errors(self): app = Flask(__name__) api = flask_restful.Api(app) view = flask_restful.Resource exception = Mock() exception.code = 404 exception.data = {"status": 404, "message": "Not Found"} api.add_resource(view, '/foo', endpoint='bor') api.add_resource(view, '/fee', endpoint='bir') api.add_resource(view, '/fii', endpoint='ber') with app.test_request_context("/faaaaa"): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 404) self.assertEquals(resp.data, dumps({ "status": 404, "message": "Not Found", })) with app.test_request_context("/fOo"): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 404) self.assertEquals(resp.data, dumps({ "status": 404, "message": "Not Found. You have requested this URI [/fOo] but did you mean /foo ?", })) with app.test_request_context("/fOo"): del exception.data["message"] resp = api.handle_error(exception) self.assertEquals(resp.status_code, 404) self.assertEquals(resp.data, dumps({ "status": 404, "message": "You have requested this URI [/fOo] but did you mean /foo ?", }))
def test_rpc_request(self): response = Mock() response.code = 200 response.body = escape.json_encode({"result": True}) cyclone.httpclient.fetch.return_value = succeed(response) result = yield self.client.foo() self.assertTrue(result)
def test_onionoo_success(self): agent = Mock() resp = Mock() resp.code = 200 def feed_response(protocol): config = { "relays": [ { "fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702", }, ] } protocol.dataReceived(json.dumps(config).encode()) protocol.connectionLost(Failure(ResponseDone())) resp.deliverBody = Mock(side_effect=feed_response) agent.request = Mock(return_value=defer.succeed(resp)) data = yield self.router.get_onionoo_details(agent) self.assertTrue('fingerprint' in data) self.assertTrue( data['fingerprint'] == "00786E43CCC5409753F25E36031C5CEA6EA43702")
def test_login_success(self, _mock): mock_response = Mock() mock_response.return_value = Future() mock_response.code = 302 mock_response.headers.get_list.side_effect = lambda key: \ { 'Location': ['/Main/Index/d9359cb0-f9a7-42c4-89d6-c2c05f5875dc'], 'Set-Cookie': ['ASP.NET_SessionId=fwtqedargnx2ogfru0tsj544'], }.get(key) future = Future() future.set_result(mock_response) _mock.return_value = future data = self._post({ 'username': '******', 'password': '******' }) self.assert_response_success(data) user = data.get('user') self.assertTrue(user) self.assertIsNotNone(user['name']) self.assertEqual(user['username'], '20140000')
def test_post_with_bad_data(service_client, get_repositories, get_repository): get_repositories.return_value = future_repositories get_repository.return_value = future_repository mock_response = Mock() mock_response.body = '{"errors": [{"source_id_type": "", "message": "not supported asset id type"}]}' mock_response.code = 400 exc = httpclient.HTTPError(400, response=mock_response) service_client.return_value = make_future(MagicMock()) client = yield service_client() endpoint = client.repository.repositories[''].search.offers endpoint.post.side_effect = exc handler = _create_offers_handler() # MUT handler.request.body = ( '[{"source_id":' + '"https://openpermissions.org/s0/hub1/asset/exampleco/ExampleCoPictureID/1",' + '"source_id_type":""}]') with pytest.raises(HTTPError) as excinfo: handler.post().result() assert excinfo.value.status_code == mock_response.code assert excinfo.value.errors == json.loads(mock_response.body)
def test_onionoo_too_many_answers(self): agent = Mock() resp = Mock() resp.code = 200 def feed_response(protocol): config = { "relays": [ { "fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702", }, { "fingerprint": "boom", } ] } protocol.dataReceived(json.dumps(config).encode()) protocol.connectionLost(Failure(ResponseDone())) resp.deliverBody = Mock(side_effect=feed_response) agent.request = Mock(return_value=defer.succeed(resp)) with self.assertRaises(Exception) as ctx: yield self.router.get_onionoo_details(agent) self.assertTrue( "multiple relays for" in str(ctx.exception) )
def dummy_balance_code(): m = Mock() m.pk = random.randint(1, 999) m.value = 100 m.code = generate_balance_code() m.refill_series.pk = random.randint(1, 99) m.refill_series.least_valid_until = date.today() return m
def setUp(self): loc_tree = Mock() loc_tree.get_hierarchy_path.return_value = ['hierarchy'] dbm = Mock(spec=DatabaseManager) form_model = Mock(spec=FormModel) location_field = Mock(spec=HierarchyField) form_model.get_field_by_name.return_value= location_field location_field.code='l' self.registration_workflow = RegistrationWorkFlow(dbm, form_model, loc_tree)
def test_onionoo_get_fails(self): agent = Mock() resp = Mock() resp.code = 500 agent.request = Mock(return_value=defer.succeed(resp)) with self.assertRaises(Exception) as ctx: yield self.router.get_onionoo_details(agent) self.assertTrue("Failed to lookup" in str(ctx.exception))
def test_call(self, treq_mock): """A call to a Mandrill API endpoint will return a deferred.""" response_mock = Mock() response_mock.json.return_value = {'some': 'response'} response_mock.code = 200 treq_mock.post.return_value = succeed(response_mock) m = TXMandrill('nah') result = yield m.users.info() self.assertEquals(result, {'some': 'response'})
def test_generate_key_module(self): """ Test that a key is generated for module functions """ def test_func(): pass stat = Mock() stat.code = test_func.__code__ expected_key = "%s.%s" % (self.__module__, stat.code.co_name) key = linesman._generate_key(stat) assert_equals(key, expected_key)
def test_generate_key_unknown(self): """ Test that unknown module functions return as strings """ def test_func(): pass stat = Mock() stat.code = test_func.__code__ expected_key = "%s.%s" % (stat.code.co_filename, stat.code.co_name) key = linesman._generate_key(stat) assert_equals(key, expected_key)
def test_299_code(self, mock_urlopen): result = Mock() result.code = 299 result.getheaders.return_value = [(u'Content-Type', u'text/plain')] result.read.side_effect = ['response'] mock_urlopen.return_value = result requester = Requester('test', 'Test/0.1') res = requester.request('https://test.test', {}) self.assertEqual(res, 'response')
def test_fetch_redirect_empty(self): client = HTTPClient("http://example.com") client.agent = Mock() client.followRedirect = True client.maxRedirects = 1 _response1 = Mock() _response1.code = 302 _response1.headers.getAllRawHeaders.return_value = {} _response1.deliverBody = lambda x: x.connectionLost(None) _response2 = Mock() _response2.code = 200 _response2.headers.getAllRawHeaders.return_value = {} _response2.deliverBody = lambda x: x.connectionLost(None) client.agent.request.side_effect = [ succeed(_response1), succeed(_response2) ] response = yield client.fetch() self.assertEqual(response.body, "")
def test_failure(self, treq_mock): """An error HTTP response will raise an exception.""" response_mock = Mock() response_mock.json.return_value = { 'name': 'ValidationError', 'status': 'error', 'message': 'Validation failed.'} response_mock.code = 404 treq_mock.post.return_value = succeed(response_mock) m = TXMandrill('nah') yield self.assertFailure(m.users.info(), ValidationError)
def test_300_code(self, mock_urlopen): result = Mock() result.code = 300 result.getheaders.return_value = [(u'Content-Type', u'text/plain')] result.read.side_effect = ['response'] mock_urlopen.return_value = result requester = Requester('test', 'Test/0.1') with self.assertRaises(ServerErrorException): res = requester.request('https://test.test', {}) pass
def test_connect_while_connected(self, mock_endpoint): "should pass http request body to TwitterStreamingProtocol" mock_http_response = Mock() mock_http_response.code = 200 mock_http_response.deliverBody = Mock() self._connect(mock_endpoint, mock_http_response) self.assertEquals(CONNECTED, self.stream.state) with self.assertRaises(ValueError): self.stream.track(TestReceiver(), ['track'])
def test_onionoo_get_fails(self): agent = Mock() resp = Mock() resp.code = 500 agent.request = Mock(return_value=defer.succeed(resp)) with self.assertRaises(Exception) as ctx: yield self.router.get_onionoo_details(agent) self.assertTrue( "Failed to lookup" in str(ctx.exception) )
def setup_urlopen(self, urlread_side_effect): """setup urlopen return value. :param urlread_side_effect: a LIST of strings or exceptions returned by urlopen.read, that will be converted to an itertools.cycle(side_effect) REMEMBER that any element of urlread_side_effect which is a nonempty string must be followed by an EMPTY STRINGS TO STOP reading otherwise we fall into an infinite loop if the argument blocksize of url read is not negative !""" self.mock_urlopen.reset_mock() # convert returned values to the given urlread return value (tuple data, code, msg) # if k is an int, convert to an HTTPError retvals = [] # Check if we have an iterable (where strings are considered not iterables): if not hasattr(urlread_side_effect, "__iter__") or \ isinstance(urlread_side_effect, (bytes, str)): # it's not an iterable (wheere str/bytes/unicode are considered NOT iterable # in both py2 and 3) urlread_side_effect = [urlread_side_effect] for k in urlread_side_effect: a = Mock() if type(k) == int: a.read.side_effect = HTTPError('url', int(k), responses[k], None, None) elif type(k) in (bytes, str): def func(k): b = BytesIO(k.encode('utf8') if type(k) == str else k) # py2to3 compatible def rse(*a, **v): rewind = not a and not v if not rewind: currpos = b.tell() ret = b.read(*a, **v) # hacky workaround to support cycle below: if reached the end, # go back to start if not rewind: cp = b.tell() rewind = cp == currpos if rewind: b.seek(0, 0) return ret return rse a.read.side_effect = func(k) a.code = 200 a.msg = responses[a.code] else: a.read.side_effect = k retvals.append(a) self.mock_urlopen.side_effect = cycle(retvals)
def test_handle_error_401_no_challenge_by_default(self): app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = 401 exception.data = {'foo': 'bar'} with app.test_request_context('/foo'): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 401) assert_false('WWW-Autheneticate' in resp.headers)
def test_handle_error_401_sends_challege_default_realm(self): app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = 401 exception.data = {'foo': 'bar'} with app.test_request_context('/foo'): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 401) self.assertEquals(resp.headers['WWW-Authenticate'], 'Basic realm="flask-restful"')
def setUp(self): self.vumi_helper = yield self.add_helper(VumiApiHelper()) response = Mock() response.code = http.OK response.delivered_body = 'javascript!' self.mocked_url_call = Mock( side_effect=[succeed(response), succeed(response)]) self.patch(ConversationConfigResource, 'load_source_from_url', self.mocked_url_call) self.config = self.vumi_helper.mk_config({ 'worker_name': 'conversation_api_worker', 'web_path': '/foo/', 'web_port': 0, 'health_path': '/health/', }) self.worker = yield self.vumi_helper.get_worker_helper().get_worker( ConversationApiWorker, self.config) self.addr = self.worker.webserver.getHost() self.url = 'http://%s:%s%s' % (self.addr.host, self.addr.port, self.config['web_path']) self.user_helper = yield self.vumi_helper.make_user(u'user') yield self.vumi_helper.setup_tagpool(u"pool", [u"tag1", u"tag2"]) yield self.user_helper.add_tagpool_permission(u"pool") self.conversation = yield self.user_helper.create_conversation( u'jsbox', config={ 'jsbox_app_config': { 'config': { 'source_url': 'http://configsourcecode/' }, }, 'jsbox': { 'source_url': 'http://sourcecode/', }, 'http_api': { 'api_tokens': ['token-1', 'token-2', 'token-3'], 'metrics_store': 'metrics_store' }, }) self.auth_headers = { 'Authorization': [ 'Basic ' + base64.b64encode('%s:%s' % (self.user_helper.account_key, 'token-1')) ], }
def test_500_code(self, mock_urlopen): result = Mock() result.code = 500 result.getheaders.return_value = [(u'Content-Type', u'text/plain')] result.read.side_effect = ['error'] mock_urlopen.return_value = result mock_urlopen.side_effect = HTTPError("https://test.test", 500, 'Internal Server Error', None, None) requester = Requester('test', 'Test/0.1') with self.assertRaises(ServerErrorException): res = requester.request('https://test.test', {}) pass
def test_handle_error_with_code(self): app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = "JSONResponseError" exception.data = {'foo': 'bar'} with app.test_request_context("/foo"): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 500) self.assertEquals(resp.data.decode(), dumps({"status": 500, "message": "Internal Server Error"}))
def _create_mocked_response(self, code=200, notification='Received', subscription='Active', device='Connected'): response = Mock() response.code = code response.MOCKED_HEADERS = { 'X-NotificationStatus': [notification], 'X-SubscriptionStatus': [subscription], 'X-DeviceConnectionStatus': [device] } response.headers.getRawHeaders = Mock( side_effect=lambda name: response.MOCKED_HEADERS.get(name)) return response
def test_successful_connection(self, mock_endpoint): "should pass http request body to TwitterStreamingProtocol" mock_http_response = Mock() mock_http_response.code = 200 mock_http_response.deliverBody = Mock() d = self._connect(mock_endpoint, mock_http_response) self.assertEquals(CONNECTED, self.stream.state) self.assertTrue(mock_http_response.deliverBody.called) self.assertTrue(d.called)
def test_failure(self, treq_mock): """An error HTTP response will raise an exception.""" response_mock = Mock() response_mock.json.return_value = { 'name': 'ValidationError', 'status': 'error', 'message': 'Validation failed.' } response_mock.code = 404 treq_mock.post.return_value = succeed(response_mock) m = TXMandrill('nah') yield self.assertFailure(m.users.info(), ValidationError)
def test_403_code(self, mock_urlopen): result = Mock() result.code = 403 result.getheaders.return_value = [(u'Content-Type', u'text/plain')] result.read.side_effect = ['error'] mock_urlopen.return_value = result mock_urlopen.side_effect = HTTPError("https://test.test", 403, 'Access Denied', None, None) requester = Requester('test', 'Test/0.1') with self.assertRaises(AccessDeniedException): res = requester.request('https://test.test', {}) pass
def test_422_code(self, mock_urlopen): result = Mock() result.code = 422 result.getheaders.return_value = [(u'Content-Type', u'text/plain')] result.read.side_effect = ['error'] mock_urlopen.return_value = result mock_urlopen.side_effect = HTTPError("https://test.test", 422, 'Unprocessable Entity', None, None) requester = Requester('test', 'Test/0.1') with self.assertRaises(InvalidMacOrOuiException): res = requester.request('https://test.test', {}) pass
def test_handle_error_401_sends_challege_configured_realm(self): app = Flask(__name__) app.config['HTTP_BASIC_AUTH_REALM'] = 'test-realm' api = flask_restful.Api(app) exception = Mock() exception.code = 401 exception.data = {'foo': 'bar'} with app.test_request_context('/foo'): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 401) self.assertEquals(resp.headers['WWW-Authenticate'], 'Basic realm="test-realm"')
def test_handle_error(self): app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = 400 exception.data = {'foo': 'bar'} with app.test_request_context("/foo"): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 400) self.assertEquals(resp.data, dumps({ 'foo': 'bar', }))
def test_handle_auth(self): app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = 401 exception.data = {'foo': 'bar'} with app.test_request_context("/foo"): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 401) self.assertEquals(resp.data.decode(), dumps({'foo': 'bar'})) self.assertTrue('WWW-Authenticate' in resp.headers)
def test_raise_client_http_error(): error = Mock() error.code = 404 errors = { "status": 404, "errors": [ {"source": "authentication", "message": "Organisation not found"} ] } error.response.body = json.dumps(errors) with pytest.raises(HTTPError) as err: remote.raise_client_http_error(error) assert err.value.status_code == error.code assert err.value.errors == errors
def test_handle_error(self): app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = 400 exception.data = {'foo': 'bar'} with app.test_request_context("/foo"): resp = api.handle_error(exception) self.assertEquals(resp.status_code, 400) self.assertEquals(resp.data.decode(), dumps({ 'foo': 'bar', }))
def test_handle_produce_response_transport_error(self, fake_retry): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) m2 = Message('test_driver', {'val': 2}, None, None, 0, 1) response = Mock() response.code = 599 response.error = object() response.request = Mock() response.request._batch = [m1, m2] response.request._id = 1 self.producer._handle_produce_response('test_driver', response) self.client.mock_for('response_5xx').assert_called_once_with('test_driver', response) fake_retry.assert_has_calls([call('test_driver', m1), call('test_driver', m2)])
def setUp(self): self.vumi_helper = yield self.add_helper(VumiApiHelper()) response = Mock() response.code = http.OK response.delivered_body = 'javascript!' self.mocked_url_call = Mock( side_effect=[succeed(response), succeed(response)]) self.patch(ConversationConfigResource, 'load_source_from_url', self.mocked_url_call) self.config = self.vumi_helper.mk_config({ 'worker_name': 'conversation_api_worker', 'web_path': '/foo/', 'web_port': 0, 'health_path': '/health/', }) self.worker = yield self.vumi_helper.get_worker_helper().get_worker( ConversationApiWorker, self.config) self.addr = self.worker.webserver.getHost() self.url = 'http://%s:%s%s' % ( self.addr.host, self.addr.port, self.config['web_path']) self.user_helper = yield self.vumi_helper.make_user(u'user') yield self.vumi_helper.setup_tagpool(u"pool", [u"tag1", u"tag2"]) yield self.user_helper.add_tagpool_permission(u"pool") self.conversation = yield self.user_helper.create_conversation( u'jsbox', config={ 'jsbox_app_config': { 'config': {'source_url': 'http://configsourcecode/'}, }, 'jsbox': { 'source_url': 'http://sourcecode/', }, 'http_api': { 'api_tokens': ['token-1', 'token-2', 'token-3'], 'metrics_store': 'metrics_store' }, }) self.auth_headers = { 'Authorization': [ 'Basic ' + base64.b64encode( '%s:%s' % (self.user_helper.account_key, 'token-1')) ], }
def test_handle_http_response(): response = Mock(HTTPResponse) response.status = 200 response.code = 'OK' response.content_type = 'text/html' response.content_length = 1234 response.content = '<html><body>hi</body></html>' value = handle_http_response(response) content_array = [ 'HTTP/1.1 200 OK', 'Content-Type: text/html', 'Content-Length: 1234', 'Server: Ocean/0.1.1', '', '<html><body>hi</body></html>' ] assert value == '\n'.join(content_array)
def test_handle_produce_response_on_200(self, fake_decode, fake_handle_success): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) m2 = Message('test_driver', {'val': 2}, None, None, 0, 1) response = Mock() response.code = 200 response.error = False response.request = Mock() response.request._batch = [m1, m2] response.request._id = 1 body = {'offsets': [{}, {}], 'value_schema_id': 1, 'key_schema_id': 2} fake_decode.return_value = body self.producer._handle_produce_response('test_driver', response) fake_handle_success.assert_called_once_with('test_driver', response, body)
def test_route_to_busy_node_saves_looks_up_and_send_check_fails(self): import autopush.router.simple as simple response_mock = Mock() self.agent_mock.request.side_effect = MockAssist( [response_mock, self._raise_connect_error]) response_mock.code = 202 self.storage_mock.save_notification.return_value = True router_data = dict(node_id="http://somewhere", uaid=dummy_uaid) self.router_mock.get_uaid.return_value = router_data d = self.router.route_notification(self.notif, router_data) def verify_deliver(result): ok_(isinstance(result, RouterResponse)) eq_(result.status_code, 202) assert(self.router_mock.clear_node.called) nk = simple.node_key(router_data["node_id"]) eq_(simple.dead_cache.get(nk), True) d.addBoth(verify_deliver) return d
def test_handle_produce_response_on_retriable(self, fake_decode, fake_retry): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) m2 = Message('test_driver', {'val': 2}, None, None, 0, 1) response = Mock() response.code = 500 response.error = False response.request = Mock() response.request._batch = [m1, m2] response.request._id = 1 body = {'offsets': [{}, {}], 'value_schema_id': 1, 'key_schema_id': 2, 'error_code': 50001, 'message': 'Retriable'} fake_decode.return_value = body self.producer._handle_produce_response('test_driver', response) fake_retry.assert_has_calls([call('test_driver', m1), call('test_driver', m2)])
def test_onionoo_success(self): agent = Mock() resp = Mock() resp.code = 200 def feed_response(protocol): config = { "relays": [ { "fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702", }, ] } protocol.dataReceived(json.dumps(config).encode()) protocol.connectionLost(Failure(ResponseDone())) resp.deliverBody = Mock(side_effect=feed_response) agent.request = Mock(return_value=defer.succeed(resp)) data = yield self.router.get_onionoo_details(agent) self.assertTrue('fingerprint' in data) self.assertTrue(data['fingerprint'] == "00786E43CCC5409753F25E36031C5CEA6EA43702")