class SimplePushRouterTestCase(unittest.TestCase):
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.router = SimpleRouter(settings, {})
self.notif = Notification(10, "data", dummy_chid, None, 200)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
def tearDown(self):
dead_cache.clear()
def _raise_connect_error(self):
raise ConnectError()
def _raise_db_error(self):
raise ProvisionedThroughputExceededException(None, None)
def _raise_item_error(self):
raise ItemNotFound()
def test_register(self):
r = self.router.register(None, {})
eq_(r, {})
def test_route_to_connected(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 200
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 200)
d.addBoth(verify_deliver)
return d
def test_route_connect_error(self):
self.agent_mock.request.side_effect = MockAssist(
[self._raise_connect_error])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.clear_node.return_value = None
d = self.router.route_notification(self.notif, router_data)
def verify_retry(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
eq_(len(self.router_mock.clear_node.mock_calls), 1)
self.router_mock.clear_node.reset_mock()
self.flushLoggedErrors()
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
eq_(len(self.router_mock.clear_node.mock_calls), 1)
self.router_mock.clear_node.reset_mock()
d = self.router.route_notification(self.notif, router_data)
d.addBoth(verify_retry)
return d
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_old_version(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = False
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_throws_db_error(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.side_effect = MockAssist(
[self._raise_db_error]
)
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_db_error]
)
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails_with_item_error(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_item_error]
)
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 404)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_no_node(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.return_value = dict()
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_202(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
assert(self.router_mock.get_uaid.called)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_send_check_fails(self):
import autopush.router.simple as simple
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
assert(self.router_mock.clear_node.called)
nk = simple.node_key(router_data["node_id"])
eq_(simple.dead_cache.get(nk), True)
d.addBoth(verify_deliver)
return d
def test_route_busy_node_saves_looks_up_and_send_check_fails_and_db(self):
import autopush.router.simple as simple
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router_mock.clear_node.side_effect = MockAssist(
[self._raise_db_error]
)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
assert(self.router_mock.clear_node.called)
nk = simple.node_key(router_data["node_id"])
eq_(simple.dead_cache.get(nk), True)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_200(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 200)
self.router.metrics.increment.assert_called_with(
"router.broadcast.save_hit"
)
d.addBoth(verify_deliver)
return d
@patch("requests.post")
def test_route_udp(self, request_mock):
self.storage_mock.save_notification.return_value = True
udp_data = {'wakeup_host': {'ip': '127.0.0.1', 'port': 9999},
'mobilenetwork': {'mcc': 'hammer'}}
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid,
udp=udp_data)
self.router_mock.get_uaid.return_value = router_data
self.router.conf = {'server': 'http://example.com',
'idle': 1, 'cert': 'test.pem'}
d = self.router.route_notification(self.notif, router_data)
def check_deliver(result):
eq_(result.status_code, 202)
d.addBoth(check_deliver)
eq_(self.router.udp, udp_data)
return d
def test_ammend(self):
resp = {"key": "value"}
eq_(resp, self.router.amend_msg(resp))
class SimplePushRouterTestCase(unittest.TestCase):
def setUp(self):
from twisted.logger import Logger
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.metrics = metrics = Mock(spec=SinkMetrics)
db = test_db(metrics=metrics)
self.agent_mock = agent = Mock(spec=Agent)
self.router = SimpleRouter(settings, {}, db, agent)
self.router.log = Mock(spec=Logger)
self.notif = Notification(10, "data", dummy_chid)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = db.router
self.storage_mock = db.storage
def _raise_connect_error(self):
raise ConnectError()
def _raise_connection_refused_error(self):
raise ConnectionRefusedError()
def _raise_db_error(self):
raise ProvisionedThroughputExceededException(None, None)
def _raise_item_error(self):
raise ItemNotFound()
def test_register(self):
router_data = {}
self.router.register("uaid", router_data=router_data, app_id="test123")
eq_(router_data, {})
def test_route_to_connected(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 200
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 200)
d.addBoth(verify_deliver)
return d
def test_route_connection_fail_saved(self):
self.agent_mock.request.side_effect = MockAssist(
[self._raise_connection_refused_error])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.clear_node.return_value = None
self.router_mock.get_uaid.return_value = {}
self.storage_mock.save_notification.return_value = True
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(reply):
eq_(len(self.router.log.debug.mock_calls), 1)
ok_(reply.status_code, 202)
eq_(len(self.router_mock.clear_node.mock_calls), 1)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_old_version(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = False
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_throws_db_error(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.side_effect = MockAssist(
[self._raise_db_error])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_db_error])
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails_with_item_error(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_item_error])
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 410)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_no_node(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.return_value = dict()
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_202(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
ok_(self.router_mock.get_uaid.called)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_send_check_fails(self):
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connection_refused_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
ok_(self.router_mock.clear_node.called)
d.addBoth(verify_deliver)
return d
def test_route_busy_node_saves_looks_up_and_send_check_fails_and_db(self):
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router_mock.clear_node.side_effect = MockAssist(
[self._raise_db_error])
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
ok_(self.router_mock.clear_node.called)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_200(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 200)
d.addBoth(verify_deliver)
return d
@patch("requests.post")
def test_route_udp(self, request_mock):
self.storage_mock.save_notification.return_value = True
udp_data = {
'wakeup_host': {
'ip': '127.0.0.1',
'port': 9999
},
'mobilenetwork': {
'mcc': 'hammer'
}
}
router_data = dict(node_id="http://somewhere",
uaid=dummy_uaid,
udp=udp_data)
self.router_mock.get_uaid.return_value = router_data
self.router.conf = {
'server': 'http://example.com',
'idle': 1,
'cert': 'test.pem'
}
d = self.router.route_notification(self.notif, router_data)
def check_deliver(result):
eq_(result.status_code, 202)
d.addBoth(check_deliver)
eq_(self.router.udp, udp_data)
return d
def test_amend(self):
resp = {"key": "value"}
expected = resp.copy()
self.router.amend_endpoint_response(resp, {})
eq_(resp, expected)
class SimplePushRouterTestCase(unittest.TestCase):
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.router = SimpleRouter(settings, {})
self.notif = Notification(10, "data", dummy_chid, None, 200)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
def tearDown(self):
dead_cache.clear()
def _raise_connect_error(self):
raise ConnectError()
def _raise_db_error(self):
raise ProvisionedThroughputExceededException(None, None)
def _raise_item_error(self):
raise ItemNotFound()
def test_register(self):
r = self.router.register(None, {})
eq_(r, {})
def test_route_to_connected(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 200
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 200)
d.addBoth(verify_deliver)
return d
def test_route_connect_error(self):
self.agent_mock.request.side_effect = MockAssist(
[self._raise_connect_error])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.clear_node.return_value = None
d = self.router.route_notification(self.notif, router_data)
def verify_retry(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
eq_(len(self.router_mock.clear_node.mock_calls), 1)
self.router_mock.clear_node.reset_mock()
self.flushLoggedErrors()
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
eq_(len(self.router_mock.clear_node.mock_calls), 1)
self.router_mock.clear_node.reset_mock()
d = self.router.route_notification(self.notif, router_data)
d.addBoth(verify_retry)
return d
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_old_version(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = False
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_throws_db_error(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.side_effect = MockAssist(
[self._raise_db_error]
)
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_db_error]
)
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails_with_item_error(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_item_error]
)
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 404)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_no_node(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.return_value = dict()
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_202(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
assert(self.router_mock.get_uaid.called)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_send_check_fails(self):
import autopush.router.simple as simple
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
assert(self.router_mock.clear_node.called)
nk = simple.node_key(router_data["node_id"])
eq_(simple.dead_cache.get(nk), True)
d.addBoth(verify_deliver)
return d
def test_route_busy_node_saves_looks_up_and_send_check_fails_and_db(self):
import autopush.router.simple as simple
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router_mock.clear_node.side_effect = MockAssist(
[self._raise_db_error]
)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 202)
assert(self.router_mock.clear_node.called)
nk = simple.node_key(router_data["node_id"])
eq_(simple.dead_cache.get(nk), True)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_200(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(isinstance(result, RouterResponse))
eq_(result.status_code, 200)
self.router.metrics.increment.assert_called_with(
"router.broadcast.save_hit"
)
d.addBoth(verify_deliver)
return d
@patch("requests.post")
def test_route_udp(self, request_mock):
self.storage_mock.save_notification.return_value = True
udp_data = {'wakeup_host': {'ip': '127.0.0.1', 'port': 9999},
'mobilenetwork': {'mcc': 'hammer'}}
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid,
udp=udp_data)
self.router_mock.get_uaid.return_value = router_data
self.router.conf = {'server': 'http://example.com',
'idle': 1, 'cert': 'test.pem'}
d = self.router.route_notification(self.notif, router_data)
def check_deliver(result):
eq_(result.status_code, 202)
d.addBoth(check_deliver)
eq_(self.router.udp, udp_data)
return d
def test_ammend(self):
resp = {"key": "value"}
eq_(resp, self.router.amend_msg(resp))
class SimplePushRouterTestCase(unittest.TestCase):
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.router = SimpleRouter(settings, {})
self.notif = Notification(10, "data", dummy_chid)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
def _raise_connect_error(self):
raise ConnectError()
def _raise_db_error(self):
raise ProvisionedThroughputExceededException(None, None)
def _raise_item_error(self):
raise ItemNotFound()
def test_register(self):
r = self.router.register(None, {})
eq_(r, {})
def test_route_to_connected(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 200
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 200)
d.addBoth(verify_deliver)
return d
def test_route_connect_error(self):
self.agent_mock.request.side_effect = MockAssist(
[self._raise_connect_error])
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.clear_node.return_value = None
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
self.flushLoggedErrors()
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_old_version(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = False
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_save_throws_db_error(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.side_effect = MockAssist(
[self._raise_db_error]
)
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 503)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_db_error]
)
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_with_no_node_saves_and_lookup_fails_with_item_error(self):
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.side_effect = MockAssist(
[self._raise_item_error]
)
router_data = dict(uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(fail):
exc = fail.value
ok_(exc, RouterException)
eq_(exc.status_code, 404)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_no_node(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
self.router_mock.get_uaid.return_value = dict()
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 202)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_202(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 202)
self.router_mock.get_uaid.assert_called()
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_send_check_fails(self):
import autopush.router.simple as simple
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 202)
self.router_mock.clear_node.assert_called()
nk = simple.node_key(router_data["node_id"])
eq_(simple.dead_cache.get(nk), True)
d.addBoth(verify_deliver)
return d
def test_route_busy_node_saves_looks_up_and_send_check_fails_and_db(self):
import autopush.router.simple as simple
response_mock = Mock()
self.agent_mock.request.side_effect = MockAssist(
[response_mock, self._raise_connect_error])
response_mock.code = 202
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
self.router_mock.clear_node.side_effect = MockAssist(
[self._raise_db_error]
)
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 202)
self.router_mock.clear_node.assert_called()
nk = simple.node_key(router_data["node_id"])
eq_(simple.dead_cache.get(nk), True)
d.addBoth(verify_deliver)
return d
def test_route_to_busy_node_saves_looks_up_and_sends_check_200(self):
self.agent_mock.request.return_value = response_mock = Mock()
response_mock.addCallback.return_value = response_mock
type(response_mock).code = PropertyMock(
side_effect=MockAssist([202, 200]))
self.storage_mock.save_notification.return_value = True
router_data = dict(node_id="http://somewhere", uaid=dummy_uaid)
self.router_mock.get_uaid.return_value = router_data
d = self.router.route_notification(self.notif, router_data)
def verify_deliver(result):
ok_(result, RouterResponse)
eq_(result.status_code, 200)
self.router.metrics.increment.assert_called_with(
"router.broadcast.save_hit"
)
d.addBoth(verify_deliver)
return d
