Test_30_single_load.setUp() - Code Metrics - Inspection of "enhancement: make authors and contributors list ge..." - ssato/python-anyconfig - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bff2ab...5dc771 )

by Satoru

created 2016-04-20 02:05 UTC

Test_30_single_load.setUp() A

↳ Parent: Test_30_single_load

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	2
rs	10

#
# Copyright (C) 2012 - 2015 Satoru SATOH <ssato at redhat.com>
# License: MIT
#
# pylint: disable=missing-docstring, invalid-name, no-member
from __future__ import absolute_import

import logging
import os
import os.path
import unittest

import anyconfig.api as TT
import anyconfig.backends
import anyconfig.template
import anyconfig.tests.common

from anyconfig.tests.common import CNF_0, SCM_0, dicts_equal
from anyconfig.compat import OrderedDict, IS_PYTHON_3
from anyconfig.mdicts import convert_to


# suppress logging messages.
TT.set_loglevel(logging.CRITICAL)

CNF_TMPL_0 = """name: {{ name|default('a') }}
a: {{ a }}
b:
    b:
      {% for x in b.b -%}
      - {{ x }}
      {% endfor %}
    c: {{ b.c }}
"""

CNF_TMPL_1 = """a: {{ a }}
b:
    b:
        {% for x in b.b -%}
        - {{ x }}
        {% endfor %}
    c: {{ b.c }}

name: {{ name }}
"""

CNF_TMPL_2 = """a: {{ a }}
b:
    b:
        {% for x in b.b -%}
        - {{ x }}
        {% endfor %}
    d: {{ b.d }}
"""


class Test_10_find_loader(unittest.TestCase):

    def _assert_isinstance(self, obj, cls, msg=False):
        self.assertTrue(isinstance(obj, cls), msg or repr(obj))

    def test_10_find_loader__w_given_parser_type(self):
        cpath = "dummy.conf"
        for psr in anyconfig.backends.PARSERS:
            self._assert_isinstance(TT.find_loader(cpath, psr.type()), psr)

    def test_12_find_loader__w_given_parser_instance(self):
        cpath = "dummy.conf"
        for psr in anyconfig.backends.PARSERS:
            self._assert_isinstance(TT.find_loader(cpath, psr()), psr)

    def test_20_find_loader__by_file(self):
        for psr in anyconfig.backends.PARSERS:
            for ext in psr.extensions():
                self._assert_isinstance(TT.find_loader("dummy." + ext), psr,
                                        "ext=%s, psr=%r" % (ext, psr))

    def test_30_find_loader__not_found(self):
        self.assertEqual(TT.find_loader("a.cnf", "type_not_exist"), None)
        self.assertEqual(TT.find_loader("dummy.ext_not_found"), None)


class Test_20_dumps_and_loads(unittest.TestCase):

    cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))

    def test_30_dumps_and_loads(self):
        cnf = TT.loads(TT.dumps(self.cnf, "json"), "json")
        self.assertTrue(dicts_equal(cnf, self.cnf), str(cnf))

    def test_30_dumps_and_loads__w_options(self):
        cnf = TT.loads(TT.dumps(self.cnf, "json", indent=2), "json",
                       ensure_ascii=False)
        self.assertTrue(dicts_equal(cnf, self.cnf), str(cnf))

    def test_32_dumps_and_loads__w_options__no_dumper(self):
        cnf = TT.loads(TT.dumps(self.cnf, "type_not_exist"), "json")
        self.assertTrue(dicts_equal(cnf, self.cnf), str(cnf))

    def test_40_loads_wo_type(self):
        a_s = "requires:bash,zsh"

        a1 = TT.loads(a_s)
        # a = dict(requires=["bash", "zsh"])
        # self.assertEqual(a1["requires"], a["requires"])
        self.assertTrue(a1 is None)

    def test_42_loads_w_type_not_exist(self):
        a_s = "requires:bash,zsh"

        a1 = TT.loads(a_s, "type_not_exist")
        # a = dict(requires=["bash", "zsh"])
        # self.assertEqual(a1["requires"], a["requires"])
        self.assertTrue(a1 is None)

    def test_44_loads_w_type__template(self):
        if not anyconfig.template.SUPPORTED:
            return

        a_s = "requires: [{{ requires|join(', ') }}]"
        context = dict(requires=["bash", "zsh"], )

        a1 = TT.loads(a_s, ac_parser="yaml", ac_template=True,
                      ac_context=context)

        a = dict(requires=["bash", "zsh"])
        self.assertEqual(a1["requires"], a["requires"])

    def test_46_loads_w_type__broken_template(self):
        if not anyconfig.template.SUPPORTED:
            return

        a = dict(requires="{% }}", )
        a_s = 'requires: "{% }}"'
        a1 = TT.loads(a_s, ac_parser="yaml", ac_template=True,
                      ac_context={})

        self.assertEqual(a1["requires"], a["requires"])

    def test_48_loads_w_validation(self):

        cnf_s = TT.dumps(CNF_0, "json")
        scm_s = TT.dumps(SCM_0, "json")
        cnf_2 = TT.loads(cnf_s, ac_parser="json", ac_context={},
                         ac_validate=scm_s)

        self.assertEqual(cnf_2["name"], CNF_0["name"])
        self.assertEqual(cnf_2["a"], CNF_0["a"])
        self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
        self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])

    def test_49_loads_w_validation_error(self):
        cnf_s = """{"a": "aaa"}"""
        scm_s = TT.dumps(SCM_0, "json")
        cnf_2 = TT.loads(cnf_s, ac_parser="json", ac_schema=scm_s)
        self.assertTrue(cnf_2 is None, cnf_2)


