Rename app_helper to router_helper in router tests.

go/routers/keyword/tests/test_views.py

@@ -6,32 +6,32 @@
 class KeywordViewTests(GoDjangoTestCase):
 
     def setUp(self):
-        self.app_helper = self.add_helper(RouterViewsHelper(u'keyword'))
-        self.user_helper = self.app_helper.vumi_helper.get_or_create_user()
-        self.client = self.app_helper.get_client()
+        self.router_helper = self.add_helper(RouterViewsHelper(u'keyword'))
+        self.user_helper = self.router_helper.vumi_helper.get_or_create_user()
+        self.client = self.router_helper.get_client()
 
     def test_new_router(self):
         router_store = self.user_helper.user_api.router_store
         self.assertEqual([], router_store.list_routers())
 
-        response = self.client.post(self.app_helper.get_new_view_url(), {
+        response = self.client.post(self.router_helper.get_new_view_url(), {
             'name': u"myrouter",
             'router_type': u'keyword',
         })
         [router_key] = router_store.list_routers()
-        rtr_helper = self.app_helper.get_router_helper_by_key(router_key)
+        rtr_helper = self.router_helper.get_router_helper_by_key(router_key)
         self.assertRedirects(response, rtr_helper.get_view_url('edit'))
 
     def test_show_stopped(self):
-        rtr_helper = self.app_helper.create_router(name=u"myrouter")
+        rtr_helper = self.router_helper.create_router(name=u"myrouter")
         response = self.client.get(rtr_helper.get_view_url('show'))
         router = response.context[0].get('router')
         self.assertEqual(router.name, u"myrouter")
         self.assertContains(response, rtr_helper.get_view_url('start'))
         self.assertNotContains(response, rtr_helper.get_view_url('stop'))
 
     def test_show_running(self):
-        rtr_helper = self.app_helper.create_router(
+        rtr_helper = self.router_helper.create_router(
             name=u"myrouter", started=True)
         response = self.client.get(rtr_helper.get_view_url('show'))
         router = response.context[0].get('router')
@@ -40,40 +40,40 @@ def test_show_running(self):
         self.assertContains(response, rtr_helper.get_view_url('stop'))
 
     def test_start(self):
-        rtr_helper = self.app_helper.create_router(started=False)
+        rtr_helper = self.router_helper.create_router(started=False)
 
         response = self.client.post(rtr_helper.get_view_url('start'))
         self.assertRedirects(response, rtr_helper.get_view_url('show'))
         router = rtr_helper.get_router()
         self.assertTrue(router.starting())
-        [start_cmd] = self.app_helper.get_api_commands_sent()
+        [start_cmd] = self.router_helper.get_api_commands_sent()
         self.assertEqual(
             start_cmd, VumiApiCommand.command(
                 '%s_router' % (router.router_type,), 'start',
                 user_account_key=router.user_account.key,
                 router_key=router.key))
 
     def test_stop(self):
-        rtr_helper = self.app_helper.create_router(started=True)
+        rtr_helper = self.router_helper.create_router(started=True)
 
         response = self.client.post(rtr_helper.get_view_url('stop'))
         self.assertRedirects(response, rtr_helper.get_view_url('show'))
         router = rtr_helper.get_router()
         self.assertTrue(router.stopping())
-        [start_cmd] = self.app_helper.get_api_commands_sent()
+        [start_cmd] = self.router_helper.get_api_commands_sent()
         self.assertEqual(
             start_cmd, VumiApiCommand.command(
                 '%s_router' % (router.router_type,), 'stop',
                 user_account_key=router.user_account.key,
                 router_key=router.key))
 
     def test_get_edit_empty_config(self):
-        rtr_helper = self.app_helper.create_router(started=True)
+        rtr_helper = self.router_helper.create_router(started=True)
         response = self.client.get(rtr_helper.get_view_url('edit'))
         self.assertEqual(response.status_code, 200)
 
     def test_get_edit_small_config(self):
-        rtr_helper = self.app_helper.create_router(started=True, config={
+        rtr_helper = self.router_helper.create_router(started=True, config={
             'keyword_endpoint_mapping': {'mykeyw[o0]rd': 'target_endpoint'},
         })
         response = self.client.get(rtr_helper.get_view_url('edit'))
@@ -82,7 +82,7 @@ def test_get_edit_small_config(self):
         self.assertContains(response, 'target_endpoint')
 
     def test_edit_router_keyword_config(self):
-        rtr_helper = self.app_helper.create_router(started=True)
+        rtr_helper = self.router_helper.create_router(started=True)
         router = rtr_helper.get_router()
         self.assertEqual(router.config, {})
         response = self.client.post(rtr_helper.get_view_url('edit'), {

go/routers/keyword/tests/test_vumi_app.py

@@ -13,35 +13,35 @@ class TestKeywordRouter(VumiTestCase):
 
     @inlineCallbacks
     def setUp(self):
-        self.app_helper = self.add_helper(RouterWorkerHelper(KeywordRouter))
-        self.router_worker = yield self.app_helper.get_router_worker({})
+        self.router_helper = self.add_helper(RouterWorkerHelper(KeywordRouter))
+        self.router_worker = yield self.router_helper.get_router_worker({})
 
     @inlineCallbacks
     def assert_routed_inbound(self, content, router, expected_endpoint):
-        msg = yield self.app_helper.make_dispatch_inbound(
+        msg = yield self.router_helper.make_dispatch_inbound(
             content, router=router)
         emsg = msg.copy()
         emsg.set_routing_endpoint(expected_endpoint)
-        rmsg = self.app_helper.get_dispatched_inbound()[-1]
+        rmsg = self.router_helper.get_dispatched_inbound()[-1]
         self.assertEqual(emsg, rmsg)
 
     @inlineCallbacks
     def assert_routed_outbound(self, content, router, src_endpoint):
-        msg = yield self.app_helper.make_dispatch_outbound(
+        msg = yield self.router_helper.make_dispatch_outbound(
             content, router=router, routing_endpoint=src_endpoint)
         emsg = msg.copy()
         emsg.set_routing_endpoint('default')
-        rmsg = self.app_helper.get_dispatched_outbound()[-1]
+        rmsg = self.router_helper.get_dispatched_outbound()[-1]
         self.assertEqual(emsg, rmsg)
 
     @inlineCallbacks
     def assert_routed_event(self, router, expected_endpoint, hops):
-        ack = self.app_helper.make_ack(router=router)
+        ack = self.router_helper.make_ack(router=router)
         self.set_event_hops(ack, hops)
-        yield self.app_helper.dispatch_event(ack)
+        yield self.router_helper.dispatch_event(ack)
         eevent = ack.copy()
         eevent.set_routing_endpoint(expected_endpoint)
-        [revent] = self.app_helper.get_dispatched_events()
+        [revent] = self.router_helper.get_dispatched_events()
         self.assertEqual(eevent, revent)
 
     def set_event_hops(self, event, outbound_hops, num_inbound_hops=1):
@@ -53,50 +53,50 @@ def set_event_hops(self, event, outbound_hops, num_inbound_hops=1):
 
     @inlineCallbacks
     def test_start(self):
-        router = yield self.app_helper.create_router()
+        router = yield self.router_helper.create_router()
         self.assertTrue(router.stopped())
         self.assertFalse(router.running())
 
-        yield self.app_helper.start_router(router)
-        router = yield self.app_helper.get_router(router.key)
+        yield self.router_helper.start_router(router)
+        router = yield self.router_helper.get_router(router.key)
         self.assertFalse(router.stopped())
         self.assertTrue(router.running())
 
     @inlineCallbacks
     def test_stop(self):
-        router = yield self.app_helper.create_router(started=True)
+        router = yield self.router_helper.create_router(started=True)
         self.assertFalse(router.stopped())
         self.assertTrue(router.running())
 
-        yield self.app_helper.stop_router(router)
-        router = yield self.app_helper.get_router(router.key)
+        yield self.router_helper.stop_router(router)
+        router = yield self.router_helper.get_router(router.key)
         self.assertTrue(router.stopped())
         self.assertFalse(router.running())
 
     @inlineCallbacks
     def test_no_messages_processed_while_stopped(self):
-        router = yield self.app_helper.create_router()
+        router = yield self.router_helper.create_router()
 
-        yield self.app_helper.make_dispatch_inbound("foo", router=router)
-        self.assertEqual([], self.app_helper.get_dispatched_inbound())
+        yield self.router_helper.make_dispatch_inbound("foo", router=router)
+        self.assertEqual([], self.router_helper.get_dispatched_inbound())
 
-        yield self.app_helper.make_dispatch_ack(router=router)
-        self.assertEqual([], self.app_helper.get_dispatched_events())
+        yield self.router_helper.make_dispatch_ack(router=router)
+        self.assertEqual([], self.router_helper.get_dispatched_events())
 
-        yield self.app_helper.make_dispatch_outbound("foo", router=router)
-        self.assertEqual([], self.app_helper.get_dispatched_outbound())
-        [nack] = self.app_helper.get_dispatched_events()
+        yield self.router_helper.make_dispatch_outbound("foo", router=router)
+        self.assertEqual([], self.router_helper.get_dispatched_outbound())
+        [nack] = self.router_helper.get_dispatched_events()
         self.assertEqual(nack['event_type'], 'nack')
 
     @inlineCallbacks
     def test_inbound_no_config(self):
-        router = yield self.app_helper.create_router(started=True)
+        router = yield self.router_helper.create_router(started=True)
         yield self.assert_routed_inbound("foo bar", router, 'default')
         yield self.assert_routed_inbound("baz quux", router, 'default')
 
     @inlineCallbacks
     def test_inbound_keyword(self):
-        router = yield self.app_helper.create_router(started=True, config={
+        router = yield self.router_helper.create_router(started=True, config={
             'keyword_endpoint_mapping': {
                 'foo': 'app1',
                 'abc123': 'app2',
@@ -109,15 +109,15 @@ def test_inbound_keyword(self):
 
     @inlineCallbacks
     def test_outbound_no_config(self):
-        router = yield self.app_helper.create_router(started=True)
+        router = yield self.router_helper.create_router(started=True)
         yield self.assert_routed_outbound("foo bar", router, 'default')
         yield self.assert_routed_outbound("baz quux", router, 'default')
         yield self.assert_routed_outbound("foo bar", router, 'app1')
         yield self.assert_routed_outbound("baz quux", router, 'app1')
 
     @inlineCallbacks
     def test_outbound(self):
-        router = yield self.app_helper.create_router(started=True, config={
+        router = yield self.router_helper.create_router(started=True, config={
             'keyword_endpoint_mapping': {
                 'foo': 'app1',
             },
@@ -129,7 +129,7 @@ def test_outbound(self):
 
     @inlineCallbacks
     def test_event_default_to_default(self):
-        router = yield self.app_helper.create_router(started=True, config={
+        router = yield self.router_helper.create_router(started=True, config={
             'keyword_endpoint_mapping': {
                 'foo': 'app1',
             },
@@ -141,7 +141,7 @@ def test_event_default_to_default(self):
 
     @inlineCallbacks
     def test_event_foo_to_default(self):
-        router = yield self.app_helper.create_router(started=True, config={
+        router = yield self.router_helper.create_router(started=True, config={
             'keyword_endpoint_mapping': {
                 'foo': 'app1',
             },
@@ -153,7 +153,7 @@ def test_event_foo_to_default(self):
 
     @inlineCallbacks
     def test_event_default_to_foo(self):
-        router = yield self.app_helper.create_router(started=True, config={
+        router = yield self.router_helper.create_router(started=True, config={
             'keyword_endpoint_mapping': {
                 'foo': 'app1',
             },
@@ -165,7 +165,7 @@ def test_event_default_to_foo(self):
 
     @inlineCallbacks
     def test_event_foo_to_bar(self):
-        router = yield self.app_helper.create_router(started=True, config={
+        router = yield self.router_helper.create_router(started=True, config={
             'keyword_endpoint_mapping': {
                 'foo': 'app1',
             },

go/routers/tests/view_helpers.py

@@ -17,16 +17,16 @@ def __init__(self, router_type):
         self.router_type = router_type
 
         self.vumi_helper = DjangoVumiApiHelper()
-        self._app_helper = RouterHelper(
+        self._router_helper = RouterHelper(
             router_type, self.vumi_helper)
-        self._app_helper.router_wrapper = self.get_router_helper
+        self._router_helper.router_wrapper = self.get_router_helper
 
         # Create the things we need to create
         self.vumi_helper.setup_vumi_api()
         self.vumi_helper.make_django_user()
 
         # Proxy methods from our helpers.
-        generate_proxies(self, self._app_helper)
+        generate_proxies(self, self._router_helper)
         generate_proxies(self, self.vumi_helper)
 
     def setup(self):
@@ -52,7 +52,7 @@ class RouterViewHelper(object):
     def __init__(self, router_views_helper, router_key):
         self.router_key = router_key
         self.router_type = router_views_helper.router_type
-        self.app_helper = router_views_helper
+        self.router_helper = router_views_helper
 
     def get_view_url(self, view):
         view_def = base_utils.get_router_view_definition(
@@ -61,14 +61,14 @@ def get_view_url(self, view):
             view, router_key=self.router_key)
 
     def get_router(self):
-        return self.app_helper.get_router(self.router_key)
+        return self.router_helper.get_router(self.router_key)
 
     def add_stored_inbound(self, count, **kw):
-        msg_helper = GoMessageHelper(mdb=self.app_helper.get_vumi_api().mdb)
+        msg_helper = GoMessageHelper(mdb=self.router_helper.get_vumi_api().mdb)
         conv = self.get_router()
         return msg_helper.add_inbound_to_conv(conv, count, **kw)
 
     def add_stored_replies(self, msgs):
-        msg_helper = GoMessageHelper(mdb=self.app_helper.get_vumi_api().mdb)
+        msg_helper = GoMessageHelper(mdb=self.router_helper.get_vumi_api().mdb)
         conv = self.get_router()
         return msg_helper.add_replies_to_conv(conv, msgs)