def test_Schema_validate_raise():
    schema = Schema()
    schema["x"] = IntChoice(choices=(1, 2))
    config = Config()
    config["x"] = 3
    with pytest.raises(InvalidChoiceError):
        validation = schema.validate(config, raise_on_error=True)
def test_Schema_PATH_add_default(tmpdir, defaults):
    fn_config = tmpdir.join("PATH_add_default.config").strpath
    fn_schema = tmpdir.join("PATH_add_default.schema").strpath
    dirname = os.path.dirname(fn_config)

    config = Config(defaults=defaults)
    schema = Schema()

    with open(fn_config, "w") as f_out:
        f_out.write("""\
[sub]
""")
    config.read(fn_config, merge=True)

    with open(fn_schema, "w") as f_out:
        f_out.write("""\
a = Str(default=PATH.dirname + 'a')
[sub]
    b = Str(default=PATH.dirname + 'b')
""")
    schema.read(fn_schema, merge=True)

    schema.validate(config)
    assert config['a'] == dirname + 'a'
    assert config['sub']['b'] == dirname + 'b'
def test_Schema_validate_no_raise():
    schema = Schema()
    schema["x"] = IntChoice(choices=(1, 2))
    config = Config()
    config["x"] = 3
    validation = schema.validate(config, raise_on_error=False)
    assert isinstance(validation["x"], InvalidChoiceError)
def test_Schema_unexpected_section_error():
    schema = Schema()
    schema['x'] = Int()
    config = Config()
    config['x'] = {}
    with pytest.raises(UnexpectedSectionError):
        schema.validate(config, raise_on_error=True)
Exemple #5
0
def simple_validation(simple_schema_content, simple_section_content):
    schema = Schema(simple_schema_content)
    simple_section_content['a'] = -10
    simple_section_content['sub']['sa'] = 100.3
    simple_section_content['sub']['sb'] = "abc"
    simple_section_content['sub']['sc'] = True
    simple_section_content['sub']['subsub']['ssx'] = "omega"
    simple_section_content['sub']['subsub']['ssy'] = []
    config = Config(simple_section_content)
    return schema.validate(config)
Exemple #6
0
def simple_validation(simple_schema_content, simple_section_content):
    schema = Schema(simple_schema_content)
    simple_section_content['a'] = -10
    simple_section_content['sub']['sa'] = 100.3
    simple_section_content['sub']['sb'] = "abc"
    simple_section_content['sub']['sc'] = True
    simple_section_content['sub']['subsub']['ssx'] = "omega"
    simple_section_content['sub']['subsub']['ssy'] = []
    config = Config(simple_section_content)
    return schema.validate(config)
Exemple #7
0
def test_main_read_write_2files(tmpdir):
    fn_cfg1 = tmpdir.join("2files_cfg1.config").strpath
    fn_cfg2 = tmpdir.join("2files_cfg2.config").strpath
    fn_sch1 = tmpdir.join("2files_sch1.schema").strpath
    fn_sch2 = tmpdir.join("2files_sch2.schema").strpath

    cfg1 = Config.from_string("""\
a = 10
[c]
    c1 = 20
""")
    cfg2 = Config.from_string("""\
b = 1.5
[d]
    d1 = 2.5
""")

    sch1 = Schema.from_string("""\
a = Int()
[d]
    d1 = Float()
    d2 = Float(default=3.5)
""")
    sch2 = Schema.from_string("""\
b = Float()
[c]
    c1 = Int()
    c2 = Int(default=30)
""")

    cfg1.to_file(fn_cfg1)
    cfg2.to_file(fn_cfg2)
    sch1.to_file(fn_sch1)
    sch2.to_file(fn_sch2)

    args = ["read", "-i", fn_cfg1, "-i", fn_cfg2, "-s", fn_sch1, "-s", fn_sch2, "--defaults"]

    log_stream, out_stream = run(args)
    reference = """\
a = 10
[c]
    c1 = 20
    c2 = 30
b = 1.5
[d]
    d1 = 2.5
    d2 = 3.5

"""
    # print("=== reference:")
    # print(reference)
    # print("=== result:")
    # print(out_stream.getvalue())
    assert out_stream.getvalue() == reference
    assert log_stream.getvalue() == ""
