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', ))