class Test_30_single_load(unittest.TestCase):

    cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))

    def setUp(self):
        self.workdir = anyconfig.tests.common.setup_workdir()

    def tearDown(self):
        anyconfig.tests.common.cleanup_workdir(self.workdir)

    def test_10_dump_and_single_load(self):
        cpath = os.path.join(self.workdir, "a.json")

        TT.dump(self.cnf, cpath)
        self.assertTrue(os.path.exists(cpath))
        cnf1 = TT.single_load(cpath)

        self.assertTrue(dicts_equal(self.cnf, cnf1), str(cnf1))

    def test_11_dump_and_single_load__to_from_stream(self):
        cpath = os.path.join(self.workdir, "a.json")

        TT.dump(self.cnf, open(cpath, 'w'))
        self.assertTrue(os.path.exists(cpath))
        cnf1 = TT.single_load(open(cpath))

        self.assertTrue(dicts_equal(self.cnf, cnf1), str(cnf1))

    def test_12_dump_and_single_load__no_parser(self):
        self.assertEqual(TT.single_load("dummy.ext_not_exist"), None)

    def test_13_dump_and_single_load__namedtuple(self):
        if not IS_PYTHON_3:  # TODO: it does not work with python3.
            cpath = os.path.join(self.workdir, "a.json")
            cnf = OrderedDict(sorted(self.cnf.items()))
            cnf0 = convert_to(cnf, ac_namedtuple=True)

            TT.dump(cnf0, cpath)
            self.assertTrue(os.path.exists(cpath))

            cnf1 = TT.single_load(cpath, ac_namedtuple=True)
            self.assertTrue(cnf0 == cnf1, "\n%r ->\n%r" % (cnf0, cnf1))

    def test_14_single_load__ignore_missing(self):
        null_cntnr = TT.to_container()
        cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
        assert not os.path.exists(cpath)

        self.assertEqual(TT.single_load(cpath, "ini", ignore_missing=True),
                         null_cntnr)

    def test_15_single_load__fail_to_render_template(self):
        if not anyconfig.template.SUPPORTED:
            return

        cnf_s = "name: '{{ name'"  # Should cause template renering error.
        cpath = os.path.join(self.workdir, "a.yaml")
        open(cpath, 'w').write(cnf_s)

        cnf = TT.single_load(cpath, ac_template=True, ac_context=dict(a=1))
        self.assertEqual(cnf["name"], "{{ name")

    def test_16_single_load__template(self):
        if not anyconfig.template.SUPPORTED:
            return

        cpath = os.path.join(self.workdir, "a.yaml")
        open(cpath, 'w').write(CNF_TMPL_0)

        cnf = TT.single_load(cpath, ac_template=True, ac_context=self.cnf)
        self.assertTrue(dicts_equal(self.cnf, cnf), str(cnf))

        spath = os.path.join(self.workdir, "scm.json")
        TT.dump(dict(type="integer"), spath)  # Validation should fail.

        cnf2 = TT.single_load(cpath, ac_template=True, ac_context=self.cnf,
                              ac_schema=spath)
        self.assertTrue(cnf2 is None)

    def test_18_single_load__templates(self):
        if not anyconfig.template.SUPPORTED:
            return

        a_path = os.path.join(self.workdir, "a.yml")
        b_path = os.path.join(self.workdir, "b.yml")
        a2_path = os.path.join(self.workdir, "x/y/z", "a.yml")

        open(a_path, 'w').write("{% include 'b.yml' %}")
        open(b_path, 'w').write(CNF_TMPL_0)
        os.makedirs(os.path.dirname(a2_path))
        open(a2_path, 'w').write("a: 'xyz'")

        cnf1 = TT.single_load(a_path, ac_template=True, ac_context=self.cnf)
        self.assertTrue(dicts_equal(self.cnf, cnf1), str(cnf1))

        cnf2 = TT.single_load(a2_path, ac_template=True)
        self.assertEqual(cnf2["a"], "xyz")

    def test_19_dump_and_single_load_with_validation(self):
        cnf = CNF_0
        scm = SCM_0

        cnf_path = os.path.join(self.workdir, "cnf_19.json")
        scm_path = os.path.join(self.workdir, "scm_19.json")

        TT.dump(cnf, cnf_path)
        TT.dump(scm, scm_path)
        self.assertTrue(os.path.exists(cnf_path))
        self.assertTrue(os.path.exists(scm_path))

        cnf_1 = TT.single_load(cnf_path, ac_schema=scm_path)

        self.assertFalse(cnf_1 is None)  # Validation should succeed.
        self.assertTrue(dicts_equal(cnf_1, cnf), cnf_1)

        cnf_2 = cnf.copy()
        cnf_2["a"] = "aaa"  # It's type should be integer not string.
        cnf_2_path = os.path.join(self.workdir, "cnf_19_2.json")
        TT.dump(cnf_2, cnf_2_path)
        self.assertTrue(os.path.exists(cnf_2_path))

        cnf_3 = TT.single_load(cnf_2_path, ac_schema=scm_path)
        self.assertTrue(cnf_3 is None)  # Validation should fail.


