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)