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(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 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 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):
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 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_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):
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 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 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 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_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 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 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_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 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 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 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):
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 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):
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)
def setUp(self):
super(TestMemoWorker, self).setUp()
self.worker = yield self.get_application({
'worker_name': 'testmemo',
})
self.worker.r_server = FakeRedis()
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 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):
self.prefix = "testpool"
self.tagpool = TagpoolManager(FakeRedis(), self.prefix)
def setup_transport(self):
log.msg('Setting up the fake transport with FakeRedis')
self.r_server = FakeRedis()
self.r_prefix = "%(transport_name)s" % self.config