class Test_40_multi_load(unittest.TestCase):

    cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))

    def setUp(self):
        self.workdir = anyconfig.tests.common.setup_workdir()

    def tearDown(self):
        anyconfig.tests.common.cleanup_workdir(self.workdir)

    def test_10_dump_and_multi_load__default_merge_strategy(self):
        a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))

        a_path = os.path.join(self.workdir, "a.json")
        b_path = os.path.join(self.workdir, "b.json")
        g_path = os.path.join(self.workdir, "*.json")

        TT.dump(a, a_path)
        TT.dump(b, b_path)

        a0 = TT.multi_load(g_path)
        a02 = TT.multi_load([g_path, b_path])

        self.assertEqual(a0["name"], a["name"])
        self.assertEqual(a0["a"], b["a"])
        self.assertEqual(a0["b"]["b"], b["b"]["b"])
        self.assertEqual(a0["b"]["c"], a["b"]["c"])
        self.assertEqual(a0["b"]["d"], b["b"]["d"])

        self.assertEqual(a02["name"], a["name"])
        self.assertEqual(a02["a"], b["a"])
        self.assertEqual(a02["b"]["b"], b["b"]["b"])
        self.assertEqual(a02["b"]["c"], a["b"]["c"])
        self.assertEqual(a02["b"]["d"], b["b"]["d"])

        a1 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_DICTS)

        self.assertEqual(a1["name"], a["name"])
        self.assertEqual(a1["a"], b["a"])
        self.assertEqual(a1["b"]["b"], b["b"]["b"])
        self.assertEqual(a1["b"]["c"], a["b"]["c"])
        self.assertEqual(a1["b"]["d"], b["b"]["d"])

    def test_12_dump_and_multi_load__default_merge_strategy(self):
        a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))

        a_path = os.path.join(self.workdir, "a.json")
        b_path = os.path.join(self.workdir, "b.json")
        g_path = os.path.join(self.workdir, "*.json")

        TT.dump(a, a_path)
        TT.dump(b, b_path)

        a2 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_DICTS_AND_LISTS)

        self.assertEqual(a2["name"], a["name"])
        self.assertEqual(a2["a"], b["a"])
        self.assertEqual(a2["b"]["b"], [0, 1, 2, 3, 4, 5])
        self.assertEqual(a2["b"]["c"], a["b"]["c"])
        self.assertEqual(a2["b"]["d"], b["b"]["d"])

        a3 = TT.multi_load(g_path)

        self.assertEqual(a3["name"], a["name"])
        self.assertEqual(a3["a"], b["a"])
        self.assertEqual(a3["b"]["b"], b["b"]["b"])
        self.assertEqual(a3["b"]["c"], a["b"]["c"])
        self.assertEqual(a3["b"]["d"], b["b"]["d"])

        a4 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_REPLACE)

        self.assertEqual(a4["name"], a["name"])
        self.assertEqual(a4["a"], b["a"])
        self.assertEqual(a4["b"]["b"], b["b"]["b"])
        self.assertFalse("c" in a4["b"])
        self.assertEqual(a4["b"]["d"], b["b"]["d"])

        a5 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_NO_REPLACE)

        self.assertEqual(a5["name"], a["name"])
        self.assertEqual(a5["a"], a["a"])
        self.assertEqual(a5["b"]["b"], a["b"]["b"])
        self.assertEqual(a5["b"]["c"], a["b"]["c"])
        self.assertFalse("d" in a5["b"])

    def test_14_multi_load__wrong_merge_strategy(self):
        try:
            TT.multi_load("/dummy/*.json", ac_merge="merge_st_not_exist")
            raise RuntimeError("Wrong merge strategy was not handled!")
        except ValueError:
            self.assertTrue(1 == 1)  # To suppress warn of pylint.

    def test_15_multi_load__empty_path_list(self):
        self.assertEqual(TT.multi_load([]), TT.to_container())

    def test_16_dump_and_multi_load__mixed_file_types(self):
        a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))

        a_path = os.path.join(self.workdir, "a.json")
        b_path = os.path.join(self.workdir, "b.yml")

        TT.dump(a, a_path)
        TT.dump(b, b_path)

        cnf = TT.multi_load([a_path, b_path])

        self.assertEqual(cnf["name"], a["name"])
        self.assertEqual(cnf["a"], b["a"])
        self.assertEqual(cnf["b"]["b"], b["b"]["b"])
        self.assertEqual(cnf["b"]["c"], a["b"]["c"])
        self.assertEqual(cnf["b"]["d"], b["b"]["d"])

    def test_18_dump_and_multi_load__namedtuple(self):
        a = convert_to(dict(a=1, b=dict(b=[0, 1], c="C"), name="a"),
                       ac_namedtuple=True)
        b = convert_to(dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D")),
                       ac_namedtuple=True)

        a_path = os.path.join(self.workdir, "a.json")
        b_path = os.path.join(self.workdir, "b.yml")

        TT.dump(a, a_path)
        TT.dump(b, b_path)
        cnf = TT.multi_load([a_path, b_path], ac_namedtuple=True)

        self.assertEqual(cnf.name, a.name)
        self.assertEqual(cnf.a, b.a)
        self.assertEqual(cnf.b.b, b.b.b)
        self.assertEqual(cnf.b.c, a.b.c)
        self.assertEqual(cnf.b.d, b.b.d)

    def test_20_dump_and_multi_load__to_from_stream(self):
        a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))

        a_path = os.path.join(self.workdir, "a.json")
        b_path = os.path.join(self.workdir, "b.json")

        TT.dump(a, open(a_path, 'w'))
        TT.dump(b, open(b_path, 'w'))
        self.assertTrue(os.path.exists(a_path))
        self.assertTrue(os.path.exists(b_path))

        cnf = TT.multi_load([open(a_path), open(b_path)])

        self.assertEqual(cnf["name"], a["name"])
        self.assertEqual(cnf["a"], b["a"])
        self.assertEqual(cnf["b"]["b"], b["b"]["b"])
        self.assertEqual(cnf["b"]["c"], a["b"]["c"])
        self.assertEqual(cnf["b"]["d"], b["b"]["d"])

    def test_30_multi_load__ignore_missing(self):
        null_cntnr = TT.to_container()
        cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
        assert not os.path.exists(cpath)

        self.assertEqual(TT.multi_load([cpath], ac_parser="ini",
                                       ignore_missing=True),
                         null_cntnr)

    def test_40_multi_load__templates(self):
        if not anyconfig.template.SUPPORTED:
            return

        a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))

        ma = TT.to_container(a, ac_merge=TT.MS_DICTS)
        ma.update(b)

        a_path = os.path.join(self.workdir, "a.yml")
        b_path = os.path.join(self.workdir, "b.yml")
        g_path = os.path.join(self.workdir, "*.yml")

        open(a_path, 'w').write(CNF_TMPL_1)
        open(b_path, 'w').write(CNF_TMPL_2)

        a0 = TT.multi_load(g_path, ac_merge=TT.MS_DICTS, ac_template=True,
                           ac_context=ma)
        a02 = TT.multi_load([g_path, b_path], ac_merge=TT.MS_DICTS,
                            ac_template=True, ac_context=ma)

        self.assertEqual(a0["name"], a["name"])
        self.assertEqual(a0["a"], b["a"])
        self.assertEqual(a0["b"]["b"], b["b"]["b"])
        self.assertEqual(a0["b"]["c"], a["b"]["c"])
        self.assertEqual(a0["b"]["d"], b["b"]["d"])

        self.assertEqual(a02["name"], a["name"])
        self.assertEqual(a02["a"], b["a"])
        self.assertEqual(a02["b"]["b"], b["b"]["b"])
        self.assertEqual(a02["b"]["c"], a["b"]["c"])
        self.assertEqual(a02["b"]["d"], b["b"]["d"])


