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))