clear-skies-aws 1.10.2__py3-none-any.whl → 2.0.2__py3-none-any.whl

clearskies_aws/backends/dynamo_db_backend_test.py

@@ -1,300 +0,0 @@
-import unittest
-from collections import OrderedDict
-from decimal import Decimal
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-import clearskies
-from boto3.dynamodb import conditions as dynamodb_conditions
-
-from ..di import StandardDependencies
-
-
-class User(clearskies.Model):
-    def __init__(self, dynamo_db_backend, columns):
-        super().__init__(dynamo_db_backend, columns)
-
-    def columns_configuration(self):
-        return OrderedDict([
-            clearskies.column_types.string('name'),
-            clearskies.column_types.string('category_id'),
-            clearskies.column_types.integer('age'),
-        ])
-class Users(clearskies.Models):
-    def __init__(self, dynamo_db_backend, columns):
-        super().__init__(dynamo_db_backend, columns)
-
-    def model_class(self):
-        return User
-class DynamoDBBackendTest(unittest.TestCase):
-    def setUp(self):
-        self.di = StandardDependencies()
-        self.di.bind('environment', {'AWS_REGION': 'us-east-2'})
-        self.dynamo_db_table = SimpleNamespace(
-            key_schema=[{
-                'KeyType': 'HASH',
-                'AttributeName': 'id'
-            }],
-            global_secondary_indexes=[
-                {
-                    'IndexName':
-                    'category_id-name-index',
-                    'KeySchema': [
-                        {
-                            'KeyType': 'HASH',
-                            'AttributeName': 'category_id'
-                        },
-                        {
-                            'KeyType': 'RANGE',
-                            'AttributeName': 'name'
-                        },
-                    ]
-                },
-                {
-                    'IndexName':
-                    'category_id-age-index',
-                    'KeySchema': [
-                        {
-                            'KeyType': 'RANGE',
-                            'AttributeName': 'age'
-                        },
-                        {
-                            'KeyType': 'HASH',
-                            'AttributeName': 'category_id'
-                        },
-                    ]
-                },
-            ],
-            local_secondary_indexes=[{
-                'IndexName':
-                'id-category_id-index',
-                'KeySchema': [
-                    {
-                        'KeyType': 'RANGE',
-                        'AttributeName': 'category_id'
-                    },
-                    {
-                        'KeyType': 'HASH',
-                        'AttributeName': 'id'
-                    },
-                ]
-            }],
-        )
-        self.dynamo_db = SimpleNamespace(Table=MagicMock(return_value=self.dynamo_db_table), )
-        self.boto3 = SimpleNamespace(resource=MagicMock(return_value=self.dynamo_db), )
-        self.di.bind('boto3', self.boto3)
-
-    def test_create(self):
-        self.dynamo_db_table.put_item = MagicMock()
-        user = self.di.build(User)
-        user.save({'name': 'sup', 'age': 5, 'category_id': '1-2-3-4'})
-        self.boto3.resource.assert_called_with('dynamodb', region_name='us-east-2')
-        self.dynamo_db.Table.assert_called_with('users')
-        self.assertEqual(1, len(self.dynamo_db_table.put_item.call_args_list))
-        call = self.dynamo_db_table.put_item.call_args_list[0]
-        self.assertEqual((), call.args)
-        self.assertEqual(1, len(call.kwargs))
-        self.assertTrue('Item' in call.kwargs)
-        saved_data = call.kwargs['Item']
-        # we're doing this a bit weird because the UUIDs will generate random values.
-        # I could mock it, or I could just be lazy and grab it from the data I was given.
-        self.assertEqual(
-            {
-                "id": saved_data["id"],
-                "name": "sup",
-                "age": 5,
-                "category_id": "1-2-3-4",
-            },
-            saved_data,
-        )
-        self.assertEqual(saved_data["id"], user.id)
-        self.assertEqual(5, user.age)
-        self.assertEqual("1-2-3-4", user.category_id)
-        self.assertEqual("sup", user.name)
-
-    def test_update(self):
-        self.dynamo_db_table.update_item = MagicMock(
-            return_value={
-                'Attributes': {
-                    'id': '1-2-3-4',
-                    'name': 'hello',
-                    'age': Decimal('10'),
-                    'category_id': '1-2-3-5',
-                }
-            }
-        )
-        user = self.di.build(User)
-        user.data = {'id': '1-2-3-4', 'name': 'sup', 'age': 5, 'category_id': '1-2-3-5'}
-        user.save({'name': 'hello', 'age': 10})
-        self.boto3.resource.assert_called_with('dynamodb', region_name='us-east-2')
-        self.dynamo_db.Table.assert_called_with('users')
-        self.dynamo_db_table.update_item.assert_called_with(
-            Key={'id': '1-2-3-4'},
-            UpdateExpression='SET #name = :name, #age = :age',
-            ExpressionAttributeValues={
-                ':name': 'hello',
-                ':age': 10
-            },
-            ExpressionAttributeNames={
-                '#name': 'name',
-                '#age': 'age'
-            },
-            ReturnValues="ALL_NEW",
-        )
-        self.assertEqual("1-2-3-4", user.id)
-        self.assertEqual("hello", user.name)
-        self.assertEqual(10, user.age)
-        self.assertEqual("1-2-3-5", user.category_id)
-
-    def test_delete(self):
-        self.dynamo_db_table.delete_item = MagicMock()
-        user = self.di.build(User)
-        user.data = {'id': '1-2-3-4', 'name': 'sup', 'age': 5, 'category_id': '1-2-3-5'}
-        user.delete()
-        self.dynamo_db_table.delete_item.assert_called_with(Key={'id': '1-2-3-4'}, )
-
-    def test_fetch_by_id(self):
-        self.dynamo_db_table.query = MagicMock(
-            return_value={'Items': [{
-                'id': '1-2-3-4',
-                'age': Decimal(10),
-                'category_id': '4-5-6'
-            }]}
-        )
-        users = self.di.build(Users)
-        user = users.where('id=1-2-3-4').first()
-        self.assertTrue(user.exists)
-        self.assertEqual("1-2-3-4", user.id)
-        self.assertEqual(10, user.age)
-        self.assertEqual("4-5-6", user.category_id)
-        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
-        call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEqual(3, len(call.kwargs))
-        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
-        self.assertEqual(True, call.kwargs["ScanIndexForward"])
-        key_condition = call.kwargs['KeyConditionExpression']
-
-        # dynamodb does not make it easy to verify that the key expression was built properly,
-        # and I don't think that mocking will make this any better.  Hoepfully they don't
-        # change their library often...
-        key_column = key_condition.get_expression()['values'][0]
-        self.assertEqual("id", key_column.name)
-        self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEqual("=", key_condition.expression_operator)
-        self.assertEqual("1-2-3-4", key_condition.get_expression()["values"][1])
-
-    def test_fetch_by_id_with_sort(self):
-        self.dynamo_db_table.query = MagicMock(
-            return_value={'Items': [{
-                'id': '1-2-3-4',
-                'age': Decimal(10),
-                'category_id': '4-5-6'
-            }]}
-        )
-        users = self.di.build(Users)
-        users = users.where('id=1-2-3-4').sort_by('category_id', 'desc').__iter__()
-        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
-        call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEqual(4, len(call.kwargs))
-        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
-        self.assertEqual("id-category_id-index", call.kwargs["IndexName"])
-        self.assertEqual(False, call.kwargs["ScanIndexForward"])
-        key_condition = call.kwargs['KeyConditionExpression']
-
-        # dynamodb does not make it easy to verify that the key expression was built properly,
-        # and I don't think that mocking will make this any better.  Hoepfully they don't
-        # change their library often...
-        key_column = key_condition.get_expression()['values'][0]
-        self.assertEqual("id", key_column.name)
-        self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEqual("=", key_condition.expression_operator)
-        self.assertEqual("1-2-3-4", key_condition.get_expression()["values"][1])
-
-    def test_fetch_by_secondary_index_twice(self):
-        self.dynamo_db_table.query = MagicMock(
-            return_value={'Items': [{
-                'id': '1-2-3-4',
-                'age': Decimal(10),
-                'category_id': '4-5-6'
-            }]}
-        )
-        users = self.di.build(Users)
-        users = users.where('category_id=1-2-3-4').where('age>10').__iter__()
-        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
-        call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEqual(4, len(call.kwargs))
-        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
-        self.assertEqual("category_id-age-index", call.kwargs["IndexName"])
-        self.assertEqual(True, call.kwargs["ScanIndexForward"])
-        key_condition = call.kwargs['KeyConditionExpression']
-        self.assertTrue(isinstance(key_condition, dynamodb_conditions.And))
-        gt_condition = key_condition.get_expression()['values'][0]
-        equal_condition = key_condition.get_expression()['values'][1]
-
-        self.assertTrue(isinstance(equal_condition, dynamodb_conditions.Equals))
-        key_column = equal_condition.get_expression()['values'][0]
-        self.assertEqual("category_id", key_column.name)
-        self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEqual("=", equal_condition.expression_operator)
-        self.assertEqual("1-2-3-4", equal_condition.get_expression()["values"][1])
-
-        self.assertTrue(isinstance(gt_condition, dynamodb_conditions.GreaterThan))
-        key_column = gt_condition.get_expression()['values'][0]
-        self.assertEqual("age", key_column.name)
-        self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEqual(">", gt_condition.expression_operator)
-        self.assertEqual(Decimal("10"), gt_condition.get_expression()["values"][1])
-
-    def test_index_and_scan(self):
-        self.dynamo_db_table.query = MagicMock(
-            return_value={'Items': [{
-                'id': '1-2-3-4',
-                'age': Decimal(10),
-                'category_id': '4-5-6'
-            }]}
-        )
-        users = self.di.build(Users)
-        users = users.where('category_id=1-2-3-4').where('age is not null').__iter__()
-        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
-        call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEqual(5, len(call.kwargs))
-        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
-        self.assertEqual("category_id-name-index", call.kwargs["IndexName"])
-        self.assertEqual(True, call.kwargs["ScanIndexForward"])
-
-        # our key condition should be an equal search on category_id
-        key_condition = call.kwargs['KeyConditionExpression']
-        key_column = key_condition.get_expression()['values'][0]
-        self.assertEqual("category_id", key_column.name)
-        self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEqual("=", key_condition.expression_operator)
-        self.assertEqual("1-2-3-4", key_condition.get_expression()["values"][1])
-
-        # and we should have a FilterExpression which is an 'is not null' condition
-        filter_condition = call.kwargs['FilterExpression']
-        key_column = filter_condition.get_expression()['values'][0]
-        self.assertEqual("age", key_column.name)
-        self.assertTrue(isinstance(key_column, dynamodb_conditions.Attr))
-        self.assertEqual("attribute_not_exists", filter_condition.expression_operator)
-
-    def test_scan_only(self):
-        self.dynamo_db_table.scan = MagicMock(
-            return_value={'Items': [{
-                'id': '1-2-3-4',
-                'age': Decimal(10),
-                'category_id': '4-5-6'
-            }]}
-        )
-        users = self.di.build(Users)
-        users = users.where('category_id>1-2-3-4').__iter__()
-        self.assertEqual(1, len(self.dynamo_db_table.scan.call_args_list))
-        call = self.dynamo_db_table.scan.call_args_list[0]
-        self.assertEqual(2, len(call.kwargs))
-        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
-
-        # and we should have a FilterExpression which is an 'is not null' condition
-        filter_condition = call.kwargs['FilterExpression']
-        key_column = filter_condition.get_expression()['values'][0]
-        self.assertEqual("category_id", key_column.name)
-        self.assertTrue(isinstance(key_column, dynamodb_conditions.Attr))
-        self.assertEqual(">", filter_condition.expression_operator)

