Quelle test_config.py Sprache: Python

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
import sys
import unittest
from pathlib import Path

from mozfile.mozfile import NamedTemporaryFile
from mozunit import main

from mach.config import (
    BooleanType,
    ConfigException,
    ConfigSettings,
    IntegerType,
    PathType,
    PositiveIntegerType,
    StringType,
)
from mach.decorators import SettingsProvider

CONFIG1 = r"""
[foo]

bar = bar_value
baz = /baz/foo.c
"""

CONFIG2 = r"""
[foo]

bar = value2
"""

@SettingsProvider
class Provider1:
    config_settings = [
        ("foo.bar", StringType, "desc"),
        ("foo.baz", PathType, "desc"),
    ]

@SettingsProvider
class ProviderDuplicate:
    config_settings = [
        ("dupesect.foo", StringType, "desc"),
        ("dupesect.foo", StringType, "desc"),
    ]

@SettingsProvider
class Provider2:
    config_settings = [
        ("a.string", StringType, "desc"),
        ("a.boolean", BooleanType, "desc"),
        ("a.pos_int", PositiveIntegerType, "desc"),
        ("a.int", IntegerType, "desc"),
        ("a.path", PathType, "desc"),
    ]

@SettingsProvider
class Provider3:
    @classmethod
    def config_settings(cls):
        return [
            ("a.string", "string", "desc"),
            ("a.boolean", "boolean", "desc"),
            ("a.pos_int", "pos_int", "desc"),
            ("a.int", "int", "desc"),
            ("a.path", "path", "desc"),
        ]

@SettingsProvider
class Provider4:
    config_settings = [
        ("foo.abc", StringType, "desc", "a", {"choices": set("abc")}),
        ("foo.xyz", StringType, "desc", "w", {"choices": set("xyz")}),
    ]

@SettingsProvider
class Provider5:
    config_settings = [
        ("foo.*", "string", "desc"),
        ("foo.bar", "string", "desc"),
    ]

class TestConfigSettings(unittest.TestCase):
    def test_empty(self):
        s = ConfigSettings()

        self.assertEqual(len(s), 0)
        self.assertNotIn("foo", s)

    def test_duplicate_option(self):
        s = ConfigSettings()

        with self.assertRaises(ConfigException):
            s.register_provider(ProviderDuplicate)

    def test_simple(self):
        s = ConfigSettings()
        s.register_provider(Provider1)

        self.assertEqual(len(s), 1)
        self.assertIn("foo", s)

        foo = s["foo"]
        foo = s.foo

        self.assertEqual(len(foo), 0)
        self.assertEqual(len(foo._settings), 2)

        self.assertIn("bar", foo._settings)
        self.assertIn("baz", foo._settings)

        self.assertNotIn("bar", foo)
        foo["bar"] = "value1"
        self.assertIn("bar", foo)

        self.assertEqual(foo["bar"], "value1")
        self.assertEqual(foo.bar, "value1")

    def test_assignment_validation(self):
        s = ConfigSettings()
        s.register_provider(Provider2)

        a = s.a

        # Assigning an undeclared setting raises.
        exc_type = AttributeError if sys.version_info < (3, 0) else KeyError
        with self.assertRaises(exc_type):
            a.undefined = True

        with self.assertRaises(KeyError):
            a["undefined"] = True

        # Basic type validation.
        a.string = "foo"
        a.string = "foo"

        with self.assertRaises(TypeError):
            a.string = False

        a.boolean = True
        a.boolean = False

        with self.assertRaises(TypeError):
            a.boolean = "foo"

        a.pos_int = 5
        a.pos_int = 0

        with self.assertRaises(ValueError):
            a.pos_int = -1

        with self.assertRaises(TypeError):
            a.pos_int = "foo"

        a.int = 5
        a.int = 0
        a.int = -5

        with self.assertRaises(TypeError):
            a.int = 1.24

        with self.assertRaises(TypeError):
            a.int = "foo"

        a.path = "/home/gps"
        a.path = "foo.c"
        a.path = "foo/bar"
        a.path = "./foo"

    def retrieval_type_helper(self, provider):
        s = ConfigSettings()
        s.register_provider(provider)

        a = s.a

        a.string = "foo"
        a.boolean = True
        a.pos_int = 12
        a.int = -4
        a.path = "./foo/bar"

        self.assertIsInstance(a.string, (str,))
        self.assertIsInstance(a.boolean, bool)
        self.assertIsInstance(a.pos_int, int)
        self.assertIsInstance(a.int, int)
        self.assertIsInstance(a.path, (str,))

    def test_retrieval_type(self):
        self.retrieval_type_helper(Provider2)
        self.retrieval_type_helper(Provider3)

    def test_choices_validation(self):
        s = ConfigSettings()
        s.register_provider(Provider4)

        foo = s.foo
        foo.abc
        with self.assertRaises(ValueError):
            foo.xyz

        with self.assertRaises(ValueError):
            foo.abc = "e"

        foo.abc = "b"
        foo.xyz = "y"

    def test_wildcard_options(self):
        s = ConfigSettings()
        s.register_provider(Provider5)

        foo = s.foo

        self.assertIn("*", foo._settings)
        self.assertNotIn("*", foo)

        foo.baz = "value1"
        foo.bar = "value2"

        self.assertIn("baz", foo)
        self.assertEqual(foo.baz, "value1")

        self.assertIn("bar", foo)
        self.assertEqual(foo.bar, "value2")

    def test_file_reading_single(self):
        temp = NamedTemporaryFile(mode="wt")
        temp.write(CONFIG1)
        temp.flush()

        s = ConfigSettings()
        s.register_provider(Provider1)

        s.load_file(Path(temp.name))

        self.assertEqual(s.foo.bar, "bar_value")

    def test_file_reading_multiple(self):
        """Loading multiple files has proper overwrite behavior."""
        temp1 = NamedTemporaryFile(mode="wt")
        temp1.write(CONFIG1)
        temp1.flush()

        temp2 = NamedTemporaryFile(mode="wt")
        temp2.write(CONFIG2)
        temp2.flush()

        s = ConfigSettings()
        s.register_provider(Provider1)

        s.load_files([Path(temp1.name), Path(temp2.name)])

        self.assertEqual(s.foo.bar, "value2")

    def test_file_reading_missing(self):
        """Missing files should silently be ignored."""

        s = ConfigSettings()

        s.load_file("/tmp/foo.ini")

    def test_file_writing(self):
        s = ConfigSettings()
        s.register_provider(Provider2)

        s.a.string = "foo"
        s.a.boolean = False

        temp = NamedTemporaryFile("wt")
        s.write(temp)
        temp.flush()

        s2 = ConfigSettings()
        s2.register_provider(Provider2)

        s2.load_file(temp.name)

        self.assertEqual(s.a.string, s2.a.string)
        self.assertEqual(s.a.boolean, s2.a.boolean)

if __name__ == "__main__":
    main()

quality95%

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.