def test_Config_err_disabled_macros_on_validation():
    from zirkon.config import ROOT
    config = Config(macros=False)
    schema = Schema()
    schema['x'] = Int()
    schema['y'] = Int(min=ROOT['x'] + 2)
    config['x'] = 3
    config['y'] = 5
    with pytest.raises(ValueError) as exc_info:
        validation = schema.validate(config)
    assert str(exc_info.value) == "cannot evaluate ROOT['x'] + 2: macros are not enabled"
def test_Config_err_disabled_macros_on_validation():
    from zirkon.config import ROOT
    config = Config(macros=False)
    schema = Schema()
    schema['x'] = Int()
    schema['y'] = Int(min=ROOT['x'] + 2)
    config['x'] = 3
    config['y'] = 5
    with pytest.raises(ValueError) as exc_info:
        validation = schema.validate(config)
    assert str(exc_info.value
               ) == "cannot evaluate ROOT['x'] + 2: macros are not enabled"
Exemple #10
0
def test_Schema_defaults_defined_in_defaults(use_defaults, has_default):
    config = Config(defaults=True)
    config.defaults["x"] = 10

    schema = Schema(use_defaults=use_defaults)
    int_kwargs = {}
    if has_default:
        int_kwargs["default"] = 100
    schema["x"] = Int(**int_kwargs)

    assert not schema.validate(config)
    assert "x" in config.defaults
    assert config["x"] == 10
def simple_schema():
    return Schema.from_string("""\
alpha = Int(default=4)
beta = Float(default=2.3)
gamma = Str()
delta = Bool(default=True)
""", fmt="zirkon")
Exemple #12
0
def test_Schema_validate_missing():
    schema = Schema.from_string("""\
a = Int(default=1)
b = Int()
c = Int()
[sub]
    a = Float(default=0.1)
    b = Float()
    c = Float()
""")
    config = Config()
    config['b'] = 2
    config['sub'] = {'b': 0.2}
    validation_result = schema.validate(config, raise_on_error=False)
    assert 'a' in config
    assert config['a'] == 1
    assert 'b' in config
    assert config['b'] == 2
    assert 'c' not in config
    assert 'a' in config['sub']
    assert config['sub']['a'] == 0.1
    assert 'b' in config['sub']
    assert config['sub']['b'] == 0.2
    assert 'c' not in config['sub']
    assert 'a' not in validation_result
    assert 'b' not in validation_result
    assert 'c' in validation_result
    assert  isinstance(validation_result['c'], MissingRequiredOptionError)
    assert 'a' not in validation_result['sub']
    assert 'b' not in validation_result['sub']
    assert 'c' in validation_result['sub']
    assert  isinstance(validation_result['sub']['c'], MissingRequiredOptionError)
def test_compile_error():
    schema = Schema.from_string("""\
x = Any()
""", fmt="zirkon")
    with pytest.raises(TypeError) as exc_info:
        parser = create_argparser(schema)
    assert str(exc_info.value) == "cannot compile validator Any()"
