def test_get_reservation_exhausted(self):
now = now_utc_sec()
account_id = random_string()
coordinate = '{}:{}'.format(self.resource_name, account_id)
mock_token_table = create_non_fung_table(self.token_table)
mock_limit_table = create_limit_table(self.limit_table)
_insert_limit(mock_limit_table, self.resource_name, account_id,
self.limit)
self.manager._token_table = mock_token_table
self.manager._limit_table = mock_limit_table
# Insert enough tokens to reach the limit
for i in range(0, self.limit):
token = {
'resourceCoordinate': coordinate,
'resourceName': self.resource_name,
'accountId': account_id,
'resourceId': 'resource-' + str(i),
'expirationTime': now + 10000,
'reservationId': random_string()
}
mock_token_table.put_item(Item=token)
self.assertRaises(CapacityExhaustedException,
self.manager.get_reservation, account_id)
def test_delete_fallback_no_type(self):
event_source = random_string()
detail_type = random_string()
event = {'source': event_source, 'detail-type': detail_type}
mock_default_processor = Mock()
mock_default_processor.source = event_source
mock_default_processor.type = None
mock_default_processor.test_and_get_id = MagicMock(
return_value=self.resource_id)
mock_type_processor = Mock()
mock_type_processor.source = event_source
mock_type_processor.type = detail_type + random_string()
mock_type_processor.test_and_get_id = MagicMock(
side_effect=Exception('Wrong processor invoked'))
mock_table = create_non_fung_table(self.table_name, self.index_name)
self._insert_token(mock_table)
self.assertEqual(1, self._get_resource_id_count(mock_table))
manager = EventProcessorManager(
table_name=self.table_name,
index_name=self.index_name,
processors=[mock_default_processor, mock_type_processor])
manager._table = mock_table
manager.process_event(event)
self.assertEqual(0, self._get_resource_id_count(mock_table))
def test_invalid_value(self):
target_value = random_string()
event = {'detail': {'state': random_string()}}
predicate = ProcessorPredicate('detail.state',
lambda state: state == target_value)
self.assertFalse(predicate.test(event))
def test_base(self):
for i in range(N_TESTS):
with self.subTest(i=i):
str1 = random_string(10)
str2 = random_string(10)
with os.popen(f"./a.out strcmp {str1} {str2}") as result:
self.check(result, [str1, str2])
def test_empty_string(self):
str1 = random_string(10)
str2 = random_string(10)
with os.popen(f'./a.out strcmp \"\" {str2}') as result:
self.check(result, ["", str2])
with os.popen(f'./a.out strcmp {str1} \"\"') as result:
self.check(result, [str1, ""])
def test_without_predicate(self):
source = random_string()
expected_id = random_string()
event = {'detail': {'id': expected_id}}
processor = EventProcessor(source, 'detail.id')
actual_id = processor.test_and_get_id(event)
self.assertEqual(expected_id, actual_id)
def setUp(self):
self.token_table = random_string()
self.limit_table = random_string()
self.resource_name = random_string()
self.limit = 5
self.manager = NonFungibleTokenManager(self.token_table,
self.limit_table,
self.resource_name, self.limit)
def test_double_create(self):
mock_token_table = Mock()
mock_token_table.delete_item = Mock()
mock_token_table.update_item = Mock()
reserve = TokenReservation(self.res_id, mock_token_table,
self.resource_name, self.account_id,
self.coordinate)
reserve.create_token(random_string())
self.assertRaises(ValueError, reserve.create_token, random_string())
def test_no_processor(self):
event_source = random_string()
event = {'source': event_source}
mock_processor = Mock()
mock_processor.source = random_string()
mock_processor.type = None
manager = EventProcessorManager(table_name=self.table_name,
index_name=self.index_name,
processors=[mock_processor])
self.assertRaises(ValueError, manager.process_event, event)
def test_decoratored_account_id_pos(self, mock_manager_delegate):
arg_1 = random_string()
arg_2 = random_string()
account_id = random_string()
mock_manager = Mock()
mock_manager.return_value.get_token = Mock()
mock_manager_delegate.return_value = mock_manager
self.assertTrue(
self._limited_func_account_id_pos(arg_1, arg_2, account_id))
mock_manager.get_token.assert_called_with(account_id)
def test_failed_predicate(self):
source = random_string()
event = {'detail': {'id': random_string()}}
mock_predicate = Mock()
mock_predicate.test = MagicMock(return_value=False)
processor = EventProcessor(source,
'detail.id',
predicate=mock_predicate)
event_id = processor.test_and_get_id(event)
self.assertIsNone(event_id)
def test_processor_properties(self):
source = random_string()
id_path = random_string()
type = random_string()
predicate = ProcessorPredicate('detail.state', lambda state: True)
processor = EventProcessor(source,
id_path,
predicate=predicate,
type=type)
self.assertEqual(source, processor.source)
self.assertEqual(id_path, processor.id_path)
self.assertEqual(type, processor.type)
self.assertEqual(predicate, processor.predicate)
def test_with_predicate(self):
source = random_string()
expected_id = random_string()
event = {'detail': {'id': expected_id}}
mock_predicate = Mock()
mock_predicate.test = MagicMock(return_value=True)
processor = EventProcessor(source,
'detail.id',
predicate=mock_predicate)
actual_id = processor.test_and_get_id(event)
self.assertEqual(expected_id, actual_id)
def setUp(self):
self.token_table = random_string()
self.limit_table = random_string()
self.resource_name = random_string()
self.limit = 10
self.window = 100
self.window_ms = self.window * 1000
self.token_ms = float(self.limit) / self.window_ms
self.ms_token = float(self.window_ms) / self.limit
self.manager = FungibleTokenManager(self.token_table, self.limit_table,
self.resource_name, self.limit,
self.window)
def test_base(self):
for i in range(N_TESTS):
with self.subTest(i=i):
src = random_string(10)
dest = "".join(["0" for _ in range(len(src))])
with os.popen(f"./a.out strcpy {dest} {src}") as result:
self.check(result, [dest, src])
def test_get_reservation(self):
now = now_utc_sec()
account_id = random_string()
coordinate = '{}:{}'.format(self.resource_name, account_id)
mock_token_table = create_non_fung_table(self.token_table)
mock_limit_table = create_limit_table(self.limit_table)
_insert_limit(mock_limit_table, self.resource_name, account_id,
self.limit)
self.manager._token_table = mock_token_table
self.manager._limit_table = mock_limit_table
self.manager.get_reservation(account_id)
response = mock_token_table.query(
KeyConditionExpression=Key('resourceCoordinate').eq(coordinate))
self.assertEqual(1, response['Count'])
items = dict(pair for item in response['Items']
for pair in item.items())
self.assertEqual(self.resource_name, items['resourceName'])
self.assertEqual(account_id, items['accountId'])
self.assertTrue(items['expirationTime'] > now)
self.assertIn('resourceId', items)
def test_get_bucket_token(self):
account_id = random_string()
exec_time = now_utc_ms()
expected = {'tokens': 5, 'last_refill': now_utc_sec()}
response = {'Attributes': expected}
mock_token_table = Mock()
mock_token_table.update_item = MagicMock(return_value=response)
self.manager._token_table = mock_token_table
actual = self.manager._get_bucket_token(account_id, exec_time,
self.ms_token)
self.assertEqual(expected, actual)
actual_args = mock_token_table.update_item.call_args_list
self.assertEqual(1, len(actual_args))
expected_args = [({
'Key': {
'resourceName': self.resource_name,
'accountId': account_id
},
'UpdateExpression': 'add tokens :dec set lastToken = :exec_time',
'ConditionExpression':
'tokens > :min OR lastToken < :failsafe OR attribute_not_exists(tokens)',
'ExpressionAttributeValues': {
':dec': -1,
':min': 0,
':failsafe': exec_time - self.ms_token,
':exec_time': exec_time
},
'ReturnValues': 'ALL_NEW'
})]
self.assertEqual(expected_args, actual_args[0])
def test_refill_bucket_tokens(self):
account_id = random_string()
tokens = 8
refill_time = now_utc_ms()
mock_token_table = Mock()
mock_token_table.update_item = Mock()
self.manager._token_table = mock_token_table
self.manager._refill_bucket_tokens(account_id, tokens, refill_time)
actual_args = mock_token_table.update_item.call_args_list
self.assertEqual(1, len(actual_args))
expected_args = [({
'Key': {
'resourceName': self.resource_name,
'accountId': account_id
},
'UpdateExpression':
'set tokens = :tokens, lastRefill = :refill_time',
'ConditionExpression':
'lastRefill < :refill_time OR attribute_not_exists(lastRefill)',
'ExpressionAttributeValues': {
':tokens': tokens,
':refill_time': refill_time
},
'ReturnValues': 'NONE'
})]
self.assertEqual(expected_args, actual_args[0])
def test_call_account_id_pos(self):
arg_1 = random_string()
arg_2 = random_string()
account_id = random_string()
account_id_pos = 2
func_to_limit = Mock()
limiter = rate_limit(self.resource_name, self.limit, self.window,
self.token_table_name, self.limit_table_name,
account_id_pos)
limiter._manager = self.mock_manager
rate_limited_func = limiter.__call__(func_to_limit)
rate_limited_func(arg_1, arg_2, account_id)
self.mock_manager.get_token.assert_called_with(account_id)
func_to_limit.assert_called_with(arg_1, arg_2, account_id)
def test_random_size(self):
for i in range(N_TESTS):
with self.subTest(i=i):
string_params = random_string(10)
size = random.randint(-20, 20)
with os.popen(
f"./a.out write 1 {string_params} {size}") as result:
self.check(result, [1, string_params, size])
def test_base(self):
for i in range(N_TESTS):
with self.subTest(i=i):
string_params = random_string(10)
with os.popen(
f"./a.out write 1 {string_params} {len(string_params)}"
) as result:
self.check(result, [1, string_params, len(string_params)])
def test_empty_string(self):
string_params = random_string(10)
with open("test_read.txt", "+w") as f:
f.write("")
f.write("")
with os.popen(
f"cat test_read.txt | ./a.out read 0 {string_params} {len(string_params)}"
) as result:
self.check(result, [0, string_params, len(string_params)])
def test_account_resource_limit_defaults(self):
account_id = random_string()
mock_limit_table = create_limit_table(self.limit_table)
self.manager._limit_table = mock_limit_table
result = self.manager._get_account_resource_limit(account_id)
self.assertEqual(self.limit, result['limit'])
self.assertEqual(self.window, result['windowSec'])
def setUp(self):
self.table_name = random_string()
self.index_name = random_string()
self.coordinate = random_string()
self.resource_name = random_string()
self.account_id = random_string()
self.resource_id = random_string()
self.reservation_id = random_string()
def test_base(self):
for i in range(N_TESTS):
with self.subTest(i=i):
string_params = random_string(10)
with open("test_read.txt", "+w") as f:
f.write(f"{string_params}")
f.write(f"{string_params}")
with os.popen(
f"cat test_read.txt |./a.out read 0 {string_params} {len(string_params)}"
) as result:
self.check(result, [0, string_params, len(string_params)])
def test_no_event_source(self):
event = {'detail': {'state': 'TERMINATED'}}
mock_processor = Mock()
mock_processor.source = random_string()
mock_processor.type = None
manager = EventProcessorManager(table_name=self.table_name,
index_name=self.index_name,
processors=[mock_processor])
self.assertRaises(ValueError, manager.process_event, event)
def test_neg_input(self):
with self.subTest(i=0):
string_params = random_string(10)
with os.popen(
f"cat test_read.txt | ./a.out read 0 {string_params} -1"
) as result:
self.check(result, [0, string_params, -1])
with os.popen(
f"cat test_read.txt | ./a.out read -1 {string_params} {len(string_params)}"
) as result:
self.check(result, [-1, string_params, len(string_params)])
def test_delete_no_token_for_id(self):
event_source = random_string()
event = {'source': event_source}
mock_processor = Mock()
mock_processor.source = event_source
mock_processor.type = None
mock_processor.test_and_get_id = MagicMock(
return_value=random_string())
mock_table = create_non_fung_table(self.table_name, self.index_name)
self._insert_token(mock_table)
self.assertEqual(1, self._get_resource_id_count(mock_table))
manager = EventProcessorManager(table_name=self.table_name,
index_name=self.index_name,
processors=[mock_processor])
manager._table = mock_table
manager.process_event(event)
self.assertEqual(1, self._get_resource_id_count(mock_table))
def test_and_sibling_false(self):
state_value = random_string()
message_value = random_string()
zone_value = random_string()
event = {
'detail': {
'state': state_value,
'message': message_value,
'zone': zone_value
}
}
state_pred = ProcessorPredicate('detail.state',
lambda state: state == state_value)
message_pred = ProcessorPredicate('detail.message',
lambda state: state == message_value)
predicate = ProcessorPredicate('detail.zone',
lambda state: state == random_string())
predicate.with_and(state_pred).with_and(message_pred)
self.assertFalse(predicate.test(event))
def test_account_resource_limit_blacklist(self):
limit = 0
window = random.randint(0, 100)
account_id = random_string()
mock_limit_table = create_limit_table(self.limit_table)
_insert_limit(mock_limit_table, self.resource_name, account_id, limit,
window)
self.manager._limit_table = mock_limit_table
self.assertRaises(CapacityExhaustedException,
self.manager._get_account_resource_limit, account_id)
