def test_example_instance(expected_yaml, expected_instance): instance = ExampleClass.example_instance() assert_serializables_equal(instance, expected_instance) assert_serializables_equal(instance, ExampleClass.from_yaml(expected_yaml)) assert ExampleClass.example_yaml() == expected_instance.to_yaml()
def test_allow_none(foo_instance, different_foo_instance, roundtrip_func): class MyClass(Serializable): required = Instance(Foo) explicit_optional = Instance(Foo, allow_none=True) implicit_optional = Instance(Foo, allow_none=True, default_value=None) with pytest.raises(TraitError): MyClass().required with pytest.raises(TraitError): # This should still raise because there's no default value. MyClass().explicit_optional assert MyClass().implicit_optional is None without_optional = MyClass(required=foo_instance, explicit_optional=None) assert without_optional.required is foo_instance assert without_optional.explicit_optional is None assert_serializables_equal( without_optional, roundtrip_func(without_optional), ) with_optional = MyClass( required=foo_instance, explicit_optional=different_foo_instance, ) assert with_optional.required is foo_instance assert with_optional.explicit_optional is different_foo_instance assert_serializables_equal( with_optional, roundtrip_func(with_optional), )
def test_nested_example(): class C(Serializable): point = Instance(Point) unicode_ = Unicode().tag(example='foo') class B(Serializable): value = Integer().tag(example=ord('b')) next_ = Instance(C) class A(Serializable): value = Integer().tag(example=ord('a')) next_ = Instance(B) expected = A( value=ord('a'), next_=B( value=ord('b'), next_=C( point=Point.example_instance(), unicode_='foo', ), ), ) assert_serializables_equal(expected, A.example_instance())
def test_example_skip_names(expected_instance, skip_names): instance = ExampleClass.example_instance(skip=skip_names) assert_serializables_equal(instance, expected_instance, skip=skip_names) for name in skip_names: with pytest.raises(TraitError): getattr(instance, name)
def test_mongo_config(mongo_required_kwargs, mongo_optional_kwargs, roundtrip_func): with pytest.raises(TraitError): MongoConfig(**mongo_optional_kwargs) optional_kwarg_defaults = { 'replicaset': None, 'slave_ok': True, 'prefer_secondary': True, 'ssl': False, } without_optionals = MongoConfig(**mongo_required_kwargs) check_attributes( without_optionals, merge(mongo_required_kwargs, optional_kwarg_defaults), ) assert_serializables_equal( without_optionals, roundtrip_func(without_optionals) ) full_kwargs = merge(mongo_required_kwargs, mongo_optional_kwargs) with_optionals = MongoConfig(**full_kwargs) check_attributes(with_optionals, full_kwargs) assert_serializables_equal(with_optionals, roundtrip_func(with_optionals))
def test_from_yaml_file(tmpdir, foo_yaml, foo_yaml_expected_result): fileobj = tmpdir.join("test.yaml") fileobj.write_text(foo_yaml, encoding='utf-8') assert_serializables_equal( Foo.from_yaml_file(fileobj.strpath), foo_yaml_expected_result, )
def test_roundtrip(foo_kwargs, roundtrip_func, skip_names): foo = Foo(**foo_kwargs) roundtripped = roundtrip_func(foo, skip=skip_names) assert isinstance(roundtripped, Foo) assert foo is not roundtripped assert_serializables_equal(roundtripped, foo, skip=skip_names) for name in skip_names: with pytest.raises(TraitError): getattr(roundtripped, name)
def test_postgres_config_required(pg_required_kwargs, roundtrip_func): cfg = PostgresConfig(**pg_required_kwargs) check_attributes( cfg, merge(pg_required_kwargs, {'port': None, 'password': None}), ) assert_urls_equal(cfg.url, "postgresql://user@/db") rounded = roundtrip_func(cfg) assert_serializables_equal(cfg, rounded, skip=['url']) assert_urls_equal(rounded.url, cfg.url) from_url = PostgresConfig.from_url(cfg.url) assert_serializables_equal(cfg, from_url, skip=['url']) assert_urls_equal(from_url.url, cfg.url)
def test_write_example_yaml(tmpdir, expected_instance, skip_names): path = tmpdir.join("test.yaml").strpath ExampleClass.write_example_yaml(path, skip=skip_names) from_file = ExampleClass.from_yaml_file(path) assert_serializables_equal( from_file, expected_instance, skip=skip_names, ) for name in skip_names: with pytest.raises(TraitError): getattr(from_file, name)
def test_postgres_config_optional(pg_required_kwargs, pg_optional_kwargs, roundtrip_func): kwargs = merge(pg_required_kwargs, pg_optional_kwargs) cfg = PostgresConfig(**kwargs) check_attributes(cfg, kwargs) assert_urls_equal( cfg.url, "postgresql://*****:*****@localhost:5432/db?" "connect_timeout=10&sslmode=require") rounded = roundtrip_func(cfg) assert_serializables_equal(cfg, rounded) assert_urls_equal(rounded.url, cfg.url) from_url = PostgresConfig.from_url(cfg.url) assert_serializables_equal(cfg, from_url, skip=['url']) assert_urls_equal(from_url.url, cfg.url)
def test_double_nested(roundtrip_func): class Bottom(Serializable): x = List() y = Unicode() class Middle(Serializable): x = Integer() bottom = Instance(Bottom) class Top(Serializable): x = Unicode() y = Tuple() middle = Instance(Middle) top = Top(x="asdf", y=(1, 2), middle=Middle(x=3, bottom=Bottom( x=[1, 2], y="foo", ))) assert_serializables_equal(roundtrip_func(top), top)
def test_inheritance(roundtrip_func, foo_instance): class Parent(Serializable): a = Integer() def _a_default(self): return 3 b = Unicode() check_attributes(Parent(b="b"), {"a": 3, "b": "b"}) class Child(Parent): x = Instance(Foo) y = Dict() def _a_default(self): return 4 child = Child(b="b", x=foo_instance, y={}) check_attributes(child, {'a': 4, 'b': 'b', 'y': {}}) assert child.x is foo_instance assert_serializables_equal(roundtrip_func(child), child)
def test_json_file(runner, expected_instance): instance = [None] # nonlocal @click.command() @click.option('--config', type=JsonConfigFile(Config)) def main(config): instance[0] = config with runner.isolated_filesystem(): with open('f.json', 'w') as f: f.write(expected_instance.to_json()) result = runner.invoke( main, ['--config', 'f.json'], input='not-json', catch_exceptions=False, ) assert result.output == '' assert result.exit_code == 0 assert_serializables_equal( instance[0], expected_instance, )
def test_nested(unicode_val, dict_val, foo_instance, different_foo_instance, roundtrip_func): instance = Nested( unicode_=unicode_val, dict_=dict_val, foo1=foo_instance, foo2=different_foo_instance, ) check_attributes(instance, { "unicode_": unicode_val, "dict_": dict_val, }) assert_serializables_equal(instance.foo1, foo_instance) assert_serializables_equal(instance.foo2, different_foo_instance) roundtripped = roundtrip_func(instance) assert_serializables_equal(instance, roundtripped)
def test_from_yaml(foo_yaml, foo_yaml_expected_result): assert_serializables_equal(Foo.from_yaml(foo_yaml), foo_yaml_expected_result)
def test_assert_serializables_equal(): class Foo(Serializable): x = Integer() y = Integer() class Bar(Serializable): x = Integer() y = Integer() assert_serializables_equal(Foo(x=1, y=1), Foo(x=1, y=1)) with pytest.raises(AssertionError): assert_serializables_equal(Foo(x=1, y=1), Bar(x=1, y=1)) with pytest.raises(AssertionError): assert_serializables_equal(Foo(x=1, y=1), Foo(x=1, y=2)) with pytest.raises(AssertionError): assert_serializables_equal( Foo(x=1, y=1), Foo(x=1, y=2), skip=('x', ), ) assert_serializables_equal(Foo(x=1), Foo(x=1), skip=('y', )) assert_serializables_equal(Foo(y=1), Foo(y=1), skip=('x', ))