Exemple #14
0
def test_Schema_default_section_subsection_option():
    schema = Schema.from_string("""\
[filesystems]
    [__default_section__]
        path = Str()
        [size]
            min_size_gb = Float(default=0.5)
            max_size_gb = Float(default=1.5)
        [files]
            __default_option__ = Str()
        [__default_section__]
            name = Str()
            __default_option__ = Int()
""")
    config = Config.from_string("""\
[filesystems]
    [home]
        path = "/home/user"
        [files]
            x = "x.txt"
            y = "y.txt"
            z = "y.txt"
        [a]
            name = "alpha"
            v0 = 10
            v1 = 20
            v2 = 30
        [b]
            name = "beta"
            v0 = 5
        [c]
            v0 = 1
            v1 = "g"
            v2 = 2
    [work]
        path = "/tmp/user"
        [size]
            min_size_gb = 0.0
""")
    validation = schema.validate(config)
    assert len(validation) == 1
    assert 'filesystems' in validation
    assert len(validation['filesystems']) == 1
    assert 'home' in validation['filesystems']
    assert len(validation['filesystems']['home']) == 1
    assert 'c' in validation['filesystems']['home']
    assert len(validation['filesystems']['home']['c']) == 2
    assert 'name' in validation['filesystems']['home']['c']
    assert 'v1' in validation['filesystems']['home']['c']

    assert validation
    assert config['filesystems']['home']['size']['min_size_gb'] == 0.5
    assert config['filesystems']['home']['size']['max_size_gb'] == 1.5
    assert 'a' in config['filesystems']['home']
    assert 'b' in config['filesystems']['home']
    assert 'c' in config['filesystems']['home']
    assert config['filesystems']['work']['size']['min_size_gb'] == 0.0
    assert config['filesystems']['work']['size']['max_size_gb'] == 1.5
Exemple #15
0
def files(tmpdir):
    fls = Files(temporary_dir=tmpdir.strpath)
    os.chdir(tmpdir.strpath)

    fls.add('x.zirkon')
    with open(fls["x.zirkon"], "w") as f_out:
        f_out.write("""\
a = 100
b = 1.4
[sub]
    name = "xyz"
    x = 10
    [fun0]
        enable = True
        value = 0.4
""")
    config = Config()
    config.read(fls["x.zirkon"], protocol="zirkon")
    fls.add("x.json")
    config.write(fls["x.json"], protocol="json")
    fls.add("xwrong.zirkon")
    config.write(fls["xwrong.zirkon"], protocol="json")

    fls.add('x.zirkon-schema')
    with open(fls["x.zirkon-schema"], "w") as f_out:
        f_out.write("""\
a = Int()
b = Float()
c = Float(default=ROOT['a'] * ROOT['b'])
[sub]
    name = Str(min_len=1)
    x = Float(min=0.0)
    y = Float(min=0.0)
    [fun0]
        enable = Bool()
        value = Float()
""")
    schema = Schema.from_file(fls["x.zirkon-schema"], protocol="zirkon")
    fls.add("x.s-json")
    schema.to_file(fls["x.s-json"], protocol="json")

    with open(fls.add("x-def-le.zirkon"), "w") as f_out:
        f_out.write("""\
n = 10
[sub]
    n1 = ROOT['n'] + 1
    [sub]
        n2 = ROOT['n'] * ROOT['sub']['n1']
""")
    with open(fls.add("x-def-ee.zirkon"), "w") as f_out:
        f_out.write("""\
n = 10
[sub]
    n1 = 11
    [sub]
        n2 = 110
""")
    return fls
Exemple #16
0
def macro_schema():
    schema = Schema()
    schema['a'] = Int()
    schema['b'] = Int()
    schema['c'] = IntChoice(choices=(SECTION['a'], SECTION['b']))
    schema['sub'] = {}
    schema['sub']['d'] = Int(min=ROOT['a'], max=ROOT['b'])
    schema['sub']['e'] = Int(default=ROOT['a'] + ROOT['b'] + SECTION['d'])
    return schema
