def setUp(self): self.cellulant_sms_calls = DeferredQueue() self.mock_cellulant_sms = MockHttpServer(self.handle_request) yield self.mock_cellulant_sms.start() self.add_cleanup(self.mock_cellulant_sms.stop) self.config = { 'web_path': "foo", 'web_port': 0, 'credentials': { '2371234567': { 'username': '******', 'password': '******', }, '9292': { 'username': '******', 'password': '******', } }, 'outbound_url': self.mock_cellulant_sms.url, 'validation_mode': 'permissive', } self.tx_helper = self.add_helper( TransportHelper(CellulantSmsTransport)) self.transport = yield self.tx_helper.get_transport(self.config) self.transport_url = self.transport.get_transport_url()
def setUp(self): self.app_helper = self.add_helper( AppWorkerHelper(NoStreamingHTTPWorker)) self.config = { 'health_path': '/health/', 'web_path': '/foo', 'web_port': 0, 'metrics_prefix': 'metrics_prefix.', } self.app = yield self.app_helper.get_app_worker(self.config) self.addr = self.app.webserver.getHost() self.url = 'http://%s:%s%s' % (self.addr.host, self.addr.port, self.config['web_path']) # Mock server to test HTTP posting of inbound messages & events self.mock_push_server = MockHttpServer(self.handle_request) yield self.mock_push_server.start() self.add_cleanup(self.mock_push_server.stop) self.push_calls = DeferredQueue() self.conversation = yield self.create_conversation( self.get_message_url(), self.get_event_url(), ['token-1', 'token-2', 'token-3']) self.auth_headers = { 'Authorization': [ 'Basic ' + base64.b64encode( '%s:%s' % (self.conversation.user_account.key, 'token-1')) ], } self._setup_wait_for_request() self.add_cleanup(self._wait_for_requests)
def test_hitting_url(self): msisdn = u'+2345' message_id = u'message-id' event = self.eh_helper.make_event( 'survey_completed', { 'from_addr': msisdn, 'message_id': message_id, 'transport_type': 'ussd', 'participant': { 'interactions': 2 }, }) self.mock_server = MockHttpServer() yield self.mock_server.start() self.eh_helper.get_handler('afropinions').url = self.mock_server.url yield self.eh_helper.dispatch_event(event) received_request = yield self.mock_server.queue.get() self.assertEqual(received_request.args['msisdn'][0], msisdn) self.assertEqual(received_request.args['amount'][0], '2000') self.assertEqual(received_request.args['reason'][0], 'foo') headers = received_request.requestHeaders self.assertEqual(headers.getRawHeaders('Content-Type'), ['application/x-www-form-urlencoded']) self.assertEqual( headers.getRawHeaders('Authorization'), ['Basic %s' % (base64.b64encode('username:password'), )]) yield self.mock_server.stop()
def setUp(self): self.mediaedgegsm_calls = DeferredQueue() self.mock_mediaedgegsm = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_mediaedgegsm.stop) yield self.mock_mediaedgegsm.start() self.config = { 'web_path': "foo", 'web_port': 0, 'username': '******', 'password': '******', 'outbound_url': self.mock_mediaedgegsm.url, 'outbound_username': '******', 'outbound_password': '******', 'operator_mappings': { '417': { '417912': 'VODA', '417913': 'TIGO', '417914': 'UNKNOWN', } } } self.tx_helper = self.add_helper( TransportHelper(MediaEdgeGSMTransport)) self.transport = yield self.tx_helper.get_transport(self.config) self.transport_url = self.transport.get_transport_url() self.mediaedgegsm_response = '' self.mediaedgegsm_response_code = http.OK
def setUp(self): self.mock_server = MockHttpServer(self.handle_inbound_request) self.outbound_requests = DeferredQueue() self.mock_server_response = '' self.mock_server_response_code = http.OK yield self.mock_server.start() self.add_cleanup(self.mock_server.stop) config = { 'web_path': 'api/v1/apposit/sms', 'web_port': 0, 'credentials': { '8123': { 'username': '******', 'password': '******', 'service_id': 'service-id-1', }, '8124': { 'username': '******', 'password': '******', 'service_id': 'service-id-2', } }, 'outbound_url': self.mock_server.url, } self.tx_helper = self.add_helper( TransportHelper( AppositTransport, transport_addr='8123', mobile_addr='251911223344')) self.transport = yield self.tx_helper.get_transport(config) self.transport_url = self.transport.get_transport_url() self.web_path = config['web_path']
def setup_resource(self, callback=None, auth=None, config=None): if callback is None: callback = lambda r: self.fail("No RapidSMS requests expected.") self.mock_server = MockHttpServer(callback) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() url = '%s%s' % (self.mock_server.url, '/test/resource/path') self.app = yield self.setup_app(url, auth=auth, config=config)
def setup_resource_with_callback(self, callback): self.mock_server = MockHttpServer(callback) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() self.app = yield self.app_helper.get_application({ 'url': '%s%s' % (self.mock_server.url, self.path), 'username': '******', 'password': '******', })
def setUp(self): self.tx_helper = self.add_helper(TransportHelper(self.transport_class)) self.mock_server = MockHttpServer(self.handle_inbound_request) self.add_cleanup(self.mock_server.stop) self.clock = Clock() yield self.mock_server.start() self._pending_reqs = [] self.add_cleanup(self.finish_requests)
class TestYoPaymentHandler(VumiTestCase): @inlineCallbacks def setUp(self): self.eh_helper = self.add_helper(EventHandlerHelper()) yield self.eh_helper.setup_event_dispatcher( 'afropinions', YoPaymentHandler, { 'poll_manager_prefix': 'vumigo.', 'username': '******', 'password': '******', 'url': None, 'method': 'POST', 'amount': 1000, 'reason': 'foo', }) self.eh_helper.track_event('survey_completed', 'afropinions') @inlineCallbacks def test_hitting_url(self): msisdn = u'+2345' message_id = u'message-id' event = self.eh_helper.make_event( 'survey_completed', { 'from_addr': msisdn, 'message_id': message_id, 'transport_type': 'ussd', 'participant': { 'interactions': 2 }, }) self.mock_server = MockHttpServer() yield self.mock_server.start() self.eh_helper.get_handler('afropinions').url = self.mock_server.url yield self.eh_helper.dispatch_event(event) received_request = yield self.mock_server.queue.get() self.assertEqual(received_request.args['msisdn'][0], msisdn) self.assertEqual(received_request.args['amount'][0], '2000') self.assertEqual(received_request.args['reason'][0], 'foo') headers = received_request.requestHeaders self.assertEqual(headers.getRawHeaders('Content-Type'), ['application/x-www-form-urlencoded']) self.assertEqual( headers.getRawHeaders('Authorization'), ['Basic %s' % (base64.b64encode('username:password'), )]) yield self.mock_server.stop() def test_auth_headers(self): handler = self.eh_helper.get_handler('afropinions') auth = handler.get_auth_headers('username', 'password') credentials = base64.b64encode('username:password') self.assertEqual( auth, {'Authorization': 'Basic %s' % (credentials.strip(), )})
class TestYoPaymentHandler(VumiTestCase): @inlineCallbacks def setUp(self): self.eh_helper = self.add_helper(EventHandlerHelper()) yield self.eh_helper.setup_event_dispatcher( 'afropinions', YoPaymentHandler, { 'poll_manager_prefix': 'vumigo.', 'username': '******', 'password': '******', 'url': None, 'method': 'POST', 'amount': 1000, 'reason': 'foo', }) self.eh_helper.track_event('survey_completed', 'afropinions') @inlineCallbacks def test_hitting_url(self): msisdn = u'+2345' message_id = u'message-id' event = self.eh_helper.make_event('survey_completed', { 'from_addr': msisdn, 'message_id': message_id, 'transport_type': 'ussd', 'participant': {'interactions': 2}, }) self.mock_server = MockHttpServer() yield self.mock_server.start() self.eh_helper.get_handler('afropinions').url = self.mock_server.url yield self.eh_helper.dispatch_event(event) received_request = yield self.mock_server.queue.get() self.assertEqual(received_request.args['msisdn'][0], msisdn) self.assertEqual(received_request.args['amount'][0], '2000') self.assertEqual(received_request.args['reason'][0], 'foo') headers = received_request.requestHeaders self.assertEqual(headers.getRawHeaders('Content-Type'), ['application/x-www-form-urlencoded']) self.assertEqual(headers.getRawHeaders('Authorization'), ['Basic %s' % (base64.b64encode('username:password'),)]) yield self.mock_server.stop() def test_auth_headers(self): handler = self.eh_helper.get_handler('afropinions') auth = handler.get_auth_headers('username', 'password') credentials = base64.b64encode('username:password') self.assertEqual(auth, { 'Authorization': 'Basic %s' % (credentials.strip(),) })
class TestTransport(TestCase): @inlineCallbacks def setUp(self): DelayedCall.debug = True self.ok_transport_calls = DeferredQueue() self.mock_service = MockHttpServer(self.handle_request) yield self.mock_service.start() config = { 'transport_name': 'test_ok_transport', 'transport_type': 'ok', 'ussd_string_prefix': '', 'web_path': "foo", 'web_port': 0, 'url': self.mock_service.url, 'username': '******', 'password': '******', } self.worker = get_stubbed_worker(OkTransport, config) self.broker = self.worker._amqp_client.broker yield self.worker.startWorker() self.worker_url = self.worker.get_transport_url() @inlineCallbacks def tearDown(self): yield self.worker.stopWorker() yield self.mock_service.stop() def handle_request(self, request): self.ok_transport_calls.put(request) return '' @inlineCallbacks def test_health(self): result = yield http_request(self.worker_url + "health", "", method='GET') self.assertEqual(json.loads(result), { 'pending_requests': 0 }) @inlineCallbacks def test_inbound(self): d = http_request(self.worker_url + "foo", '', method='GET') msg, = yield self.broker.wait_messages("vumi", "test_ok_transport.inbound", 1) payload = msg.payload tum = TransportUserMessage(**payload) rep = tum.reply("OK") self.broker.publish_message("vumi", "test_ok_transport.outbound", rep) response = yield d self.assertEqual(response, 'OK')
def setUp(self): self.clock = Clock() MessengerTransport.clock = self.clock self.remote_server = MockHttpServer(lambda _: 'OK') yield self.remote_server.start() self.addCleanup(self.remote_server.stop) self.tx_helper = self.add_helper( HttpRpcTransportHelper(PatchedMessengerTransport)) self.msg_helper = self.add_helper(MessageHelper()) connection_pool = HTTPConnectionPool(reactor, persistent=False) treq._utils.set_global_pool(connection_pool)
def setUp(self): yield super(SimagriTransportTestCase, self).setUp() self.simagri_sms_calls = DeferredQueue() self.mock_simagri_sms = MockHttpServer(self.handle_request) yield self.mock_simagri_sms.start() self.config = { 'transport_name': self.transport_name, 'receive_path': 'sendsms', 'receive_port': 9998, 'outbound_url': self.mock_simagri_sms.url } self.transport = yield self.get_transport(self.config) self.transport_url = self.transport.get_transport_url()
def test_hitting_url(self): msisdn = u'+2345' message_id = u'message-id' event = self.eh_helper.make_event('survey_completed', { 'from_addr': msisdn, 'message_id': message_id, 'transport_type': 'ussd', 'participant': {'interactions': 2}, }) self.mock_server = MockHttpServer() yield self.mock_server.start() self.eh_helper.get_handler('afropinions').url = self.mock_server.url yield self.eh_helper.dispatch_event(event) received_request = yield self.mock_server.queue.get() self.assertEqual(received_request.args['msisdn'][0], msisdn) self.assertEqual(received_request.args['amount'][0], '2000') self.assertEqual(received_request.args['reason'][0], 'foo') headers = received_request.requestHeaders self.assertEqual(headers.getRawHeaders('Content-Type'), ['application/x-www-form-urlencoded']) self.assertEqual(headers.getRawHeaders('Authorization'), ['Basic %s' % (base64.b64encode('username:password'),)]) yield self.mock_server.stop()
class WeChatTestCase(VumiTestCase): def setUp(self): self.tx_helper = self.add_helper(TransportHelper(WeChatTransport)) self.request_queue = DeferredQueue() self.mock_server = MockHttpServer(self.handle_api_request) self.add_cleanup(self.mock_server.stop) return self.mock_server.start() def handle_api_request(self, request): self.request_queue.put(request) return NOT_DONE_YET def get_transport(self, **config): defaults = { 'api_url': self.mock_server.url, 'auth_token': 'token', 'twisted_endpoint': 'tcp:0', 'wechat_appid': 'appid', 'wechat_secret': 'secret', 'embed_user_profile': False, } defaults.update(config) return self.tx_helper.get_transport(defaults) @inlineCallbacks def get_transport_with_access_token(self, access_token, **config): transport = yield self.get_transport(**config) yield transport.redis.set(WeChatTransport.ACCESS_TOKEN_KEY, access_token) returnValue(transport)
def setUp(self): self.app_helper = self.add_helper( AppWorkerHelper(NoStreamingHTTPWorker)) self.config = { 'health_path': '/health/', 'web_path': '/foo', 'web_port': 0, 'metrics_prefix': 'metrics_prefix.', } self.app = yield self.app_helper.get_app_worker(self.config) self.addr = self.app.webserver.getHost() self.url = 'http://%s:%s%s' % ( self.addr.host, self.addr.port, self.config['web_path']) # Mock server to test HTTP posting of inbound messages & events self.mock_push_server = MockHttpServer(self.handle_request) yield self.mock_push_server.start() self.add_cleanup(self.mock_push_server.stop) self.push_calls = DeferredQueue() self.conversation = yield self.create_conversation( self.get_message_url(), self.get_event_url(), ['token-1', 'token-2', 'token-3']) self.auth_headers = { 'Authorization': ['Basic ' + base64.b64encode('%s:%s' % ( self.conversation.user_account.key, 'token-1'))], } self._setup_wait_for_request() self.add_cleanup(self._wait_for_requests)
def start_app_worker(self, config_overrides={}): # Mock server to test HTTP posting of inbound messages & events self.mock_push_server = MockHttpServer(self.handle_request) yield self.mock_push_server.start() self.add_cleanup(self.mock_push_server.stop) self.push_calls = DeferredQueue() self.config = { 'conversation_key': 'key_conversation', 'push_message_url': self.get_message_url(), 'push_event_url': self.get_event_url(), 'health_path': '/health/', 'web_path': '/foo', 'web_port': 0, 'api_tokens': [{ 'account': 'account_key', 'conversation': 'key_conversation', 'tokens': ['token-1', 'token-2', 'token-3'], }, ] } self.config.update(config_overrides) self.app = yield self.app_helper.get_application(self.config) self.conversation = self.config['conversation_key'] self.addr = self.app.webserver.getHost() self.url = 'http://%s:%s%s' % ( self.addr.host, self.addr.port, self.config['web_path']) self.auth_headers = { 'Authorization': ['Basic ' + base64.b64encode('%s:%s' % ( 'account_key', 'token-1'))], }
def setUp(self): super(TestMediafoneTransport, self).setUp() self.mediafone_calls = DeferredQueue() self.mock_mediafone = MockHttpServer(self.handle_request) yield self.mock_mediafone.start() self.config = { 'transport_name': self.transport_name, 'web_path': "foo", 'web_port': 0, 'username': '******', 'password': '******', 'outbound_url': self.mock_mediafone.url, } self.transport = yield self.get_transport(self.config) self.transport_url = self.transport.get_transport_url()
def setUp(self): self.mediafone_calls = DeferredQueue() self.mock_mediafone = MockHttpServer(self.handle_request) yield self.mock_mediafone.start() self.config = { 'web_path': "foo", 'web_port': 0, 'username': '******', 'password': '******', 'outbound_url': self.mock_mediafone.url, } self.tx_helper = self.add_helper(TransportHelper(MediafoneTransport)) self.transport = yield self.tx_helper.get_transport(self.config) self.transport_url = self.transport.get_transport_url() self.mediafonemc_response = '' self.mediafonemc_response_code = http.OK
def setUp(self): self.integrat_calls = DeferredQueue() self.mock_integrat = MockHttpServer(self.handle_request) yield self.mock_integrat.start() config = { 'transport_name': 'testgrat', 'web_path': "foo", 'web_port': "0", 'url': self.mock_integrat.url, 'username': '******', 'password': '******', } self.worker = get_stubbed_worker(IntegratTransport, config) self.broker = self.worker._amqp_client.broker yield self.worker.startWorker() addr = self.worker.web_resource.getHost() self.worker_url = "http://%s:%s/" % (addr.host, addr.port)
def setUp(self): self.integrat_calls = DeferredQueue() self.mock_integrat = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_integrat.stop) yield self.mock_integrat.start() config = { 'web_path': "foo", 'web_port': "0", 'url': self.mock_integrat.url, 'username': '******', 'password': '******', } self.tx_helper = self.add_helper(TransportHelper(IntegratTransport)) self.transport = yield self.tx_helper.get_transport(config) addr = self.transport.web_resource.getHost() self.transport_url = "http://%s:%s/" % (addr.host, addr.port) self.higate_response = '<Response status_code="0"/>'
def setUp(self): yield super(AirtelBfTransportTestCase, self).setUp() self.airtel_sms_calls = DeferredQueue() self.mock_airtel_sms = MockHttpServer(self.handle_request) yield self.mock_airtel_sms.start() self.config = { 'transport_name': self.transport_name, 'receive_path': 'sendsms', 'receive_port': 9998, 'outbound_url': self.mock_airtel_sms.url, 'default_shortcode': '3411', 'login': '******', 'password': '******' } self.transport = yield self.get_transport(self.config) self.transport_url = self.transport.get_transport_url()
def setUp(self): self.mock_server = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() self.url = self.mock_server.url self.client = StreamingClient() self.messages_received = DeferredQueue() self.errors_received = DeferredQueue() self.disconnects_received = DeferredQueue() def reason_trapper(reason): if reason.trap(ResponseDone): self.disconnects_received.put(reason.getErrorMessage()) self.receiver = self.client.stream(Message, self.messages_received.put, self.errors_received.put, self.url, on_disconnect=reason_trapper)
def setUp(self): self.cellulant_sms_calls = DeferredQueue() self.mock_mtech_sms = MockHttpServer(self.handle_request) yield self.mock_mtech_sms.start() self.valid_creds = { 'mt_username': '******', 'mt_password': '******', } self.config = { 'web_path': "foo", 'web_port': 0, 'outbound_url': self.mock_mtech_sms.url, } self.config.update(self.valid_creds) self.tx_helper = self.add_helper( TransportHelper(self.transport_class, mobile_addr='2371234567')) self.transport = yield self.tx_helper.get_transport(self.config) self.transport_url = self.transport.get_transport_url()
def setUp(self): self.mock_http = MockHttpServer(self.handle_request) self.mock_request_queue = DeferredQueue() yield self.mock_http.start() self.addCleanup(self.mock_http.stop) config = { 'web_port': 0, 'web_path': '/api/v1/mxit/mobiportal/', 'client_id': 'client_id', 'client_secret': 'client_secret', 'api_send_url': self.mock_http.url, 'api_auth_url': self.mock_http.url, } self.sample_loc_str = 'cc,cn,sc,sn,cc,c,noi,cfb,ci' self.sample_profile_str = 'lc,cc,dob,gender,tariff' self.sample_html_str = '<&>' self.sample_req_headers = { 'X-Device-User-Agent': 'ua', 'X-Mxit-Contact': 'contact', 'X-Mxit-USERID-R': 'user-id', 'X-Mxit-Nick': 'nick', 'X-Mxit-Location': self.sample_loc_str, 'X-Mxit-Profile': self.sample_profile_str, 'X-Mxit-User-Input': self.sample_html_str, } self.sample_menu_resp = "\n".join([ "Hello!", "1. option 1", "2. option 2", "3. option 3", ]) # same as above but the o's are replaced with # http://www.fileformat.info/info/unicode/char/f8/index.htm slashed_o = '\xc3\xb8' self.sample_unicode_menu_resp = unicode( self.sample_menu_resp.replace('o', slashed_o), 'utf-8') self.tx_helper = self.add_helper(TransportHelper(MxitTransport)) self.transport = yield self.tx_helper.get_transport(config) # NOTE: priming redis with an access token self.transport.redis.set(self.transport.access_token_key, 'foo') self.url = self.transport.get_transport_url(config['web_path'])
def setUp(self): DelayedCall.debug = True self.ok_transport_calls = DeferredQueue() self.mock_service = MockHttpServer(self.handle_request) yield self.mock_service.start() config = { 'transport_name': 'test_ok_transport', 'transport_type': 'ok', 'ussd_string_prefix': '', 'web_path': "foo", 'web_port': 0, 'url': self.mock_service.url, 'username': '******', 'password': '******', } self.worker = get_stubbed_worker(OkTransport, config) self.broker = self.worker._amqp_client.broker yield self.worker.startWorker() self.worker_url = self.worker.get_transport_url()
def setUp(self): DelayedCall.debug = True yield super(CmYoTransportTestCase, self).setUp() self.cmyo_sms_calls = DeferredQueue() self.mock_cmyo_sms = MockHttpServer(self.handle_request) yield self.mock_cmyo_sms.start() self.config = { 'transport_name': self.transport_name, 'login': '******', 'password': '******', 'default_origin': "+313455", 'customer_id': '3454', 'receive_path': 'yo', 'receive_port': 9998, 'outbound_url': self.mock_cmyo_sms.url, } self.transport = yield self.get_transport(self.config) self.transport_url = self.transport.get_transport_url() self.today = datetime.utcnow().date()
def setUp(self): self.clock = Clock() self.patch(Vas2NetsSmsTransport, 'get_clock', lambda _: self.clock) self.remote_request_handler = lambda _: 'OK.1234' self.remote_server = MockHttpServer(self.remote_handle_request) yield self.remote_server.start() self.addCleanup(self.remote_server.stop) self.tx_helper = self.add_helper( HttpRpcTransportHelper(Vas2NetsSmsTransport)) connection_pool = HTTPConnectionPool(reactor, persistent=False) treq._utils.set_global_pool(connection_pool)
def mk_mock_server(self, body, headers=None, code=http.OK): if headers is None: headers = {'X-Nth-Smsid': 'message_id'} def handler(request): request.setResponseCode(code) for k, v in headers.items(): request.setHeader(k, v) return body self.mock_server = MockHttpServer(handler) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() self.worker.config['url'] = self.mock_server.url
class TestStreamingClient(VumiTestCase): @inlineCallbacks def setUp(self): self.mock_server = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() self.url = self.mock_server.url self.client = StreamingClient() self.messages_received = DeferredQueue() self.errors_received = DeferredQueue() self.disconnects_received = DeferredQueue() def reason_trapper(reason): if reason.trap(ResponseDone): self.disconnects_received.put(reason.getErrorMessage()) self.receiver = self.client.stream( Message, self.messages_received.put, self.errors_received.put, self.url, on_disconnect=reason_trapper) def handle_request(self, request): self.mock_server.queue.put(request) return NOT_DONE_YET @inlineCallbacks def test_callback_on_disconnect(self): req = yield self.mock_server.queue.get() req.write( '%s\n' % (Message(foo='bar').to_json().encode('utf-8'),)) req.finish() message = yield self.messages_received.get() self.assertEqual(message['foo'], 'bar') reason = yield self.disconnects_received.get() # this is the error message we get when a ResponseDone is raised # which happens when the remote server closes the connection. self.assertEqual(reason, 'Response body fully received') @inlineCallbacks def test_invalid_json(self): req = yield self.mock_server.queue.get() req.write("Hello\n") req.finish() try: yield self.errors_received.get() except VumiBridgeInvalidJsonError, e: self.assertEqual(e.args, ("Hello",)) else:
def test_default_handler(self): """ The default request handler puts the request in a queue. """ mock_server = yield self.start_mock_server(MockHttpServer()) agent = Agent(reactor) request_d = mock_server.queue.get() self.assertNoResult(request_d) response = yield agent.request("GET", mock_server.url + "path") # We got a valid request and returned a valid (error) response. request = self.successResultOf(request_d) self.assertEqual(request.method, "GET") self.assertEqual(request.path, "/path") yield self.assert_response(response, 500)
def test_simple_PUT(self): """ MockHttpHelper can handle a simple HTTP PUT request. """ requests = [] mock_server = yield self.start_mock_server( MockHttpServer(lambda req: requests.append(req) or "hi")) agent = Agent(reactor) response = yield agent.request("PUT", mock_server.url + "path") # We got a valid request and returned a valid response. [request] = requests self.assertEqual(request.method, "PUT") self.assertEqual(request.path, "/path") yield self.assert_response(response, 200, "hi")
class TestStreamingClient(VumiTestCase): @inlineCallbacks def setUp(self): self.mock_server = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() self.url = self.mock_server.url self.client = StreamingClient() self.messages_received = DeferredQueue() self.errors_received = DeferredQueue() self.disconnects_received = DeferredQueue() def reason_trapper(reason): if reason.trap(ResponseDone): self.disconnects_received.put(reason.getErrorMessage()) self.receiver = self.client.stream(Message, self.messages_received.put, self.errors_received.put, self.url, on_disconnect=reason_trapper) def handle_request(self, request): self.mock_server.queue.put(request) return NOT_DONE_YET @inlineCallbacks def test_callback_on_disconnect(self): req = yield self.mock_server.queue.get() req.write('%s\n' % (Message(foo='bar').to_json().encode('utf-8'), )) req.finish() message = yield self.messages_received.get() self.assertEqual(message['foo'], 'bar') reason = yield self.disconnects_received.get() # this is the error message we get when a ResponseDone is raised # which happens when the remote server closes the connection. self.assertEqual(reason, 'Response body fully received') @inlineCallbacks def test_invalid_json(self): req = yield self.mock_server.queue.get() req.write("Hello\n") req.finish() try: yield self.errors_received.get() except VumiBridgeInvalidJsonError, e: self.assertEqual(e.args, ("Hello", )) else:
class TestGoConversationTransportBase(VumiTestCase): transport_class = None @inlineCallbacks def setUp(self): self.tx_helper = self.add_helper(TransportHelper(self.transport_class)) self.mock_server = MockHttpServer(self.handle_inbound_request) self.add_cleanup(self.mock_server.stop) self.clock = Clock() yield self.mock_server.start() self._pending_reqs = [] self.add_cleanup(self.finish_requests) @inlineCallbacks def get_transport(self, **config): defaults = { 'base_url': self.mock_server.url, 'account_key': 'account-key', 'conversation_key': 'conversation-key', 'access_token': 'access-token', } defaults.update(config) transport = yield self.tx_helper.get_transport(defaults) yield self.setup_transport(transport) returnValue(transport) def setup_transport(self, transport): pass @inlineCallbacks def finish_requests(self): for req in self._pending_reqs: if not req.finished: yield req.finish() def handle_inbound_request(self, request): self.mock_server.queue.put(request) return NOT_DONE_YET @inlineCallbacks def get_next_request(self): req = yield self.mock_server.queue.get() self._pending_reqs.append(req) returnValue(req)
class TestQuietGetPage(VumiTestCase): @inlineCallbacks def setUp(self): self.mock_http = MockHttpServer(self._handle_request) self.add_cleanup(self.mock_http.stop) yield self.mock_http.start() def _handle_request(self, request): request.setResponseCode(http.OK) request.do_not_log = True return "Hello" @inlineCallbacks def test_request(self): with LogCatcher() as lc: result = yield quiet_get_page(self.mock_http.url) self.assertEqual(lc.logs, []) self.assertEqual(result, "Hello")
def setUp(self): yield super(AirtelBfTransportTestCase, self).setUp() self.airtel_sms_calls = DeferredQueue() self.mock_airtel_sms = MockHttpServer(self.handle_request) yield self.mock_airtel_sms.start() self.config = { "transport_name": self.transport_name, "receive_path": "sendsms", "receive_port": 9998, "outbound_url": self.mock_airtel_sms.url, "default_shortcode": "3411", "login": "******", "password": "******", } self.transport = yield self.get_transport(self.config) self.transport_url = self.transport.get_transport_url()
def setUp(self): self.mediafone_calls = DeferredQueue() self.mock_mediafone = MockHttpServer(self.handle_request) yield self.mock_mediafone.start() self.add_cleanup(self.mock_mediafone.stop) self.config = { 'web_path': "foo", 'web_port': 0, 'username': '******', 'password': '******', 'outbound_url': self.mock_mediafone.url, } self.tx_helper = self.add_helper(TransportHelper(MediafoneTransport)) self.transport = yield self.tx_helper.get_transport(self.config) self.transport_url = self.transport.get_transport_url() self.mediafonemc_response = '' self.mediafonemc_response_code = http.OK
def setUp(self): self.mock_server = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() self.url = self.mock_server.url self.client = StreamingClient() self.messages_received = DeferredQueue() self.errors_received = DeferredQueue() self.disconnects_received = DeferredQueue() def reason_trapper(reason): if reason.trap(ResponseDone): self.disconnects_received.put(reason.getErrorMessage()) self.receiver = self.client.stream( Message, self.messages_received.put, self.errors_received.put, self.url, on_disconnect=reason_trapper)
def setUp(self): self.mock_http = MockHttpServer(self.handle_request) self.mock_request_queue = DeferredQueue() yield self.mock_http.start() self.addCleanup(self.mock_http.stop) config = { "web_port": 0, "web_path": "/api/v1/mxit/mobiportal/", "client_id": "client_id", "client_secret": "client_secret", "api_send_url": self.mock_http.url, "api_auth_url": self.mock_http.url, } self.sample_loc_str = "cc,cn,sc,sn,cc,c,noi,cfb,ci" self.sample_profile_str = "lc,cc,dob,gender,tariff" self.sample_html_str = "<&>" self.sample_req_headers = { "X-Device-User-Agent": "ua", "X-Mxit-Contact": "contact", "X-Mxit-USERID-R": "user-id", "X-Mxit-Nick": "nick", "X-Mxit-Location": self.sample_loc_str, "X-Mxit-Profile": self.sample_profile_str, "X-Mxit-User-Input": self.sample_html_str, } self.sample_menu_resp = "\n".join(["Hello!", "1. option 1", "2. option 2", "3. option 3"]) # same as above but the o's are replaced with # http://www.fileformat.info/info/unicode/char/f8/index.htm slashed_o = "\xc3\xb8" self.sample_unicode_menu_resp = unicode(self.sample_menu_resp.replace("o", slashed_o), "utf-8") self.tx_helper = self.add_helper(TransportHelper(MxitTransport)) self.transport = yield self.tx_helper.get_transport(config) # NOTE: priming redis with an access token self.transport.redis.set(self.transport.access_token_key, "foo") self.url = self.transport.get_transport_url(config["web_path"])
class TestIntegratTransport(VumiTestCase): @inlineCallbacks def setUp(self): self.integrat_calls = DeferredQueue() self.mock_integrat = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_integrat.stop) yield self.mock_integrat.start() config = { 'web_path': "foo", 'web_port': "0", 'url': self.mock_integrat.url, 'username': '******', 'password': '******', } self.tx_helper = self.add_helper(TransportHelper(IntegratTransport)) self.transport = yield self.tx_helper.get_transport(config) addr = self.transport.web_resource.getHost() self.transport_url = "http://%s:%s/" % (addr.host, addr.port) self.higate_response = '<Response status_code="0"/>' def handle_request(self, request): # The content attr will have been set to None by the time we read this. request.content_body = request.content.getvalue() self.integrat_calls.put(request) return self.higate_response @inlineCallbacks def test_health(self): result = yield http_request(self.transport_url + "health", "", method='GET') self.assertEqual(result, "OK") @inlineCallbacks def test_outbound(self): yield self.tx_helper.make_dispatch_outbound("hi", transport_metadata={ 'session_id': "sess123", }) req = yield self.integrat_calls.get() self.assertEqual(req.path, '/') self.assertEqual(req.method, 'POST') self.assertEqual(req.getHeader('content-type'), 'text/xml; charset=utf-8') self.assertEqual(req.content_body, '<Message><Version Version="1.0" />' '<Request Flags="0" SessionID="sess123"' ' Type="USSReply">' '<UserID Orientation="TR">testuser</UserID>' '<Password>testpass</Password>' '<USSText Type="TEXT">hi</USSText>' '</Request></Message>') @inlineCallbacks def test_outbound_no_content(self): yield self.tx_helper.make_dispatch_outbound(None, transport_metadata={ 'session_id': "sess123", }) req = yield self.integrat_calls.get() self.assertEqual(req.path, '/') self.assertEqual(req.method, 'POST') self.assertEqual(req.getHeader('content-type'), 'text/xml; charset=utf-8') self.assertEqual(req.content_body, '<Message><Version Version="1.0" />' '<Request Flags="0" SessionID="sess123"' ' Type="USSReply">' '<UserID Orientation="TR">testuser</UserID>' '<Password>testpass</Password>' '<USSText Type="TEXT" />' '</Request></Message>') @inlineCallbacks def test_inbound(self): xml = XML_TEMPLATE % { 'ussd_type': 'Request', 'sid': 'sess1234', 'network_sid': "netsid12345", 'msisdn': '27345', 'connstr': '*120*99#', 'text': 'foobar', } yield http_request(self.transport_url + "foo", xml, method='GET') [msg] = yield self.tx_helper.wait_for_dispatched_inbound(1) self.assertEqual(msg['transport_name'], self.tx_helper.transport_name) self.assertEqual(msg['transport_type'], "ussd") self.assertEqual(msg['transport_metadata'], {"session_id": "sess1234"}) self.assertEqual(msg['session_event'], TransportUserMessage.SESSION_RESUME) self.assertEqual(msg['from_addr'], '27345') self.assertEqual(msg['to_addr'], '*120*99#') self.assertEqual(msg['content'], 'foobar') @inlineCallbacks def test_inbound_non_ascii(self): xml = (XML_TEMPLATE % { 'ussd_type': 'Request', 'sid': 'sess1234', 'network_sid': "netsid12345", 'msisdn': '27345', 'connstr': '*120*99#', 'text': u'öæł', }).encode("utf-8") yield http_request(self.transport_url + "foo", xml, method='GET') [msg] = yield self.tx_helper.wait_for_dispatched_inbound(1) self.assertEqual(msg['content'], u'öæł') @inlineCallbacks def test_nack(self): self.higate_response = """ <Response status_code="-1"> <Data name="method_error"> <field name="error_code" value="-1"/> <field name="reason" value="Expecting POST, not GET"/> </Data> </Response>""".strip() msg = yield self.tx_helper.make_dispatch_outbound( "hi", transport_metadata={'session_id': "sess123"}) yield self.integrat_calls.get() [nack] = yield self.tx_helper.wait_for_dispatched_events(1) self.assertEqual(nack['user_message_id'], msg['message_id']) self.assertEqual(nack['sent_message_id'], msg['message_id']) self.assertEqual(nack['nack_reason'], 'error_code: -1, reason: Expecting POST, not GET')
class TestMxitTransport(VumiTestCase): @inlineCallbacks def setUp(self): self.mock_http = MockHttpServer(self.handle_request) self.mock_request_queue = DeferredQueue() yield self.mock_http.start() self.addCleanup(self.mock_http.stop) config = { 'web_port': 0, 'web_path': '/api/v1/mxit/mobiportal/', 'client_id': 'client_id', 'client_secret': 'client_secret', 'api_send_url': self.mock_http.url, 'api_auth_url': self.mock_http.url, } self.sample_loc_str = 'cc,cn,sc,sn,cc,c,noi,cfb,ci' self.sample_profile_str = 'lc,cc,dob,gender,tariff' self.sample_html_str = '<&>' self.sample_req_headers = { 'X-Device-User-Agent': 'ua', 'X-Mxit-Contact': 'contact', 'X-Mxit-USERID-R': 'user-id', 'X-Mxit-Nick': 'nick', 'X-Mxit-Location': self.sample_loc_str, 'X-Mxit-Profile': self.sample_profile_str, 'X-Mxit-User-Input': self.sample_html_str, } self.sample_menu_resp = "\n".join([ "Hello!", "1. option 1", "2. option 2", "3. option 3", ]) # same as above but the o's are replaced with # http://www.fileformat.info/info/unicode/char/f8/index.htm slashed_o = '\xc3\xb8' self.sample_unicode_menu_resp = unicode( self.sample_menu_resp.replace('o', slashed_o), 'utf-8') self.tx_helper = self.add_helper(TransportHelper(MxitTransport)) self.transport = yield self.tx_helper.get_transport(config) # NOTE: priming redis with an access token self.transport.redis.set(self.transport.access_token_key, 'foo') self.url = self.transport.get_transport_url(config['web_path']) def handle_request(self, request): self.mock_request_queue.put(request) return NOT_DONE_YET def test_is_mxit_request(self): req = Request(None, True) self.assertFalse(self.transport.is_mxit_request(req)) req.requestHeaders.addRawHeader('X-Mxit-Contact', 'foo') self.assertTrue(self.transport.is_mxit_request(req)) def test_noop(self): self.assertEqual(self.transport.noop('foo'), 'foo') def test_parse_location(self): self.assertEqual(self.transport.parse_location(self.sample_loc_str), { 'country_code': 'cc', 'country_name': 'cn', 'subdivision_code': 'sc', 'subdivision_name': 'sn', 'city_code': 'cc', 'city': 'c', 'network_operator_id': 'noi', 'client_features_bitset': 'cfb', 'cell_id': 'ci', }) def test_parse_profile(self): self.assertEqual( self.transport.parse_profile(self.sample_profile_str), { 'country_code': 'cc', 'date_of_birth': 'dob', 'gender': 'gender', 'language_code': 'lc', 'tariff_plan': 'tariff', }) def test_html_decode(self): self.assertEqual( self.transport.html_decode(self.sample_html_str), '<&>') def test_get_request_data(self): req = Request(None, True) headers = req.requestHeaders for key, value in self.sample_req_headers.items(): headers.addRawHeader(key, value) data = self.transport.get_request_data(req) self.assertEqual(data, { 'X-Device-User-Agent': 'ua', 'X-Mxit-Contact': 'contact', 'X-Mxit-Location': { 'cell_id': 'ci', 'city': 'c', 'city_code': 'cc', 'client_features_bitset': 'cfb', 'country_code': 'cc', 'country_name': 'cn', 'network_operator_id': 'noi', 'subdivision_code': 'sc', 'subdivision_name': 'sn', }, 'X-Mxit-Nick': 'nick', 'X-Mxit-Profile': { 'country_code': 'cc', 'date_of_birth': 'dob', 'gender': 'gender', 'language_code': 'lc', 'tariff_plan': 'tariff', }, 'X-Mxit-USERID-R': 'user-id', 'X-Mxit-User-Input': u'<&>', }) def test_get_request_content_from_header(self): req = Request(None, True) req.requestHeaders.addRawHeader('X-Mxit-User-Input', 'foo') self.assertEqual(self.transport.get_request_content(req), 'foo') def test_get_quote_plus_request_content_from_header(self): req = Request(None, True) req.requestHeaders.addRawHeader('X-Mxit-User-Input', 'foo+bar') self.assertEqual( self.transport.get_request_content(req), 'foo bar') def test_get_quoted_request_content_from_header(self): req = Request(None, True) req.requestHeaders.addRawHeader('X-Mxit-User-Input', 'foo%20bar') self.assertEqual( self.transport.get_request_content(req), 'foo bar') def test_get_request_content_from_args(self): req = Request(None, True) req.args = {'input': ['bar']} self.assertEqual(self.transport.get_request_content(req), 'bar') def test_get_request_content_when_missing(self): req = Request(None, True) self.assertEqual(self.transport.get_request_content(req), None) @inlineCallbacks def test_invalid_request(self): resp = yield http_request_full(self.url) self.assertEqual(resp.code, BAD_REQUEST) @inlineCallbacks def test_request(self): resp_d = http_request_full( self.url, headers=self.sample_req_headers) [msg] = yield self.tx_helper.wait_for_dispatched_inbound(1) self.tx_helper.make_dispatch_reply(msg, self.sample_menu_resp) resp = yield resp_d self.assertTrue('1. option 1' in resp.delivered_body) self.assertTrue('2. option 2' in resp.delivered_body) self.assertTrue('3. option 3' in resp.delivered_body) self.assertTrue('?input=1' in resp.delivered_body) self.assertTrue('?input=2' in resp.delivered_body) self.assertTrue('?input=3' in resp.delivered_body) def test_response_parser(self): header, items = ResponseParser.parse(self.sample_menu_resp) self.assertEqual(header, 'Hello!') self.assertEqual(items, [ ('1', 'option 1'), ('2', 'option 2'), ('3', 'option 3'), ]) header, items = ResponseParser.parse('foo!') self.assertEqual(header, 'foo!') self.assertEqual(items, []) @inlineCallbacks def test_unicode_rendering(self): resp_d = http_request_full( self.url, headers=self.sample_req_headers) [msg] = yield self.tx_helper.wait_for_dispatched_inbound(1) self.tx_helper.make_dispatch_reply(msg, self.sample_unicode_menu_resp) resp = yield resp_d self.assertTrue( 'Hell\xc3\xb8' in resp.delivered_body) self.assertTrue( '\xc3\xb8pti\xc3\xb8n 1' in resp.delivered_body) @inlineCallbacks def test_outbound_that_is_not_a_reply(self): d = self.tx_helper.make_dispatch_outbound( content="Send!", to_addr="mxit-1", from_addr="mxit-2") req = yield self.mock_request_queue.get() body = json.load(req.content) self.assertEqual(body, { 'Body': 'Send!', 'To': 'mxit-1', 'From': 'mxit-2', 'ContainsMarkup': 'true', 'Spool': 'true', }) [auth] = req.requestHeaders.getRawHeaders('Authorization') # primed access token self.assertEqual(auth, 'Bearer foo') req.finish() yield d @inlineCallbacks def test_getting_access_token(self): transport = self.transport redis = transport.redis # clear primed value yield redis.delete(transport.access_token_key) d = transport.get_access_token() req = yield self.mock_request_queue.get() [auth] = req.requestHeaders.getRawHeaders('Authorization') self.assertEqual( auth, 'Basic %s' % ( base64.b64encode('client_id:client_secret'))) self.assertEqual( 'scope=message%2Fsend&grant_type=client_credentials', req.content.read()) req.write(json.dumps({ 'access_token': 'access_token', 'expires_in': '10' })) req.finish() access_token = yield d self.assertEqual(access_token, 'access_token') self.assertFalse(isinstance(access_token, unicode)) ttl = yield redis.ttl(transport.access_token_key) self.assertTrue( 0 < ttl <= (transport.access_token_auto_decay * 10))
class TestRapidSMSRelay(VumiTestCase): def setUp(self): self.app_helper = self.add_helper(ApplicationHelper(RapidSMSRelay)) @inlineCallbacks def setup_resource(self, callback=None, auth=None, config=None): if callback is None: callback = lambda r: self.fail("No RapidSMS requests expected.") self.mock_server = MockHttpServer(callback) self.add_cleanup(self.mock_server.stop) yield self.mock_server.start() url = '%s%s' % (self.mock_server.url, '/test/resource/path') self.app = yield self.setup_app(url, auth=auth, config=config) def setup_app(self, url, auth=None, config=None): vumi_username, vumi_password = auth if auth else (None, None) app_config = { 'rapidsms_url': url, 'web_path': '/send/', 'web_port': '0', 'rapidsms_username': '******', 'rapidsms_password': '******', 'vumi_username': vumi_username, 'vumi_password': vumi_password, 'allowed_endpoints': ['default', '10010', '10020'], } if config: app_config.update(config) return self.app_helper.get_application(app_config) def get_response_msgs(self, response): payloads = from_json(response.delivered_body) return [ TransportUserMessage(_process_fields=False, **to_kwargs(payload)) for payload in payloads ] @inlineCallbacks def test_rapidsms_relay_success(self): def cb(request): msg = TransportUserMessage.from_json(request.content.read()) self.assertEqual(msg['content'], 'hello world') self.assertEqual(msg['from_addr'], '+41791234567') return 'OK' yield self.setup_resource(cb) yield self.app_helper.make_dispatch_inbound("hello world") self.assertEqual([], self.app_helper.get_dispatched_outbound()) @inlineCallbacks def test_rapidsms_relay_unicode(self): def cb(request): msg = TransportUserMessage.from_json(request.content.read()) self.assertEqual(msg['content'], u'h\xc6llo') return 'OK' yield self.setup_resource(cb) yield self.app_helper.make_dispatch_inbound(u'h\xc6llo') self.assertEqual([], self.app_helper.get_dispatched_outbound()) @inlineCallbacks def test_rapidsms_relay_with_basic_auth(self): def cb(request): self.assertEqual(request.getUser(), 'username') self.assertEqual(request.getPassword(), 'password') msg = TransportUserMessage.from_json(request.content.read()) self.assertEqual(msg['message_id'], 'abc') self.assertEqual(msg['content'], 'hello world') self.assertEqual(msg['from_addr'], '+41791234567') return 'OK' yield self.setup_resource(cb) yield self.app_helper.make_dispatch_inbound("hello world", message_id="abc") self.assertEqual([], self.app_helper.get_dispatched_outbound()) @inlineCallbacks def test_rapidsms_relay_with_bad_basic_auth(self): def cb(request): request.setResponseCode(http.UNAUTHORIZED) return 'Not Authorized' yield self.setup_resource(cb) yield self.app_helper.make_dispatch_inbound("hi") self.assertEqual([], self.app_helper.get_dispatched_outbound()) @inlineCallbacks def test_rapidsms_relay_logs_events(self): yield self.setup_resource() with LogCatcher() as lc: yield self.app_helper.make_dispatch_delivery_report( self.app_helper.make_outbound("foo", message_id="abc")) yield self.app_helper.make_dispatch_ack( self.app_helper.make_outbound("foo", message_id="1")) self.assertEqual(lc.messages(), [ "Delivery report received for message u'abc'," " status u'delivered'", "Acknowledgement received for message u'1'", ]) self.assertEqual([], self.app_helper.get_dispatched_outbound()) @inlineCallbacks def test_rapidsms_relay_with_unicode_rapidsms_http_method(self): def cb(request): msg = TransportUserMessage.from_json(request.content.read()) self.assertEqual(msg['content'], 'hello world') self.assertEqual(msg['from_addr'], '+41791234567') return 'OK' yield self.setup_resource(cb, config={"rapidsms_http_method": u"POST"}) yield self.app_helper.make_dispatch_inbound("hello world") self.assertEqual([], self.app_helper.get_dispatched_outbound()) def _call_relay(self, data, auth=None): data = json.dumps(data) host = self.app.web_resource.getHost() send_url = "http://127.0.0.1:%d/send" % (host.port, ) headers = {} if auth is not None: headers['Authorization'] = basic_auth_string(*auth) return http_request_full(send_url, data, headers=headers) def _check_messages(self, response, expecteds): response_msgs = self.get_response_msgs(response) msgs = self.app_helper.get_dispatched_outbound() for rmsg, msg, expected in zip(response_msgs, msgs, expecteds): self.assertEqual(msg, rmsg) for k, v in expected.items(): self.assertEqual(msg[k], v) self.assertEqual(len(msgs), len(expecteds)) self.assertEqual(len(response_msgs), len(expecteds)) @inlineCallbacks def test_rapidsms_relay_outbound(self): yield self.setup_resource() response = yield self._call_relay({ 'to_addr': ['+123456'], 'content': 'foo', }) self.assertEqual(response.headers.getRawHeaders('content-type'), ['application/json; charset=utf-8']) self._check_messages(response, [{ 'to_addr': '+123456', 'content': u'foo' }]) @inlineCallbacks def test_rapidsms_relay_outbound_unicode(self): yield self.setup_resource() response = yield self._call_relay({ 'to_addr': ['+123456'], 'content': u'f\xc6r', }) self._check_messages(response, [{ 'to_addr': '+123456', 'content': u'f\xc6r' }]) @inlineCallbacks def test_rapidsms_relay_multiple_outbound(self): yield self.setup_resource() addresses = ['+123456', '+678901'] response = yield self._call_relay({ 'to_addr': addresses, 'content': 'foo', }) self._check_messages(response, [{ 'to_addr': addr, 'content': u'foo' } for addr in addresses]) @inlineCallbacks def test_rapidsms_relay_reply(self): msg_id, to_addr = 'abc', '+1234' yield self.setup_resource(lambda r: 'OK') yield self.app_helper.make_dispatch_inbound("foo", message_id=msg_id, from_addr=to_addr) response = yield self._call_relay({ 'to_addr': [to_addr], 'content': 'foo', 'in_reply_to': msg_id, }) self._check_messages(response, [{ 'to_addr': to_addr, 'content': u'foo', 'in_reply_to': msg_id }]) @inlineCallbacks def test_rapidsms_relay_reply_unknown_msg(self): yield self.setup_resource() response = yield self._call_relay({ 'to_addr': ['+123456'], 'content': 'foo', 'in_reply_to': 'unknown_message_id', }) self.assertEqual(response.code, 400) self.assertEqual(response.delivered_body, "Original message u'unknown_message_id' not found.") [err] = self.flushLoggedErrors(BadRequestError) @inlineCallbacks def test_rapidsms_relay_outbound_authenticated(self): auth = ("username", "good-password") yield self.setup_resource(callback=None, auth=auth) response = yield self._call_relay( { 'to_addr': ['+123456'], 'content': u'f\xc6r', }, auth=auth) self._check_messages(response, [{ 'to_addr': '+123456', 'content': u'f\xc6r' }]) @inlineCallbacks def test_rapidsms_relay_outbound_failed_authenticated(self): bad_auth = ("username", "bad-password") good_auth = ("username", "good-password") yield self.setup_resource(callback=None, auth=good_auth) response = yield self._call_relay( { 'to_addr': ['+123456'], 'content': u'f\xc6r', }, auth=bad_auth) self.assertEqual(response.code, 401) self.assertEqual(response.delivered_body, "Unauthorized") @inlineCallbacks def test_rapidsms_relay_outbound_on_specific_endpoint(self): yield self.setup_resource() response = yield self._call_relay({ 'to_addr': ['+123456'], 'content': u'foo', 'endpoint': '10010', }) self._check_messages(response, [{ 'to_addr': '+123456', 'content': u'foo' }]) [msg] = self.app_helper.get_dispatched_outbound() self.assertEqual(msg['routing_metadata'], { 'endpoint_name': '10010', }) @inlineCallbacks def test_rapidsms_relay_outbound_on_default_endpoint(self): yield self.setup_resource() response = yield self._call_relay({ 'to_addr': ['+123456'], 'content': u'foo', }) self._check_messages(response, [{ 'to_addr': '+123456', 'content': u'foo' }]) [msg] = self.app_helper.get_dispatched_outbound() self.assertEqual(msg['routing_metadata'], { 'endpoint_name': 'default', }) @inlineCallbacks def test_rapidsms_relay_outbound_on_invalid_endpoint(self): yield self.setup_resource() response = yield self._call_relay({ 'to_addr': ['+123456'], 'content': u'foo', 'endpoint': u'bar', }) self.assertEqual([], self.app_helper.get_dispatched_outbound()) self.assertEqual(response.code, 400) self.assertEqual( response.delivered_body, "Endpoint u'bar' not defined in list of allowed" " endpoints ['default', '10010', '10020']") [err] = self.flushLoggedErrors(BadRequestError) @inlineCallbacks def test_rapidsms_relay_outbound_on_invalid_to_addr(self): yield self.setup_resource() response = yield self._call_relay({ 'to_addr': '+123456', 'content': u'foo', 'endpoint': u'bar', }) self.assertEqual([], self.app_helper.get_dispatched_outbound()) self.assertEqual(response.code, 400) self.assertEqual(response.delivered_body, "Supplied `to_addr` (u'+123456') was not a list.") [err] = self.flushLoggedErrors(BadRequestError)
def setUp(self): self.mock_http = MockHttpServer(self._handle_request) self.add_cleanup(self.mock_http.stop) yield self.mock_http.start()