class MiddlewareHelper(object):
implements(IHelper)
def __init__(self, middleware_class):
self._vumi_helper = VumiApiHelper()
self._msg_helper = GoMessageHelper()
self.middleware_class = middleware_class
self._middlewares = []
generate_proxies(self, self._vumi_helper)
generate_proxies(self, self._msg_helper)
def setup(self):
return self._vumi_helper.setup(setup_vumi_api=False)
@inlineCallbacks
def cleanup(self):
for mw in self._middlewares:
yield mw.teardown_middleware()
yield self._vumi_helper.cleanup()
@inlineCallbacks
def create_middleware(self, config=None, middleware_class=None,
name='dummy_middleware'):
worker_helper = self._vumi_helper.get_worker_helper()
dummy_worker = yield worker_helper.get_worker(
ToyWorker, self.mk_config({}))
config = self.mk_config(config or {})
if middleware_class is None:
middleware_class = self.middleware_class
mw = middleware_class(name, config, dummy_worker)
self._middlewares.append(mw)
yield mw.setup_middleware()
returnValue(mw)
def __init__(self, middleware_class):
self._vumi_helper = VumiApiHelper()
self._msg_helper = GoMessageHelper()
self.middleware_class = middleware_class
self._middlewares = []
generate_proxies(self, self._vumi_helper)
generate_proxies(self, self._msg_helper)
def __init__(self, use_riak=True):
# Note: We pass `is_sync=True` to the VumiApiHelper because a Django
# test case cannot be async. We define a property lower down that
# proxies `is_sync` from the VumiApiHelper we're wrapping so that
# we can be used by other helpers more easily.
self._vumi_helper = VumiApiHelper(is_sync=True, use_riak=use_riak)
self.use_riak = use_riak # So create_user_profile() knows what to do.
generate_proxies(self, self._vumi_helper)
# TODO: Better/more generic way to do this patching?
self._settings_patches = []
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.msg_helper = self.add_helper(
GoMessageHelper(vumi_helper=self.vumi_helper))
self.user_helper = yield self.vumi_helper.make_user(u'user')
self.conv = yield self.user_helper.create_conversation(
conversation_type=u'some_conversation')
def setUp(self):
super(TestMessageStoreResource, self).setUp()
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.msg_helper = self.add_helper(GoMessageHelper())
self.user_helper = yield self.vumi_helper.make_user(u"user")
self.app_worker.user_api = self.user_helper.user_api
self.message_store = self.vumi_helper.get_vumi_api().mdb
self.conversation = yield self.user_helper.create_conversation(
u'jsbox', started=True)
# store inbound
yield self.message_store.add_inbound_message(
self.msg_helper.make_inbound('hello'),
batch_id=self.conversation.batch.key)
# store outbound
outbound_msg = self.msg_helper.make_outbound('hello')
yield self.message_store.add_outbound_message(
outbound_msg, batch_id=self.conversation.batch.key)
# ack outbound
event = self.msg_helper.make_ack(outbound_msg)
yield self.message_store.add_event(event)
# monkey patch for when no conversation_key is provided
self.app_worker.conversation_for_api = lambda *a: self.conversation
yield self.create_resource({})
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.msg_helper = self.add_helper(GoMessageHelper())
self.billing_api = BillingApiMock()
self.ri_helper = self.vumi_helper.get_worker_helper(
"billing_dispatcher_ri")
self.ro_helper = self.vumi_helper.get_worker_helper(
"billing_dispatcher_ro")
def setUp(self):
super(TestGoOutboundResource, self).setUp()
yield self.create_resource({})
self.vumi_helper = yield self.add_helper(VumiApiHelper(),
setup_vumi_api=True)
self.app_helper = self.add_helper(
ApplicationHelper(u"dummy", self.vumi_helper))
self.msg_helper = self.add_helper(GoMessageHelper())
def __init__(self, middleware_class):
self._vumi_helper = VumiApiHelper()
self._msg_helper = GoMessageHelper()
self.middleware_class = middleware_class
self._middlewares = []
generate_proxies(self, self._vumi_helper)
generate_proxies(self, self._msg_helper)
def setUp(self):
self.vumi_helper = yield self.add_helper(
VumiApiHelper(is_sync=self.is_sync))
self.user_helper = yield self.vumi_helper.make_user(u'user')
user_account = yield self.user_helper.get_user_account()
self.optout_store = OptOutStore.from_user_account(user_account)
self.conv_store = ConversationStore.from_user_account(user_account)
self.contact_store = ContactStore.from_user_account(user_account)
def setUp(self):
super(TestContactsResource, self).setUp()
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.make_user(u"user")
self.app_worker.user_api = self.user_helper.user_api
self.contact_store = self.user_helper.user_api.contact_store
yield self.create_resource({'delivery_class': u'sms'})
def setUp(self):
super(TestGroupsResource, self).setUp()
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.make_user(u"user")
self.app_worker.user_api = self.user_helper.user_api
self.contact_store = self.user_helper.user_api.contact_store
yield self.create_resource({})
def __init__(self, worker_class, **msg_helper_args):
self._worker_class = worker_class
self.vumi_helper = VumiApiHelper()
self._app_helper = ApplicationHelper(self._conversation_type(),
self.vumi_helper)
self.msg_helper = GoMessageHelper(**msg_helper_args)
self.transport_name = self.msg_helper.transport_name
self.worker_helper = self.vumi_helper.get_worker_helper(
self.transport_name)
self.dispatch_helper = MessageDispatchHelper(self.msg_helper,
self.worker_helper)
# Proxy methods from our helpers.
generate_proxies(self, self._app_helper)
generate_proxies(self, self.msg_helper)
generate_proxies(self, self.worker_helper)
generate_proxies(self, self.dispatch_helper)
def setUp(self):
self.vumi_helper = yield self.add_helper(
VumiApiHelper(is_sync=self.is_sync))
self.vumi_api = self.vumi_helper.get_vumi_api()
self.user_helper = yield self.vumi_helper.make_user(u'Buster')
self.user_api = self.user_helper.user_api
# Some stores for old versions to test migrations.
self.account_store_vnone = AccountStoreVNone(self.vumi_api.manager)
self.account_store_v1 = AccountStoreV1(self.vumi_api.manager)
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.make_user(u'user')
user_account = yield self.user_helper.get_user_account()
self.store = ContactStore.from_user_account(user_account)
self.alt_user_helper = yield self.vumi_helper.make_user(u'other_user')
alt_user_account = yield self.alt_user_helper.get_user_account()
self.store_alt = ContactStore.from_user_account(alt_user_account)
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.get_or_create_user()
riak_manager = self.vumi_helper.get_riak_manager()
self.contact_store = ContactStore(
riak_manager, self.user_helper.account_key)
# Old contact proxy for making unindexed contacts.
per_account_manager = riak_manager.sub_manager(
self.user_helper.account_key)
self.contacts_v1 = per_account_manager.proxy(ContactV1)
def __init__(self, worker_class, **msg_helper_args):
self._worker_class = worker_class
msg_helper_kw = {}
if msg_helper_args is not None:
msg_helper_kw.update(msg_helper_args)
self.vumi_helper = VumiApiHelper()
self._router_helper = RouterHelper(
self._router_type(), self.vumi_helper)
self.msg_helper = GoMessageHelper(**msg_helper_kw)
# Proxy methods from our helpers.
generate_proxies(self, self._router_helper)
generate_proxies(self, self.msg_helper)
self.ri = RouterConnectorHelper(
'ri_conn', self.vumi_helper, self.msg_helper)
self.ro = RouterConnectorHelper(
'ro_conn', self.vumi_helper, self.msg_helper)
def setUp(self):
self.vumi_helper = self.add_helper(VumiApiHelper(),
setup_vumi_api=False)
self.worker_helper = self.vumi_helper.get_worker_helper()
self.api = yield self.worker_helper.get_worker(
CommandDispatcher,
self.vumi_helper.mk_config({
'transport_name':
'this should not be an ApplicationWorker',
'worker_names': ['worker_1', 'worker_2'],
}))
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.make_user(u'user')
self.user_api = self.user_helper.user_api
self.campaign_key = self.user_helper.account_key
site = Site(
GoApiServer(self.campaign_key, self.vumi_helper.get_vumi_api()))
self.server = yield reactor.listenTCP(0, site)
self.add_cleanup(self.server.loseConnection)
addr = self.server.getHost()
self.proxy = Proxy("http://%s:%d/" % (addr.host, addr.port))
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
response = Mock()
response.code = http.OK
response.delivered_body = 'javascript!'
self.mocked_url_call = Mock(
side_effect=[succeed(response),
succeed(response)])
self.patch(ConversationConfigResource, 'load_source_from_url',
self.mocked_url_call)
self.config = self.vumi_helper.mk_config({
'worker_name': 'conversation_api_worker',
'web_path': '/foo/',
'web_port': 0,
'health_path': '/health/',
})
self.worker = yield self.vumi_helper.get_worker_helper().get_worker(
ConversationApiWorker, self.config)
self.addr = self.worker.webserver.getHost()
self.url = 'http://%s:%s%s' % (self.addr.host, self.addr.port,
self.config['web_path'])
self.user_helper = yield self.vumi_helper.make_user(u'user')
yield self.vumi_helper.setup_tagpool(u"pool", [u"tag1", u"tag2"])
yield self.user_helper.add_tagpool_permission(u"pool")
self.conversation = yield self.user_helper.create_conversation(
u'jsbox',
config={
'jsbox_app_config': {
'config': {
'source_url': 'http://configsourcecode/'
},
},
'jsbox': {
'source_url': 'http://sourcecode/',
},
'http_api': {
'api_tokens': ['token-1', 'token-2', 'token-3'],
'metrics_store': 'metrics_store'
},
})
self.auth_headers = {
'Authorization': [
'Basic ' +
base64.b64encode('%s:%s' %
(self.user_helper.account_key, 'token-1'))
],
}
def setUp(self):
self.vumi_helper = self.add_helper(VumiApiHelper(),
setup_vumi_api=False)
self.worker_helper = self.vumi_helper.get_worker_helper()
self.ed = yield self.worker_helper.get_worker(
EventDispatcher,
self.vumi_helper.mk_config({
'transport_name': 'this should not be an ApplicationWorker',
'event_handlers': {
'handler1':
"%s.%s" % (SendMessageCommandHandler.__module__,
SendMessageCommandHandler.__name__)
},
}))
class MiddlewareHelper(object):
implements(IHelper)
def __init__(self, middleware_class):
self._vumi_helper = VumiApiHelper()
self._msg_helper = GoMessageHelper()
self.middleware_class = middleware_class
self._middlewares = []
generate_proxies(self, self._vumi_helper)
generate_proxies(self, self._msg_helper)
def setup(self):
return self._vumi_helper.setup(setup_vumi_api=False)
@inlineCallbacks
def cleanup(self):
for mw in self._middlewares:
yield mw.teardown_middleware()
yield self._vumi_helper.cleanup()
@inlineCallbacks
def create_middleware(self,
config=None,
middleware_class=None,
name='dummy_middleware'):
worker_helper = self._vumi_helper.get_worker_helper()
dummy_worker = yield worker_helper.get_worker(ToyWorker,
self.mk_config({}))
config = self.mk_config(config or {})
if middleware_class is None:
middleware_class = self.middleware_class
mw = middleware_class(name, config, dummy_worker)
self._middlewares.append(mw)
yield mw.setup_middleware()
returnValue(mw)
def setUp(self):
self.vumi_helper = self.add_helper(VumiApiHelper(),
setup_vumi_api=False)
self.worker_helper = self.vumi_helper.get_worker_helper()
self.ed = yield self.worker_helper.get_worker(
EventDispatcher,
self.vumi_helper.mk_config({
'transport_name': 'this should not be an ApplicationWorker',
'event_handlers': {
'handler1': '%s.ToyHandler' % __name__,
'handler2': '%s.ToyHandler' % __name__,
},
}))
self.handler1 = self.ed.handlers['handler1']
self.handler2 = self.ed.handlers['handler2']
def setUp(self):
self.vumi_helper = self.add_helper(VumiApiHelper(is_sync=True))
self.user_helper = self.vumi_helper.get_or_create_user()
wrapped_conv = self.user_helper.create_conversation(
u'subscription',
config={
'handlers': [{
'campaign_name': 'campaign-1'
}, {
'campaign_name': 'campaign-2'
}]
})
self.conv = wrapped_conv.c
self.conv_def = ConversationDefinition(self.conv)
def test_add_conversation_metadata(self):
md = self.mk_md()
self.assertEqual(md._go_metadata, {})
vumi_helper = yield self.add_helper(VumiApiHelper())
user_helper = yield vumi_helper.make_user(u'user')
conv = yield user_helper.create_conversation(u'bulk_message')
md.add_conversation_metadata(conv)
self.assertEqual(
md._go_metadata, {
'user_account': user_helper.account_key,
'conversation_type': conv.conversation_type,
'conversation_key': conv.key,
})
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.make_user(u'username')
self.msg_helper = self.add_helper(
GoMessageHelper(vumi_helper=self.vumi_helper))
self.conv = yield self.user_helper.create_conversation(u'dummy')
yield self.vumi_helper.setup_tagpool(
u"pool", [u"tag%s" % (i, ) for i in range(1, 5)],
metadata={
"display_name": "pool",
"delivery_class": "sms",
"transport_type": "sms",
"transport_name": self.msg_helper.transport_name,
})
yield self.user_helper.add_tagpool_permission(u"pool")
def test_add_router_metadata(self):
md = self.mk_md()
self.assertEqual(md._go_metadata, {})
vumi_helper = yield self.add_helper(VumiApiHelper())
user_helper = yield vumi_helper.make_user(u'user')
router = yield user_helper.create_router(u'keyword')
md.add_router_metadata(router)
self.assertEqual(
md._go_metadata, {
'user_account': user_helper.account_key,
'router_type': router.router_type,
'router_key': router.key,
})
def __init__(self, worker_class, **msg_helper_args):
self._worker_class = worker_class
self.vumi_helper = VumiApiHelper()
self._app_helper = ApplicationHelper(
self._conversation_type(), self.vumi_helper)
self.msg_helper = GoMessageHelper(**msg_helper_args)
self.transport_name = self.msg_helper.transport_name
self.worker_helper = self.vumi_helper.get_worker_helper(
self.transport_name)
self.dispatch_helper = MessageDispatchHelper(
self.msg_helper, self.worker_helper)
# Proxy methods from our helpers.
generate_proxies(self, self._app_helper)
generate_proxies(self, self.msg_helper)
generate_proxies(self, self.worker_helper)
generate_proxies(self, self.dispatch_helper)
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.get_or_create_user()
self.conv = yield self.user_helper.create_conversation(
u'some_conversation')
contact_store = self.user_helper.user_api.contact_store
self.contact1 = yield contact_store.new_contact(
name=u'contact-1',
msisdn=u'+27831234567')
self.contact2 = yield contact_store.new_contact(
name=u'contact-2',
msisdn=u'+27831234568')
yield self.contact1.save()
yield self.contact2.save()
self.metric = ToySubscriptionMetric(self.conv, 'campaign-1')
def setUp(self):
super(TestOptOutResource, self).setUp()
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.msg_helper = self.add_helper(GoMessageHelper())
self.user_helper = yield self.vumi_helper.make_user(u'user')
user_account = yield self.user_helper.get_user_account()
user_account.can_manage_optouts = True
yield user_account.save()
self.app_worker.user_api = self.user_helper.user_api
self.contact_store = self.user_helper.user_api.contact_store
self.optout_store = OptOutStore.from_user_account(user_account)
yield self.create_resource({})
self.contact1 = yield self.new_contact(name=u'A',
surname=u'Person',
msisdn=u'+27123456789')
self.contact2 = yield self.new_contact(name=u'B',
surname=u'Person',
msisdn=u'+27000000000')
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.vumi_api = yield self.vumi_helper.get_vumi_api()
class AppWorkerHelper(object):
implements(IHelper)
def __init__(self, worker_class, **msg_helper_args):
self._worker_class = worker_class
self.vumi_helper = VumiApiHelper()
self._app_helper = ApplicationHelper(
self._conversation_type(), self.vumi_helper)
self.msg_helper = GoMessageHelper(**msg_helper_args)
self.transport_name = self.msg_helper.transport_name
self.worker_helper = self.vumi_helper.get_worker_helper(
self.transport_name)
self.dispatch_helper = MessageDispatchHelper(
self.msg_helper, self.worker_helper)
# Proxy methods from our helpers.
generate_proxies(self, self._app_helper)
generate_proxies(self, self.msg_helper)
generate_proxies(self, self.worker_helper)
generate_proxies(self, self.dispatch_helper)
def _worker_name(self):
return self._worker_class.worker_name
def _conversation_type(self):
# This is a guess based on worker_name.
# TODO: We need a better way to do this, probably involving either the
# conversation definition or go.config.
return self._worker_name().rpartition('_')[0].decode('utf-8')
def setup(self):
return self.vumi_helper.setup(setup_vumi_api=False)
def cleanup(self):
return self.vumi_helper.cleanup()
@inlineCallbacks
def get_app_worker(self, config=None, start=True):
# Note: We assume that this is called exactly once per test.
config = self.vumi_helper.mk_config(config or {})
config.setdefault('worker_name', self._worker_name())
config.setdefault('transport_name', self.msg_helper.transport_name)
worker = yield self.get_worker(self._worker_class, config, start)
# Set up our other bits of helper.
self.vumi_helper.set_vumi_api(worker.vumi_api)
self.msg_helper.mdb = worker.vumi_api.mdb
returnValue(worker)
@inlineCallbacks
def start_conversation(self, conversation):
assert self._get_pending_commands() == [], (
"Found pending commands while starting conversation, aborting.")
yield conversation.start()
yield self.dispatch_commands_to_app()
@inlineCallbacks
def stop_conversation(self, conversation):
assert self._get_pending_commands() == [], (
"Found pending commands while stopping conversation, aborting.")
yield conversation.stop_conversation()
yield self.dispatch_commands_to_app()
def _get_pending_commands(self):
return self.worker_helper.get_dispatched('vumi', 'api', VumiApiCommand)
@inlineCallbacks
def dispatch_commands_to_app(self):
pending_commands = self._get_pending_commands()
self.worker_helper._clear_dispatched('vumi', 'api')
for command in pending_commands:
yield self.worker_helper.dispatch_raw(
"%s.control" % (self._worker_name(),), command)
@inlineCallbacks
def dispatch_command(self, command, *args, **kw):
cmd = VumiApiCommand.command(
self._worker_name(), command, *args, **kw)
yield self.worker_helper.dispatch_raw('vumi.api', cmd)
yield self.dispatch_commands_to_app()
def get_published_metrics(self, worker):
metrics = []
for metric_msg in self.worker_helper.get_dispatched_metrics():
for name, _aggs, data in metric_msg:
for _time, value in data:
metrics.append((name, value))
return metrics
def get_dispatched_app_events(self):
return self.worker_helper.get_dispatched('vumi', 'event', VumiApiEvent)
class DjangoVumiApiHelper(object):
implements(IHelper)
def __init__(self, use_riak=True):
# Note: We pass `is_sync=True` to the VumiApiHelper because a Django
# test case cannot be async. We define a property lower down that
# proxies `is_sync` from the VumiApiHelper we're wrapping so that
# we can be used by other helpers more easily.
self._vumi_helper = VumiApiHelper(is_sync=True, use_riak=use_riak)
self.use_riak = use_riak # So create_user_profile() knows what to do.
generate_proxies(self, self._vumi_helper)
# TODO: Better/more generic way to do this patching?
self._settings_patches = []
def setup(self, setup_vumi_api=True):
# We defer `setup_vumi_api` until we've patched Django.
self._vumi_helper.setup(False)
self.replace_django_bits()
if setup_vumi_api:
return self.setup_vumi_api()
def cleanup(self):
self._vumi_helper.cleanup()
self.restore_django_bits()
for patch in reversed(self._settings_patches):
patch.disable()
@property
def is_sync(self):
return self._vumi_helper.is_sync
@property
def amqp_connection(self):
return getattr(self._vumi_helper, 'django_amqp_connection', None)
def replace_django_bits(self):
self._replace_settings()
self._replace_post_save_hooks()
def _replace_settings(self):
# We do this redis manager hackery here because we might use it from
# Django-land before setting (or without) up a vumi_api.
# TODO: Find a nicer way to give everything the same fake redis.
pcfg = self._vumi_helper._persistence_helper._config_overrides
pcfg['redis_manager']['FAKE_REDIS'] = self.get_redis_manager()
vumi_config = self.mk_config(settings.VUMI_API_CONFIG)
self.patch_settings(VUMI_API_CONFIG=vumi_config)
def _replace_post_save_hooks(self):
has_listeners = lambda: post_save.has_listeners(get_user_model())
assert has_listeners(), (
"User model has no post_save listeners. Make sure"
" DjangoVumiApiHelper is cleaned up properly in earlier tests.")
post_save.disconnect(
sender=get_user_model(),
dispatch_uid='go.base.models.create_user_profile')
assert not has_listeners(), (
"User model still has post_save listeners. Make sure"
" DjangoVumiApiHelper is cleaned up properly in earlier tests.")
post_save.connect(
self.create_user_profile,
sender=get_user_model(),
dispatch_uid='DjangoVumiApiHelper.create_user_profile')
def restore_django_bits(self):
post_save.disconnect(
sender=get_user_model(),
dispatch_uid='DjangoVumiApiHelper.create_user_profile')
post_save.connect(
base_models.create_user_profile,
sender=get_user_model(),
dispatch_uid='go.base.models.create_user_profile')
@proxyable
def get_client(self, username='******', password='******'):
client = Client()
client.login(username=username, password=password)
return client
@proxyable
def patch_settings(self, **kwargs):
patch = override_settings(**kwargs)
patch.enable()
self._settings_patches.append(patch)
@proxyable
def make_django_user(self, email='*****@*****.**', password='******',
first_name="Test", last_name="User", superuser=False):
if superuser:
user = get_user_model().objects.create_superuser(
email=email, password=password)
else:
user = get_user_model().objects.create_user(
email=email, password=password)
user.first_name = first_name
user.last_name = last_name
user.save()
user_api = base_utils.vumi_api_for_user(user)
return self.get_user_helper(user_api.user_account_key)
def create_user_profile(self, sender, instance, created, **kwargs):
if not created:
return
if not self.use_riak:
# Just create the account key, no actual user.
base_models.UserProfile.objects.create(
user=instance, user_account=uuid.uuid4())
return
user_helper = self.make_user(
unicode(instance.email), enable_search=True,
django_user_pk=instance.pk)
base_models.UserProfile.objects.create(
user=instance, user_account=user_helper.account_key)
class RouterWorkerHelper(object):
implements(IHelper)
def __init__(self, worker_class, **msg_helper_args):
self._worker_class = worker_class
msg_helper_kw = {}
if msg_helper_args is not None:
msg_helper_kw.update(msg_helper_args)
self.vumi_helper = VumiApiHelper()
self._router_helper = RouterHelper(
self._router_type(), self.vumi_helper)
self.msg_helper = GoMessageHelper(**msg_helper_kw)
# Proxy methods from our helpers.
generate_proxies(self, self._router_helper)
generate_proxies(self, self.msg_helper)
self.ri = RouterConnectorHelper(
'ri_conn', self.vumi_helper, self.msg_helper)
self.ro = RouterConnectorHelper(
'ro_conn', self.vumi_helper, self.msg_helper)
def _worker_name(self):
return self._worker_class.worker_name
def _router_type(self):
# This is a guess based on worker_name.
# We need a better way to do this.
return self._worker_name().rpartition('_')[0].decode('utf-8')
def setup(self):
self.vumi_helper.setup(setup_vumi_api=False)
@inlineCallbacks
def cleanup(self):
yield self.ro.cleanup()
yield self.ri.cleanup()
yield self.msg_helper.cleanup()
yield self.vumi_helper.cleanup()
@inlineCallbacks
def get_router_worker(self, config=None, start=True):
# Note: We assume that this is called exactly once per test.
config = self.vumi_helper.mk_config(config or {})
config.setdefault('worker_name', self._worker_name())
config.setdefault('ri_connector_name', self.ri.connector_name)
config.setdefault('ro_connector_name', self.ro.connector_name)
worker = yield self.ri.get_worker(self._worker_class, config, start)
# Set up our other bits of helper.
self.vumi_helper.set_vumi_api(worker.vumi_api)
self.msg_helper.mdb = worker.vumi_api.mdb
returnValue(worker)
@inlineCallbacks
def start_router(self, router):
assert self._get_pending_commands() == [], (
"Found pending commands while starting router, aborting.")
user_helper = yield self.vumi_helper.get_or_create_user()
router_api = user_helper.user_api.get_router_api(
router.router_type, router.key)
yield router_api.start_router(router)
yield self.dispatch_commands_to_router()
@inlineCallbacks
def stop_router(self, router):
assert self._get_pending_commands() == [], (
"Found pending commands while stopping router, aborting.")
user_helper = yield self.vumi_helper.get_or_create_user()
router_api = user_helper.user_api.get_router_api(
router.router_type, router.key)
yield router_api.stop_router(router)
yield self.dispatch_commands_to_router()
def _get_pending_commands(self):
return self.ri.get_dispatched('vumi', 'api', VumiApiCommand)
@inlineCallbacks
def dispatch_commands_to_router(self):
pending_commands = self._get_pending_commands()
self.ri._worker_helper._clear_dispatched('vumi', 'api')
for command in pending_commands:
yield self.ri.dispatch_raw(
"%s.control" % (self._worker_name(),), command)
@inlineCallbacks
def dispatch_command(self, command, *args, **kw):
cmd = VumiApiCommand.command(
self._worker_name(), command, *args, **kw)
yield self.dispatch_raw('vumi.api', cmd)
yield self.dispatch_commands_to_router()
def get_published_metrics(self, worker):
return [
(metric.name, value)
for metric, ((time, value),) in worker.metrics._oneshot_msgs]
def get_dispatched_router_events(self):
return self.get_dispatched('vumi', 'event', VumiApiEvent)
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper(),
setup_vumi_api=True)
self.app_helper = self.add_helper(
ApplicationHelper(u"dummy", self.vumi_helper))
self.msg_helper = self.add_helper(GoMessageHelper())
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.msg_helper = self.add_helper(
GoMessageHelper(vumi_helper=self.vumi_helper))
self.user_helper = yield self.vumi_helper.make_user(u'user')
self.patch(time, 'time', lambda: 1985)