Exemple #17
0
def test_create_template_from_schema(string_io):
    schema = Schema()
    schema['m0'] = Int(default=3)
    schema['m1'] = Int(default=ROOT['m0'] + 1)
    config = Config()
    create_template_from_schema(schema, config=config)
    
    config.dump(stream=string_io)
    assert string_io.getvalue() == """\
def schema_de():
    schema = Schema()
    schema['alpha'] = Int(default=10)
    schema['beta'] = Int(default=ROOT['alpha'] - 3)
    schema['sub'] = {}
    schema['sub']['x'] = Int(min=ROOT['beta'])
    schema['sub']['y'] = Int(default=ROOT['alpha'] + SECTION['x'])
    schema['sub']['z'] = Int(default=0)
    return schema
def test_Schema_PATH_list(tmpdir, defaults):
    schema = Schema.from_string("""\
dirs = StrList(default=[PATH.cwd + PATH.sep + "xdir"])
files = StrList(default=[PATH.cwd + PATH.sep + "x.txt"])
""")
    config = Config.from_string("""\
dirs = ["xdir", PATH.cwd + PATH.sep + "ydir"]
""", schema=schema)
    assert config["dirs"] == ["xdir", os.path.abspath("ydir")]
    assert config["files"] == [os.path.abspath("x.txt")]
def test_create_argparser_prefix_str(prefix):
    fqname = _make_fqname(prefix) + ("xval",)
    argname = argument_name(fqname)
    argdest = argument_dest(fqname)
    schema = Schema.from_string("""\
xval = Int(doc="x value")
""", fmt="zirkon")
    parser = create_argparser(schema, prefix=prefix)
    namespace = parser.parse_args(["{}=2".format(argname)])
    assert getattr(namespace, argdest) == 2
def test_Config_use_defaults_False(string_io, use_defaults):
    config = Config()
    schema = Schema(use_defaults=use_defaults)
    schema['x'] = Int(default=10)
    schema['sub'] = {'y': Int(default=20)}
    schema['sub']['sub'] = {'z': Int(default=30)}
    validation = schema.validate(config)
    assert config['x'] == 10
    assert config['sub']['y'] == 20
    assert config['sub']['sub']['z'] == 30
    assert not validation
    config.dump(string_io)
    if use_defaults:
        assert string_io.getvalue() == """\
[sub]
    [sub]
"""
    else:
        assert string_io.getvalue() == """\
def test_Config_use_defaults_False(string_io, use_defaults):
    config = Config()
    schema = Schema(use_defaults=use_defaults)
    schema['x'] = Int(default=10)
    schema['sub'] = {'y': Int(default=20)}
    schema['sub']['sub'] = {'z': Int(default=30)}
    validation = schema.validate(config)
    assert config['x'] == 10
    assert config['sub']['y'] == 20
    assert config['sub']['sub']['z'] == 30
    assert not validation
    config.dump(string_io)
    if use_defaults:
        assert string_io.getvalue() == """\
[sub]
    [sub]
"""
    else:
        assert string_io.getvalue() == """\
Exemple #23
0
def test_main_read_write_evaluate(tmpdir, evaluate, defaults):
    fn_cfg1 = tmpdir.join("evaluate_cfg1.config").strpath
    fn_sch1 = tmpdir.join("evaluate_sch1.schema").strpath

    cfg1 = Config.from_string("""\
a1 = 10
[b]
    b1 = ROOT['a1'] + 1
    b2 = PATH.filename + PATH.extsep + 'b2'
""", defaults=defaults)
    
    sch1 = Schema.from_string("""\
a1 = Int()
a2 = Int(default=SECTION['a1'] * 2)
[b]
    b1 = Int()
    b2 = Str()
    b3 = Str(default=PATH.dirname + PATH.sep + "b3")
""")

    cfg1.to_file(fn_cfg1)
    sch1.to_file(fn_sch1)

    args = ["read", "-i", fn_cfg1, "-s", fn_sch1, "--defaults"]
    if evaluate:
        args.append("-e")

    log_stream, out_stream = run(args)
    if evaluate:
        reference = """\
a1 = 10
[b]
    b1 = 11
    b2 = {b2!r}
    b3 = {b3!r}
a2 = 20

""".format(b2=fn_cfg1 + os.path.extsep + 'b2', b3=os.path.dirname(fn_cfg1) + os.path.sep + 'b3')
    else:
        reference = """\