class Test_50_load_and_dump(unittest.TestCase):

    cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))

    def setUp(self):
        self.workdir = anyconfig.tests.common.setup_workdir()

    def tearDown(self):
        anyconfig.tests.common.cleanup_workdir(self.workdir)

    def test_30_dump_and_load(self):
        a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))

        a_path = os.path.join(self.workdir, "a.json")
        b_path = os.path.join(self.workdir, "b.json")

        TT.dump(a, a_path)
        self.assertTrue(os.path.exists(a_path))

        TT.dump(b, b_path)
        self.assertTrue(os.path.exists(b_path))

        a1 = TT.load(a_path)

        self.assertEqual(a1["name"], a["name"])
        self.assertEqual(a1["a"], a["a"])
        self.assertEqual(a1["b"]["b"], a["b"]["b"])
        self.assertEqual(a1["b"]["c"], a["b"]["c"])

        a2 = TT.load(os.path.join(self.workdir, '*.json'))

        self.assertEqual(a2["name"], a["name"])
        self.assertEqual(a2["a"], b["a"])
        self.assertEqual(a2["b"]["b"], [1, 2, 3, 4, 5])
        self.assertEqual(a2["b"]["c"], a["b"]["c"])
        self.assertEqual(a2["b"]["d"], b["b"]["d"])

        a3 = TT.load([a_path, b_path])

        self.assertEqual(a3["name"], a["name"])
        self.assertEqual(a3["a"], b["a"])
        self.assertEqual(a3["b"]["b"], [1, 2, 3, 4, 5])
        self.assertEqual(a3["b"]["c"], a["b"]["c"])
        self.assertEqual(a3["b"]["d"], b["b"]["d"])

    def test_31_dump_and_load__to_from_stream(self):
        cnf = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        cpath = os.path.join(self.workdir, "a.json")

        with open(cpath, 'w') as strm:
            TT.dump(cnf, strm)

        self.assertTrue(os.path.exists(cpath))

        with open(cpath, 'r') as strm:
            cnf1 = TT.load(strm, ac_parser="json")

        self.assertTrue(dicts_equal(cnf, cnf1),
                        "cnf vs. cnf1: %s\n\n%s" % (str(cnf), str(cnf1)))

    def test_32_dump_and_load__w_options(self):
        a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
        b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))

        a_path = os.path.join(self.workdir, "a.json")
        b_path = os.path.join(self.workdir, "b.json")

        TT.dump(a, a_path, indent=2)
        self.assertTrue(os.path.exists(a_path))

        TT.dump(b, b_path, indent=2)
        self.assertTrue(os.path.exists(b_path))

        a1 = TT.load(a_path, parse_int=int)

        self.assertEqual(a1["name"], a["name"])
        self.assertEqual(a1["a"], a["a"])
        self.assertEqual(a1["b"]["b"], a["b"]["b"])
        self.assertEqual(a1["b"]["c"], a["b"]["c"])

        a2 = TT.load(os.path.join(self.workdir, '*.json'), parse_int=int)

        self.assertEqual(a2["name"], a["name"])
        self.assertEqual(a2["a"], b["a"])
        self.assertEqual(a2["b"]["b"], [1, 2, 3, 4, 5])
        self.assertEqual(a2["b"]["c"], a["b"]["c"])
        self.assertEqual(a2["b"]["d"], b["b"]["d"])

        a3 = TT.load([a_path, b_path], parse_int=int)

        self.assertEqual(a3["name"], a["name"])
        self.assertEqual(a3["a"], b["a"])
        self.assertEqual(a3["b"]["b"], [1, 2, 3, 4, 5])
        self.assertEqual(a3["b"]["c"], a["b"]["c"])
        self.assertEqual(a3["b"]["d"], b["b"]["d"])

    def test_34_load__ignore_missing(self):
        null_cntnr = TT.to_container()
        cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
        assert not os.path.exists(cpath)

        self.assertEqual(TT.load([cpath], ac_parser="ini",
                                 ignore_missing=True),
                         null_cntnr)

    def test_36_load_w_validation(self):

        cnf_path = os.path.join(self.workdir, "cnf.json")
        scm_path = os.path.join(self.workdir, "scm.json")
        TT.dump(CNF_0, cnf_path)
        TT.dump(SCM_0, scm_path)

        cnf_2 = TT.load(cnf_path, ac_context={}, ac_validate=scm_path)

        self.assertEqual(cnf_2["name"], CNF_0["name"])
        self.assertEqual(cnf_2["a"], CNF_0["a"])
        self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
        self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])

    def test_38_load_w_validation_yaml(self):

        cnf_path = os.path.join(self.workdir, "cnf.yml")
        scm_path = os.path.join(self.workdir, "scm.yml")
        TT.dump(CNF_0, cnf_path)
        TT.dump(SCM_0, scm_path)

        cnf_2 = TT.load(cnf_path, ac_context={}, ac_validate=scm_path)

        self.assertEqual(cnf_2["name"], CNF_0["name"])
        self.assertEqual(cnf_2["a"], CNF_0["a"])
        self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
        self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])

    def test_39_single_load__w_validation(self):
        (cnf, scm) = (CNF_0, SCM_0)
        cpath = os.path.join(self.workdir, "cnf.json")
        spath = os.path.join(self.workdir, "scm.json")

        TT.dump(cnf, cpath)
        TT.dump(scm, spath)

        cnf1 = TT.single_load(cpath, ac_schema=spath)
        self.assertTrue(dicts_equal(cnf, cnf1), str(cnf1))

# vim:sw=4:ts=4:et:


