def test_set_type_instance(): """Set can take an instance of a Type as well as a Type subclass""" type_instance = String() instance_set = Set(type_instance) assert instance_set.inner_typedef is type_instance type_subclass = String subclass_set = Set(type_subclass) assert isinstance(subclass_set.inner_typedef, type_subclass)
def test_sets(engine, set_type, loaded, dumped): typedef = Set(set_type) assert typedef.dynamo_load(dumped, context={"engine": engine}) == loaded # Can't use a simple set because the values are unhashable dicts like {"S": "value"} actual_dumped = typedef.dynamo_dump(loaded, context={"engine": engine}) assert len(actual_dumped) == len(dumped) for item in actual_dumped: assert item in dumped
def test_repr(): typedef = Type() assert repr(typedef) == "<Type[None:None]>" # Not all python types will be classes typedef.backing_type = "foo" typedef.python_type = 3 assert repr(typedef) == "<Type[foo:3]>" set_typedef = Set(Integer) assert repr(set_typedef) == "<Set[NS:Set]>"
def test_set_registered(): """set registers its typedef so loading/dumping happens properly""" type_engine = declare.TypeEngine.unique() string_type = String() string_set_type = Set(string_type) type_engine.bind() assert string_type not in type_engine.bound_types type_engine.register(string_set_type) type_engine.bind() assert string_type in type_engine.bound_types
def test_set_illegal_backing_type(): """The backing type for a set MUST be one of S/N/B, not BOOL""" for typedef in [Boolean, Set(Integer)]: with pytest.raises(TypeError): Set(typedef)
@pytest.mark.parametrize( "typedef", [String, UUID, DateTime, Number, Integer, Binary, Boolean]) def test_none_scalar_types(typedef): """single-value types without an explicit 'lack of value' sentinel should return None when given None""" type = typedef() context = {} assert type._load(None, context=context) is None assert type._load({typedef.backing_type: None}, context=context) is None assert type.dynamo_load(None, context=context) is None assert type._dump(None, context=context) is None assert type.dynamo_dump(None, context=context) is None @pytest.mark.parametrize("typedef, default", [(Set(String), set()), (Set(Integer), set()), (Set(Binary), set()), (List(DateTime), list()), (DocumentType, { "Rating": None, "Stock": None, "Description": { "Heading": None, "Body": None, "Specifications": None }, "Id": None, "Updated": None })]) def test_load_none_vector_types(engine, typedef, default):
typedef = MyType() with pytest.raises(NotImplementedError): typedef._load({"S": "value"}, context={}) with pytest.raises(NotImplementedError): typedef._dump("value", context={}) @pytest.mark.parametrize("type", [ Type(), String(), Binary(), Number(), Boolean(), Set(String), Set(Binary), Set(Number), ]) def test_type_paths_raise(type): """List, Map, DynamicList, and DynamicMap are the only types that support paths""" with pytest.raises(RuntimeError): _ = type["string-key"] # noqa: F841 with pytest.raises(RuntimeError): _ = type[3] # noqa: F841 def test_load_dump_best_effort(engine): """python_type is an informational field, and doesn't check types on load/dump""" class MyType(String): backing_type = "FOO"
typedef = MyType() with pytest.raises(NotImplementedError): typedef._load({"S": "value"}, context={}) with pytest.raises(NotImplementedError): typedef._dump("value", context={}) @pytest.mark.parametrize("type", [ Type(), String(), Binary(), Number(), Boolean(), Set(String), Set(Binary), Set(Number), ]) def test_type_paths_raise(type): """List, Map, DynamicList, and DynamicMap are the only types that support paths""" with pytest.raises(RuntimeError): _ = type["string-key"] # noqa: F841 with pytest.raises(RuntimeError): _ = type[3] # noqa: F841 def test_load_dump_best_effort(engine): """python_type is an informational field, and doesn't check types on load/dump""" class MyType(String): backing_type = "FOO"
assert condition.values == [3] condition = c.is_not(3) assert condition.operation == "!=" assert condition.column is c assert condition.values == [3] @pytest.mark.parametrize( "op, typedefs, args", [("begins_with", [ Integer(), List(String), Map(s=String), Boolean(), Set(Integer), Set(Binary), Set(String) ], ("one-arg", )), ("contains", [Integer(), Boolean(), Map(s=String)], ("one-arg", )), ("between", [ Set(String), Set(Binary), Set(String), List(String), Map(s=String), Boolean() ], ("first-arg", "second-arg"))]) def test_unsupported_mixin_function_conditions(op, typedefs, args): class Model(BaseModel): id = Column(Integer, hash_key=True)