a1 = 10
[b]
    b1 = ROOT['a1'] + 1
    b2 = PATH.filename + PATH.extsep + 'b2'
    b3 = PATH.dirname + PATH.sep + 'b3'
a2 = SECTION['a1'] * 2

"""
    print("=== evaluate={}".format(evaluate))
    print("=== reference:")
    print(reference)
    print("=== result:")
    print(out_stream.getvalue())
    assert out_stream.getvalue() == reference
    assert log_stream.getvalue() == ""
def test_read_write_schema_de(protocol, schema_de):
    schema_de_string = schema_de.to_string(protocol=protocol)
    ref_schema_de_string = SCHEMA_DE_STRING.get(protocol, None)
    if ref_schema_de_string:
        assert schema_de_string == ref_schema_de_string
    schema_de_reloaded = Schema.from_string(schema_de_string, protocol=protocol)
    assert schema_de == schema_de_reloaded
    schema_de_reloaded_string = schema_de_reloaded.to_string(protocol=protocol)
    if ref_schema_de_string:
        assert schema_de_reloaded_string == schema_de_string
    else:
        assert schema_de_reloaded.to_string(protocol='zirkon') == schema_de.to_string(protocol='zirkon')
def test_read_write_schema_de(fmt, schema_de):
    schema_de_string = schema_de.to_string(fmt=fmt)
    ref_schema_de_string = SCHEMA_DE_STRING.get(fmt, None)
    if ref_schema_de_string:
        assert schema_de_string == ref_schema_de_string
    schema_de_reloaded = Schema.from_string(schema_de_string, fmt=fmt)
    assert schema_de == schema_de_reloaded
    schema_de_reloaded_string = schema_de_reloaded.to_string(fmt=fmt)
    if ref_schema_de_string:
        assert schema_de_reloaded_string == schema_de_string
    else:
        assert compare_dicts(schema_de_reloaded, schema_de)
def schema():
    schema = Schema()
    schema['filename'] = Str()
    schema['run_mode'] = StrChoice(choices=("alpha", "beta", "gamma"))
    schema['values'] = {}
    schema['values']['x'] = Float(min=10.0, max=20.0)
    schema['values']['y'] = Float(min=10.0, max=20.0)
    schema['values']['z'] = Float(min=10.0, max=20.0)
    schema['operation'] = StrChoice(choices=("+", "-"))
    schema['parameters'] = {}
    schema['parameters']['max_iterations'] = Int(default=100)
    schema['parameters']['frequencies'] = FloatList(min_len=2)
    return schema
Exemple #27
0
def test_Schema_validation_order():
    schema = Schema.from_string("""\
__default_option__ = Str()
homedir = Str(default="/home/user")
""")
    config = Config.from_string("""\
