def test_expression_methods() -> None:
        query = DynamoQuery.build_batch_get_item()

        with pytest.raises(DynamoQueryError):
            query.update("key")

        with pytest.raises(DynamoQueryError):
            query.projection("key")
    def test_errors() -> None:
        filter_expression_mock = MagicMock()
        projection_expression_mock = MagicMock()
        table_resource_mock = MagicMock()
        query = DynamoQuery.build_query(
            key_condition_expression=ConditionExpression("key", "contains"),
            index_name="my_index",
            filter_expression=filter_expression_mock,
            projection_expression=projection_expression_mock,
            limit=100,
        ).table(table=table_resource_mock, table_keys=("pk", "sk"))

        with pytest.raises(DynamoQueryError):
            query.execute_dict({"key": "value"})

        query = DynamoQuery.build_query(
            key_condition_expression=ConditionExpression("key"),
            index_name="my_index",
            filter_expression=filter_expression_mock,
            projection_expression=projection_expression_mock,
            limit=100,
        ).table(table=table_resource_mock, table_keys=("pk", "sk"))

        with pytest.raises(DynamoQueryError):
            query.execute_dict({"key1": "value"})

        with pytest.raises(DynamoQueryError):
            query.execute(DataTable({"key": [1, 2], "b": [3]}))

        with pytest.raises(DynamoQueryError):
            query.execute(DataTable({"key": [3, DataTable.NOT_SET]}))

        with pytest.raises(DynamoQueryError):
            DynamoQuery.build_batch_get_item().table(
                table=table_resource_mock, table_keys=("pk", "sk")).execute(
                    DataTable({
                        "pk": ["test"],
                        "sk": [DataTable.NOT_SET]
                    }))

        with pytest.raises(DynamoQueryError):
            DynamoQuery.build_batch_get_item().table(
                table=table_resource_mock,
                table_keys=("pk", "sk")).execute(DataTable({"pk": ["test"]}))
    def test_methods() -> None:
        table_resource_mock = MagicMock()
        query = DynamoQuery.build_query(
            key_condition_expression=ConditionExpression("key"),
            index_name="my_index",
            filter_expression=ConditionExpression("test"),
            limit=100,
        ).projection("return")

        with pytest.raises(DynamoQueryError):
            _ = query.table_resource

        with pytest.raises(DynamoQueryError):
            _ = query.table_keys

        query.table(table=table_resource_mock)
        assert str(query) == "<DynamoQuery type=query>"
        assert query.table_resource == table_resource_mock
        assert not query.was_executed()
        assert query.has_more_results()

        query.execute_dict({"key": "value", "test": "data"})
        assert query.was_executed()
        assert query.has_more_results()
        assert query.get_last_evaluated_key() == table_resource_mock.query(
        ).get()
        assert query.get_raw_responses() == [table_resource_mock.query()]

        table_resource_mock.key_schema = [
            {
                "AttributeName": "key"
            },
            {
                "NotKey": "not_key"
            },
        ]
        assert query.get_table_keys(table_resource_mock) == {"key"}
        assert query.limit(10)

        with pytest.raises(DynamoQueryError):
            DynamoQuery.build_batch_get_item().limit(10)
 def test_batch_get_item() -> None:
     table_resource_mock = MagicMock()
     query = DynamoQuery.build_batch_get_item().table(
         table=table_resource_mock, table_keys=("pk", "sk"))
     result = query.execute_dict({"pk": "value", "sk": "value"})
     table_resource_mock.meta.client.batch_get_item.assert_called_with(
         RequestItems={
             table_resource_mock.name: {
                 "Keys": [{
                     "pk": "value",
                     "sk": "value"
                 }]
             }
         },
         ReturnConsumedCapacity="NONE",
     )
     assert list(result.get_records()) == [{"pk": "value", "sk": "value"}]