class GCMRouterTestCase(unittest.TestCase):
@patch("gcmclient.gcm.GCM", spec=gcmclient.gcm.GCM)
def setUp(self, fgcm):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
gcm_config = {'s3_bucket': 'None',
'senderid_list': {'test123':
{"auth": "12345678abcdefg"}}}
self.gcm = fgcm
self.router = GCMRouter(settings, gcm_config)
self.notif = Notification(10, "data", dummy_chid, None, 200)
self.router_data = dict(
router_data=dict(
token="connect_data",
creds=dict(senderID="test123", auth="12345678abcdefg")))
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.mock_result = mock_result
fgcm.send.return_value = mock_result
def tearDown(self):
self.router.senderIDs.stop()
def _check_error_call(self, exc, code):
ok_(isinstance(exc, RouterException))
eq_(exc.status_code, code)
assert(self.router.gcm.send.called)
self.flushLoggedErrors()
def test_init(self):
self.router.senderIDs.get_ID = Mock()
def throw_ex():
raise AttributeError
fsenderids = Mock()
fsenderids.choose_ID.side_effect = throw_ex
self.assertRaises(IOError, GCMRouter, {}, {"senderIDs": fsenderids})
def test_register(self):
result = self.router.register("uaid", {"token": "connect_data"})
# Check the information that will be recorded for this user
eq_(result, {"token": "connect_data",
"creds": {"senderID": "test123",
"auth": "12345678abcdefg"}})
def test_register_bad(self):
self.assertRaises(RouterException, self.router.register, "uaid", {})
def test_route_notification(self):
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_auth_error(self):
def throw_auth(arg):
raise gcmclient.GCMAuthenticationError()
self.gcm.send.side_effect = throw_auth
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 500)
d.addBoth(check_results)
return d
def test_router_notification_gcm_other_error(self):
def throw_other(arg):
raise Exception("oh my!")
self.gcm.send.side_effect = throw_other
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 500)
d.addBoth(check_results)
return d
def test_router_notification_gcm_id_change(self):
self.mock_result.canonical["old"] = "new"
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
eq_(result.router_data, dict(token="new"))
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_not_regged(self):
self.mock_result.not_registered = {"connect_data": True}
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
eq_(result.router_data, dict())
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_failed_items(self):
self.mock_result.failed = dict(connect_data=True)
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 503)
d.addBoth(check_results)
return d
def test_router_notification_gcm_needs_retry(self):
self.mock_result.needs_retry.return_value = True
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 503)
d.addBoth(check_results)
return d
def test_router_notification_gcm_no_auth(self):
d = self.router.route_notification(self.notif,
{"router_data": {"token": "abc"}})
def check_results(fail):
eq_(fail.value.status_code, 500)
d.addBoth(check_results)
return d
def test_ammend(self):
self.router.register("uaid", {"token": "connect_data"})
resp = {"key": "value"}
eq_({"key": "value", "senderid": "test123"},
self.router.amend_msg(resp))
class GCMRouterTestCase(unittest.TestCase):
@patch("gcmclient.gcm.GCM", spec=gcmclient.gcm.GCM)
def setUp(self, fgcm):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.gcm_config = {'s3_bucket': 'None',
'max_data': 32,
'senderid_list': {'test123':
{"auth": "12345678abcdefg"}}}
self.gcm = fgcm
self.router = GCMRouter(settings, self.gcm_config)
self.headers = {"content-encoding": "aesgcm",
"encryption": "test",
"encryption-key": "test"}
# Data will most likely be binary values.
self.notif = Notification(10, "\xab\xad\x1d\xea", dummy_chid,
self.headers, 200)
self.router_data = dict(
router_data=dict(
token="connect_data",
creds=dict(senderID="test123", auth="12345678abcdefg")))
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.mock_result = mock_result
fgcm.send.return_value = mock_result
def tearDown(self):
self.router.senderIDs.stop()
def _check_error_call(self, exc, code):
ok_(isinstance(exc, RouterException))
eq_(exc.status_code, code)
assert(self.router.gcm.send.called)
self.flushLoggedErrors()
def test_init(self):
self.router.senderIDs.get_ID = Mock()
def throw_ex():
raise AttributeError
fsenderids = Mock()
fsenderids.choose_ID.side_effect = throw_ex
self.assertRaises(IOError, GCMRouter, {}, {"senderIDs": fsenderids})
def test_register(self):
result = self.router.register("uaid", {"token": "connect_data"})
# Check the information that will be recorded for this user
eq_(result, {"token": "connect_data",
"creds": {"senderID": "test123",
"auth": "12345678abcdefg"}})
def test_register_bad(self):
self.assertRaises(RouterException, self.router.register, "uaid", {})
def test_invalid_token(self):
self.router.gcm = self.gcm
(t, v) = self.router.check_token("test123")
ok_(t)
eq_(v, self.gcm_config['senderid_list'].keys()[0])
(t, v) = self.router.check_token("invalid")
eq_(t, False)
eq_(v, self.gcm_config['senderid_list'].keys()[0])
def test_route_notification(self):
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
assert(self.router.gcm.send.called)
# Make sure the data was encoded as base64
data = self.router.gcm.send.call_args[0][0].data
eq_(data['body'], 'q60d6g==')
eq_(data['enc'], 'test')
eq_(data['enckey'], 'test')
eq_(data['con'], 'aesgcm')
d.addCallback(check_results)
return d
def test_long_data(self):
self.router.gcm = self.gcm
badNotif = Notification(
10, "\x01abcdefghijklmnopqrstuvwxyz0123456789", dummy_chid,
self.headers, 200)
d = self.router.route_notification(badNotif, self.router_data)
def check_results(result):
ok_(isinstance(result.value, RouterException))
eq_(result.value.status_code, 413)
eq_(result.value.errno, 104)
d.addBoth(check_results)
return d
def test_route_crypto_notification(self):
self.router.gcm = self.gcm
del(self.notif.headers['encryption-key'])
self.notif.headers['crypto-key'] = 'crypto'
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_missing_enc_key_header(self):
self.router.gcm = self.gcm
del(self.notif.headers['encryption-key'])
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result.value, RouterException))
eq_(result.value.status_code, 400)
d.addBoth(check_results)
return d
def test_router_bogus_headers(self):
self.router.gcm = self.gcm
self.notif.headers['crypto-key'] = "crypto"
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result.value, RouterException))
eq_(result.value.status_code, 400)
d.addBoth(check_results)
return d
def test_router_missing_enc_header(self):
self.router.gcm = self.gcm
del(self.notif.headers['encryption'])
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result.value, RouterException))
eq_(result.value.status_code, 400)
d.addBoth(check_results)
return d
def test_router_missing_cont_enc_header(self):
self.router.gcm = self.gcm
del(self.notif.headers['content-encoding'])
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result.value, RouterException))
eq_(result.value.status_code, 400)
d.addBoth(check_results)
return d
def test_router_notification_gcm_auth_error(self):
def throw_auth(arg):
raise gcmclient.GCMAuthenticationError()
self.gcm.send.side_effect = throw_auth
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 500)
d.addBoth(check_results)
return d
def test_router_notification_gcm_other_error(self):
def throw_other(arg):
raise Exception("oh my!")
self.gcm.send.side_effect = throw_other
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 500)
d.addBoth(check_results)
return d
def test_router_notification_gcm_id_change(self):
self.mock_result.canonical["old"] = "new"
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
eq_(result.router_data, dict(token="new"))
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_not_regged(self):
self.mock_result.not_registered = {"connect_data": True}
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
eq_(result.router_data, dict())
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_failed_items(self):
self.mock_result.failed = dict(connect_data=True)
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 503)
d.addBoth(check_results)
return d
def test_router_notification_gcm_needs_retry(self):
self.mock_result.needs_retry.return_value = True
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 503)
d.addBoth(check_results)
return d
def test_router_notification_gcm_no_auth(self):
d = self.router.route_notification(self.notif,
{"router_data": {"token": "abc"}})
def check_results(fail):
eq_(fail.value.status_code, 500)
d.addBoth(check_results)
return d
def test_ammend(self):
self.router.register("uaid", {"token": "connect_data"})
resp = {"key": "value"}
result = self.router.amend_msg(resp,
self.router_data.get('router_data'))
eq_({"key": "value", "senderid": "test123"},
result)
class GCMRouterTestCase(unittest.TestCase):
@patch("gcmclient.gcm.GCM", spec=gcmclient.gcm.GCM)
def setUp(self, fgcm):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.gcm_config = {'s3_bucket': 'None',
'max_data': 32,
'ttl': 60,
'senderid_list': {'test123':
{"auth": "12345678abcdefg"}}}
self.gcm = fgcm
self.router = GCMRouter(settings, self.gcm_config)
self.headers = {"content-encoding": "aesgcm",
"encryption": "test",
"encryption-key": "test"}
# Payloads are Base64-encoded.
self.notif = Notification(10, "q60d6g", dummy_chid, self.headers,
200)
self.router_data = dict(
router_data=dict(
token="connect_data",
creds=dict(senderID="test123", auth="12345678abcdefg")))
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.mock_result = mock_result
fgcm.send.return_value = mock_result
def tearDown(self):
self.router.senderIDs.stop()
def _check_error_call(self, exc, code):
ok_(isinstance(exc, RouterException))
eq_(exc.status_code, code)
assert(self.router.gcm.send.called)
self.flushLoggedErrors()
def test_init(self):
self.router.senderIDs.get_ID = Mock()
def throw_ex():
raise AttributeError
fsenderids = Mock()
fsenderids.choose_ID.side_effect = throw_ex
self.assertRaises(IOError, GCMRouter, {}, {"senderIDs": fsenderids})
def test_register(self):
result = self.router.register("uaid", {"token": "connect_data"})
# Check the information that will be recorded for this user
eq_(result, {"token": "connect_data",
"creds": {"senderID": "test123",
"auth": "12345678abcdefg"}})
def test_register_bad(self):
self.assertRaises(RouterException, self.router.register, "uaid", {})
def test_invalid_token(self):
self.router.gcm = self.gcm
(t, v) = self.router.check_token("test123")
ok_(t)
eq_(v, self.gcm_config['senderid_list'].keys()[0])
(t, v) = self.router.check_token("invalid")
eq_(t, False)
eq_(v, self.gcm_config['senderid_list'].keys()[0])
def test_route_notification(self):
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
assert(self.router.gcm.send.called)
# Make sure the data was encoded as base64
data = self.router.gcm.send.call_args[0][0].data
eq_(data['body'], 'q60d6g')
eq_(data['enc'], 'test')
eq_(data['enckey'], 'test')
eq_(data['con'], 'aesgcm')
d.addCallback(check_results)
return d
def test_ttl_none(self):
self.router.gcm = self.gcm
self.notif = Notification(version=10,
data="q60d6g",
channel_id=dummy_chid,
headers=self.headers,
ttl=None)
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
assert(self.router.gcm.send.called)
# Make sure the data was encoded as base64
data = self.router.gcm.send.call_args[0][0].data
options = self.router.gcm.send.call_args[0][0].options
eq_(data['body'], 'q60d6g')
eq_(data['enc'], 'test')
eq_(data['enckey'], 'test')
eq_(data['con'], 'aesgcm')
# use the defined min TTL
eq_(options['time_to_live'], 60)
d.addCallback(check_results)
return d
def test_long_data(self):
self.router.gcm = self.gcm
badNotif = Notification(
10, "\x01abcdefghijklmnopqrstuvwxyz0123456789", dummy_chid,
self.headers, 200)
d = self.router.route_notification(badNotif, self.router_data)
def check_results(result):
ok_(isinstance(result.value, RouterException))
eq_(result.value.status_code, 413)
eq_(result.value.errno, 104)
d.addBoth(check_results)
return d
def test_route_crypto_notification(self):
self.router.gcm = self.gcm
del(self.notif.headers['encryption-key'])
self.notif.headers['crypto-key'] = 'crypto'
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_auth_error(self):
def throw_auth(arg):
raise gcmclient.GCMAuthenticationError()
self.gcm.send.side_effect = throw_auth
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 500)
d.addBoth(check_results)
return d
def test_router_notification_gcm_other_error(self):
def throw_other(arg):
raise Exception("oh my!")
self.gcm.send.side_effect = throw_other
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 500)
d.addBoth(check_results)
return d
def test_router_notification_gcm_id_change(self):
self.mock_result.canonical["old"] = "new"
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
eq_(result.router_data, dict(token="new"))
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_not_regged(self):
self.mock_result.not_registered = {"connect_data": True}
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(result):
ok_(isinstance(result, RouterResponse))
eq_(result.router_data, dict())
assert(self.router.gcm.send.called)
d.addCallback(check_results)
return d
def test_router_notification_gcm_failed_items(self):
self.mock_result.failed = dict(connect_data=True)
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 503)
d.addBoth(check_results)
return d
def test_router_notification_gcm_needs_retry(self):
self.mock_result.needs_retry.return_value = True
self.router.gcm = self.gcm
d = self.router.route_notification(self.notif, self.router_data)
def check_results(fail):
self._check_error_call(fail.value, 503)
d.addBoth(check_results)
return d
def test_router_notification_gcm_no_auth(self):
d = self.router.route_notification(self.notif,
{"router_data": {"token": "abc"}})
def check_results(fail):
eq_(fail.value.status_code, 500)
d.addBoth(check_results)
return d
def test_ammend(self):
self.router.register("uaid", {"token": "connect_data"})
resp = {"key": "value"}
result = self.router.amend_msg(resp,
self.router_data.get('router_data'))
eq_({"key": "value", "senderid": "test123"},
result)