workdir = SECTION["homedir"] + "/work"
""")

    validation = schema.validate(config)
    assert not validation
    assert config["homedir"] == "/home/user"
    assert config["workdir"] == "/home/user/work"
Exemple #28
0
def test_Schema_defaults_undefined(defaults, use_defaults, has_default):
    config = Config(defaults=defaults)

    schema = Schema(use_defaults=use_defaults)
    int_kwargs = {}
    if has_default:
        int_kwargs["default"] = 100
    schema["x"] = Int(**int_kwargs)

    if has_default:
        assert not schema.validate(config)
    else:
        assert schema.validate(config)

    if has_default:
        assert "x" in config
        if defaults:
            if use_defaults:
                assert "x" in config.defaults
            else:
                assert "x" not in config.defaults
    else:
        assert "x" not in config
def test_read_write_schema_de(protocol, schema_de):
    schema_de_string = schema_de.to_string(protocol=protocol)
    ref_schema_de_string = SCHEMA_DE_STRING.get(protocol, None)
    if ref_schema_de_string:
        assert schema_de_string == ref_schema_de_string
    schema_de_reloaded = Schema.from_string(schema_de_string,
                                            protocol=protocol)
    assert schema_de == schema_de_reloaded
    schema_de_reloaded_string = schema_de_reloaded.to_string(protocol=protocol)
    if ref_schema_de_string:
        assert schema_de_reloaded_string == schema_de_string
    else:
        assert schema_de_reloaded.to_string(
            protocol='zirkon') == schema_de.to_string(protocol='zirkon')
def test_tdata_namespace(tdata):
    schema = Schema.from_string(
        """\
{} = {}
""".format(tdata.name, tdata.validator_source),
        fmt="zirkon")
    parser = create_argparser(schema)
    for args, value, parsing_error, validation_error in tdata.checks:
        try:
            namespace = parser.parse_args(args)
        except SystemExit:
            assert parsing_error
            continue
        else:
            assert not parsing_error
        assert getattr(namespace, tdata.name) == value
Exemple #31
0
def test_create_template_from_schema(string_io):
    schema = Schema()
    schema['m0'] = Int(default=3)
    schema['m1'] = Int()
    schema['alpha'] = Float(default=0.5)
    schema['input_file'] = Str(min_len=1)
    schema['data'] = {}
    schema['data']['i'] = Int(max=10)
    schema['data']['isub'] = {}
    schema['data']['isub']['a'] = Str()
    schema['data']['isub']['b'] = Str(default='bc')
    schema['data']['isub']['c'] = Str(default=SECTION['b'] * ROOT['m0'])
    schema['data']['isub']['d'] = Str(default=SECTION['b'] * ROOT['m1'])
    schema['data']['j'] = Int(default=2)
    config = create_template_from_schema(schema)
    config.dump(stream=string_io)
    assert string_io.getvalue() == """\
def tschema():
    return Schema.from_string("""\
[pack0]
    db_url = Int(default=10, doc="the db url")
    [filesystems]
        homedir = Str(default="/home/user")
        __default_option__ = Str()
    [comp0]
        alpha = Float(default=1.0, doc="alpha value")
        beta = Float(default=1.0)
        [mod0]
            x0 = Str(default="")
        [mod1]
            x1 = Str(default="")
    [comp1]
        [mod0]
            x0 = Str(default="")
""", fmt="zirkon")
Exemple #33
0
def test_Schema_default_option():
    schema = Schema.from_string("""\
[filesystems]
    __default_option__ = Str()
""")
    config = Config.from_string("""\
[filesystems]
    home = "/home/user"
    work = "/tmp/user"
    data = 6.5
""")
    validation = schema.validate(config)
    assert validation
    assert len(validation) == 1
    assert 'filesystems' in validation
    assert len(validation['filesystems']) == 1
    assert 'data' in validation['filesystems']
    assert config['filesystems']['home'] == "/home/user"
    assert config['filesystems']['work'] == "/tmp/user"
Exemple #34
0
def test_Schema_default_section():
    schema = Schema.from_string("""\
[filesystems]
    [__default_section__]
        path = Str()
        max_size_gb = Float(default=1.0)
""")
    config = Config.from_string("""\
[filesystems]
    [home]
        path = "/home/user"
    [work]
        path = "/tmp/user"
        max_size_gb = 6.5
""")
    validation = schema.validate(config)
    assert not validation
    assert config['filesystems']['home']['max_size_gb'] == 1.0
    assert config['filesystems']['work']['max_size_gb'] == 6.5
Exemple #35
0
def test_create_template_from_schema_with_defaults(include_default_kwargs):
    schema = Schema.from_string("""\
[a]
    x = Int(default=11)
    __default_option__ = Str()
[__default_section__]
    y = Float(default=5.5)
    """, fmt="zirkon")
    include_default_sections = include_default_kwargs.get("include_default_sections", False)
    include_default_options = include_default_kwargs.get("include_default_options", False)
    print(include_default_kwargs)
    config = create_template_from_schema(schema, **include_default_kwargs)
    config.dump()
    if include_default_options:
        assert "__default_option__" in config["a"]
    else:
        assert not "__default_option__" in config["a"]
    if include_default_sections:
        assert "__default_section__" in config
    else:
        assert not "__default_section__" in config
