boto3-assist 0.18.0__tar.gz → 0.20.0__tar.gz

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/.vscode/settings.json

@@ -27,7 +27,8 @@
         "editor.defaultFormatter": "ms-python.black-formatter",
     },
     "cSpell.words": [
-        "addopts"
+        "addopts",
+        "geekcafe"
     ],
     
 }

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boto3_assist
-Version: 0.18.0
+Version: 0.20.0
 Summary: Additional boto3 wrappers to make your life a little easier
 Author-email: Eric Wilson <boto3-assist@geekcafe.com>
 License-File: LICENSE-EXPLAINED.txt

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/pyproject.toml

@@ -15,7 +15,7 @@ addopts = "-m 'not integration'"
 
 [project]
 name = "boto3_assist"
-version = "0.18.0"
+version = "0.20.0"
 
 authors = [
   { name="Eric Wilson", email="boto3-assist@geekcafe.com" }

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/src/boto3_assist/dynamodb/dynamodb.py

@@ -15,11 +15,11 @@ from boto3.dynamodb.conditions import (
     ComparisonCondition,
     ConditionBase,
 )
-from boto3_assist.dynamodb.dynamodb_connection import DynamoDBConnection
-from boto3_assist.dynamodb.dynamodb_helpers import DynamoDBHelpers
-from boto3_assist.dynamodb.dynamodb_model_base import DynamoDBModelBase
-from boto3_assist.utilities.string_utility import StringUtility
-
+from .dynamodb_connection import DynamoDBConnection
+from .dynamodb_helpers import DynamoDBHelpers
+from .dynamodb_model_base import DynamoDBModelBase
+from ..utilities.string_utility import StringUtility
+from .dynamodb_index import DynamoDBIndex
 
 logger = Logger()
 
@@ -69,9 +69,9 @@ class DynamoDB(DynamoDBConnection):
         """
         Save an item to the database
         Args:
-            item (dict): DynamoDB Dictionay Object or DynamoDBModelBase.  Supports the "client" or
+            item (dict): DynamoDB Dictionary Object or DynamoDBModelBase.  Supports the "client" or
             "resource" syntax
-            table_name (str): The DyamoDb Table Name
+            table_name (str): The DynamoDb Table Name
             source (str, optional): The source of the call, used for logging. Defaults to None.
 
         Raises:
@@ -98,7 +98,7 @@ class DynamoDB(DynamoDBConnection):
                 except Exception as e:  # pylint: disable=w0718
                     logger.exception(e)
                     raise RuntimeError(
-                        "An error occured during model converation.  The entry was not saved. "
+                        "An error occurred during model conversion.  The entry was not saved. "
                     ) from e
 
             if isinstance(item, dict):
@@ -279,11 +279,11 @@ class DynamoDB(DynamoDBConnection):
 
     def query(
         self,
-        key: dict | Key | ConditionBase | ComparisonCondition,
+        key: dict | Key | ConditionBase | ComparisonCondition | DynamoDBIndex,
+        table_name: str,
         *,
         index_name: Optional[str] = None,
         ascending: bool = False,
-        table_name: Optional[str] = None,
         source: Optional[str] = None,
         strongly_consistent: bool = False,
         projection_expression: Optional[str] = None,
@@ -305,6 +305,17 @@ class DynamoDB(DynamoDBConnection):
         """
 
         logger.debug({"action": "query", "source": source})
+        if not key:
+            raise ValueError("Query failed: key must be provided.")
+
+        if not table_name:
+            raise ValueError("Query failed: table_name must be provided.")
+
+        if isinstance(key, DynamoDBIndex):
+            if not index_name:
+                index_name = key.name
+            # turn it into a key expected by dynamodb
+            key = key.key()
 
         kwargs: dict = {}
         if index_name:
@@ -330,7 +341,16 @@ class DynamoDB(DynamoDBConnection):
             raise ValueError("Query failed: table_name must be provided.")
 
         table = self.dynamodb_resource.Table(table_name)
-        response = dict(table.query(**kwargs))
+        response: dict = {}
+        try:
+            response = dict(table.query(**kwargs))
+        except Exception as e:  # pylint: disable=w0718
+            logger.exception(
+                {"source": f"{source}", "metric_filter": "query", "error": str(e)}
+            )
+            response = {"exception": str(e)}
+            if self.raise_on_error:
+                raise e
 
         return response
 

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/src/boto3_assist/dynamodb/dynamodb_model_base.py

@@ -40,7 +40,7 @@ def exclude_indexes_from_serialization(method):
 
 
 class DynamoDBModelBase(SerializableModel):
-    """DyanmoDb Model Base"""
+    """DynamoDb Model Base"""
 
     T = TypeVar("T", bound="DynamoDBModelBase")
 
@@ -53,6 +53,9 @@ class DynamoDBModelBase(SerializableModel):
         self.__auto_generate_projections: bool = auto_generate_projections
         self.__actively_serializing_data__: bool = False
 
+    def serialization_in_progress(self) -> bool:
+        return self.__actively_serializing_data__
+
     @property
     @exclude_from_serialization
     def indexes(self) -> DynamoDBIndexes:

boto3_assist-0.20.0/src/boto3_assist/dynamodb/dynamodb_re_indexer.py

@@ -0,0 +1,165 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+import json
+from typing import Any, Dict, Optional, List, Type
+from aws_lambda_powertools import Logger
+from boto3_assist.dynamodb.dynamodb import DynamoDB
+from boto3_assist.dynamodb.dynamodb_model_base import DynamoDBModelBase
+from boto3_assist.utilities.serialization_utility import Serialization
+from boto3_assist.dynamodb.dynamodb_index import DynamoDBIndex
+from boto3_assist.dynamodb.dynamodb_iservice import IDynamoDBService
+
+logger = Logger()
+
+
+class DynamoDBReIndexer:
+    """ReIndexing your database"""
+
+    def __init__(
+        self,
+        table_name: str,
+        *,
+        db: Optional[DynamoDB] = None,
+        aws_profile: Optional[str] = None,
+        aws_region: Optional[str] = None,
+        aws_end_point_url: Optional[str] = None,
+        aws_access_key_id: Optional[str] = None,
+        aws_secret_access_key: Optional[str] = None,
+    ):
+        self.table_name = table_name
+        self.db: DynamoDB = db or DynamoDB(
+            aws_profile=aws_profile,
+            aws_region=aws_region,
+            aws_end_point_url=aws_end_point_url,
+            aws_access_key_id=aws_access_key_id,
+            aws_secret_access_key=aws_secret_access_key,
+        )
+
+    def reindex_item(
+        self,
+        original_primary_key: dict,
+        model: DynamoDBModelBase,
+        *,
+        dry_run: bool = False,
+        inplace: bool = True,
+        leave_original_record: bool = False,
+        service_cls: Type[IDynamoDBService] | None,
+    ):
+        """
+        Reindex the record
+
+        Args:
+            original_primary_key (dict): The original primary key of the record to be reindexed.
+                This is either the partition_key or a composite key (partition_key, sort_key)
+            model (DynamoDBModelBase): A model instance that will be used to serialize the new keys
+                into a dictionary. It must inherit from DynamoDBModelBase
+
+            dry_run (bool, optional): Ability to log the actions without executing them. Defaults to False.
+            inplace (bool, optional): Ability to just update the indexes only.
+                No other fields will be updated, however you can't update the primary_key (partition/sort key)
+                with this action since they are immutable.
+                Defaults to True.
+            leave_original_record (bool, optional): _description_. Defaults to False.
+        """
+
+        if inplace:
+            keys: List[DynamoDBIndex] = model.list_keys()
+            # Update the item in DynamoDB with new keys
+            self.update_item_in_dynamodb(
+                original_primary_key=original_primary_key, keys=keys, dry_run=dry_run
+            )
+            # todo: add some additional error handling here and throw a more
+            # descriptive error if they try to use a different primary
+            # pk or sk, which you can't do.  If that's the case
+        else:
+            # add the new one first and optionally delete the older one
+            # once we are succesfull
+            try:
+                # save the new one first
+                service_instance: Optional[IDynamoDBService] = (
+                    service_cls(db=self.db) if callable(service_cls) else None
+                )
+
+                if service_instance:
+                    service_instance.save(model=model)
+                else:
+                    self.db.save(
+                        item=model, table_name=self.table_name, source="reindex"
+                    )
+
+                # then delete the old on
+                if not leave_original_record:
+                    self.db.delete(
+                        table_name=self.table_name, primary_key=original_primary_key
+                    )
+            except Exception as e:  # pylint: disable=broad-except
+                logger.error(str(e))
+                raise RuntimeError(str(e)) from e
+            # this gets a little more trick as we need to delete the item
+
+    def load_model(
+        self, db_item: dict, db_model: DynamoDBModelBase
+    ) -> DynamoDBModelBase | None:
+        """load the model which will serialze the dynamodb dictionary to an instance of an object"""
+
+        base_model = Serialization.map(db_item, db_model)
+        return base_model
+
+    def update_item_in_dynamodb(
+        self,
+        original_primary_key: dict,
+        keys: List[DynamoDBIndex],
+        dry_run: bool = False,
+    ):
+        """Update the dynamodb item"""
+        dictionary = self.db.helpers.keys_to_dictionary(keys=keys)
+
+        update_expression = self.build_update_expression(dictionary)
+        expression_attribute_values = self.build_expression_attribute_values(dictionary)
+
+        if not dry_run:
+            self.db.update_item(
+                table_name=self.table_name,
+                key=original_primary_key,
+                update_expression=update_expression,
+                expression_attribute_values=expression_attribute_values,
+            )
+        else:
+            print("Dry run: Skipping Update item")
+            print(f"{json.dumps(original_primary_key, indent=4)}")
+            print(f"{update_expression}")
+            print(f"{json.dumps(expression_attribute_values, indent=4)}")
+
+    def build_update_expression(self, updated_keys: Dict[str, Any]) -> str:
+        """
+        Build the expression for updating the item
+
+        Args:
+            updated_keys (Dict[str, Any]): _description_
+
+        Returns:
+            str: _description_
+        """
+        update_expression = "SET " + ", ".join(
+            f"{k} = :{k}" for k in updated_keys.keys()
+        )
+        return update_expression
+
+    def build_expression_attribute_values(
+        self, updated_keys: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Build the expression attribute values for the update expression
+
+        Args:
+            updated_keys (Dict[str, Any]): _description_
+
+        Returns:
+            Dict[str, Any]: _description_
+        """
+        expression_attribute_values = {f":{k}": v for k, v in updated_keys.items()}
+        return expression_attribute_values

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/src/boto3_assist/utilities/serialization_utility.py

@@ -470,7 +470,7 @@ class Serialization:
                 "To work around this create a boolean (bool) property named __actively_serializing_data__. \n"
                 "e.g. self.__actively_serializing_data__: bool = False\n\n"
                 "Only issue/raise your exception if __actively_serializing_data__ is not True. \n\n"
-                "e.g. if not self.some_propert and not self.__actively_serializing_data__:\n"
+                "e.g. if not self.some_property and not self.__actively_serializing_data__:\n"
                 '    raise ValueError("some_property must be set")\n\n'
                 "This procedure will update the property from False to True while serializing, "
                 "then back to False once serialization is complete. "

boto3_assist-0.20.0/src/boto3_assist/version.py

@@ -0,0 +1 @@
+__version__ = '0.20.0'

boto3_assist-0.20.0/tests/unit/common/db_test_helpers.py

@@ -0,0 +1,50 @@
+from mypy_boto3_dynamodb import DynamoDBClient
+
+
+class DbTestHelper:
+
+    def helper_create_mock_table(self, table_name: str, client: DynamoDBClient) -> None:
+        """
+        Create a mock DynamoDB table.
+        """
+
+        gs_indexes = []
+
+        for i in range(1, 11):
+            gs_indexes.append(
+                {
+                    "IndexName": f"gsi{i}",
+                    "KeySchema": [
+                        {
+                            "AttributeName": f"gsi{i}_pk",
+                            "KeyType": "HASH",
+                        },  # Partition key for GSI
+                        {
+                            "AttributeName": f"gsi{i}_sk",
+                            "KeyType": "RANGE",
+                        },  # Sort key for GSI
+                    ],
+                    "Projection": {"ProjectionType": "ALL"},  # Project all attributes
+                }
+            )
+
+        attributes = [
+            {"AttributeName": "pk", "AttributeType": "S"},
+            {"AttributeName": "sk", "AttributeType": "S"},
+        ]
+        for i in range(1, 11):
+            attributes.append({"AttributeName": f"gsi{i}_pk", "AttributeType": "S"})
+            attributes.append({"AttributeName": f"gsi{i}_sk", "AttributeType": "S"})
+
+        response = client.create_table(
+            TableName=table_name,
+            KeySchema=[
+                {"AttributeName": "pk", "KeyType": "HASH"},  # Partition key
+                {"AttributeName": "sk", "KeyType": "RANGE"},  # Sort key
+            ],
+            AttributeDefinitions=attributes,
+            GlobalSecondaryIndexes=gs_indexes,
+            BillingMode="PAY_PER_REQUEST",
+        )
+
+        print(response)

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/tests/unit/dynamodb_tests/db_models/user_model.py

@@ -38,26 +38,26 @@ class User(DynamoDBModelBase):
         primary.sort_key.value = lambda: DynamoDBKey.build_key(("user", self.id))
         self.indexes.add_primary(primary)
 
-        gsi0: DynamoDBIndex = DynamoDBIndex(index_name="gsi0")
-        gsi0.partition_key.attribute_name = "gsi0_pk"
+        gsi0: DynamoDBIndex = DynamoDBIndex(index_name="gsi1")
+        gsi0.partition_key.attribute_name = "gsi1_pk"
         gsi0.partition_key.value = lambda: DynamoDBKey.build_key(("users", None))
-        gsi0.sort_key.attribute_name = "gsi0_sk"
+        gsi0.sort_key.attribute_name = "gsi1_sk"
         gsi0.sort_key.value = lambda: DynamoDBKey.build_key(("email", self.email))
         self.indexes.add_secondary(gsi0)
 
-        gsi1: DynamoDBIndex = DynamoDBIndex(index_name="gsi1")
-        gsi1.partition_key.attribute_name = "gsi1_pk"
+        gsi1: DynamoDBIndex = DynamoDBIndex(index_name="gsi2")
+        gsi1.partition_key.attribute_name = "gsi2_pk"
         gsi1.partition_key.value = lambda: DynamoDBKey.build_key(("users", None))
-        gsi1.sort_key.attribute_name = "gsi1_sk"
+        gsi1.sort_key.attribute_name = "gsi2_sk"
         gsi1.sort_key.value = lambda: DynamoDBKey.build_key(
             ("lastname", self.last_name), ("firstname", self.first_name)
         )
         self.indexes.add_secondary(gsi1)
 
-        gsi0: DynamoDBIndex = DynamoDBIndex(index_name="gsi2")
-        gsi0.partition_key.attribute_name = "gsi2_pk"
+        gsi0: DynamoDBIndex = DynamoDBIndex(index_name="gsi3")
+        gsi0.partition_key.attribute_name = "gsi3_pk"
         gsi0.partition_key.value = lambda: DynamoDBKey.build_key(("users", None))
-        gsi0.sort_key.attribute_name = "gsi2_sk"
+        gsi0.sort_key.attribute_name = "gsi3_sk"
         gsi0.sort_key.value = lambda: DynamoDBKey.build_key(
             ("firstname", self.first_name), ("lastname", self.last_name)
         )

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/tests/unit/dynamodb_tests/db_models/user_required_fields_model.py

@@ -32,7 +32,6 @@ class User(DynamoDBModelBase):
     def __setup_indexes(self):
         primary: DynamoDBIndex = DynamoDBIndex()
         primary.partition_key.attribute_name = "pk"
-        # allows for a wild card search on all "sites"
         primary.partition_key.value = lambda: DynamoDBKey.build_key(("user", self.id))
         primary.sort_key.attribute_name = "sk"
         primary.sort_key.value = lambda: DynamoDBKey.build_key(("user", self.id))

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/tests/unit/dynamodb_tests/dynamodb_model_base_test.py

@@ -82,43 +82,42 @@ class DynamoDBModelUnitTest(unittest.TestCase):
 
         pk = user.indexes.primary.partition_key.value
         self.assertEqual(pk, "user#123456")
-        index_name = "gsi1"
+        index_name = "gsi2"
         gsi_key = user.get_key(index_name).key()
 
         expression = user.helpers.get_filter_expressions(gsi_key)
         print(f"expression: {expression}")
         keys: List[Dict] = expression.get("keys")
         key_0: Dict = keys[0].get("key")
-        self.assertEqual(key_0.get("name"), "gsi1_pk")
+        self.assertEqual(key_0.get("name"), "gsi2_pk")
         self.assertEqual(key_0.get("key"), "users#")
 
         key_1: Dict = keys[1].get("key")
-        self.assertEqual(key_1.get("name"), "gsi1_sk")
+        self.assertEqual(key_1.get("name"), "gsi2_sk")
         # we didn't populate a last name so this is correct (based on the current logic)
         # we stop here and don't go any further
         self.assertEqual(key_1.get("key"), "lastname#")
 
-        ### gsi3 mapped to a name of gsi2
-        index_name = "gsi2"
+        index_name = "gsi3"
         gsi_key = user.get_key(index_name).key()
         # this should be mapped to gsi0
-        self.assertEqual(index_name, "gsi2")
+        self.assertEqual(index_name, "gsi3")
 
         expression = user.helpers.get_filter_expressions(gsi_key)
         print(f"expression: {expression}")
         keys: List[Dict] = expression.get("keys")
         key_0: Dict = keys[0].get("key")
-        self.assertEqual(key_0.get("name"), "gsi2_pk")
+        self.assertEqual(key_0.get("name"), "gsi3_pk")
         self.assertEqual(key_0.get("key"), "users#")
 
         key_1: Dict = keys[1].get("key")
-        self.assertEqual(key_1.get("name"), "gsi2_sk")
+        self.assertEqual(key_1.get("name"), "gsi3_sk")
         self.assertEqual(key_1.get("key"), "firstname#John#lastname#")
 
         resource = user.to_resource_dictionary()
         self.assertIsNotNone(resource)
 
-    def test_keylist(self):
+    def test_key_list(self):
         """Test Listing Keys"""
         # Arrange
         data = {
@@ -145,21 +144,21 @@ class DynamoDBModelUnitTest(unittest.TestCase):
         self.assertEqual(keys[0].sort_key.attribute_name, "sk")
         self.assertEqual(keys[0].sort_key.value, "user#123456")
 
-        self.assertEqual(keys[1].partition_key.attribute_name, "gsi0_pk")
+        self.assertEqual(keys[1].partition_key.attribute_name, "gsi1_pk")
         self.assertEqual(keys[1].partition_key.value, "users#")
-        self.assertEqual(keys[1].sort_key.attribute_name, "gsi0_sk")
+        self.assertEqual(keys[1].sort_key.attribute_name, "gsi1_sk")
         self.assertEqual(keys[1].sort_key.value, "email#john@example.com")
 
-        self.assertEqual(keys[2].partition_key.attribute_name, "gsi1_pk")
+        self.assertEqual(keys[2].partition_key.attribute_name, "gsi2_pk")
         self.assertEqual(keys[2].partition_key.value, "users#")
-        self.assertEqual(keys[2].sort_key.attribute_name, "gsi1_sk")
+        self.assertEqual(keys[2].sort_key.attribute_name, "gsi2_sk")
         self.assertEqual(keys[2].sort_key.value, "lastname#")
         expression = user.helpers.get_filter_expressions(keys[2].key())
         print(f"expression: {expression}")
 
-        self.assertEqual(keys[3].partition_key.attribute_name, "gsi2_pk")
+        self.assertEqual(keys[3].partition_key.attribute_name, "gsi3_pk")
         self.assertEqual(keys[3].partition_key.value, "users#")
-        self.assertEqual(keys[3].sort_key.attribute_name, "gsi2_sk")
+        self.assertEqual(keys[3].sort_key.attribute_name, "gsi3_sk")
         self.assertEqual(keys[3].sort_key.value, "firstname#John#lastname#")
 
         print("stop")
@@ -186,14 +185,14 @@ class DynamoDBModelUnitTest(unittest.TestCase):
         self.assertEqual(dictionary.get("pk"), "user#123456")
         self.assertEqual(dictionary.get("sk"), "user#123456")
 
-        self.assertEqual(dictionary.get("gsi0_pk"), "users#")
-        self.assertEqual(dictionary.get("gsi0_sk"), "email#john@example.com")
-
         self.assertEqual(dictionary.get("gsi1_pk"), "users#")
-        self.assertEqual(dictionary.get("gsi1_sk"), "lastname#Smith#firstname#John")
+        self.assertEqual(dictionary.get("gsi1_sk"), "email#john@example.com")
 
         self.assertEqual(dictionary.get("gsi2_pk"), "users#")
-        self.assertEqual(dictionary.get("gsi2_sk"), "firstname#John#lastname#Smith")
+        self.assertEqual(dictionary.get("gsi2_sk"), "lastname#Smith#firstname#John")
+
+        self.assertEqual(dictionary.get("gsi3_pk"), "users#")
+        self.assertEqual(dictionary.get("gsi3_sk"), "firstname#John#lastname#Smith")
 
         print("stop")
 
@@ -218,13 +217,13 @@ class DynamoDBModelUnitTest(unittest.TestCase):
         self.assertEqual(dictionary.get("pk"), "user#123456")
         self.assertEqual(dictionary.get("sk"), "user#123456")
 
-        self.assertEqual(dictionary.get("gsi0_pk"), "users#")
-        self.assertEqual(dictionary.get("gsi0_sk"), "email#john@example.com")
-
         self.assertEqual(dictionary.get("gsi1_pk"), "users#")
-        self.assertEqual(dictionary.get("gsi1_sk"), "lastname#")
+        self.assertEqual(dictionary.get("gsi1_sk"), "email#john@example.com")
 
         self.assertEqual(dictionary.get("gsi2_pk"), "users#")
-        self.assertEqual(dictionary.get("gsi2_sk"), "firstname#John#lastname#")
+        self.assertEqual(dictionary.get("gsi2_sk"), "lastname#")
+
+        self.assertEqual(dictionary.get("gsi3_pk"), "users#")
+        self.assertEqual(dictionary.get("gsi3_sk"), "firstname#John#lastname#")
 
         print("stop")

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/tests/unit/dynamodb_tests/dynamodb_moto_sorting_test.py

@@ -31,7 +31,7 @@ class DynamoDB_SortingUnitTest(unittest.TestCase):
 
     def setUp(self):
         # load our test environment file to make sure we override any default AWS Environment Vars setup
-        # we don't want to accidently connec to live environments
+        # we don't want to accidentally connect to live environments
         # https://docs.getmoto.org/en/latest/docs/getting_started.html
 
         self.db: DynamoDB = self.db or DynamoDB()
@@ -54,7 +54,7 @@ class DynamoDB_SortingUnitTest(unittest.TestCase):
             table_name=self.__table_name, key=key, source="unittest", ascending=True
         )
 
-        # after the insert we can sort our expected vaues
+        # after the insert we can sort our expected values
         slugs.sort()
 
         self.assertIn("Items", pages)
@@ -107,7 +107,7 @@ class DynamoDB_SortingUnitTest(unittest.TestCase):
         """
 
         return [
-            "/zerbras",
+            "/zebras",
             "/docs/docs.html",
             "/blogs/blog.html",
             "/blog/re-certify-your-aws-associates-and-cloud-practitioner-certifications-for-free.html",
@@ -131,7 +131,7 @@ class DynamoDB_SortingUnitTest(unittest.TestCase):
                 {"AttributeName": "pk", "AttributeType": "S"},
                 {"AttributeName": "sk", "AttributeType": "S"},
                 {"AttributeName": "gsi1_pk", "AttributeType": "S"},
-                {"AttributeName": "gsi1_sk", "AttributeType": "N"},
+                {"AttributeName": "gsi1_sk", "AttributeType": "S"},
             ],
             GlobalSecondaryIndexes=[
                 {

boto3_assist-0.20.0/tests/unit/dynamodb_tests/dynamodb_query_test.py

@@ -0,0 +1,66 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+import unittest
+import moto
+
+from tests.unit.dynamodb_tests.db_models.user_model import User
+from boto3_assist.environment_services.environment_loader import EnvironmentLoader
+from boto3_assist.dynamodb.dynamodb import DynamoDB
+from tests.unit.common.db_test_helpers import DbTestHelper
+
+
+@moto.mock_aws
+class DbQueryTest(unittest.TestCase):
+    "Serialization Tests"
+
+    def __init__(self, methodName="runTest"):
+        super().__init__(methodName)
+
+        ev: EnvironmentLoader = EnvironmentLoader()
+        # NOTE: you need to make sure the the env file below exists or you will get an error
+        ev.load_environment_file(file_name=".env.unittest")
+        self.__table_name = "mock_test_table"
+
+        self.db: DynamoDB = DynamoDB()
+
+    def setUp(self):
+        # load our test environment file to make sure we override any default AWS Environment Vars setup
+        # we don't want to accidentally connect to live environments
+        # https://docs.getmoto.org/en/latest/docs/getting_started.html
+
+        self.db: DynamoDB = self.db or DynamoDB()
+        DbTestHelper().helper_create_mock_table(self.__table_name, self.db.client)
+        print("Setup Complete")
+
+    def test_query_user(self):
+
+        # create a few users
+        for i in range(1, 11):
+            user = User(i)
+
+            user.first_name = f"first_{i}"
+            user.last_name = f"last_{i}"
+            user.email = f"email_{i}@example.com"
+            response = self.db.save(table_name=self.__table_name, item=user)
+
+            self.assertEqual(response["ResponseMetadata"]["HTTPStatusCode"], 200)
+
+        # query for all users
+        user = User()
+        key = user.get_key("gsi1")
+        response = self.db.query(table_name=self.__table_name, key=key)
+        items = response["Items"]
+        self.assertEqual(len(items), 10)
+
+        # query for one user
+        user = User()
+        user.email = "email_1@example.com"
+        # use the same index but this time we have an email address to add to the filter
+        response = self.db.query(table_name=self.__table_name, key=user.get_key("gsi1"))
+
+        items = response["Items"]
+        self.assertEqual(len(items), 1)

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/tests/unit/dynamodb_tests/dynamodb_reindex_test.py

@@ -8,7 +8,7 @@ import unittest
 from typing import Optional, List
 
 from src.boto3_assist.dynamodb.dynamodb_model_base import DynamoDBModelBase
-from src.boto3_assist.dynamodb.dynamodb_reindexer import DynamoDBReindexer
+from boto3_assist.dynamodb.dynamodb_re_indexer import DynamoDBReIndexer
 from src.boto3_assist.dynamodb.dynamodb_key import DynamoDBKey
 from src.boto3_assist.dynamodb.dynamodb_index import DynamoDBIndex
 
@@ -120,12 +120,12 @@ class ReindexTest(unittest.TestCase):
         user: User = User().map(data)
         keys: List[DynamoDBKey] = user.list_keys()
 
-        reindexer: DynamoDBReindexer = DynamoDBReindexer("dummy_table")
+        re_indexer: DynamoDBReIndexer = DynamoDBReIndexer("dummy_table")
 
         dictionary = user.helpers.keys_to_dictionary(keys=keys)
 
-        update_expression = reindexer.build_update_expression(dictionary)
-        expression_attribute_values = reindexer.build_expression_attribute_values(
+        update_expression = re_indexer.build_update_expression(dictionary)
+        expression_attribute_values = re_indexer.build_expression_attribute_values(
             dictionary
         )
 

{boto3_assist-0.18.0 → boto3_assist-0.20.0}/tests/unit/lambda_tests/event_info_test.py

@@ -71,7 +71,7 @@ class TestLambdaEventInfo(unittest.TestCase):
         self.assertEqual(result, "access")
 
     @patch("boto3_assist.cognito.cognito_authorizer.CognitoCustomAuthorizer.parse_jwt")
-    def testget_value_from_token(self, mock_parse_jwt):
+    def test_get_value_from_token(self, mock_parse_jwt):
         """
         Test that values are correctly extracted from the JWT token.
         """

boto3_assist-0.18.0/src/boto3_assist/version.py

@@ -1 +0,0 @@
-__version__ = '0.18.0'