clearskies_aws/backends/dynamo_db_condition_parser_test.py

@@ -1,266 +0,0 @@
-import unittest
-from decimal import Decimal
-
-from clearskies_aws.backends.dynamo_db_condition_parser import DynamoDBConditionParser
-
-
-class TestDynamoDBConditionParser(unittest.TestCase):
-    def setUp(self):
-        """Set up the parser for each test."""
-        self.parser = DynamoDBConditionParser()
-
-    def test_to_dynamodb_attribute_value_string(self):
-        """Test conversion of a simple string."""
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value("hello"), {"S": "hello"}
-        )
-
-    def test_to_dynamodb_attribute_value_int(self):
-        """Test conversion of an integer."""
-        self.assertEqual(self.parser.to_dynamodb_attribute_value(123), {"N": "123"})
-
-    def test_to_dynamodb_attribute_value_float(self):
-        """Test conversion of a float."""
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value(123.45), {"N": "123.45"}
-        )
-
-    def test_to_dynamodb_attribute_value_decimal(self):
-        """Test conversion of a Decimal object."""
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value(Decimal("99.01")), {"N": "99.01"}
-        )
-
-    def test_to_dynamodb_attribute_value_bool_true(self):
-        """Test conversion of a boolean True."""
-        self.assertEqual(self.parser.to_dynamodb_attribute_value(True), {"BOOL": True})
-
-    def test_to_dynamodb_attribute_value_bool_false(self):
-        """Test conversion of a boolean False."""
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value(False), {"BOOL": False}
-        )
-
-    def test_to_dynamodb_attribute_value_none(self):
-        """Test conversion of None."""
-        self.assertEqual(self.parser.to_dynamodb_attribute_value(None), {"NULL": True})
-
-    def test_to_dynamodb_attribute_value_string_true_false_null(self):
-        """Test conversion of string representations of boolean, null, and numbers."""
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value("true"), {"BOOL": True}
-        )
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value("FALSE"), {"BOOL": False}
-        )
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value("NuLl"), {"NULL": True}
-        )
-        self.assertEqual(self.parser.to_dynamodb_attribute_value("123"), {"N": "123"})
-        self.assertEqual(self.parser.to_dynamodb_attribute_value("-45"), {"N": "-45"})
-        self.assertEqual(
-            self.parser.to_dynamodb_attribute_value("123.45"), {"N": "123.45"}
-        )
-        self.assertEqual(self.parser.to_dynamodb_attribute_value("text"), {"S": "text"})
-
-    def test_to_dynamodb_attribute_value_list(self):
-        """Test conversion of a list with mixed data types."""
-        val = ["a", 1, True, None, Decimal("2.3")]
-        expected = {
-            "L": [
-                {"S": "a"},
-                {"N": "1"},
-                {"BOOL": True},
-                {"NULL": True},
-                {"N": "2.3"},
-            ]
-        }
-        self.assertEqual(self.parser.to_dynamodb_attribute_value(val), expected)
-
-    def test_to_dynamodb_attribute_value_map(self):
-        """Test conversion of a dictionary (map)."""
-        val = {"key_s": "val", "key_n": 100}
-        expected = {"M": {"key_s": {"S": "val"}, "key_n": {"N": "100"}}}
-        self.assertEqual(self.parser.to_dynamodb_attribute_value(val), expected)
-
-    def test_to_dynamodb_attribute_value_set_string(self):
-        """Test conversion of a set of strings."""
-        val = {"a", "b", "a"}
-        expected = {"SS": sorted(["a", "b"])}
-        self.assertEqual(self.parser.to_dynamodb_attribute_value(val), expected)
-
-    def test_to_dynamodb_attribute_value_set_number(self):
-        """Test conversion of a set of numbers (int and Decimal)."""
-        val = {1, 2, Decimal("3.0")}
-        expected = {"NS": sorted(["1", "2", "3.0"])}
-        self.assertEqual(self.parser.to_dynamodb_attribute_value(val), expected)
-
-    def test_to_dynamodb_attribute_value_unsupported(self):
-        """Test conversion of an unsupported data type raises TypeError."""
-
-        class MyObject:
-            pass
-
-        with self.assertRaises(TypeError):
-            self.parser.to_dynamodb_attribute_value(MyObject())
-
-    def test_parse_condition_list_simple(self):
-        """Test the internal _parse_condition_list helper method."""
-        self.assertEqual(
-            self.parser._parse_condition_list("'a', 'b', 'c'"), ["a", "b", "c"]
-        )
-        self.assertEqual(self.parser._parse_condition_list("1, 2, 3"), ["1", "2", "3"])
-        self.assertEqual(self.parser._parse_condition_list("('a', \"b\")"), ["a", "b"])
-        self.assertEqual(self.parser._parse_condition_list(""), [])
-        self.assertEqual(self.parser._parse_condition_list("  "), [])
-        self.assertEqual(self.parser._parse_condition_list(" 'item1' "), ["item1"])
-
-    def test_parse_condition_equals_string(self):
-        """Test parsing an equality condition with a string value."""
-        result = self.parser.parse_condition("name = 'John Doe'")
-        self.assertEqual(result["column"], "name")
-        self.assertEqual(result["operator"], "=")
-        self.assertEqual(result["values"], [{"S": "John Doe"}])
-        self.assertEqual(result["parsed"], '"name" = ?')
-        self.assertEqual(result["table"], "")
-
-    def test_parse_condition_equals_number(self):
-        """Test parsing an equality condition with a numeric value."""
-        result = self.parser.parse_condition("age = 30")
-        self.assertEqual(result["column"], "age")
-        self.assertEqual(result["operator"], "=")
-        self.assertEqual(result["values"], [{"N": "30"}])
-        self.assertEqual(result["parsed"], '"age" = ?')
-
-    def test_parse_condition_greater_than(self):
-        """Test parsing a greater than condition."""
-        result = self.parser.parse_condition("price > 10.5")
-        self.assertEqual(result["column"], "price")
-        self.assertEqual(result["operator"], ">")
-        self.assertEqual(result["values"], [{"N": "10.5"}])
-        self.assertEqual(result["parsed"], '"price" > ?')
-
-    def test_parse_condition_table_column(self):
-        """Test parsing a condition with a table-prefixed column."""
-        result = self.parser.parse_condition("user.id = 'user123'")
-        self.assertEqual(result["table"], "user")
-        self.assertEqual(result["column"], "id")
-        self.assertEqual(result["operator"], "=")
-        self.assertEqual(result["values"], [{"S": "user123"}])
-        self.assertEqual(result["parsed"], '"user"."id" = ?')
-
-    def test_parse_condition_is_null(self):
-        """Test parsing an 'IS NULL' condition (remapped to IS MISSING)."""
-        result = self.parser.parse_condition("email is null")
-        self.assertEqual(result["column"], "email")
-        self.assertEqual(result["operator"], "IS MISSING")
-        self.assertEqual(result["values"], [])
-        self.assertEqual(result["parsed"], '"email" IS MISSING')
-
-    def test_parse_condition_is_not_null(self):
-        """Test parsing an 'IS NOT NULL' condition (remapped to IS NOT MISSING)."""
-        result = self.parser.parse_condition("address is not null")
-        self.assertEqual(result["column"], "address")
-        self.assertEqual(result["operator"], "IS NOT MISSING")
-        self.assertEqual(result["values"], [])
-        self.assertEqual(result["parsed"], '"address" IS NOT MISSING')
-
-    def test_parse_condition_like_begins_with(self):
-        """Test parsing a 'LIKE value%' condition (becomes BEGINS_WITH)."""
-        result = self.parser.parse_condition("name LIKE 'Jo%'")
-        self.assertEqual(result["column"], "name")
-        self.assertEqual(result["operator"], "BEGINS_WITH")
-        self.assertEqual(result["values"], [{"S": "Jo"}])
-        self.assertEqual(result["parsed"], 'begins_with("name", ?)')
-
-    def test_parse_condition_like_contains(self):
-        """Test parsing a 'LIKE %value%' condition (becomes CONTAINS)."""
-        result = self.parser.parse_condition("description LIKE '%word%'")
-        self.assertEqual(result["column"], "description")
-        self.assertEqual(result["operator"], "CONTAINS")
-        self.assertEqual(result["values"], [{"S": "word"}])
-        self.assertEqual(result["parsed"], 'contains("description", ?)')
-
-    def test_parse_condition_like_exact(self):
-        """Test parsing a 'LIKE value' condition (no wildcards, becomes =)."""
-        result = self.parser.parse_condition("tag LIKE 'exactmatch'")
-        self.assertEqual(result["column"], "tag")
-        self.assertEqual(result["operator"], "=")
-        self.assertEqual(result["values"], [{"S": "exactmatch"}])
-        self.assertEqual(result["parsed"], '"tag" = ?')
-
-    def test_parse_condition_like_ends_with_error(self):
-        """Test that 'LIKE %value' (ends with) raises an error."""
-        with self.assertRaisesRegex(
-            ValueError, "DynamoDB PartiQL does not directly support 'ends_with'"
-        ):
-            self.parser.parse_condition("filename LIKE '%doc'")
-
-    def test_parse_condition_in_list_strings(self):
-        """Test parsing an 'IN' condition with a list of strings."""
-        result = self.parser.parse_condition("status IN ('active', 'pending')")
-        self.assertEqual(result["column"], "status")
-        self.assertEqual(result["operator"], "IN")
-        self.assertEqual(result["values"], [{"S": "active"}, {"S": "pending"}])
-        self.assertEqual(result["parsed"], '"status" IN (?, ?)')
-
-    def test_parse_condition_in_list_numbers(self):
-        """Test parsing an 'IN' condition with a list of numbers."""
-        result = self.parser.parse_condition("id IN (1, 2, 3)")
-        self.assertEqual(result["column"], "id")
-        self.assertEqual(result["operator"], "IN")
-        self.assertEqual(result["values"], [{"N": "1"}, {"N": "2"}, {"N": "3"}])
-        self.assertEqual(result["parsed"], '"id" IN (?, ?, ?)')
-
-    def test_parse_condition_in_list_single_value(self):
-        """Test parsing an 'IN' condition with a single value in the list."""
-        result = self.parser.parse_condition("id IN (1)")
-        self.assertEqual(result["column"], "id")
-        self.assertEqual(result["operator"], "IN")
-        self.assertEqual(result["values"], [{"N": "1"}])
-        self.assertEqual(result["parsed"], '"id" IN (?)')
-
-    def test_parse_condition_contains_function(self):
-        """Test parsing a 'CONTAINS' function call."""
-        result = self.parser.parse_condition("tags CONTAINS 'important'")
-        self.assertEqual(result["column"], "tags")
-        self.assertEqual(result["operator"], "CONTAINS")
-        self.assertEqual(result["values"], [{"S": "important"}])
-        self.assertEqual(result["parsed"], 'contains("tags", ?)')
-
-    def test_parse_condition_begins_with_function(self):
-        """Test parsing a 'BEGINS_WITH' function call."""
-        result = self.parser.parse_condition("sku BEGINS_WITH 'ABC-'")
-        self.assertEqual(result["column"], "sku")
-        self.assertEqual(result["operator"], "BEGINS_WITH")
-        self.assertEqual(result["values"], [{"S": "ABC-"}])
-        self.assertEqual(result["parsed"], 'begins_with("sku", ?)')
-
-    def test_parse_condition_quoted_column(self):
-        """Test parsing a condition with a double-quoted column name."""
-        result = self.parser.parse_condition('"my-column" = "test value"')
-        self.assertEqual(result["column"], "my-column")
-        self.assertEqual(result["operator"], "=")
-        self.assertEqual(result["values"], [{"S": "test value"}])
-        self.assertEqual(result["parsed"], '"my-column" = ?')
-
-    def test_parse_condition_no_operator(self):
-        """Test that parsing a condition without a valid operator raises an error."""
-        with self.assertRaisesRegex(ValueError, "No supported operators found"):
-            self.parser.parse_condition("column value")
-
-    def test_parse_condition_is_operator(self):
-        """Test parsing an 'IS' condition."""
-        result = self.parser.parse_condition("status IS 'active'")
-        self.assertEqual(result["column"], "status")
-        self.assertEqual(result["operator"], "IS")
-        self.assertEqual(result["values"], [{"S": "active"}])
-        self.assertEqual(result["parsed"], '"status" IS ?')
-
-    def test_parse_condition_is_not_operator(self):
-        """Test parsing an 'IS NOT' condition."""
-        result = self.parser.parse_condition("type IS NOT 'internal'")
-        self.assertEqual(result["column"], "type")
-        self.assertEqual(result["operator"], "IS NOT")
-        self.assertEqual(result["values"], [{"S": "internal"}])
-        self.assertEqual(result["parsed"], '"type" IS NOT ?')