def test_init(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
with assert_raises(IOError):
GCMRouter(settings, {"senderIDs": {}}, SinkMetrics())
def setUp(self):
from autopush.web.base import BaseWebHandler
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.request_mock = Mock(body=b'',
arguments={},
headers={"ttl": "0"},
host='example.com:8080')
self.base = BaseWebHandler(
EndpointHTTPFactory(settings,
db=test_db(SinkMetrics()),
routers=None), self.request_mock)
self.status_mock = self.base.set_status = Mock()
self.write_mock = self.base.write = Mock()
self.base.log = Mock(spec=Logger)
d = self.finish_deferred = Deferred()
self.base.finish = lambda: d.callback(True)
# Attach some common cors stuff for testing
self.base.cors_methods = "POST,PUT"
self.base.cors_request_headers = [
"content-encoding", "encryption", "crypto-key", "ttl",
"encryption-key", "content-type", "authorization"
]
self.base.cors_response_headers = ["location", "www-authenticate"]
def test_message_storage(self):
chid = str(uuid.uuid4())
chid2 = str(uuid.uuid4())
m = get_rotating_message_table()
message = Message(m, SinkMetrics())
message.register_channel(self.uaid, chid)
message.register_channel(self.uaid, chid2)
data1 = str(uuid.uuid4())
data2 = str(uuid.uuid4())
ttl = int(time.time()) + 100
time1, time2, time3 = self._nstime(), self._nstime(
), self._nstime() + 1
message.store_message(self.uaid, chid, time1, ttl, data1, {})
message.store_message(self.uaid, chid2, time2, ttl, data2, {})
message.store_message(self.uaid, chid2, time3, ttl, data1, {})
all_messages = list(message.fetch_messages(self.uaid))
eq_(len(all_messages), 3)
message.delete_messages_for_channel(self.uaid, chid2)
all_messages = list(message.fetch_messages(self.uaid))
eq_(len(all_messages), 1)
message.delete_message(self.uaid, chid, time1)
all_messages = list(message.fetch_messages(self.uaid))
eq_(len(all_messages), 0)
def test_incomplete_uaid(self):
# Older records may be incomplete. We can't inject them using normal
# methods.
uaid = str(uuid.uuid4())
router = Router(self.table_conf, SinkMetrics(), resource=self.resource)
mm = Mock()
mm.get_item = Mock()
mm.get_item.return_value = {
"ResponseMetadata": {
"HTTPStatusCode": 200
},
"Item": {
"uaid": uuid.uuid4().hex
}
}
mm.delete_item.return_value = {
"ResponseMetadata": {
"HTTPStatusCode": 200
},
}
router.table = mm
router.drop_user = Mock()
try:
router.register_user(dict(uaid=uaid))
except AutopushException:
pass
with pytest.raises(ItemNotFound):
router.get_uaid(uaid)
assert router.drop_user.called
def test_init(self):
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
)
with pytest.raises(IOError):
GCMRouter(conf, {"senderIDs": {}}, SinkMetrics())
def test_db(metrics=None):
"""Return a test DatabaseManager: its Storage/Router are mocked"""
return DatabaseManager(
storage=Mock(spec=Storage),
router=Mock(spec=Router),
metrics=SinkMetrics() if metrics is None else metrics
)
def test_db(metrics=None):
"""Return a test DatabaseManager: its Storage/Router are mocked"""
return DatabaseManager(
router_conf=DDBTableConfig(tablename='router'),
router=Mock(spec=Router),
message_conf=DDBTableConfig(tablename='message'),
metrics=SinkMetrics() if metrics is None else metrics)
def test_node_clear(self):
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(
dict(uaid=dummy_uaid,
node_id="asdf",
connected_at=1234,
router_key="webpush"))
# Verify
user = router.get_uaid(dummy_uaid)
eq_(user["node_id"], "asdf")
eq_(user["connected_at"], 1234)
eq_(user["router_key"], "webpush")
# Clear
router.clear_node(user)
# Verify
user = router.get_uaid(dummy_uaid)
eq_(user.get("node_id"), None)
eq_(user["connected_at"], 1234)
eq_(user["router_key"], "webpush")
def test_message_delete_pagination(self):
def make_messages(channel_id, count):
m = []
t = self._nstime()
ttl = int(time.time()) + 200
for i in range(count):
m.append(
(self.uaid, channel_id, str(uuid.uuid4()), ttl, {}, t + i))
return m
chid = str(uuid.uuid4())
m = get_rotating_message_table()
message = Message(m, SinkMetrics())
message.register_channel(self.uaid, chid)
# Shove 80 messages in
for message_args in make_messages(chid, 80):
message.store_message(*message_args)
# Verify we can see them all
all_messages = list(message.fetch_messages(self.uaid, limit=100))
eq_(len(all_messages), 80)
# Delete them all
message.delete_messages_for_channel(self.uaid, chid)
# Verify they're gone
all_messages = list(message.fetch_messages(self.uaid, limit=100))
eq_(len(all_messages), 0)
def test_unregister(self):
chid = str(uuid.uuid4())
m = get_rotating_message_table()
message = Message(m, SinkMetrics())
message.register_channel(self.uaid, chid)
# Verify its in the db
rows = m.query_2(uaid__eq=self.uaid, chidmessageid__eq=" ")
results = list(rows)
assert (len(results) == 1)
eq_(results[0]["chids"], set([chid]))
message.unregister_channel(self.uaid, chid)
# Verify its not in the db
rows = m.query_2(uaid__eq=self.uaid, chidmessageid__eq=" ")
results = list(rows)
assert (len(results) == 1)
eq_(results[0]["chids"], set([]))
# Test for the very unlikely case that there's no 'chid'
m.connection.update_item = Mock()
m.connection.update_item.return_value = {
'Attributes': {
'uaid': {
'S': self.uaid
}
},
'ConsumedCapacityUnits': 0.5
}
r = message.unregister_channel(self.uaid, dummy_chid)
eq_(r, False)
def test_drop_user(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(dict(uaid=uaid, node_id="asdf",
connected_at=1234))
router.drop_user(uaid)
def _make_fut(self):
from autopush.web.webpush import WebPushRequestSchema
schema = WebPushRequestSchema()
schema.context.update(conf=Mock(),
metrics=SinkMetrics(),
db=test_db(),
routers=Mock(),
log=Mock())
return schema
def _make_fut(self):
from autopush.web.simplepush import SimplePushRequestSchema
schema = SimplePushRequestSchema()
schema.context.update(settings=Mock(),
metrics=SinkMetrics(),
db=test_db(),
routers=Mock(),
log=Mock())
return schema
def test_drop_old_users(self):
# First create a bunch of users
r = get_router_table()
router = Router(r, SinkMetrics())
for _ in range(0, 53):
router.register_user(self._create_minimal_record())
results = router.drop_old_users(months_ago=0)
eq_(list(results), [25, 25, 3])
def test_save_new(self):
r = get_router_table()
router = Router(r, SinkMetrics())
# Sadly, moto currently does not return an empty value like boto
# when not updating data.
router.table.connection = Mock()
router.table.connection.update_item.return_value = {}
result = router.register_user(
dict(uaid="", node_id="me", connected_at=1234))
eq_(result[0], True)
def test_incomplete_uaid(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
router.register_user(dict(uaid=uaid))
self.assertRaises(ItemNotFound, router.get_uaid, uaid)
self.assertRaises(ItemNotFound,
router.table.get_item,
consistent=True,
uaid=uaid)
def test_register(self):
chid = str(uuid.uuid4())
m = get_rotating_message_table()
message = Message(m, SinkMetrics())
message.register_channel(self.uaid, chid)
# Verify its in the db
rows = m.query_2(uaid__eq=self.uaid, chidmessageid__eq=" ")
results = list(rows)
assert (len(results) == 1)
def test_save_uaid(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
result = router.register_user(
dict(uaid=uaid, node_id="me", connected_at=1234))
eq_(result[0], True)
eq_(result[1], {"uaid": uaid, "connected_at": 1234, "node_id": "me"})
result = router.get_uaid(uaid)
eq_(bool(result), True)
eq_(result["node_id"], "me")
def test_fetch_boto_err(self):
s = get_storage_table()
storage = Storage(s, SinkMetrics())
storage.table.connection = Mock()
def raise_error(*args, **kwargs):
raise BotoServerError(None, None)
storage.table.connection.put_item.side_effect = raise_error
with assert_raises(BotoServerError):
storage.save_notification(dummy_uaid, dummy_chid, 12)
def test_uaid_provision_failed(self):
r = get_router_table()
router = Router(r, SinkMetrics())
router.table = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
router.table.get_item.side_effect = raise_error
with self.assertRaises(ProvisionedThroughputExceededException):
router.get_uaid(uaid="asdf")
def test_delete_over_provisioned(self):
s = get_storage_table()
storage = Storage(s, SinkMetrics())
storage.table.connection = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
storage.table.connection.delete_item.side_effect = raise_error
results = storage.delete_notification(dummy_uaid, dummy_chid)
eq_(results, False)
def test_save_over_provisioned(self):
s = get_storage_table()
storage = Storage(s, SinkMetrics())
storage.table = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
storage.table.query_2.side_effect = raise_error
with self.assertRaises(ProvisionedThroughputExceededException):
storage.fetch_notifications(dummy_uaid)
def test_fetch_over_provisioned(self):
s = get_storage_table()
storage = Storage(s, SinkMetrics())
storage.table.connection = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
storage.table.connection.put_item.side_effect = raise_error
with self.assertRaises(ProvisionedThroughputExceededException):
storage.save_notification(dummy_uaid, dummy_chid, 12)
def test_drop_old_users(self):
# First create a bunch of users
r = get_router_table()
router = Router(r, SinkMetrics())
# Purge any existing users from previous runs.
router.drop_old_users(0)
for _ in range(0, 53):
router.register_user(self._create_minimal_record())
results = router.drop_old_users(months_ago=0)
assert list(results) == [25, 25, 3]
def test_node_clear_fail(self):
r = get_router_table()
router = Router(r, SinkMetrics())
def raise_condition(*args, **kwargs):
raise ConditionalCheckFailedException(None, None)
router.table.connection.put_item = Mock()
router.table.connection.put_item.side_effect = raise_condition
data = dict(uaid=dummy_uaid, node_id="asdf", connected_at=1234)
result = router.clear_node(Item(r, data))
eq_(result, False)
def test_save_fail(self):
r = get_router_table()
router = Router(r, SinkMetrics())
def raise_condition(*args, **kwargs):
raise ConditionalCheckFailedException(None, None)
router.table.connection = Mock()
router.table.connection.update_item.side_effect = raise_condition
router_data = dict(uaid=dummy_uaid, node_id="asdf", connected_at=1234)
result = router.register_user(router_data)
eq_(result, (False, {}, router_data))
def test_drop_user(self):
uaid = str(uuid.uuid4())
r = get_router_table()
router = Router(r, SinkMetrics())
# Register a node user
router.register_user(dict(uaid=uaid, node_id="asdf",
connected_at=1234))
result = router.drop_user(uaid)
eq_(result, True)
# Deleting already deleted record should return false.
result = router.drop_user(uaid)
eq_(result, False)
def test_preflight_check_wait(self):
router = Router(get_router_table(), SinkMetrics())
storage = Storage(get_storage_table(), SinkMetrics())
storage.table.describe = mock_describe = Mock()
values = [
dict(Table=dict(TableStatus="PENDING")),
dict(Table=dict(TableStatus="ACTIVE")),
]
def return_vals(*args, **kwargs):
return values.pop(0)
mock_describe.side_effect = return_vals
pf_uaid = "deadbeef00000000deadbeef01010101"
preflight_check(storage, router, pf_uaid)
# now check that the database reports no entries.
notifs = storage.fetch_notifications(pf_uaid)
eq_(len(notifs), 0)
assert_raises(ItemNotFound, router.get_uaid, pf_uaid)
def test_init(self, ffcm):
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
)
def throw_auth(*args, **kwargs):
raise Exception("oopsy")
ffcm.side_effect = throw_auth
with pytest.raises(IOError):
FCMRouter(conf, {}, SinkMetrics())
def test_register_user_provision_failed(self):
r = get_router_table()
router = Router(r, SinkMetrics())
router.table.connection = Mock()
def raise_error(*args, **kwargs):
raise ProvisionedThroughputExceededException(None, None)
router.table.connection.update_item.side_effect = raise_error
with self.assertRaises(ProvisionedThroughputExceededException):
router.register_user(
dict(uaid=dummy_uaid, node_id="me", connected_at=1234))
def test_passing(self):
sm = SinkMetrics()
sm.start()
eq_(None, sm.increment("test"))
eq_(None, sm.gauge("test", 10))
eq_(None, sm.timing("test", 10))