Exemple #36
0
def test_Schema_from_file_json(simple_schema, tmp_text_file):
    tmp_text_file.write(SIMPLE_SCHEMA_JSON_SERIALIZATION)
    tmp_text_file.flush()
    tmp_text_file.seek(0)
    schema = Schema.from_file(filename=tmp_text_file.name, fmt="json")
    assert schema == simple_schema
Exemple #37
0
def test_Schema_create_dictionary_init(dictionary, simple_schema_content, string_io):
    schema = Schema(dictionary=dictionary, init=simple_schema_content)
    schema.dump(stream=string_io)
    assert string_io.getvalue() == SIMPLE_SCHEMA_DUMP
    assert len(dictionary) > 0
Exemple #38
0
def test_Schema_create_dictionary(dictionary, string_io):
    schema = Schema(dictionary=dictionary)
    schema.dump(stream=string_io)
    assert string_io.getvalue() == ""
Exemple #39
0
def test_Schema_get_serializer_json():
    assert isinstance(Schema.get_serializer("json"), JSONSerializer)
Exemple #40
0
def test_Schema_get_serializer_configobj():
    assert isinstance(Schema.get_serializer("configobj"), ConfigObjSerializer)
Exemple #41
0
def test_Schema_get_serializer_pickle():
    assert isinstance(Schema.get_serializer("pickle"), PickleSerializer)
Exemple #42
0
def test_Schema_create_dictionary_init(dictionary, simple_schema_content, string_io):
    schema = Schema(dictionary=dictionary, init=simple_schema_content)
    schema.dump(stream=string_io)
    assert string_io.getvalue() == SIMPLE_SCHEMA_DUMP
    assert len(dictionary) > 0
Exemple #43
0
def test_Schema_get_serializer_zirkon():
    assert isinstance(Schema.get_serializer("zirkon"), ZirkonSerializer)
Exemple #44
0
def test_Schema_create_empty(string_io):
    schema = Schema()
    schema.dump(stream=string_io)
    assert string_io.getvalue() == ""
Exemple #45
0
def test_Schema_from_file_configobj(simple_schema, tmp_text_file):
    tmp_text_file.write(SIMPLE_SCHEMA_CONFIGOBJ_SERIALIZATION)
    tmp_text_file.flush()
    tmp_text_file.seek(0)
    schema = Schema.from_file(filename=tmp_text_file.name, protocol="configobj")
    assert schema == simple_schema
Exemple #46
0
def test_Schema_create_dictionary(dictionary, string_io):
    schema = Schema(dictionary=dictionary)
    schema.dump(stream=string_io)
    assert string_io.getvalue() == ""
Exemple #47
0
def test_Schema_from_file_configobj(simple_schema, tmp_text_file):
    tmp_text_file.write(SIMPLE_SCHEMA_CONFIGOBJ_SERIALIZATION)
    tmp_text_file.flush()
    tmp_text_file.seek(0)
    schema = Schema.from_file(filename=tmp_text_file.name, fmt="configobj")
    assert schema == simple_schema
Exemple #48
0
def simple_schema(dictionary, simple_schema_content):
    schema = Schema(dictionary=dictionary, init=simple_schema_content)
    return schema
Exemple #49
0
def test_Schema_from_file_json(simple_schema, tmp_text_file):
    tmp_text_file.write(SIMPLE_SCHEMA_JSON_SERIALIZATION)
    tmp_text_file.flush()
    tmp_text_file.seek(0)
    schema = Schema.from_file(filename=tmp_text_file.name, protocol="json")
    assert schema == simple_schema