class TestDatabaseFieldsInitialization(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel)
def test_initialize_new_nested_object(self):
field_random_value: int = random.randint(0, 100)
project_id = "testFieldInitializationNewProjectId"
query_kwargs = {'nestedObjectId': project_id}
set_success: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='nestedObject.{{nestedObjectId}}.value',
query_kwargs=query_kwargs,
value_to_set=field_random_value)
self.assertTrue(set_success)
retrieved_value: Optional[int] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='nestedObject.{{nestedObjectId}}.value',
query_kwargs=query_kwargs)
self.assertEqual(retrieved_value, field_random_value)
deletion_success: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID,
field_path='nestedObject.{{nestedObjectId}}',
query_kwargs=query_kwargs)
self.assertTrue(deletion_success)
class TestFieldKeyWithSpecialChars(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel)
def test_field_key_with_points(self):
random_item_id = f".pointBefore.{str(uuid4())}.pointAfter."
query_kwargs = {'itemId': random_item_id}
set_success: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.{{itemId}}',
query_kwargs=query_kwargs,
value_to_set={'value': 42})
self.assertTrue(set_success)
retrieved_value = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.{{itemId}}.value',
query_kwargs=query_kwargs)
self.assertEqual(retrieved_value, 42)
deletion_success: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.{{itemId}}',
query_kwargs=query_kwargs)
self.assertTrue(deletion_success)
class TestDatabaseFieldsInitialization(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel)
def test_retrieve_multiple_attributes_from_single_object(self):
"""
Test both the get_field and the get_multiple_fields function
"""
randomized_item_key = f"key_{uuid4()}"
random_name = f"name-{uuid4()}"
random_value = f"value-{uuid4()}"
timestamp = time()
randomized_item = {
'name': random_name,
'value': random_value,
'timestamp': timestamp
}
query_kwargs = {'itemKey': randomized_item_key}
set_success: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='multiAttributesContainer.{{itemKey}}',
query_kwargs=query_kwargs,
value_to_set=randomized_item)
self.assertTrue(set_success)
retrieved_values: dict = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='multiAttributesContainer.{{itemKey}}.(name, value)',
query_kwargs=query_kwargs)
self.assertEqual(retrieved_values.get('name'), random_name)
self.assertEqual(retrieved_values.get('value'), random_value)
retrieved_values: dict = self.users_table.get_multiple_fields(
key_value=TEST_ACCOUNT_ID,
getters={
'one':
FieldGetter(
field_path=
'multiAttributesContainer.{{itemKey}}.(name, value)',
query_kwargs=query_kwargs)
})
self.assertEqual(retrieved_values['one'].get('name', None),
random_name)
self.assertEqual(retrieved_values['one'].get('value', None),
random_value)
deletion_success: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID,
field_path='multiAttributesContainer.{{itemKey}}',
query_kwargs=query_kwargs)
self.assertTrue(deletion_success)
class TestsSetObjectType(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel)
def test_crash_on_untyped_set(self):
def init_table():
class TableModel(TableDataModel):
accountId = BaseField(field_type=str, required=True)
untypedSet = BaseField(field_type=set,
key_name='setKey',
required=False)
users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel())
self.assertRaises(UsageOfUntypedSetException, init_table)
def test_set_retrieve_individual_typed_set_item(self):
valid_random_set_values: Set[str] = set(str(uuid4()) for i in range(5))
single_valid_set_item = list(valid_random_set_values)[2]
random_set_values = valid_random_set_values.copy()
random_set_values.add(42)
# Add invalid value to the random_set_values
set_success: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.typedSet',
value_to_set=random_set_values)
self.assertTrue(set_success)
# todo: add support for retrieving single set item (we need to check if the set item exists)
retrieved_set_item: Optional[str] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.typedSet.{{setKey}}',
query_kwargs={'setKey': "ee"})
self.assertEqual(retrieved_set_item, single_valid_set_item)
retrieved_entire_set: Optional[Set[str]] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID, field_path='container.typedSet')
self.assertEqual(valid_random_set_values, retrieved_entire_set)
deletion_success: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID, field_path='container.typedSet')
self.assertTrue(deletion_success)
class TestDeleteNonExistingItems(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel)
def test_delete_nested(self):
success_delete_item_one = self.users_table.delete_field(key_value=TEST_ACCOUNT_ID, field_path='fieldsToDeleteContainer.existingItemOneToDelete')
success_delete_item_two = self.users_table.delete_field(key_value=TEST_ACCOUNT_ID, field_path='fieldsToDeleteContainer.existingItemOneToDelete')
self.assertTrue(success_delete_item_one)
self.assertTrue(success_delete_item_two)
random_item_one_value = f"itemOne_{uuid4()}"
random_item_two_value = f"itemTwo_{uuid4()}"
update_success = self.users_table.update_multiple_fields(
key_value=TEST_ACCOUNT_ID, setters=[
FieldSetter(field_path='fieldsToDeleteContainer.existingItemOneToDelete', value_to_set=random_item_one_value),
FieldSetter(field_path='fieldsToDeleteContainer.existingItemOneToDelete', value_to_set=random_item_two_value)
]
)
self.assertTrue(update_success)
class TestRemoveFieldOperations(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel)
def test_delete_basic_item_from_path_target(self):
success_field_set = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='fieldToRemove',
value_to_set="yolo mon ami !")
self.assertTrue(success_field_set)
success_field_remove = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID, field_path='fieldToRemove')
self.assertTrue(success_field_remove)
retrieved_field_data = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID, field_path='fieldToRemove')
self.assertIsNone(retrieved_field_data)
def test_remove_sophisticated_item_from_path_target(self):
query_kwargs = {'id': 'sampleId'}
first_message = f"one_{uuid4()}"
second_message = f"two_{uuid4()}"
def set_data():
success_field_set = self.users_table.update_multiple_fields(
key_value=TEST_ACCOUNT_ID,
setters=[
FieldSetter(
field_path=
"sophisticatedFieldToRemove.{{id}}.firstNestedValue",
query_kwargs=query_kwargs,
value_to_set=first_message),
FieldSetter(
field_path=
"sophisticatedFieldToRemove.{{id}}.secondNestedValue",
query_kwargs=query_kwargs,
value_to_set=second_message)
])
self.assertTrue(success_field_set)
set_data()
removed_first_message = self.users_table.remove_field(
field_path="sophisticatedFieldToRemove.{{id}}.firstNestedValue",
key_value=TEST_ACCOUNT_ID,
query_kwargs=query_kwargs,
)
self.assertEqual(first_message, removed_first_message)
removed_second_message = self.users_table.remove_field(
field_path="sophisticatedFieldToRemove.{{id}}.secondNestedValue",
key_value=TEST_ACCOUNT_ID,
query_kwargs=query_kwargs)
self.assertEqual(second_message, removed_second_message)
set_data()
# Since we removed the individuals items, before we can retrieve
# the entire data, we need to re-set it in the database.
removed_entire_item = self.users_table.remove_field(
field_path="sophisticatedFieldToRemove.{{id}}",
key_value=TEST_ACCOUNT_ID,
query_kwargs=query_kwargs,
)
self.assertEqual(removed_entire_item, {
'firstNestedValue': first_message,
'secondNestedValue': second_message
})
# Python does not care about the dict ordering when doing a dict comparison
def test_remove_multiple_fields(self):
random_id = str(uuid4())
random_value_one = f"one_{uuid4()}"
random_value_two = f"two_{uuid4()}"
update_success = self.users_table.update_multiple_fields(
key_value=TEST_ACCOUNT_ID,
setters=[
FieldSetter(field_path='fieldToRemove',
value_to_set=random_value_one),
FieldSetter(
field_path=
'sophisticatedFieldToRemove.{{id}}.firstNestedValue',
query_kwargs={'id': random_id},
value_to_set=random_value_two)
])
self.assertTrue(update_success)
get_response_data = self.users_table.get_multiple_fields(
key_value=TEST_ACCOUNT_ID,
getters={
'one':
FieldGetter(field_path='fieldToRemove'),
'two':
FieldGetter(
field_path=
'sophisticatedFieldToRemove.{{id}}.firstNestedValue',
query_kwargs={'id': random_id})
})
self.assertEqual(get_response_data.get('one', None), random_value_one)
self.assertEqual(get_response_data.get('two', None), random_value_two)
remove_response_data = self.users_table.remove_multiple_fields(
key_value=TEST_ACCOUNT_ID,
removers={
'one':
FieldRemover(field_path='fieldToRemove'),
'two':
FieldRemover(
field_path=
'sophisticatedFieldToRemove.{{id}}.firstNestedValue',
query_kwargs={'id': random_id})
})
print(remove_response_data)
def test_remove_multiple_fields_with_multi_selectors(self):
"""
Removing multiple fields with a multi selector in single field_path in a remove_multiple_fields operation is
awkward, because a single key per field_path can be assigned. Which means that the multiple fields retrieved
with the multi selector must be send back in the same dictionary, like if it was a get_field with multi selectors.
"""
random_id = str(uuid4())
field_one_random = f"field_one_{uuid4()}"
field_two_random = f"field_two_{uuid4()}"
field_three_random = f"field_three_{uuid4()}"
update_success = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='sophisticatedFieldToRemove.{{id}}',
query_kwargs={'id': random_id},
value_to_set={
'firstNestedValue': field_one_random,
'secondNestedValue': field_two_random,
'thirdNestedValue': field_three_random
})
self.assertTrue(update_success)
get_response_data = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
query_kwargs={'id': random_id},
field_path=
'sophisticatedFieldToRemove.{{id}}.(firstNestedValue, secondNestedValue, thirdNestedValue)'
)
self.assertEqual(get_response_data.get('firstNestedValue', None),
field_one_random)
self.assertEqual(get_response_data.get('secondNestedValue', None),
field_two_random)
self.assertEqual(get_response_data.get('thirdNestedValue', None),
field_three_random)
remove_response_data = self.users_table.remove_multiple_fields(
key_value=TEST_ACCOUNT_ID,
removers={
'one':
FieldRemover(
field_path=
'sophisticatedFieldToRemove.{{id}}.(firstNestedValue, secondNestedValue)',
query_kwargs={'id': random_id})
})
self.assertEqual(
remove_response_data.get('one', {}).get('firstNestedValue', None),
field_one_random)
self.assertEqual(
remove_response_data.get('one', {}).get('secondNestedValue', None),
field_two_random)
retrieved_third_value = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
query_kwargs={'id': random_id},
field_path='sophisticatedFieldToRemove.{{id}}.thirdNestedValue')
self.assertEqual(retrieved_third_value, field_three_random)
class TestTableOperations(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(
data_model=UsersTableModel)
def test_get_name_of_one_project(self):
response_data: Optional[str] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}.projectName',
query_kwargs={'projectId': TEST_PROJECT_ID})
self.assertIn("test", response_data)
def test_update_project_name(self):
success = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}.projectName',
query_kwargs={'projectId': TEST_PROJECT_ID},
value_to_set="test2")
self.assertTrue(success)
response_data: Optional[str] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}.projectName',
query_kwargs={'projectId': TEST_PROJECT_ID})
self.assertEqual(response_data, "test2")
def test_update_entire_project_model(self):
success = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}',
value_to_set={'projectName': "test3"},
query_kwargs={'projectId': TEST_PROJECT_ID})
# todo: allow to set the item of a dict (currently, when doing a query on the projects object,
# we will perform an operation of the project map, and not on an individual project item).
self.assertTrue(success)
response_data: Optional[str] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}.projectName',
query_kwargs={'projectId': TEST_PROJECT_ID})
self.assertEqual(response_data, "test3")
def test_update_entire_project_model_with_missing_project_name(self):
success = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}',
value_to_set={},
query_kwargs={'projectId': TEST_PROJECT_ID})
self.assertFalse(success)
def test_update_entire_project_model_with_invalid_data(self):
success = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}',
value_to_set={'invalidProjectName': "test4"},
query_kwargs={'projectId': TEST_PROJECT_ID})
self.assertFalse(success)
try:
response_data: Optional[str] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}.invalidProjectName',
query_kwargs={'projectId': TEST_PROJECT_ID})
# If we do not get an error while trying to access an invalid field in the
# get_field function, then we failed the test.
self.fail()
except FieldTargetNotFoundException as e:
print(e)
def test_multi_types_field(self):
success_str: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path="multiTypes",
value_to_set="yolo")
self.assertTrue(success_str)
success_none: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path="multiTypes",
value_to_set=None)
self.assertTrue(success_none)
success_bool: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path="multiTypes",
value_to_set=True)
self.assertFalse(success_bool)
def test_basic_get_multiple_fields_values_in_single_query(self):
response_data: Optional[dict] = self.users_table.get_multiple_fields(
key_value=TEST_ACCOUNT_ID,
getters={
'theAccountId': FieldGetter(field_path='accountId'),
'theProjects': FieldGetter(field_path='projects')
})
self.assertIsNotNone(response_data)
self.assertEqual(response_data.get('theAccountId', None),
TEST_ACCOUNT_ID)
def test_sophisticated_get_multiple_fields_in_single_query(self):
response_data: Optional[dict] = self.users_table.get_multiple_fields(
key_value=TEST_ACCOUNT_ID,
getters={
'theAccountId':
FieldGetter(field_path='accountId'),
'theProjectName':
FieldGetter(field_path='projects.{{projectId}}.projectName',
query_kwargs={'projectId': TEST_PROJECT_ID})
})
self.assertIsNotNone(response_data)
self.assertEqual(response_data.get('theAccountId', None),
TEST_ACCOUNT_ID)
self.assertIn("test", response_data.get('theProjectName', ""))
def test_basic_update_multiple_fields_in_single_query(self):
success: bool = self.users_table.update_multiple_fields(
key_value=TEST_ACCOUNT_ID,
setters=[
FieldSetter(field_path='number1', value_to_set=42),
FieldSetter(field_path='string1', value_to_set="Quarante-deux")
])
self.assertTrue(success)
def test_sophisticated_update_multiple_fields_in_single_query(self):
success: bool = self.users_table.update_multiple_fields(
key_value=TEST_ACCOUNT_ID,
setters=[
FieldSetter(field_path='number1', value_to_set=42),
FieldSetter(
field_path='projects.{{projectId}}.projectName',
query_kwargs={'projectId': TEST_PROJECT_ID},
value_to_set="test5",
)
])
self.assertTrue(success)
project_name_data: Optional[str] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='projects.{{projectId}}.projectName',
query_kwargs={'projectId': TEST_PROJECT_ID},
)
self.assertEqual(project_name_data, "test5")
def test_set_and_get_float_in_field_value(self):
source_float_value = 10.42021023492
set_float_value_success = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='floatTest',
value_to_set=source_float_value)
self.assertTrue(set_float_value_success)
retrieved_float_value: Optional[float] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID, field_path='floatTest')
self.assertEqual(retrieved_float_value, source_float_value)
def test_remove_basic_item_from_path_target(self):
success_field_set: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path="fieldToDelete",
value_to_set="yolo mon ami !")
self.assertTrue(success_field_set)
success_field_remove: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID, field_path="fieldToDelete")
self.assertTrue(success_field_remove)
retrieved_field_data: Optional[float] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID, field_path="fieldToDelete")
self.assertIsNone(retrieved_field_data)
def test_remove_sophisticated_item_from_path_target(self):
query_kwargs = {"id": "sampleId"}
success_field_set = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='sophisticatedRemoval.{{id}}.nestedVariable',
query_kwargs=query_kwargs,
value_to_set="Soooooo, does it works ? :)")
self.assertTrue(success_field_set)
success_field_remove = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID,
field_path='sophisticatedRemoval.{{id}}.nestedVariable',
query_kwargs=query_kwargs)
self.assertTrue(success_field_remove)
retrieved_field_data = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='sophisticatedRemoval.{{id}}.nestedVariable',
query_kwargs=query_kwargs)
self.assertIsNone(retrieved_field_data)
def test_remove_multiple_basic_and_sophisticated_items_from_path_target(
self):
query_kwargs = {"id": "sampleIdTwo"}
success_fields_set: bool = self.users_table.update_multiple_fields(
key_value=TEST_ACCOUNT_ID,
setters=[
FieldSetter(
field_path='fieldToDelete',
value_to_set="multipleBasicAndSophisticatedRemoval"),
FieldSetter(
field_path='sophisticatedRemoval.{{id}}.nestedVariable',
query_kwargs=query_kwargs,
value_to_set="nestedDude")
])
self.assertTrue(success_fields_set)
deletion_response = self.users_table.delete_multiple_fields(
key_value=TEST_ACCOUNT_ID,
removers={
'field':
FieldRemover(field_path="fieldToDelete"),
'nested':
FieldRemover(
field_path="sophisticatedRemoval.{{id}}.nestedVariable",
query_kwargs=query_kwargs)
})
self.assertTrue(all(deletion_response.values()))
def test_put_and_delete_records(self):
success_put_invalid_record = self.users_table.put_record(
record_dict_data={
"invalidAccountId": "testAccountId",
"multiTypes": "testPutRecord"
})
self.assertFalse(success_put_invalid_record)
success_put_valid_record = self.users_table.put_record(
record_dict_data={
"accountId": "testAccountId",
"multiTypes": "testPutRecord"
})
self.assertTrue(success_put_valid_record)
success_delete_record_with_index_typo = self.users_table.delete_record(
indexes_keys_selectors={"accountIdWithTypo": "testAccountId"})
self.assertFalse(success_delete_record_with_index_typo)
success_delete_record_without_typo = self.users_table.delete_record(
indexes_keys_selectors={"accountId": "testAccountId"})
self.assertTrue(success_delete_record_without_typo)
def test_get_value_from_path_target_by_secondary_index(self):
account_id: Optional[str] = self.users_table.get_field(
index_name="email",
key_value=TEST_ACCOUNT_EMAIL,
field_path="accountId")
self.assertEqual(account_id, TEST_ACCOUNT_ID)
account_data: Optional[dict] = self.users_table.get_multiple_fields(
index_name="email",
key_value=TEST_ACCOUNT_EMAIL,
getters={
"accountId": FieldGetter(field_path="accountId"),
"username": FieldGetter(field_path="username")
})
self.assertEqual(account_data.get("accountId", None), TEST_ACCOUNT_ID)
self.assertEqual(account_data.get("username", None),
TEST_ACCOUNT_USERNAME)
def test_set_data_inside_a_map_model_field(self):
dummy_value = str(uuid4())
set_update_success: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='testMapModel.sampleText',
value_to_set=dummy_value)
self.assertEqual(set_update_success, True)
retrieved_value: Optional[str] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID, field_path='testMapModel.sampleText')
self.assertEqual(retrieved_value, dummy_value)
delete_field_success: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID, field_path="testMapModel.sampleText")
self.assertEqual(delete_field_success, True)
def test_set_dict_item_with_primitive_value(self):
success_valid: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='testDictWithPrimitiveValue.{{key}}',
query_kwargs={'key': "one"},
value_to_set=True)
self.assertTrue(success_valid)
success_invalid: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='testDictWithPrimitiveValue.{{key}}',
query_kwargs={'key': "one"},
value_to_set={'keyOfDictThatShouldNotBeHere': True})
self.assertFalse(success_invalid)
class TestListObjectType(unittest.TestCase):
def __init__(self, method_name: str):
super().__init__(methodName=method_name)
self.users_table = PlaygroundDynamoDBBasicTable(data_model=TableModel)
def test_untyped_list(self):
random_list_values: List[Any] = list(str(uuid4()) for i in range(5))
single_valid_list_item = random_list_values[2]
random_list_values.append(42)
# Add a value of different type, that is valid to the untypedList
set_success: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.untypedList',
value_to_set=random_list_values
)
self.assertTrue(set_success)
retrieved_list_item: Optional[str or int] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.untypedList.{{listIndex}}',
query_kwargs={'listIndex': 2}
)
self.assertEqual(retrieved_list_item, single_valid_list_item)
retrieved_entire_list: Optional[list] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.untypedList',
query_kwargs={'listIndex': 2}
)
self.assertEqual(retrieved_entire_list, random_list_values)
deletion_success: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.untypedList'
)
self.assertTrue(deletion_success)
def test_typed_list(self):
valid_random_list_values: List[str] = [str(uuid4()) for i in range(5)]
single_valid_list_item = valid_random_list_values[2]
random_list_values = valid_random_list_values.copy()
random_list_values.append(42)
# Add invalid value to the random_list_values
set_success: bool = self.users_table.update_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.typedList',
value_to_set=random_list_values
)
self.assertTrue(set_success)
query_kwargs = {'listIndex': 2}
retrieved_list_item: Optional[dict] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.typedList.{{listIndex}}',
query_kwargs=query_kwargs
)
self.assertEqual(retrieved_list_item, single_valid_list_item)
retrieved_entire_list: Optional[list] = self.users_table.get_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.typedList',
query_kwargs=query_kwargs
)
self.assertEqual(valid_random_list_values, retrieved_entire_list)
deletion_success: bool = self.users_table.delete_field(
key_value=TEST_ACCOUNT_ID,
field_path='container.typedList',
query_kwargs=query_kwargs
)
self.assertTrue(deletion_success)