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_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 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_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_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_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="asdf", node_id="me", connected_at=1234))
def test_clear_node_provision_failed(self): r = get_router_table() router = Router(r, SinkMetrics()) router.table.connection.put_item = Mock() def raise_error(*args, **kwargs): raise ProvisionedThroughputExceededException(None, None) router.table.connection.put_item.side_effect = raise_error with self.assertRaises(ProvisionedThroughputExceededException): router.clear_node(Item(r, dict(uaid="asdf", connected_at="1234", node_id="asdf")))
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_fail(self): router = Router(get_router_table(), SinkMetrics()) storage = Storage(get_storage_table(), SinkMetrics()) def raise_exc(*args, **kwargs): # pragma: no cover raise Exception("Oops") router.clear_node = Mock() router.clear_node.side_effect = raise_exc with self.assertRaises(Exception): preflight_check(storage, router)
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="asdf", node_id="asdf", connected_at=1234) result = router.register_user(router_data) eq_(result, (False, {}, router_data))
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="asdf", node_id="asdf", connected_at=1234) result = router.clear_node(Item(r, data)) eq_(result, False)
def test_node_clear(self): r = get_router_table() router = Router(r, SinkMetrics()) # Register a node user router.register_user(dict(uaid="asdf", node_id="asdf", connected_at=1234)) # Verify user = router.get_uaid("asdf") eq_(user["node_id"], "asdf") # Clear router.clear_node(user) # Verify user = router.get_uaid("asdf") eq_(user.get("node_id"), None)
def test_drop_user(self): uaid = str(uuid.uuid4()) router = Router(self.table_conf, SinkMetrics(), resource=self.resource) # Register a node user router.register_user( dict(uaid=uaid, node_id="asdf", router_type="webpush", connected_at=1234)) result = router.drop_user(uaid) assert result is True # Deleting already deleted record should return false. result = router.drop_user(uaid) assert result is False
def test_failed_uaid(self): 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": 400 }, } router.table = mm router.drop_user = Mock() with pytest.raises(ItemNotFound): router.get_uaid(uaid)
def test_node_clear(self): router = Router(self.table_conf, SinkMetrics(), resource=self.resource) # Register a node user router.register_user(dict(uaid=dummy_uaid, node_id="asdf", connected_at=1234, router_type="webpush")) # Verify user = router.get_uaid(dummy_uaid) assert user["node_id"] == "asdf" assert user["connected_at"] == 1234 assert user["router_type"] == "webpush" # Clear router.clear_node(user) # Verify user = router.get_uaid(dummy_uaid) assert user.get("node_id") is None assert user["connected_at"] == 1234 assert user["router_type"] == "webpush"
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", router_type="simplepush", 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_uaid_provision_failed(self): router = Router(self.table_conf, SinkMetrics(), resource=self.resource) router.table = Mock() def raise_condition(*args, **kwargs): raise ClientError( {'Error': { 'Code': 'ProvisionedThroughputExceededException' }}, 'mock_update_item') mm = Mock() mm.get_item = Mock(side_effect=raise_condition) router.table = mm with pytest.raises(ClientError) as ex: router.get_uaid(uaid="asdf") assert (ex.value.response['Error']['Code'] == "ProvisionedThroughputExceededException")
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_type="webpush")) # Verify user = router.get_uaid(dummy_uaid) eq_(user["node_id"], "asdf") eq_(user["connected_at"], 1234) eq_(user["router_type"], "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_type"], "webpush")
def test_incomplete_uaid(self): # Older records may be incomplete. We can't inject them using normal # methods. uaid = str(uuid.uuid4()) r = get_router_table() router = Router(r, SinkMetrics()) router.table.get_item = Mock() router.drop_user = Mock() router.table.get_item.return_value = { "ResponseMetadata": { "HTTPStatusCode": 200 }, "Item": { "uaid": uuid.uuid4().hex } } 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_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_no_uaid_found(self): uaid = str(uuid.uuid4()) r = get_router_table() router = Router(r, SinkMetrics()) self.assertRaises(ItemNotFound, router.get_uaid, uaid)
def setUp(cls): cls.resource = autopush.tests.boto_resource cls.table_conf = DDBTableConfig("router_test") cls.router = Router(cls.table_conf, SinkMetrics(), resource=cls.resource)
def setup_module(): global test_router config = DDBTableConfig("router_test") test_router = Router(config, SinkMetrics(), resource=autopush.tests.boto_resource)
def __init__( self, crypto_key=None, datadog_api_key=None, datadog_app_key=None, datadog_flush_interval=None, hostname=None, port=None, router_scheme=None, router_hostname=None, router_port=None, endpoint_scheme=None, endpoint_hostname=None, endpoint_port=None, router_conf=None, router_tablename="router", router_read_throughput=5, router_write_throughput=5, storage_tablename="storage", storage_read_throughput=5, storage_write_throughput=5, message_tablename="message", message_read_throughput=5, message_write_throughput=5, statsd_host="localhost", statsd_port=8125, resolve_hostname=False, max_data=4096, # Reflected up from UDP Router wake_timeout=0, env='development', enable_cors=False, hello_timeout=0, bear_hash_key=None, preflight_uaid="deadbeef00000000deadbeef00000000", ami_id=None, client_certs=None, msg_limit=100, debug=False, connect_timeout=0.5, ): """Initialize the Settings object Upon creation, the HTTP agent will initialize, all configured routers will be setup and started, logging will be started, and the database will have a preflight check done. """ # Use a persistent connection pool for HTTP requests. pool = HTTPConnectionPool(reactor) if not debug: pool._factory = QuietClientFactory self.agent = Agent(reactor, connectTimeout=connect_timeout, pool=pool) if not crypto_key: crypto_key = [Fernet.generate_key()] if not isinstance(crypto_key, list): crypto_key = [crypto_key] self.update(crypto_key=crypto_key) self.crypto_key = crypto_key if bear_hash_key is None: bear_hash_key = [] if not isinstance(bear_hash_key, list): bear_hash_key = [bear_hash_key] self.bear_hash_key = bear_hash_key self.max_data = max_data self.clients = {} # Setup hosts/ports/urls default_hostname = socket.gethostname() self.hostname = hostname or default_hostname if resolve_hostname: self.hostname = resolve_ip(self.hostname) # Metrics setup if datadog_api_key: self.metrics = DatadogMetrics( hostname=self.hostname, api_key=datadog_api_key, app_key=datadog_app_key, flush_interval=datadog_flush_interval, ) elif statsd_host: self.metrics = TwistedMetrics(statsd_host, statsd_port) else: self.metrics = SinkMetrics() self.port = port self.endpoint_hostname = endpoint_hostname or self.hostname self.router_hostname = router_hostname or self.hostname if router_conf is None: router_conf = {} self.router_conf = router_conf self.router_url = canonical_url(router_scheme or 'http', self.router_hostname, router_port) self.endpoint_url = canonical_url(endpoint_scheme or 'http', self.endpoint_hostname, endpoint_port) self.enable_tls_auth = client_certs is not None self.client_certs = client_certs # Database objects self.router_table = get_router_table(router_tablename, router_read_throughput, router_write_throughput) self.storage_table = get_storage_table(storage_tablename, storage_read_throughput, storage_write_throughput) self.message_table = get_rotating_message_table( message_tablename, message_read_throughput=message_read_throughput, message_write_throughput=message_write_throughput) self._message_prefix = message_tablename self.message_limit = msg_limit self.storage = Storage(self.storage_table, self.metrics) self.router = Router(self.router_table, self.metrics) # Used to determine whether a connection is out of date with current # db objects. There are three noteworty cases: # 1 "Last Month" the table requires a rollover. # 2 "This Month" the most common case. # 3 "Next Month" where the system will soon be rolling over, but with # timing, some nodes may roll over sooner. Ensuring the next month's # table is present before the switchover is the main reason for this, # just in case some nodes do switch sooner. self.create_initial_message_tables() # Run preflight check preflight_check(self.storage, self.router, preflight_uaid) # CORS self.cors = enable_cors # Force timeout in idle seconds self.wake_timeout = wake_timeout # Setup the routers self.routers = dict() self.routers["simplepush"] = SimpleRouter( self, router_conf.get("simplepush")) self.routers["webpush"] = WebPushRouter(self, None) if 'apns' in router_conf: self.routers["apns"] = APNSRouter(self, router_conf["apns"]) if 'gcm' in router_conf: self.routers["gcm"] = GCMRouter(self, router_conf["gcm"]) # Env self.env = env self.hello_timeout = hello_timeout self.ami_id = ami_id # Generate messages per legacy rules, only used for testing to # generate legacy data. self._notification_legacy = False
def test_no_uaid_found(self): uaid = str(uuid.uuid4()) r = get_router_table() router = Router(r, SinkMetrics()) with pytest.raises(ItemNotFound): router.get_uaid(uaid)
def __init__( self, crypto_key=None, datadog_api_key=None, datadog_app_key=None, datadog_flush_interval=None, hostname=None, port=None, router_scheme=None, router_hostname=None, router_port=None, endpoint_scheme=None, endpoint_hostname=None, endpoint_port=None, router_conf={}, router_tablename="router", router_read_throughput=5, router_write_throughput=5, storage_tablename="storage", storage_read_throughput=5, storage_write_throughput=5, message_tablename="message", message_read_throughput=5, message_write_throughput=5, statsd_host="localhost", statsd_port=8125, resolve_hostname=False, max_data=4096, # Reflected up from UDP Router wake_timeout=0, env='development', enable_cors=False, s3_bucket=DEFAULT_BUCKET, senderid_expry=SENDERID_EXPRY, senderid_list={}, hello_timeout=0, ): """Initialize the Settings object Upon creation, the HTTP agent will initialize, all configured routers will be setup and started, logging will be started, and the database will have a preflight check done. """ # Use a persistent connection pool for HTTP requests. pool = HTTPConnectionPool(reactor) self.agent = Agent(reactor, connectTimeout=5, pool=pool) # Metrics setup if datadog_api_key: self.metrics = DatadogMetrics( api_key=datadog_api_key, app_key=datadog_app_key, flush_interval=datadog_flush_interval) elif statsd_host: self.metrics = TwistedMetrics(statsd_host, statsd_port) else: self.metrics = SinkMetrics() if not crypto_key: crypto_key = [Fernet.generate_key()] if not isinstance(crypto_key, list): crypto_key = [crypto_key] self.update(crypto_key=crypto_key) self.crypto_key = crypto_key self.max_data = max_data self.clients = {} # Setup hosts/ports/urls default_hostname = socket.gethostname() self.hostname = hostname or default_hostname if resolve_hostname: self.hostname = resolve_ip(self.hostname) self.port = port self.endpoint_hostname = endpoint_hostname or self.hostname self.router_hostname = router_hostname or self.hostname self.router_conf = router_conf self.router_url = canonical_url(router_scheme or 'http', self.router_hostname, router_port) self.endpoint_url = canonical_url(endpoint_scheme or 'http', self.endpoint_hostname, endpoint_port) # Database objects self.router_table = get_router_table(router_tablename, router_read_throughput, router_write_throughput) self.storage_table = get_storage_table(storage_tablename, storage_read_throughput, storage_write_throughput) self.message_table = get_message_table(message_tablename, message_read_throughput, message_write_throughput) self.storage = Storage(self.storage_table, self.metrics) self.router = Router(self.router_table, self.metrics) self.message = Message(self.message_table, self.metrics) # Run preflight check preflight_check(self.storage, self.router) # CORS self.cors = enable_cors # Force timeout in idle seconds self.wake_timeout = wake_timeout # Setup the routers self.routers = {} self.routers["simplepush"] = SimpleRouter( self, router_conf.get("simplepush")) self.routers["webpush"] = WebPushRouter(self, None) if 'apns' in router_conf: self.routers["apns"] = APNSRouter(self, router_conf["apns"]) if 'gcm' in router_conf: self.routers["gcm"] = GCMRouter(self, router_conf["gcm"]) # Env self.env = env self.hello_timeout = hello_timeout