1		#
2		# Copyright (C) 2012 - 2015 Satoru SATOH <ssato at redhat.com>
3		# License: MIT
4		#
5		# pylint: disable=missing-docstring, invalid-name, no-member
6		from __future__ import absolute_import
7
8		import logging
9		import os
10		import os.path
11		import unittest
12
13		import anyconfig.api as TT
14		import anyconfig.backends
15		import anyconfig.template
16		import anyconfig.tests.common
17
18		from anyconfig.tests.common import CNF_0, SCM_0, dicts_equal
19		from anyconfig.compat import OrderedDict, IS_PYTHON_3
20		from anyconfig.mdicts import convert_to
21
22
23		# suppress logging messages.
24		TT.set_loglevel(logging.CRITICAL)
25
26		CNF_TMPL_0 = """name: {{ name\|default('a') }}
27		a: {{ a }}
28		b:
29		b:
30		{% for x in b.b -%}
31		- {{ x }}
32		{% endfor %}
33		c: {{ b.c }}
34		"""
35
36		CNF_TMPL_1 = """a: {{ a }}
37		b:
38		b:
39		{% for x in b.b -%}
40		- {{ x }}
41		{% endfor %}
42		c: {{ b.c }}
43
44		name: {{ name }}
45		"""
46
47		CNF_TMPL_2 = """a: {{ a }}
48		b:
49		b:
50		{% for x in b.b -%}
51		- {{ x }}
52		{% endfor %}
53		d: {{ b.d }}
54		"""
55
56
57		class Test_10_find_loader(unittest.TestCase):
58
59		def _assert_isinstance(self, obj, cls, msg=False):
60		self.assertTrue(isinstance(obj, cls), msg or repr(obj))
61
62		def test_10_find_loader__w_given_parser_type(self):
63		cpath = "dummy.conf"
64		for psr in anyconfig.backends.PARSERS:
65		self._assert_isinstance(TT.find_loader(cpath, psr.type()), psr)
66
67		def test_12_find_loader__w_given_parser_instance(self):
68		cpath = "dummy.conf"
69		for psr in anyconfig.backends.PARSERS:
70		self._assert_isinstance(TT.find_loader(cpath, psr()), psr)
71
72		def test_20_find_loader__by_file(self):
73		for psr in anyconfig.backends.PARSERS:
74		for ext in psr.extensions():
75		self._assert_isinstance(TT.find_loader("dummy." + ext), psr,
76		"ext=%s, psr=%r" % (ext, psr))
77
78		def test_30_find_loader__not_found(self):
79		self.assertEqual(TT.find_loader("a.cnf", "type_not_exist"), None)
80		self.assertEqual(TT.find_loader("dummy.ext_not_found"), None)
81
82
83		class Test_20_dumps_and_loads(unittest.TestCase):
84
85		cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))
86
87		def test_30_dumps_and_loads(self):
88		cnf = TT.loads(TT.dumps(self.cnf, "json"), "json")
89		self.assertTrue(dicts_equal(cnf, self.cnf), str(cnf))
90
91		def test_30_dumps_and_loads__w_options(self):
92		cnf = TT.loads(TT.dumps(self.cnf, "json", indent=2), "json",
93		ensure_ascii=False)
94		self.assertTrue(dicts_equal(cnf, self.cnf), str(cnf))
95
96		def test_32_dumps_and_loads__w_options__no_dumper(self):
97		cnf = TT.loads(TT.dumps(self.cnf, "type_not_exist"), "json")
98		self.assertTrue(dicts_equal(cnf, self.cnf), str(cnf))
99
100		def test_40_loads_wo_type(self):
101		a_s = "requires:bash,zsh"
102
103		a1 = TT.loads(a_s)
104		# a = dict(requires=["bash", "zsh"])
105		# self.assertEqual(a1["requires"], a["requires"])
106		self.assertTrue(a1 is None)
107
108		def test_42_loads_w_type_not_exist(self):
109		a_s = "requires:bash,zsh"
110
111		a1 = TT.loads(a_s, "type_not_exist")
112		# a = dict(requires=["bash", "zsh"])
113		# self.assertEqual(a1["requires"], a["requires"])
114		self.assertTrue(a1 is None)
115
116		def test_44_loads_w_type__template(self):
117		if not anyconfig.template.SUPPORTED:
118		return
119
120		a_s = "requires: [{{ requires\|join(', ') }}]"
121		context = dict(requires=["bash", "zsh"], )
122
123		a1 = TT.loads(a_s, ac_parser="yaml", ac_template=True,
124		ac_context=context)
125
126		a = dict(requires=["bash", "zsh"])
127		self.assertEqual(a1["requires"], a["requires"])
128
129		def test_46_loads_w_type__broken_template(self):
130		if not anyconfig.template.SUPPORTED:
131		return
132
133		a = dict(requires="{% }}", )
134		a_s = 'requires: "{% }}"'
135		a1 = TT.loads(a_s, ac_parser="yaml", ac_template=True,
136		ac_context={})
137
138		self.assertEqual(a1["requires"], a["requires"])
139
140	View Code Duplication	def test_48_loads_w_validation(self):
		0 ignored issues – show Duplication introduced 2016-04-20 02:06 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
