def test_incr(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual(2, self.r_server.incr("inc"))
self.assertEqual(3, self.r_server.incr("inc"))
self.assertEqual('3', self.r_server.get("inc"))
def test_sunion(self):
self.r_server = FakeRedis()
self.r_server.sadd('set1', 1)
self.r_server.sadd('set2', 2)
self.assertEqual(self.r_server.sunion('set1'), set(['1']))
self.assertEqual(self.r_server.sunion('set1', 'set2'), set(['1', '2']))
self.assertEqual(self.r_server.sunion('other'), set())
def setUp(self):
yield super(TestContentKeywordRouter, self).setUp()
self.config = {
'dispatcher_name':
'keyword_dispatcher',
'router_class':
'vumi.dispatchers.base.ContentKeywordRouter',
'transport_names': ['transport1', 'transport2'],
'transport_mappings': {
'shortcode1': 'transport1',
'shortcode2': 'transport2',
},
'exposed_names': ['app1', 'app2', 'app3', 'fallback_app'],
'rules': [{
'app': 'app1',
'keyword': 'KEYWORD1',
'to_addr': '8181',
'prefix': '+256',
}, {
'app': 'app2',
'keyword': 'KEYWORD2',
}],
'keyword_mappings': {
'app2': 'KEYWORD3',
'app3': 'KEYWORD1',
},
'fallback_application':
'fallback_app',
'expire_routing_memory':
'3',
}
self.fake_redis = FakeRedis()
self.dispatcher = yield self.get_dispatcher(self.config)
self.router = self.dispatcher._router
self.router.r_server = self.fake_redis
def setUp(self):
self.today = datetime.utcnow().date()
self.port = 9999
self.path = '/api/v1/sms/vas2nets/receive/'
self.config = {
'transport_name': 'vas2nets',
'url': 'http://localhost:%s%s' % (self.port, self.path),
'username': '******',
'password': '******',
'owner': 'owner',
'service': 'service',
'subservice': 'subservice',
'web_receive_path': '/receive',
'web_receipt_path': '/receipt',
'web_port': 9998,
}
self.fail_config = {
'transport_name': 'vas2nets',
'retry_routing_key': '%(transport_name)s.outbound',
'failures_routing_key': '%(transport_name)s.failures',
}
self.workers = []
self.broker = FakeAMQPBroker()
self.redis = FakeRedis()
self.worker = yield self.mk_transport_worker(self.config, self.broker)
self.fail_worker = yield self.mk_failure_worker(
self.fail_config, self.broker, self.redis)
def test_hgetall_returns_copy(self):
self.r_server = FakeRedis()
self.r_server.hset("hash", "foo", "1")
data = self.r_server.hgetall("hash")
data["foo"] = "2"
self.assertEqual(self.r_server.hgetall("hash"), {
"foo": "1",
})
def test_incr_with_by_param(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual(2, self.r_server.incr("inc", 1))
self.assertEqual(4, self.r_server.incr("inc", 2))
self.assertEqual(7, self.r_server.incr("inc", 3))
self.assertEqual(11, self.r_server.incr("inc", 4))
self.assertEqual(111, self.r_server.incr("inc", 100))
self.assertEqual('111', self.r_server.get("inc"))
def test_hincrby(self):
self.r_server = FakeRedis()
hincrby = self.r_server.hincrby
self.assertEqual(hincrby("inc", "field1"), 1)
self.assertEqual(hincrby("inc", "field1"), 2)
self.assertEqual(hincrby("inc", "field1", 3), 5)
self.assertEqual(hincrby("inc", "field1", "2"), 7)
self.assertRaises(Exception, hincrby, "inc", "field1", "1.5")
self.r_server.hset("inc", "field2", "a")
self.assertRaises(Exception, hincrby, "inc", "field2")
self.r_server.set("key", "string")
self.assertRaises(Exception, self.r_server.hincrby, "key", "field1")
def test_smove(self):
self.r_server = FakeRedis()
self.r_server.sadd('set1', 1)
self.r_server.sadd('set2', 2)
self.assertEqual(self.r_server.smove('set1', 'set2', '1'), True)
self.assertEqual(self.r_server.smembers('set1'), set())
self.assertEqual(self.r_server.smembers('set2'), set(['1', '2']))
self.assertEqual(self.r_server.smove('set1', 'set2', '1'), False)
self.assertEqual(self.r_server.smove('set2', 'set3', '1'), True)
self.assertEqual(self.r_server.smembers('set2'), set(['2']))
self.assertEqual(self.r_server.smembers('set3'), set(['1']))
class SessionManagerTestCase(TestCase):
def setUp(self):
self.fake_redis = FakeRedis()
self.sm = SessionManager(self.fake_redis, prefix="test")
def tearDown(self):
self.sm.stop()
self.fake_redis.teardown()
def test_active_sessions(self):
def get_sessions():
return sorted(self.sm.active_sessions())
def ids():
return [x[0] for x in get_sessions()]
self.assertEqual(ids(), [])
self.sm.create_session("u1")
self.assertEqual(ids(), ["u1"])
# 10 seconds later
self.sm.create_session("u2", created_at=time.time() + 10)
self.assertEqual(ids(), ["u1", "u2"])
s1, s2 = get_sessions()
self.assertTrue(s1[1]['created_at'] < s2[1]['created_at'])
def test_schedule_session_expiry(self):
self.sm.max_session_length = 60.0
self.sm.create_session("u1")
def test_create_and_retrieve_session(self):
session = self.sm.create_session("u1")
self.assertEqual(sorted(session.keys()), ['created_at'])
self.assertTrue(time.time() - float(session['created_at']) < 10.0)
loaded = self.sm.load_session("u1")
self.assertEqual(loaded, session)
def test_save_session(self):
test_session = {"foo": 5, "bar": "baz"}
self.sm.create_session("u1")
self.sm.save_session("u1", test_session)
session = self.sm.load_session("u1")
self.assertTrue(session.pop('created_at') is not None)
# Redis saves & returns all session values as strings
self.assertEqual(session, dict([map(str, kvs) for kvs
in test_session.items()]))
def test_lazy_clearing(self):
self.sm.save_session('user_id', {})
self.assertEqual(list(self.sm.active_sessions()), [])
def setUp(self):
yield super(UserGroupingRouterTestCase, self).setUp()
self.config = {
'dispatcher_name': 'user_group_dispatcher',
'router_class': 'vumi.dispatchers.base.UserGroupingRouter',
'transport_names': [
self.transport_name,
],
'exposed_names': [
'app1',
'app2',
],
'group_mappings': {
'group1': 'app1',
'group2': 'app2',
},
'transport_mappings': {
'upstream1': self.transport_name,
}
}
self.fake_redis = FakeRedis()
self.dispatcher = yield self.get_dispatcher(self.config)
self.router = self.dispatcher._router
self.router.r_server = self.fake_redis
self.router.setup_routing()
def test_incr(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual(2, self.r_server.incr("inc"))
self.assertEqual(3, self.r_server.incr("inc"))
self.assertEqual('3', self.r_server.get("inc"))
def setUp(self):
self.today = datetime.utcnow().date()
self.port = 9999
self.path = "/api/v1/sms/vas2nets/receive/"
self.config = {
"transport_name": "vas2nets",
"url": "http://localhost:%s%s" % (self.port, self.path),
"username": "******",
"password": "******",
"owner": "owner",
"service": "service",
"subservice": "subservice",
"web_receive_path": "/receive",
"web_receipt_path": "/receipt",
"web_port": 9998,
}
self.fail_config = {
"transport_name": "vas2nets",
"retry_routing_key": "sms.outbound.%(transport_name)s",
"failures_routing_key": "sms.outbound.%(transport_name)s.failures",
}
self.workers = []
self.broker = FakeAMQPBroker()
self.redis = FakeRedis()
self.worker = yield self.mk_transport_worker(self.config, self.broker)
self.fail_worker = yield self.mk_failure_worker(self.fail_config, self.broker, self.redis)
def test_sunion(self):
self.r_server = FakeRedis()
self.r_server.sadd('set1', 1)
self.r_server.sadd('set2', 2)
self.assertEqual(self.r_server.sunion('set1'), set(['1']))
self.assertEqual(self.r_server.sunion('set1', 'set2'), set(['1', '2']))
self.assertEqual(self.r_server.sunion('other'), set())
def setUp(self):
self.today = datetime.utcnow().date()
self.port = 9999
self.path = '/api/v1/sms/vas2nets/receive/'
self.config = {
'transport_name': 'vas2nets',
'url': 'http://localhost:%s%s' % (self.port, self.path),
'username': '******',
'password': '******',
'owner': 'owner',
'service': 'service',
'subservice': 'subservice',
'web_receive_path': '/receive',
'web_receipt_path': '/receipt',
'web_port': 9998,
}
self.fail_config = {
'transport_name': 'vas2nets',
'retry_routing_key': '%(transport_name)s.outbound',
'failures_routing_key': '%(transport_name)s.failures',
}
self.workers = []
self.broker = FakeAMQPBroker()
self.redis = FakeRedis()
self.worker = yield self.mk_transport_worker(self.config, self.broker)
self.fail_worker = yield self.mk_failure_worker(
self.fail_config, self.broker, self.redis)
def setUp(self):
yield super(TestContentKeywordRouter, self).setUp()
self.config = {
'dispatcher_name': 'keyword_dispatcher',
'router_class': 'vumi.dispatchers.base.ContentKeywordRouter',
'transport_names': ['transport1', 'transport2'],
'transport_mappings': {
'shortcode1': 'transport1',
'shortcode2': 'transport2',
},
'exposed_names': ['app1', 'app2', 'app3', 'fallback_app'],
'rules': [{'app': 'app1',
'keyword': 'KEYWORD1',
'to_addr': '8181',
'prefix': '+256',
},
{'app': 'app2',
'keyword': 'KEYWORD2',
}],
'keyword_mappings': {
'app2': 'KEYWORD3',
'app3': 'KEYWORD1',
},
'fallback_application': 'fallback_app',
'expire_routing_memory': '3',
}
self.fake_redis = FakeRedis()
self.dispatcher = yield self.get_dispatcher(self.config)
self.router = self.dispatcher._router
self.router.r_server = self.fake_redis
def setUp(self):
yield super(TwitterTransportTestCase, self).setUp()
self.config = {
'app_name': 'testapp',
'consumer_key': 'consumer1',
'consumer_secret': 'consumersecret1',
'access_token': 'token1',
'access_token_secret': 'tokensecret1',
'terms': ['some', 'trending', 'topic'],
}
self.transport = yield self.get_transport(self.config, start=False)
self.transport.validate_config()
self.transport.r_server = FakeRedis()
self.transport.transport_name = self.transport_name
self.transport.concurrent_sends = None
self.transport._consumers = []
self.transport.twitter = FakeTwitter()
yield self.transport.start_tracking_terms()
self.transport.start_checking_for_replies()
yield self.transport._setup_failure_publisher()
yield self.transport._setup_message_publisher()
yield self.transport._setup_event_publisher()
yield self.transport.setup_middleware()
def setUp(self):
yield super(EsmeToSmscTestCase, self).setUp()
delivery_report_regex = "id:(?P<id>\S{,65})" \
" +sub:(?P<sub>.{1,3})" \
" +dlvrd:(?P<dlvrd>.{1,3})" \
" +submit date:(?P<submit_date>\d*)" \
" +done date:(?P<done_date>\d*)" \
" +stat:(?P<stat>[0-9,A-Z]{1,7})" \
" +err:(?P<err>.{1,3})" \
" +[Tt]ext:(?P<text>.{,20}).*" \
self.config = {
"system_id": "VumiTestSMSC",
"password": "******",
"host": "localhost",
"port": 0,
"redis": {},
"transport_name": self.transport_name,
"transport_type": "smpp",
"delivery_report_regex": delivery_report_regex,
"smsc_delivery_report_string": (
'id:%s sub:1 dlvrd:1 submit date:%s done date:%s '
'stat:0 err:0 text:If a general electio'),
}
self.service = SmppService(None, config=self.config)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.get_transport(self.config, start=False)
self.transport.r_server = FakeRedis()
self.expected_delivery_status = 'delivered' # stat:0 means delivered
def setUp(self):
dummy_worker = object()
config = {}
self.mw = StoringMiddleware("dummy_storer", config, dummy_worker)
self.mw.setup_middleware()
self.mw.store.r_server = FakeRedis()
self.store = self.mw.store
def get_esme(self, **callbacks):
config = ClientConfig(host="127.0.0.1",
port="0",
system_id="1234",
password="******")
esme_callbacks = EsmeCallbacks(**callbacks)
esme = FakeEsmeTransceiver(config, FakeRedis(), esme_callbacks)
return esme
def test_hgetall_returns_copy(self):
self.r_server = FakeRedis()
self.r_server.hset("hash", "foo", "1")
data = self.r_server.hgetall("hash")
data["foo"] = "2"
self.assertEqual(self.r_server.hgetall("hash"), {
"foo": "1",
})
def setUp(self):
super(TestDecisionTreeWorker, self).setUp()
self.worker = yield self.get_application({
'worker_name':
'test_decision_tree_worker',
})
self.worker.r_server = FakeRedis()
self.worker.session_manager.r_server = self.worker.r_server
def test_incrby(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual('2', self.r_server.incrby("inc", 1))
self.assertEqual('4', self.r_server.incrby("inc", 2))
self.assertEqual('7', self.r_server.incrby("inc", 3))
self.assertEqual('11', self.r_server.incrby("inc", 4))
self.assertEqual('111', self.r_server.incrby("inc", 100))
def test_zrange(self):
self.r_server = FakeRedis()
self.r_server.zadd('set', one=0.1, two=0.2, three=0.3)
self.assertEqual(self.r_server.zrange('set', 0, 0), ['one'])
self.assertEqual(self.r_server.zrange('set', 0, 1), ['one', 'two'])
self.assertEqual(self.r_server.zrange('set', 0, 2),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, 3),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, -1),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, -1, withscores=True),
[(0.1, 'one'), (0.2, 'two'), (0.3, 'three')])
self.assertEqual(self.r_server.zrange('set', 0, -1, desc=True),
['three', 'two', 'one'])
self.assertEqual(
self.r_server.zrange('set', 0, -1, desc=True, withscores=True),
[(0.3, 'three'), (0.2, 'two'), (0.1, 'one')])
def test_incr_with_by_param(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual(2, self.r_server.incr("inc", 1))
self.assertEqual(4, self.r_server.incr("inc", 2))
self.assertEqual(7, self.r_server.incr("inc", 3))
self.assertEqual(11, self.r_server.incr("inc", 4))
self.assertEqual(111, self.r_server.incr("inc", 100))
self.assertEqual('111', self.r_server.get("inc"))
def setUp(self):
yield super(TestCellulantTransportTestCase, self).setUp()
self.config = {
'web_port': 0,
'web_path': '/api/v1/ussd/cellulant/',
'ussd_session_timeout': 60,
'redis': {}
}
self.transport = yield self.get_transport(self.config)
self.transport_url = self.transport.get_transport_url(
self.config['web_path'])
self.transport.r_server = FakeRedis()
def test_hincrby(self):
self.r_server = FakeRedis()
hincrby = self.r_server.hincrby
self.assertEqual(hincrby("inc", "field1"), 1)
self.assertEqual(hincrby("inc", "field1"), 2)
self.assertEqual(hincrby("inc", "field1", 3), 5)
self.assertEqual(hincrby("inc", "field1", "2"), 7)
self.assertRaises(Exception, hincrby, "inc", "field1", "1.5")
self.r_server.hset("inc", "field2", "a")
self.assertRaises(Exception, hincrby, "inc", "field2")
self.r_server.set("key", "string")
self.assertRaises(Exception, self.r_server.hincrby, "key", "field1")
def setUp(self):
super(TestTruteqTransport, self).setUp()
self.dummy_connect = MockConnectTCPForSSMI()
self.patch(reactor, 'connectTCP', self.dummy_connect)
self.config = {
'username': '******',
'password': '******',
'host': 'localhost',
'port': 1234,
}
self.transport = yield self.get_transport(self.config, start=True)
self.transport.r_server = FakeRedis()
def setUp(self):
config = {
'transport_name': 'test_infobip',
'transport_type': 'ussd',
'web_path': "/session/",
'web_port': 0,
}
self.worker = get_stubbed_worker(InfobipTransport, config)
self.broker = self.worker._amqp_client.broker
yield self.worker.startWorker()
self.worker_url = self.worker.get_transport_url()
self.worker.r_server = FakeRedis()
def test_smove(self):
self.r_server = FakeRedis()
self.r_server.sadd('set1', 1)
self.r_server.sadd('set2', 2)
self.assertEqual(self.r_server.smove('set1', 'set2', '1'), True)
self.assertEqual(self.r_server.smembers('set1'), set())
self.assertEqual(self.r_server.smembers('set2'), set(['1', '2']))
self.assertEqual(self.r_server.smove('set1', 'set2', '1'), False)
self.assertEqual(self.r_server.smove('set2', 'set3', '1'), True)
self.assertEqual(self.r_server.smembers('set2'), set(['2']))
self.assertEqual(self.r_server.smembers('set3'), set(['1']))
def test_sequence_rollover(self):
config = ClientConfig(host="127.0.0.1",
port="0",
system_id="1234",
password="******")
esme = FakeEsmeTransceiver(config, FakeRedis(), None)
self.assertEqual(1, esme.get_seq())
esme.get_next_seq()
self.assertEqual(2, esme.get_seq())
esme.set_seq(4004004004)
self.assertEqual(4004004004, esme.get_seq())
esme.get_next_seq()
self.assertEqual(1, esme.get_seq())
def make_worker(self, retry_delivery_period=0):
self.config = {
'transport_name': 'sphex',
'retry_routing_key': 'sms.outbound.%(transport_name)s',
'failures_routing_key': 'sms.failures.%(transport_name)s',
'retry_delivery_period': retry_delivery_period,
}
self.worker = get_stubbed_worker(FailureWorker, self.config)
self.worker.r_server = FakeRedis()
self.worker.r_server.flushdb()
self.redis = self.worker.r_server
yield self.worker.startWorker()
self.broker = self.worker._amqp_client.broker
self.retry_timestamps_key = self.worker._retry_timestamps_key
def mk_transport(self, cls=OperaTransport, **config):
default_config = {
'url': 'http://testing.domain',
'channel': 'channel',
'service': 'service',
'password': '******',
'web_receipt_path': '/receipt.xml',
'web_receive_path': '/receive.xml',
'web_port': self.port
}
default_config.update(config)
self.r_server = FakeRedis()
worker = yield self.get_transport(default_config, cls)
worker.r_server = self.r_server
returnValue(worker)
def test_zrange(self):
self.r_server = FakeRedis()
self.r_server.zadd('set', one=0.1, two=0.2, three=0.3)
self.assertEqual(self.r_server.zrange('set', 0, 0), ['one'])
self.assertEqual(self.r_server.zrange('set', 0, 1), ['one', 'two'])
self.assertEqual(self.r_server.zrange('set', 0, 2),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, 3),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, -1),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, -1, withscores=True),
[(0.1, 'one'), (0.2, 'two'), (0.3, 'three')])
self.assertEqual(self.r_server.zrange('set', 0, -1, desc=True),
['three', 'two', 'one'])
self.assertEqual(self.r_server.zrange('set', 0, -1, desc=True,
withscores=True), [(0.3, 'three'), (0.2, 'two'), (0.1, 'one')])
def setUp(self):
yield super(EsmeToSmscTestCase, self).setUp()
self.config = {
"system_id": "VumiTestSMSC",
"password": "******",
"host": "localhost",
"port": 0,
"redis": {},
"transport_name": self.transport_name,
"transport_type": "smpp",
}
self.service = SmppService(None, config=self.config)
yield self.service.startWorker()
self.service.factory.protocol = SmscTestServer
self.config['port'] = self.service.listening.getHost().port
self.transport = yield self.get_transport(self.config, start=False)
self.transport.r_server = FakeRedis()
self.expected_delivery_status = 'delivered'
def setUp(self):
super(TestHangmanWorker, self).setUp()
root = Resource()
# data is elephant with a UTF-8 encoded BOM
# it is a sad elephant (as seen in the wild)
root.putChild("word", Data('\xef\xbb\xbfelephant\r\n', 'text/html'))
site_factory = Site(root)
self.webserver = yield reactor.listenTCP(0, site_factory)
addr = self.webserver.getHost()
random_word_url = "http://%s:%s/word" % (addr.host, addr.port)
self.worker = yield self.get_application({
'worker_name':
'test_hangman',
'random_word_url':
random_word_url,
})
self.worker.r_server = FakeRedis()
def setUp(self):
super(FakeRedisRespTestCase, self).setUp()
self.config = {
"TRANSPORT_NAME": "redis_testing_transport",
"system_id": "vumitest-vumitest-vumitest",
"host": "host",
"port": "port",
"password": "******",
}
self.vumi_options = {
"vhost": "develop",
}
self.clientConfig = ClientConfig(
system_id=self.config['system_id'],
host=self.config['host'],
port=self.config['port'],
password=self.config['password'],
)
# hack a lot of transport setup
self.transport = yield self.get_transport(self.config, start=False)
self.transport.r_server = FakeRedis()
self.esme_callbacks = EsmeCallbacks(
connect=lambda: None, disconnect=lambda: None,
submit_sm_resp=self.transport.submit_sm_resp,
delivery_report=lambda: None, deliver_sm=lambda: None)
self.esme = RedisTestEsmeTransceiver(
self.clientConfig,
self.transport.r_server,
self.esme_callbacks)
self.esme.state = 'BOUND_TRX'
self.transport.esme_client = self.esme
yield self.transport.startWorker()
self.transport.esme_connected(self.esme)
class Vas2NetsFailureWorkerTestCase(unittest.TestCase):
@inlineCallbacks
def setUp(self):
self.today = datetime.utcnow().date()
self.port = 9999
self.path = "/api/v1/sms/vas2nets/receive/"
self.config = {
"transport_name": "vas2nets",
"url": "http://localhost:%s%s" % (self.port, self.path),
"username": "******",
"password": "******",
"owner": "owner",
"service": "service",
"subservice": "subservice",
"web_receive_path": "/receive",
"web_receipt_path": "/receipt",
"web_port": 9998,
}
self.fail_config = {
"transport_name": "vas2nets",
"retry_routing_key": "sms.outbound.%(transport_name)s",
"failures_routing_key": "sms.outbound.%(transport_name)s.failures",
}
self.workers = []
self.broker = FakeAMQPBroker()
self.redis = FakeRedis()
self.worker = yield self.mk_transport_worker(self.config, self.broker)
self.fail_worker = yield self.mk_failure_worker(self.fail_config, self.broker, self.redis)
def tearDown(self):
for worker in self.workers:
worker.stopWorker()
@inlineCallbacks
def mk_transport_worker(self, config, broker):
worker = get_stubbed_worker(Vas2NetsTransport, config, broker)
self.workers.append(worker)
yield worker.startWorker()
returnValue(worker)
@inlineCallbacks
def mk_failure_worker(self, config, broker, redis):
w = get_stubbed_worker(Vas2NetsFailureWorker, config, broker)
self.workers.append(w)
yield w.startWorker()
w.retry_publisher = yield self.worker.publish_to("foo")
w.r_server = redis
returnValue(w)
@inlineCallbacks
def mk_resource_worker(self, body, headers=None, code=http.OK):
w = get_stubbed_worker(TestResourceWorker, {}, self.broker)
self.workers.append(w)
w.set_resources([(self.path, BadVas2NetsResource, (body, headers, code))])
yield w.startWorker()
returnValue(w)
def get_dispatched(self, rkey):
return self.broker.get_dispatched("vumi", rkey)
def get_retry_keys(self):
timestamps = self.redis.zrange(self.fail_worker._retry_timestamps_key, 0, 0)
retry_keys = set()
for timestamp in timestamps:
bucket_key = self.fail_worker.r_key("retry_keys." + timestamp)
retry_keys.update(self.redis.smembers(bucket_key))
return retry_keys
def mkmsg_out(self, in_reply_to=None):
msg = TransportSMS(
transport="vas2nets",
to_addr="+27761234567",
from_addr="9292",
message_id="1",
in_reply_to=in_reply_to,
transport_metadata={"network_id": "network-id"},
message="hello world",
)
return msg
def assert_dispatched_count(self, count, routing_key):
self.assertEqual(count, len(self.get_dispatched(routing_key)))
@inlineCallbacks
def test_send_sms_success(self):
yield self.mk_resource_worker("Result_code: 00, Message OK")
yield self.worker.handle_outbound_message(self.mkmsg_out())
self.assert_dispatched_count(1, "sms.ack.vas2nets")
self.assert_dispatched_count(0, "sms.failures.vas2nets")
@inlineCallbacks
def test_send_sms_fail(self):
"""
A 'No SmsId Header' error should not be retried.
"""
self.worker.failure_published = FailureCounter(1)
self.worker.SUPPRESS_EXCEPTIONS = True
yield self.mk_resource_worker("Result_code: 04, Internal system error " "occurred while processing message", {})
yield self.worker.handle_outbound_message(self.mkmsg_out())
yield self.worker.failure_published.deferred
self.assert_dispatched_count(0, "sms.ack.vas2nets")
self.assert_dispatched_count(1, "sms.outbound.vas2nets.failures")
[fmsg] = self.get_dispatched("sms.outbound.vas2nets.failures")
fmsg = from_json(fmsg.body)
self.assertTrue("Vas2NetsTransportError: No SmsId Header" in fmsg["reason"])
yield self.broker.kick_delivery()
[key] = self.fail_worker.get_failure_keys()
self.assertEqual(set(), self.get_retry_keys())
@inlineCallbacks
def test_send_sms_noconn(self):
"""
A 'connection refused' error should be retried.
"""
self.worker.failure_published = FailureCounter(1)
self.worker.SUPPRESS_EXCEPTIONS = True
msg = self.mkmsg_out()
yield self.worker.handle_outbound_message(msg)
yield self.worker.failure_published.deferred
self.assert_dispatched_count(0, "sms.ack.vas2nets")
self.assert_dispatched_count(1, "sms.outbound.vas2nets.failures")
[fmsg] = self.get_dispatched("sms.outbound.vas2nets.failures")
fmsg = from_json(fmsg.body)
self.assertEqual(msg, fmsg["message"])
self.assertEqual("connection refused", fmsg["reason"])
yield self.broker.kick_delivery()
[key] = self.fail_worker.get_failure_keys()
self.assertEqual(set([key]), self.get_retry_keys())
def setUp(self):
self.r_server = FakeRedis()
self.store = MessageStore(self.r_server, 'teststore')
class TestMessageStore(ApplicationTestCase):
# inherits from ApplicationTestCase for .mkmsg_in and .mkmsg_out
def setUp(self):
self.r_server = FakeRedis()
self.store = MessageStore(self.r_server, 'teststore')
def tearDown(self):
self.r_server.teardown()
def test_batch_start(self):
tag1 = ("poolA", "tag1")
batch_id = self.store.batch_start([tag1])
self.assertEqual(self.store.batch_messages(batch_id), [])
self.assertEqual(self.store.batch_status(batch_id), {
'ack': 0, 'delivery_report': 0, 'message': 0, 'sent': 0,
})
self.assertEqual(self.store.batch_common(batch_id),
{"tags": [tag1]})
self.assertEqual(self.store.tag_common(tag1),
{"current_batch_id": batch_id})
def test_batch_done(self):
tag1 = ("poolA", "tag1")
batch_id = self.store.batch_start([tag1])
self.store.batch_done(batch_id)
self.assertEqual(self.store.batch_common(batch_id),
{"tags": [tag1]})
self.assertEqual(self.store.tag_common(tag1),
{"current_batch_id": None})
def test_add_outbound_message(self):
msg = self.mkmsg_out(content="outfoo")
msg_id = msg['message_id']
self.store.add_outbound_message(msg)
self.assertEqual(self.store.get_outbound_message(msg_id), msg)
self.assertEqual(self.store.message_events(msg_id), [])
def test_add_outbound_message_with_batch_id(self):
batch_id = self.store.batch_start([("pool", "tag")])
msg = self.mkmsg_out(content="outfoo")
msg_id = msg['message_id']
self.store.add_outbound_message(msg, batch_id=batch_id)
self.assertEqual(self.store.get_outbound_message(msg_id), msg)
self.assertEqual(self.store.message_batches(msg_id), [batch_id])
self.assertEqual(self.store.batch_messages(batch_id), [msg_id])
self.assertEqual(self.store.message_events(msg_id), [])
self.assertEqual(self.store.batch_status(batch_id), {
'ack': 0, 'delivery_report': 0, 'message': 1, 'sent': 1,
})
def test_add_outbound_message_with_tag(self):
batch_id = self.store.batch_start([("pool", "tag")])
msg = self.mkmsg_out(content="outfoo")
msg_id = msg['message_id']
self.store.add_outbound_message(msg, tag=("pool", "tag"))
self.assertEqual(self.store.get_outbound_message(msg_id), msg)
self.assertEqual(self.store.message_batches(msg_id), [batch_id])
self.assertEqual(self.store.batch_messages(batch_id), [msg_id])
self.assertEqual(self.store.message_events(msg_id), [])
self.assertEqual(self.store.batch_status(batch_id), {
'ack': 0, 'delivery_report': 0, 'message': 1, 'sent': 1,
})
def test_add_ack_event(self):
batch_id = self.store.batch_start([("pool", "tag")])
msg = self.mkmsg_out(content="outfoo")
msg_id = msg['message_id']
ack = TransportEvent(user_message_id=msg_id, event_type='ack',
sent_message_id='xyz')
ack_id = ack['event_id']
self.store.add_outbound_message(msg, batch_id=batch_id)
self.store.add_event(ack)
self.assertEqual(self.store.get_event(ack_id), ack)
self.assertEqual(self.store.message_events(msg_id), [ack_id])
def test_add_inbound_message(self):
msg = self.mkmsg_in(content="infoo")
msg_id = msg['message_id']
self.store.add_inbound_message(msg)
self.assertEqual(self.store.get_inbound_message(msg_id), msg)
def test_add_inbound_message_with_batch_id(self):
batch_id = self.store.batch_start([("pool1", "default10001")])
msg = self.mkmsg_in(content="infoo", to_addr="+1234567810001",
transport_type="sms")
msg_id = msg['message_id']
self.store.add_inbound_message(msg, batch_id=batch_id)
self.assertEqual(self.store.get_inbound_message(msg_id), msg)
self.assertEqual(self.store.batch_replies(batch_id), [msg_id])
def test_add_inbound_message_with_tag(self):
batch_id = self.store.batch_start([("pool1", "default10001")])
msg = self.mkmsg_in(content="infoo", to_addr="+1234567810001",
transport_type="sms")
msg_id = msg['message_id']
self.store.add_inbound_message(msg, tag=("pool1", "default10001"))
self.assertEqual(self.store.get_inbound_message(msg_id), msg)
self.assertEqual(self.store.batch_replies(batch_id), [msg_id])
def setUp(self):
self.fake_redis = FakeRedis()
self.sm = SessionManager(self.fake_redis, prefix="test")
def test_delete(self):
self.r_server = FakeRedis()
self.r_server.set("delete_me", 1)
self.assertEqual(True, self.r_server.delete("delete_me"))
self.assertEqual(False, self.r_server.delete("delete_me"))
def setUp(self):
super(TestMemoWorker, self).setUp()
self.worker = yield self.get_application({
'worker_name': 'testmemo',
})
self.worker.r_server = FakeRedis()
class Vas2NetsFailureWorkerTestCase(unittest.TestCase):
@inlineCallbacks
def setUp(self):
self.today = datetime.utcnow().date()
self.port = 9999
self.path = '/api/v1/sms/vas2nets/receive/'
self.config = {
'transport_name': 'vas2nets',
'url': 'http://localhost:%s%s' % (self.port, self.path),
'username': '******',
'password': '******',
'owner': 'owner',
'service': 'service',
'subservice': 'subservice',
'web_receive_path': '/receive',
'web_receipt_path': '/receipt',
'web_port': 9998,
}
self.fail_config = {
'transport_name': 'vas2nets',
'retry_routing_key': '%(transport_name)s.outbound',
'failures_routing_key': '%(transport_name)s.failures',
}
self.workers = []
self.broker = FakeAMQPBroker()
self.redis = FakeRedis()
self.worker = yield self.mk_transport_worker(self.config, self.broker)
self.fail_worker = yield self.mk_failure_worker(
self.fail_config, self.broker, self.redis)
def tearDown(self):
for worker in self.workers:
worker.stopWorker()
@inlineCallbacks
def mk_transport_worker(self, config, broker):
worker = get_stubbed_worker(Vas2NetsTransport, config, broker)
self.workers.append(worker)
yield worker.startWorker()
returnValue(worker)
@inlineCallbacks
def mk_failure_worker(self, config, broker, redis):
w = get_stubbed_worker(FailureWorker, config, broker)
self.workers.append(w)
yield w.startWorker()
w.retry_publisher = yield self.worker.publish_to("foo")
w.r_server = redis
returnValue(w)
@inlineCallbacks
def mk_resource_worker(self, body, headers=None, code=http.OK):
w = get_stubbed_worker(TestResourceWorker, {}, self.broker)
self.workers.append(w)
w.set_resources([(self.path, BadVas2NetsResource,
(body, headers, code))])
yield w.startWorker()
returnValue(w)
def get_dispatched(self, rkey):
return self.broker.get_dispatched('vumi', rkey)
def get_retry_keys(self):
timestamps = self.redis.zrange(
self.fail_worker._retry_timestamps_key, 0, 0)
retry_keys = set()
for timestamp in timestamps:
bucket_key = self.fail_worker.r_key("retry_keys." + timestamp)
retry_keys.update(self.redis.smembers(bucket_key))
return retry_keys
def mkmsg_out(self, in_reply_to=None):
return TransportUserMessage(
to_addr='+41791234567',
from_addr='9292',
message_id='1',
transport_name='vas2nets',
transport_type='sms',
transport_metadata={
'network_id': 'network-id',
},
content='hello world',
in_reply_to=in_reply_to,
)
def assert_dispatched_count(self, count, routing_key):
self.assertEqual(count, len(self.get_dispatched(routing_key)))
@inlineCallbacks
def test_send_sms_success(self):
yield self.mk_resource_worker("Result_code: 00, Message OK")
yield self.worker._process_message(self.mkmsg_out())
self.assert_dispatched_count(1, 'vas2nets.event')
self.assert_dispatched_count(0, 'vas2nets.failures')
@inlineCallbacks
def test_send_sms_fail(self):
"""
A 'No SmsId Header' error should not be retried.
"""
self.worker.failure_published = FailureCounter(1)
yield self.mk_resource_worker("Result_code: 04, Internal system error "
"occurred while processing message",
{})
yield self.worker._process_message(self.mkmsg_out())
yield self.worker.failure_published.deferred
yield self.broker.kick_delivery()
self.assert_dispatched_count(0, 'vas2nets.event')
self.assert_dispatched_count(1, 'vas2nets.failures')
[fmsg] = self.get_dispatched('vas2nets.failures')
fmsg = from_json(fmsg.body)
self.assertTrue(
"Vas2NetsTransportError: No SmsId Header" in fmsg['reason'])
yield self.broker.kick_delivery()
[key] = self.fail_worker.get_failure_keys()
self.assertEqual(set(), self.get_retry_keys())
@inlineCallbacks
def test_send_sms_noconn(self):
"""
A 'connection refused' error should be retried.
"""
self.worker.failure_published = FailureCounter(1)
msg = self.mkmsg_out()
yield self.worker._process_message(msg)
yield self.worker.failure_published.deferred
self.assert_dispatched_count(0, 'vas2nets.event')
self.assert_dispatched_count(1, 'vas2nets.failures')
[fmsg] = self.get_dispatched('vas2nets.failures')
fmsg = from_json(fmsg.body)
self.assertEqual(msg.payload, fmsg['message'])
self.assertEqual(FailureMessage.FC_TEMPORARY,
fmsg['failure_code'])
self.assertTrue(fmsg['reason'].strip().endswith("connection refused"))
yield self.broker.kick_delivery()
[key] = self.fail_worker.get_failure_keys()
self.assertEqual(set([key]), self.get_retry_keys())
def test_sadd(self):
self.r_server = FakeRedis()
self.r_server.sadd('set', 1)
self.r_server.sadd('set', 2, 3, 4)
self.assertEqual(self.r_server.smembers('set'), set([
'1', '2', '3', '4']))
def test_sadd(self):
self.r_server = FakeRedis()
self.r_server.sadd('set', 1)
self.r_server.sadd('set', 2, 3, 4)
self.assertEqual(self.r_server.smembers('set'),
set(['1', '2', '3', '4']))
class SchedulerTestCase(TestCase):
def setUp(self):
self.r_server = FakeRedis()
self.scheduler = Scheduler(self.r_server, self._scheduler_callback)
self._delivery_history = []
def tearDown(self):
if self.scheduler.is_running:
self.scheduler.stop()
def _scheduler_callback(self, scheduled_at, message):
self._delivery_history.append((scheduled_at, message))
return (scheduled_at, message)
def assertDelivered(self, message):
delivered_messages = [TransportUserMessage(**payload)
for _, payload in self._delivery_history]
self.assertIn(message['message_id'],
[message['message_id'] for message in delivered_messages])
def assertNumDelivered(self, number):
self.assertEqual(number, len(self._delivery_history))
def get_pending_messages(self):
scheduled_timestamps = self.scheduler.r_key('scheduled_timestamps')
return self.r_server.zrange(scheduled_timestamps, 0, -1)
def mkmsg_in(self, content='hello world', message_id='abc',
to_addr='9292', from_addr='+41791234567',
session_event=None, transport_type='sms',
transport_name='test_transport',
helper_metadata={}, transport_metadata={}):
return TransportUserMessage(
from_addr=from_addr,
to_addr=to_addr,
message_id=message_id,
transport_name=transport_name,
transport_type=transport_type,
transport_metadata=transport_metadata,
helper_metadata=helper_metadata,
content=content,
session_event=session_event,
timestamp=datetime.now(),
)
def test_scheduling(self):
msg = self.mkmsg_in()
now = time.mktime(datetime(2012, 1, 1).timetuple())
delta = 10 # seconds from now
key, bucket_key = self.scheduler.schedule(delta, msg.payload, now)
self.assertEqual(bucket_key, '%s#%s.%s' % (
self.scheduler.r_prefix,
'scheduled_keys',
self.scheduler.get_next_write_timestamp(delta, now)
))
scheduled_key = self.scheduler.get_scheduled_key(now)
self.assertEqual(scheduled_key, None)
scheduled_time = now + delta
scheduled_key = self.scheduler.get_scheduled_key(scheduled_time)
self.assertTrue(scheduled_key)
self.assertEqual(set([scheduled_key]),
self.scheduler.get_all_scheduled_keys())
@inlineCallbacks
def test_delivery_loop(self):
msg = self.mkmsg_in()
now = time.mktime(datetime(2012, 1, 1).timetuple())
delta = 16 # seconds from now
self.scheduler.schedule(delta, msg.payload, now)
scheduled_time = now + delta + self.scheduler.granularity
yield self.scheduler.deliver_scheduled(scheduled_time)
self.assertDelivered(msg)
@inlineCallbacks
def test_deliver_loop_future(self):
now = time.mktime(datetime(2012, 1, 1).timetuple())
for i in range(0, 3):
msg = self.mkmsg_in(message_id='message_%s' % (i,))
delta = i * 10
key, _ = self.scheduler.schedule(delta, msg.payload, now)
scheduled_time = now + delta + self.scheduler.granularity
self.assertEqual(set([key]),
self.scheduler.get_all_scheduled_keys())
yield self.scheduler.deliver_scheduled(scheduled_time)
self.assertNumDelivered(i + 1)
self.assertEqual(set(), self.scheduler.get_all_scheduled_keys())
@inlineCallbacks
def test_deliver_ancient_messages(self):
# something stuck in the queue since 1912 or scheduler hasn't
# been running since 1912
msg = self.mkmsg_in()
way_back = time.mktime(datetime(1912, 1, 1).timetuple())
scheduled_key, _ = self.scheduler.schedule(0, msg.payload, way_back)
self.assertTrue(scheduled_key)
now = time.mktime(datetime.now().timetuple())
yield self.scheduler.deliver_scheduled(now)
self.assertEqual(set([scheduled_key]),
self.scheduler.get_all_scheduled_keys())
self.assertEqual(len(self.get_pending_messages()), 1)
yield self.scheduler.deliver_scheduled(
way_back + self.scheduler.granularity)
self.assertDelivered(msg)
self.assertEqual(self.get_pending_messages(), [])
self.assertEqual(set(), self.scheduler.get_all_scheduled_keys())
@inlineCallbacks
def test_clear_scheduled_messages(self):
msg = self.mkmsg_in()
now = time.mktime(datetime.now().timetuple())
scheduled_time = now + self.scheduler.granularity
key, bucket = self.scheduler.schedule(0, msg.payload, scheduled_time)
self.assertEqual(len(self.get_pending_messages()), 1)
self.assertEqual(set([key]),
self.scheduler.get_all_scheduled_keys())
self.scheduler.clear_scheduled(key)
yield self.scheduler.deliver_scheduled()
self.assertEqual(self.r_server.hgetall(key), {})
self.assertEqual(self.r_server.smembers(bucket), set())
self.assertNumDelivered(0)
def setUp(self):
self.r_server = FakeRedis()
self.scheduler = Scheduler(self.r_server, self._scheduler_callback)
self._delivery_history = []
class FakeRedisTestCase(TestCase):
def test_delete(self):
self.r_server = FakeRedis()
self.r_server.set("delete_me", 1)
self.assertEqual(True, self.r_server.delete("delete_me"))
self.assertEqual(False, self.r_server.delete("delete_me"))
def test_incr(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual(2, self.r_server.incr("inc"))
self.assertEqual(3, self.r_server.incr("inc"))
self.assertEqual('3', self.r_server.get("inc"))
def test_incr_with_by_param(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual(2, self.r_server.incr("inc", 1))
self.assertEqual(4, self.r_server.incr("inc", 2))
self.assertEqual(7, self.r_server.incr("inc", 3))
self.assertEqual(11, self.r_server.incr("inc", 4))
self.assertEqual(111, self.r_server.incr("inc", 100))
self.assertEqual('111', self.r_server.get("inc"))
def test_zrange(self):
self.r_server = FakeRedis()
self.r_server.zadd('set', one=0.1, two=0.2, three=0.3)
self.assertEqual(self.r_server.zrange('set', 0, 0), ['one'])
self.assertEqual(self.r_server.zrange('set', 0, 1), ['one', 'two'])
self.assertEqual(self.r_server.zrange('set', 0, 2),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, 3),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, -1),
['one', 'two', 'three'])
self.assertEqual(self.r_server.zrange('set', 0, -1, withscores=True),
[(0.1, 'one'), (0.2, 'two'), (0.3, 'three')])
self.assertEqual(self.r_server.zrange('set', 0, -1, desc=True),
['three', 'two', 'one'])
self.assertEqual(self.r_server.zrange('set', 0, -1, desc=True,
withscores=True), [(0.3, 'three'), (0.2, 'two'), (0.1, 'one')])
def test_hgetall_returns_copy(self):
self.r_server = FakeRedis()
self.r_server.hset("hash", "foo", "1")
data = self.r_server.hgetall("hash")
data["foo"] = "2"
self.assertEqual(self.r_server.hgetall("hash"), {
"foo": "1",
})
def test_hincrby(self):
self.r_server = FakeRedis()
hincrby = self.r_server.hincrby
self.assertEqual(hincrby("inc", "field1"), 1)
self.assertEqual(hincrby("inc", "field1"), 2)
self.assertEqual(hincrby("inc", "field1", 3), 5)
self.assertEqual(hincrby("inc", "field1", "2"), 7)
self.assertRaises(Exception, hincrby, "inc", "field1", "1.5")
self.r_server.hset("inc", "field2", "a")
self.assertRaises(Exception, hincrby, "inc", "field2")
self.r_server.set("key", "string")
self.assertRaises(Exception, self.r_server.hincrby, "key", "field1")
def test_sadd(self):
self.r_server = FakeRedis()
self.r_server.sadd('set', 1)
self.r_server.sadd('set', 2, 3, 4)
self.assertEqual(self.r_server.smembers('set'), set([
'1', '2', '3', '4']))
def test_smove(self):
self.r_server = FakeRedis()
self.r_server.sadd('set1', 1)
self.r_server.sadd('set2', 2)
self.assertEqual(self.r_server.smove('set1', 'set2', '1'), True)
self.assertEqual(self.r_server.smembers('set1'), set())
self.assertEqual(self.r_server.smembers('set2'), set(['1', '2']))
self.assertEqual(self.r_server.smove('set1', 'set2', '1'), False)
self.assertEqual(self.r_server.smove('set2', 'set3', '1'), True)
self.assertEqual(self.r_server.smembers('set2'), set(['2']))
self.assertEqual(self.r_server.smembers('set3'), set(['1']))
def test_sunion(self):
self.r_server = FakeRedis()
self.r_server.sadd('set1', 1)
self.r_server.sadd('set2', 2)
self.assertEqual(self.r_server.sunion('set1'), set(['1']))
self.assertEqual(self.r_server.sunion('set1', 'set2'), set(['1', '2']))
self.assertEqual(self.r_server.sunion('other'), set())
class TestContentKeywordRouter(DispatcherTestCase):
dispatcher_class = BaseDispatchWorker
transport_name = 'test_transport'
@inlineCallbacks
def setUp(self):
yield super(TestContentKeywordRouter, self).setUp()
self.config = {
'dispatcher_name': 'keyword_dispatcher',
'router_class': 'vumi.dispatchers.base.ContentKeywordRouter',
'transport_names': ['transport1', 'transport2'],
'transport_mappings': {
'shortcode1': 'transport1',
'shortcode2': 'transport2',
},
'exposed_names': ['app1', 'app2', 'app3', 'fallback_app'],
'rules': [{'app': 'app1',
'keyword': 'KEYWORD1',
'to_addr': '8181',
'prefix': '+256',
},
{'app': 'app2',
'keyword': 'KEYWORD2',
}],
'keyword_mappings': {
'app2': 'KEYWORD3',
'app3': 'KEYWORD1',
},
'fallback_application': 'fallback_app',
'expire_routing_memory': '3',
}
self.fake_redis = FakeRedis()
self.dispatcher = yield self.get_dispatcher(self.config)
self.router = self.dispatcher._router
self.router.r_server = self.fake_redis
def tearDown(self):
self.fake_redis.teardown()
super(TestContentKeywordRouter, self).tearDown()
@inlineCallbacks
def test_inbound_message_routing(self):
msg = self.mkmsg_in(content='KEYWORD1 rest of a msg',
to_addr='8181',
from_addr='+256788601462')
yield self.dispatch(msg,
transport_name='transport1',
direction='inbound')
msg2 = self.mkmsg_in(content='KEYWORD2 rest of a msg',
to_addr='8181',
from_addr='+256788601462')
yield self.dispatch(msg2,
transport_name='transport1',
direction='inbound')
msg3 = self.mkmsg_in(content='KEYWORD3 rest of a msg',
to_addr='8181',
from_addr='+256788601462')
yield self.dispatch(msg3,
transport_name='transport1',
direction='inbound')
app1_inbound_msg = self.get_dispatched_messages('app1',
direction='inbound')
self.assertEqual(app1_inbound_msg, [msg])
app2_inbound_msg = self.get_dispatched_messages('app2',
direction='inbound')
self.assertEqual(app2_inbound_msg, [msg2, msg3])
app3_inbound_msg = self.get_dispatched_messages('app3',
direction='inbound')
self.assertEqual(app3_inbound_msg, [msg])
@inlineCallbacks
def test_inbound_message_routing_empty_message_content(self):
msg = self.mkmsg_in(content=None)
yield self.dispatch(msg,
transport_name='transport1',
direction='inbound')
app1_inbound_msg = self.get_dispatched_messages('app1',
direction='inbound')
self.assertEqual(app1_inbound_msg, [])
app2_inbound_msg = self.get_dispatched_messages('app2',
direction='inbound')
self.assertEqual(app2_inbound_msg, [])
fallback_msgs = self.get_dispatched_messages('fallback_app',
direction='inbound')
self.assertEqual(fallback_msgs, [msg])
@inlineCallbacks
def test_inbound_message_routing_not_casesensitive(self):
msg = self.mkmsg_in(content='keyword1 rest of a msg',
to_addr='8181',
from_addr='+256788601462')
yield self.dispatch(msg,
transport_name='transport1',
direction='inbound')
app1_inbound_msg = self.get_dispatched_messages('app1',
direction='inbound')
self.assertEqual(app1_inbound_msg, [msg])
@inlineCallbacks
def test_inbound_event_routing_ok(self):
msg = self.mkmsg_ack(user_message_id='1',
transport_name='transport1')
self.router.r_server.set('keyword_dispatcher:message:1',
'app2')
yield self.dispatch(msg,
transport_name='transport1',
direction='event')
app2_event_msg = self.get_dispatched_messages('app2',
direction='event')
self.assertEqual(app2_event_msg, [msg])
app1_event_msg = self.get_dispatched_messages('app1',
direction='event')
self.assertEqual(app1_event_msg, [])
@inlineCallbacks
def test_inbound_event_routing_failing_publisher_not_defined(self):
msg = self.mkmsg_ack(transport_name='transport1')
yield self.dispatch(msg,
transport_name='transport1',
direction='event')
app1_routed_msg = self.get_dispatched_messages('app1',
direction='event')
self.assertEqual(app1_routed_msg, [])
app2_routed_msg = self.get_dispatched_messages('app2',
direction='event')
self.assertEqual(app2_routed_msg, [])
@inlineCallbacks
def test_inbound_event_routing_failing_no_routing_back_in_redis(self):
msg = self.mkmsg_ack(transport_name='transport1')
yield self.dispatch(msg,
transport_name='transport1',
direction='event')
app1_routed_msg = self.get_dispatched_messages('app1',
direction='event')
self.assertEqual(app1_routed_msg, [])
app2_routed_msg = self.get_dispatched_messages('app2',
direction='event')
self.assertEqual(app2_routed_msg, [])
@inlineCallbacks
def test_outbound_message_routing(self):
msg = self.mkmsg_out(content="KEYWORD1 rest of msg",
from_addr='shortcode1',
transport_name='app2')
yield self.dispatch(msg,
transport_name='app2',
direction='outbound')
transport1_msgs = self.get_dispatched_messages('transport1',
direction='outbound')
self.assertEqual(transport1_msgs, [msg])
transport2_msgs = self.get_dispatched_messages('transport2',
direction='outbound')
self.assertEqual(transport2_msgs, [])
app2_route = self.fake_redis.get('keyword_dispatcher:message:1')
self.assertEqual(app2_route, 'app2')
def test_delete(self):
self.r_server = FakeRedis()
self.r_server.set("delete_me", 1)
self.assertEqual(True, self.r_server.delete("delete_me"))
self.assertEqual(False, self.r_server.delete("delete_me"))
def setUp(self):
self.prefix = "testpool"
self.tagpool = TagpoolManager(FakeRedis(), self.prefix)
class FakeRedisIncrTestCase(TestCase):
def test_incr(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual('2', self.r_server.incr("inc"))
self.assertEqual('3', self.r_server.incr("inc"))
def test_incrby(self):
self.r_server = FakeRedis()
self.r_server.set("inc", 1)
self.assertEqual('1', self.r_server.get("inc"))
self.assertEqual('2', self.r_server.incrby("inc", 1))
self.assertEqual('4', self.r_server.incrby("inc", 2))
self.assertEqual('7', self.r_server.incrby("inc", 3))
self.assertEqual('11', self.r_server.incrby("inc", 4))
self.assertEqual('111', self.r_server.incrby("inc", 100))
