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_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(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 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 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 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)
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"/>'
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):
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)
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):
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"])
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()