141		cnf_s = TT.dumps(CNF_0, "json")
142		scm_s = TT.dumps(SCM_0, "json")
143		cnf_2 = TT.loads(cnf_s, ac_parser="json", ac_context={},
144		ac_validate=scm_s)
145
146		self.assertEqual(cnf_2["name"], CNF_0["name"])
147		self.assertEqual(cnf_2["a"], CNF_0["a"])
148		self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
149		self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])
150
151		def test_49_loads_w_validation_error(self):
152		cnf_s = """{"a": "aaa"}"""
153		scm_s = TT.dumps(SCM_0, "json")
154		cnf_2 = TT.loads(cnf_s, ac_parser="json", ac_schema=scm_s)
155		self.assertTrue(cnf_2 is None, cnf_2)
156
157
158		class Test_30_single_load(unittest.TestCase):
159
160		cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))
161
162		def setUp(self):
163		self.workdir = anyconfig.tests.common.setup_workdir()
164
165		def tearDown(self):
166		anyconfig.tests.common.cleanup_workdir(self.workdir)
167
168		def test_10_dump_and_single_load(self):
169		cpath = os.path.join(self.workdir, "a.json")
170
171		TT.dump(self.cnf, cpath)
172		self.assertTrue(os.path.exists(cpath))
173		cnf1 = TT.single_load(cpath)
174
175		self.assertTrue(dicts_equal(self.cnf, cnf1), str(cnf1))
176
177		def test_11_dump_and_single_load__to_from_stream(self):
178		cpath = os.path.join(self.workdir, "a.json")
179
180		TT.dump(self.cnf, open(cpath, 'w'))
181		self.assertTrue(os.path.exists(cpath))
182		cnf1 = TT.single_load(open(cpath))
183
184		self.assertTrue(dicts_equal(self.cnf, cnf1), str(cnf1))
185
186		def test_12_dump_and_single_load__no_parser(self):
187		self.assertEqual(TT.single_load("dummy.ext_not_exist"), None)
188
189		def test_13_dump_and_single_load__namedtuple(self):
190		if not IS_PYTHON_3: # TODO: it does not work with python3.
191		cpath = os.path.join(self.workdir, "a.json")
192		cnf = OrderedDict(sorted(self.cnf.items()))
193		cnf0 = convert_to(cnf, ac_namedtuple=True)
194
195		TT.dump(cnf0, cpath)
196		self.assertTrue(os.path.exists(cpath))
197
198		cnf1 = TT.single_load(cpath, ac_namedtuple=True)
199		self.assertTrue(cnf0 == cnf1, "\n%r ->\n%r" % (cnf0, cnf1))
200
201		def test_14_single_load__ignore_missing(self):
202		null_cntnr = TT.to_container()
203		cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
204		assert not os.path.exists(cpath)
205
206		self.assertEqual(TT.single_load(cpath, "ini", ignore_missing=True),
207		null_cntnr)
208
209		def test_15_single_load__fail_to_render_template(self):
210		if not anyconfig.template.SUPPORTED:
211		return
212
213		cnf_s = "name: '{{ name'" # Should cause template renering error.
214		cpath = os.path.join(self.workdir, "a.yaml")
215		open(cpath, 'w').write(cnf_s)
216
217		cnf = TT.single_load(cpath, ac_template=True, ac_context=dict(a=1))
218		self.assertEqual(cnf["name"], "{{ name")
219
220		def test_16_single_load__template(self):
221		if not anyconfig.template.SUPPORTED:
222		return
223
224		cpath = os.path.join(self.workdir, "a.yaml")
225		open(cpath, 'w').write(CNF_TMPL_0)
226
227		cnf = TT.single_load(cpath, ac_template=True, ac_context=self.cnf)
228		self.assertTrue(dicts_equal(self.cnf, cnf), str(cnf))
229
230		spath = os.path.join(self.workdir, "scm.json")
231		TT.dump(dict(type="integer"), spath) # Validation should fail.
232
233		cnf2 = TT.single_load(cpath, ac_template=True, ac_context=self.cnf,
234		ac_schema=spath)
235		self.assertTrue(cnf2 is None)
236
237		def test_18_single_load__templates(self):
238		if not anyconfig.template.SUPPORTED:
239		return
240
241		a_path = os.path.join(self.workdir, "a.yml")
242		b_path = os.path.join(self.workdir, "b.yml")
243		a2_path = os.path.join(self.workdir, "x/y/z", "a.yml")
244
245		open(a_path, 'w').write("{% include 'b.yml' %}")
246		open(b_path, 'w').write(CNF_TMPL_0)
247		os.makedirs(os.path.dirname(a2_path))
248		open(a2_path, 'w').write("a: 'xyz'")
249
250		cnf1 = TT.single_load(a_path, ac_template=True, ac_context=self.cnf)
251		self.assertTrue(dicts_equal(self.cnf, cnf1), str(cnf1))
252
253		cnf2 = TT.single_load(a2_path, ac_template=True)
254		self.assertEqual(cnf2["a"], "xyz")
255
256		def test_19_dump_and_single_load_with_validation(self):
257		cnf = CNF_0
258		scm = SCM_0
259
260		cnf_path = os.path.join(self.workdir, "cnf_19.json")
261		scm_path = os.path.join(self.workdir, "scm_19.json")
262
263		TT.dump(cnf, cnf_path)
264		TT.dump(scm, scm_path)
265		self.assertTrue(os.path.exists(cnf_path))
266		self.assertTrue(os.path.exists(scm_path))
267
268		cnf_1 = TT.single_load(cnf_path, ac_schema=scm_path)
269
270		self.assertFalse(cnf_1 is None) # Validation should succeed.
271		self.assertTrue(dicts_equal(cnf_1, cnf), cnf_1)
272
273		cnf_2 = cnf.copy()
274		cnf_2["a"] = "aaa" # It's type should be integer not string.
275		cnf_2_path = os.path.join(self.workdir, "cnf_19_2.json")
276		TT.dump(cnf_2, cnf_2_path)
277		self.assertTrue(os.path.exists(cnf_2_path))
278
279		cnf_3 = TT.single_load(cnf_2_path, ac_schema=scm_path)
280		self.assertTrue(cnf_3 is None) # Validation should fail.
281
282
283		class Test_40_multi_load(unittest.TestCase):
284
285		cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))
286
287		def setUp(self):
288		self.workdir = anyconfig.tests.common.setup_workdir()
289
290		def tearDown(self):
291		anyconfig.tests.common.cleanup_workdir(self.workdir)
292
293		def test_10_dump_and_multi_load__default_merge_strategy(self):
294		a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
295		b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
296
297		a_path = os.path.join(self.workdir, "a.json")
298		b_path = os.path.join(self.workdir, "b.json")
299		g_path = os.path.join(self.workdir, "*.json")
300
301		TT.dump(a, a_path)
302		TT.dump(b, b_path)
303
304		a0 = TT.multi_load(g_path)
305		a02 = TT.multi_load([g_path, b_path])
306
307		self.assertEqual(a0["name"], a["name"])
308		self.assertEqual(a0["a"], b["a"])
309		self.assertEqual(a0["b"]["b"], b["b"]["b"])
310		self.assertEqual(a0["b"]["c"], a["b"]["c"])
311		self.assertEqual(a0["b"]["d"], b["b"]["d"])
312
313		self.assertEqual(a02["name"], a["name"])
314		self.assertEqual(a02["a"], b["a"])
315		self.assertEqual(a02["b"]["b"], b["b"]["b"])
316		self.assertEqual(a02["b"]["c"], a["b"]["c"])
317		self.assertEqual(a02["b"]["d"], b["b"]["d"])
318
319		a1 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_DICTS)
320
321		self.assertEqual(a1["name"], a["name"])
322		self.assertEqual(a1["a"], b["a"])
323		self.assertEqual(a1["b"]["b"], b["b"]["b"])
324		self.assertEqual(a1["b"]["c"], a["b"]["c"])
325		self.assertEqual(a1["b"]["d"], b["b"]["d"])
326
327		def test_12_dump_and_multi_load__default_merge_strategy(self):
328		a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
329		b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
330
331		a_path = os.path.join(self.workdir, "a.json")
332		b_path = os.path.join(self.workdir, "b.json")
333		g_path = os.path.join(self.workdir, "*.json")
334
335		TT.dump(a, a_path)
336		TT.dump(b, b_path)
337
338		a2 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_DICTS_AND_LISTS)
339
340		self.assertEqual(a2["name"], a["name"])
341		self.assertEqual(a2["a"], b["a"])
342		self.assertEqual(a2["b"]["b"], [0, 1, 2, 3, 4, 5])
343		self.assertEqual(a2["b"]["c"], a["b"]["c"])
344		self.assertEqual(a2["b"]["d"], b["b"]["d"])
345
346		a3 = TT.multi_load(g_path)
347
348		self.assertEqual(a3["name"], a["name"])
349		self.assertEqual(a3["a"], b["a"])
350		self.assertEqual(a3["b"]["b"], b["b"]["b"])
351		self.assertEqual(a3["b"]["c"], a["b"]["c"])
352		self.assertEqual(a3["b"]["d"], b["b"]["d"])
353
354		a4 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_REPLACE)
355
356		self.assertEqual(a4["name"], a["name"])
357		self.assertEqual(a4["a"], b["a"])
358		self.assertEqual(a4["b"]["b"], b["b"]["b"])
359		self.assertFalse("c" in a4["b"])
360		self.assertEqual(a4["b"]["d"], b["b"]["d"])
361
362		a5 = TT.multi_load([a_path, b_path], ac_merge=TT.MS_NO_REPLACE)
363
364		self.assertEqual(a5["name"], a["name"])
365		self.assertEqual(a5["a"], a["a"])
366		self.assertEqual(a5["b"]["b"], a["b"]["b"])
367		self.assertEqual(a5["b"]["c"], a["b"]["c"])
368		self.assertFalse("d" in a5["b"])
369
370		def test_14_multi_load__wrong_merge_strategy(self):
371		try:
372		TT.multi_load("/dummy/*.json", ac_merge="merge_st_not_exist")
373		raise RuntimeError("Wrong merge strategy was not handled!")
374		except ValueError:
375		self.assertTrue(1 == 1) # To suppress warn of pylint.
376
377		def test_15_multi_load__empty_path_list(self):
378		self.assertEqual(TT.multi_load([]), TT.to_container())
379
380		def test_16_dump_and_multi_load__mixed_file_types(self):
381		a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
382		b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
383
384		a_path = os.path.join(self.workdir, "a.json")
385		b_path = os.path.join(self.workdir, "b.yml")
386
387		TT.dump(a, a_path)
388		TT.dump(b, b_path)
389
390		cnf = TT.multi_load([a_path, b_path])
391
392		self.assertEqual(cnf["name"], a["name"])
393		self.assertEqual(cnf["a"], b["a"])
394		self.assertEqual(cnf["b"]["b"], b["b"]["b"])
395		self.assertEqual(cnf["b"]["c"], a["b"]["c"])
396		self.assertEqual(cnf["b"]["d"], b["b"]["d"])
397
398		def test_18_dump_and_multi_load__namedtuple(self):
399		a = convert_to(dict(a=1, b=dict(b=[0, 1], c="C"), name="a"),
400		ac_namedtuple=True)
401		b = convert_to(dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D")),
402		ac_namedtuple=True)
403
404		a_path = os.path.join(self.workdir, "a.json")
405		b_path = os.path.join(self.workdir, "b.yml")
406
407		TT.dump(a, a_path)
408		TT.dump(b, b_path)
409		cnf = TT.multi_load([a_path, b_path], ac_namedtuple=True)
410
411		self.assertEqual(cnf.name, a.name)
412		self.assertEqual(cnf.a, b.a)
413		self.assertEqual(cnf.b.b, b.b.b)
414		self.assertEqual(cnf.b.c, a.b.c)
415		self.assertEqual(cnf.b.d, b.b.d)
416
417		def test_20_dump_and_multi_load__to_from_stream(self):
418		a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
419		b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
420
421		a_path = os.path.join(self.workdir, "a.json")
422		b_path = os.path.join(self.workdir, "b.json")
423
424		TT.dump(a, open(a_path, 'w'))
425		TT.dump(b, open(b_path, 'w'))
426		self.assertTrue(os.path.exists(a_path))
427		self.assertTrue(os.path.exists(b_path))
428
429		cnf = TT.multi_load([open(a_path), open(b_path)])
430
431		self.assertEqual(cnf["name"], a["name"])
432		self.assertEqual(cnf["a"], b["a"])
433		self.assertEqual(cnf["b"]["b"], b["b"]["b"])
434		self.assertEqual(cnf["b"]["c"], a["b"]["c"])
435		self.assertEqual(cnf["b"]["d"], b["b"]["d"])
436
437		def test_30_multi_load__ignore_missing(self):
438		null_cntnr = TT.to_container()
439		cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
440		assert not os.path.exists(cpath)
441
442		self.assertEqual(TT.multi_load([cpath], ac_parser="ini",
443		ignore_missing=True),
444		null_cntnr)
445
446		def test_40_multi_load__templates(self):
447		if not anyconfig.template.SUPPORTED:
448		return
449
450		a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
451		b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
452
453		ma = TT.to_container(a, ac_merge=TT.MS_DICTS)
454		ma.update(b)
455
456		a_path = os.path.join(self.workdir, "a.yml")
457		b_path = os.path.join(self.workdir, "b.yml")
458		g_path = os.path.join(self.workdir, "*.yml")
459
460		open(a_path, 'w').write(CNF_TMPL_1)
461		open(b_path, 'w').write(CNF_TMPL_2)
462
463		a0 = TT.multi_load(g_path, ac_merge=TT.MS_DICTS, ac_template=True,
464		ac_context=ma)
465		a02 = TT.multi_load([g_path, b_path], ac_merge=TT.MS_DICTS,
466		ac_template=True, ac_context=ma)
467
468		self.assertEqual(a0["name"], a["name"])
469		self.assertEqual(a0["a"], b["a"])
470		self.assertEqual(a0["b"]["b"], b["b"]["b"])
471		self.assertEqual(a0["b"]["c"], a["b"]["c"])
472		self.assertEqual(a0["b"]["d"], b["b"]["d"])
473
474		self.assertEqual(a02["name"], a["name"])
475		self.assertEqual(a02["a"], b["a"])
476		self.assertEqual(a02["b"]["b"], b["b"]["b"])
477		self.assertEqual(a02["b"]["c"], a["b"]["c"])
478		self.assertEqual(a02["b"]["d"], b["b"]["d"])
479
480
481		class Test_50_load_and_dump(unittest.TestCase):
482
483		cnf = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))
484
485		def setUp(self):
486		self.workdir = anyconfig.tests.common.setup_workdir()
487
488		def tearDown(self):
489		anyconfig.tests.common.cleanup_workdir(self.workdir)
490
491		def test_30_dump_and_load(self):
492		a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
493		b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
494
495		a_path = os.path.join(self.workdir, "a.json")
496		b_path = os.path.join(self.workdir, "b.json")
497
498		TT.dump(a, a_path)
499		self.assertTrue(os.path.exists(a_path))
500
501		TT.dump(b, b_path)
502		self.assertTrue(os.path.exists(b_path))
503
504		a1 = TT.load(a_path)
505
506		self.assertEqual(a1["name"], a["name"])
507		self.assertEqual(a1["a"], a["a"])
508		self.assertEqual(a1["b"]["b"], a["b"]["b"])
509		self.assertEqual(a1["b"]["c"], a["b"]["c"])
510
511		a2 = TT.load(os.path.join(self.workdir, '*.json'))
512
513		self.assertEqual(a2["name"], a["name"])
514		self.assertEqual(a2["a"], b["a"])
515		self.assertEqual(a2["b"]["b"], [1, 2, 3, 4, 5])
516		self.assertEqual(a2["b"]["c"], a["b"]["c"])
517		self.assertEqual(a2["b"]["d"], b["b"]["d"])
518
519		a3 = TT.load([a_path, b_path])
520
521		self.assertEqual(a3["name"], a["name"])
522		self.assertEqual(a3["a"], b["a"])
523		self.assertEqual(a3["b"]["b"], [1, 2, 3, 4, 5])
524		self.assertEqual(a3["b"]["c"], a["b"]["c"])
525		self.assertEqual(a3["b"]["d"], b["b"]["d"])
526
527		def test_31_dump_and_load__to_from_stream(self):
528		cnf = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
529		cpath = os.path.join(self.workdir, "a.json")
530
531		with open(cpath, 'w') as strm:
532		TT.dump(cnf, strm)
533
534		self.assertTrue(os.path.exists(cpath))
535
536		with open(cpath, 'r') as strm:
537		cnf1 = TT.load(strm, ac_parser="json")
538
539		self.assertTrue(dicts_equal(cnf, cnf1),
540		"cnf vs. cnf1: %s\n\n%s" % (str(cnf), str(cnf1)))
541
542		def test_32_dump_and_load__w_options(self):
543		a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
544		b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
545
546		a_path = os.path.join(self.workdir, "a.json")
547		b_path = os.path.join(self.workdir, "b.json")
548
549		TT.dump(a, a_path, indent=2)
550		self.assertTrue(os.path.exists(a_path))
551
552		TT.dump(b, b_path, indent=2)
553		self.assertTrue(os.path.exists(b_path))
554
555		a1 = TT.load(a_path, parse_int=int)
556
557		self.assertEqual(a1["name"], a["name"])
558		self.assertEqual(a1["a"], a["a"])
559		self.assertEqual(a1["b"]["b"], a["b"]["b"])
560		self.assertEqual(a1["b"]["c"], a["b"]["c"])
561
562		a2 = TT.load(os.path.join(self.workdir, '*.json'), parse_int=int)
563
564		self.assertEqual(a2["name"], a["name"])
565		self.assertEqual(a2["a"], b["a"])
566		self.assertEqual(a2["b"]["b"], [1, 2, 3, 4, 5])
567		self.assertEqual(a2["b"]["c"], a["b"]["c"])
568		self.assertEqual(a2["b"]["d"], b["b"]["d"])
569
570		a3 = TT.load([a_path, b_path], parse_int=int)
571
572		self.assertEqual(a3["name"], a["name"])
573		self.assertEqual(a3["a"], b["a"])
574		self.assertEqual(a3["b"]["b"], [1, 2, 3, 4, 5])
575		self.assertEqual(a3["b"]["c"], a["b"]["c"])
576		self.assertEqual(a3["b"]["d"], b["b"]["d"])
577
578		def test_34_load__ignore_missing(self):
579		null_cntnr = TT.to_container()
580		cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
581		assert not os.path.exists(cpath)
582
583		self.assertEqual(TT.load([cpath], ac_parser="ini",
584		ignore_missing=True),
585		null_cntnr)
586
587	View Code Duplication	def test_36_load_w_validation(self):
		0 ignored issues – show Duplication introduced 2016-04-20 02:06 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
