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_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_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_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_preflight_check(self):
router = Router(get_router_table(), SinkMetrics())
storage = Storage(get_storage_table(), SinkMetrics())
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)
self.assertRaises(ItemNotFound, router.get_uaid, pf_uaid)
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_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_preflight_check(self):
router = Router(get_router_table(), SinkMetrics())
message = Message(get_rotating_message_table(), SinkMetrics())
pf_uaid = "deadbeef00000000deadbeef01010101"
preflight_check(message, router, pf_uaid)
# now check that the database reports no entries.
_, notifs = message.fetch_messages(uuid.UUID(pf_uaid))
assert len(notifs) == 0
with pytest.raises(ItemNotFound):
router.get_uaid(pf_uaid)
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_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_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_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.update_item = Mock(return_value={})
result = router.register_user(
dict(uaid=dummy_uaid,
node_id="me",
router_type="webpush",
connected_at=1234))
assert result[0] is True
def test_preflight_check_fail(self):
router = Router(get_router_table(), SinkMetrics())
message = Message(get_rotating_message_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 pytest.raises(Exception):
preflight_check(message, router)
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_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_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_failed_uaid(self):
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": 400
},
}
with pytest.raises(ItemNotFound):
router.get_uaid(uaid)
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_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_node_clear_fail(self):
r = get_router_table()
router = Router(r, SinkMetrics())
def raise_condition(*args, **kwargs):
raise ClientError(
{'Error': {
'Code': 'ConditionalCheckFailedException'
}}, 'mock_update_item')
router.table.put_item = Mock(side_effect=raise_condition)
data = dict(uaid=dummy_uaid, node_id="asdf", connected_at=1234)
result = router.clear_node(data)
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_preflight_check_fail(self):
router = Router(self.table_conf, SinkMetrics(), resource=self.resource)
message = Message(
get_rotating_message_tablename(boto_resource=self.resource),
boto_resource=self.resource)
def raise_exc(*args, **kwargs): # pragma: no cover
raise Exception("Oops")
router.clear_node = Mock()
router.clear_node.side_effect = raise_exc
with pytest.raises(Exception):
preflight_check(message, router, self.resource)
def test_preflight_check_wait(self):
router = Router(get_router_table(), SinkMetrics())
message = Message(get_rotating_message_table(), SinkMetrics())
values = ["PENDING", "ACTIVE"]
message.table_status = Mock(side_effect=values)
pf_uaid = "deadbeef00000000deadbeef01010101"
preflight_check(message, router, pf_uaid)
# now check that the database reports no entries.
_, notifs = message.fetch_messages(uuid.UUID(pf_uaid))
assert len(notifs) == 0
with pytest.raises(ItemNotFound):
router.get_uaid(pf_uaid)
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 = {"uaid": uuid.uuid4().hex}
try:
router.register_user(dict(uaid=uaid))
except AutopushException:
pass
assert_raises(ItemNotFound, router.get_uaid, uaid)
ok_(router.drop_user.called)
def drop_users(router_table_name, months_ago, batch_size, pause_time):
router_table = get_router_table(router_table_name)
router = Router(router_table, SinkMetrics())
click.echo("Deleting users with a last_connect %s months ago." %
months_ago)
count = 0
for deletes in router.drop_old_users(months_ago):
click.echo("")
count += deletes
if count >= batch_size:
click.echo("Deleted %s user records, pausing for %s seconds." %
pause_time)
time.sleep(pause_time)
count = 0
click.echo("Finished old user purge.")
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_register_user_condition_failed(self):
router = Router(self.table_conf, SinkMetrics(),
resource=self.resource)
router.table.meta.client = Mock()
def raise_error(*args, **kwargs):
raise ClientError(
{'Error': {'Code': 'ConditionalCheckFailedException'}},
'mock_update_item'
)
mm = Mock()
mm.update_item = Mock(side_effect=raise_error)
router.table = mm
res = router.register_user(dict(uaid=dummy_uaid, node_id="me",
connected_at=1234,
router_type="webpush"))
assert res == (False, {})
def test_save_fail(self):
router = Router(self.table_conf, SinkMetrics(),
resource=self.resource)
def raise_condition(*args, **kwargs):
raise ClientError(
{'Error': {'Code': 'ConditionalCheckFailedException'}},
'mock_update_item'
)
mock_update = Mock()
mock_update.update_item = Mock(side_effect=raise_condition)
router.table = mock_update
router_data = dict(uaid=dummy_uaid, node_id="asdf", connected_at=1234,
router_type="webpush")
result = router.register_user(router_data)
assert result == (False, {})