588		cnf_path = os.path.join(self.workdir, "cnf.json")
589		scm_path = os.path.join(self.workdir, "scm.json")
590		TT.dump(CNF_0, cnf_path)
591		TT.dump(SCM_0, scm_path)
592
593		cnf_2 = TT.load(cnf_path, ac_context={}, ac_validate=scm_path)
594
595		self.assertEqual(cnf_2["name"], CNF_0["name"])
596		self.assertEqual(cnf_2["a"], CNF_0["a"])
597		self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
598		self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])
599
600	View Code Duplication	def test_38_load_w_validation_yaml(self):
		0 ignored issues – show Duplication introduced 2016-04-20 02:06 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
601		cnf_path = os.path.join(self.workdir, "cnf.yml")
602		scm_path = os.path.join(self.workdir, "scm.yml")
603		TT.dump(CNF_0, cnf_path)
604		TT.dump(SCM_0, scm_path)
605
606		cnf_2 = TT.load(cnf_path, ac_context={}, ac_validate=scm_path)
607
608		self.assertEqual(cnf_2["name"], CNF_0["name"])
609		self.assertEqual(cnf_2["a"], CNF_0["a"])
610		self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
611		self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])
612
613		def test_39_single_load__w_validation(self):
614		(cnf, scm) = (CNF_0, SCM_0)
615		cpath = os.path.join(self.workdir, "cnf.json")
616		spath = os.path.join(self.workdir, "scm.json")
617
618		TT.dump(cnf, cpath)
619		TT.dump(scm, spath)
620
621		cnf1 = TT.single_load(cpath, ac_schema=spath)
622		self.assertTrue(dicts_equal(cnf, cnf1), str(cnf1))
623
624		# vim:sw=4:ts=4:et:
625

ssato / python-anyconfig

Push — master ( bff2ab...5dc771 )

Test_30_single_load.setUp() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like