Squashed 'kiauh/core/submodules/simple_config_parser/' content from commit 188dd1f

git-subtree-dir: kiauh/core/submodules/simple_config_parser
git-subtree-split: 188dd1ffd80bf72a2dc6075147ddc9339b059c4b

tests/features/internal_state/test_content_handling.py

@@ -0,0 +1,95 @@
+import pytest
+
+from src.simple_config_parser.simple_config_parser import SimpleConfigParser
+
+
+@pytest.fixture
+def parser():
+    parser = SimpleConfigParser()
+    parser._header = ["header1\n", "header2\n"]
+    parser._config = {
+        "section1": {
+            "_raw": "[section1]\n",
+            "body": [
+                {
+                    "_raw": "option1: value1\n",
+                    "_raw_value": "value1\n",
+                    "is_multiline": False,
+                    "option": "option1",
+                    "value": "value1",
+                },
+                {
+                    "_raw": "option2: value2\n",
+                    "_raw_value": "value2\n",
+                    "is_multiline": False,
+                    "option": "option2",
+                    "value": "value2",
+                },
+            ],
+        },
+        "section2": {
+            "_raw": "[section2]\n",
+            "body": [
+                {
+                    "_raw": "option3: value3\n",
+                    "_raw_value": "value3\n",
+                    "is_multiline": False,
+                    "option": "option3",
+                    "value": "value3",
+                },
+            ],
+        },
+        "section3": {
+            "_raw": "[section3]\n",
+            "body": [
+                {
+                    "_raw": "option4:\n",
+                    "_raw_value": ["    value4\n", "    value5\n", "    value6\n"],
+                    "is_multiline": True,
+                    "option": "option4",
+                    "value": ["value4", "value5", "value6"],
+                },
+            ],
+        },
+    }
+    return parser
+
+
+def test_construct_content(parser):
+    content = parser._construct_content()
+    assert (
+        content == "header1\nheader2\n"
+        "[section1]\n"
+        "option1: value1\n"
+        "option2: value2\n"
+        "[section2]\n"
+        "option3: value3\n"
+        "[section3]\n"
+        "option4:\n"
+        "    value4\n"
+        "    value5\n"
+        "    value6\n"
+    )
+
+
+def test_construct_content_no_header(parser):
+    parser._header = None
+    content = parser._construct_content()
+    assert (
+        content == "[section1]\n"
+        "option1: value1\n"
+        "option2: value2\n"
+        "[section2]\n"
+        "option3: value3\n"
+        "[section3]\n"
+        "option4:\n"
+        "    value4\n"
+        "    value5\n"
+        "    value6\n"
+    )
+
+
+def test_construct_content_no_sections(parser):
+    parser._config = {}
+    content = parser._construct_content()
+    assert content == "".join(parser._header)

tests/features/internal_state/test_internal_state_changes.py

@@ -0,0 +1,83 @@
+import pytest
+
+from src.simple_config_parser.simple_config_parser import (
+    DuplicateOptionError,
+    DuplicateSectionError,
+    SimpleConfigParser,
+)
+
+
+@pytest.fixture
+def parser():
+    return SimpleConfigParser()
+
+
+class TestInternalStateChanges:
+    @pytest.mark.parametrize(
+        "given", ["dummy_section", "dummy_section 2", "another_section"]
+    )
+    def test_ensure_section_body_exists(self, parser, given):
+        parser._config = {}
+        parser.section_name = given
+        parser._ensure_section_body_exists()
+
+        assert parser._config[given] is not None
+        assert parser._config[given]["body"] == []
+
+    def test_add_option_to_section_body(self):
+        pass
+
+    @pytest.mark.parametrize(
+        "given", ["dummy_section", "dummy_section 2", "another_section\n"]
+    )
+    def test_store_internal_state_section(self, parser, given):
+        parser._store_internal_state_section(given, given)
+
+        assert parser._all_sections == [given]
+        assert parser._config[given]["body"] == []
+        assert parser._config[given]["_raw"] == given
+
+    def test_duplicate_section_error(self, parser):
+        section_name = "dummy_section"
+        parser._all_sections = [section_name]
+
+        with pytest.raises(DuplicateSectionError) as excinfo:
+            parser._store_internal_state_section(section_name, section_name)
+            message = f"Section '{section_name}' is defined more than once"
+            assert message in str(excinfo.value)
+
+        # Check that the internal state of the parser is correct
+        assert parser.in_option_block is False
+        assert parser.section_name == ""
+        assert parser._all_sections == [section_name]
+
+    @pytest.mark.parametrize(
+        "given_name, given_value, given_raw_value",
+        [("dummyoption", "dummyvalue", "dummyvalue\n")],
+    )
+    def test_store_internal_state_option(
+        self, parser, given_name, given_value, given_raw_value
+    ):
+        parser.section_name = "dummy_section"
+        parser._store_internal_state_option(given_name, given_value, given_raw_value)
+
+        assert parser._all_options[parser.section_name] == {given_name: given_value}
+
+        new_option = {
+            "is_multiline": False,
+            "option": given_name,
+            "value": given_value,
+            "_raw": given_raw_value,
+        }
+        assert parser._config[parser.section_name]["body"] == [new_option]
+
+    def test_duplicate_option_error(self, parser):
+        option_name = "dummyoption"
+        value = "dummyvalue"
+        parser.section_name = "dummy_section"
+        parser._all_options = {parser.section_name: {option_name: value}}
+
+        with pytest.raises(DuplicateOptionError) as excinfo:
+            parser._store_internal_state_option(option_name, value, value)
+            message = f"Option '{option_name}' in section '{parser.section_name}' is defined more than once"
+            assert message in str(excinfo.value)

tests/features/line_parsing/data/case_parse_comment.py

@@ -0,0 +1,6 @@
+testcases = [
+    "# comment # 1",
+    "; comment # 2",
+    "    ; indented comment",
+    "        # another indented comment",
+]

tests/features/line_parsing/data/case_parse_option.py

@@ -0,0 +1,19 @@
+testcases = [
+    ("option: value", "option", "value"),
+    ("option : value", "option", "value"),
+    ("option :value", "option", "value"),
+    ("option= value", "option", "value"),
+    ("option = value", "option", "value"),
+    ("option =value", "option", "value"),
+    ("option: value\n", "option", "value"),
+    ("option: value # inline comment", "option", "value"),
+    ("option: value # inline comment\n", "option", "value"),
+    ("description: homing!", "description", "homing!"),
+    ("description: inline macro :-)", "description", "inline macro :-)"),
+    ("path: %GCODES_DIR%", "path", "%GCODES_DIR%"),
+    (
+        "serial = /dev/serial/by-id/<your-mcu-id>",
+        "serial",
+        "/dev/serial/by-id/<your-mcu-id>",
+    ),
+]

tests/features/line_parsing/data/case_parse_section.py

@@ -0,0 +1,6 @@
+testcases = [
+    ("[test_section]", "test_section"),
+    ("[test_section two]", "test_section two"),
+    ("[section1] # inline comment", "section1"),
+    ("[section2] ; second comment", "section2"),
+]

tests/features/line_parsing/test_line_parsing.py

@@ -0,0 +1,92 @@
+import pytest
+from data.case_parse_comment import testcases as case_parse_comment
+from data.case_parse_option import testcases as case_parse_option
+from data.case_parse_section import testcases as case_parse_section
+
+from src.simple_config_parser.simple_config_parser import (
+    Option,
+    SimpleConfigParser,
+)
+
+
+@pytest.fixture
+def parser():
+    return SimpleConfigParser()
+
+
+class TestLineParsing:
+    @pytest.mark.parametrize("given, expected", [*case_parse_section])
+    def test_parse_section(self, parser, given, expected):
+        parser._parse_section(given)
+
+        # Check that the internal state of the parser is correct
+        assert parser.section_name == expected
+        assert parser.in_option_block is False
+        assert parser._all_sections == [expected]
+        assert parser._config[expected]["_raw"] == given
+        assert parser._config[expected]["body"] == []
+
+    @pytest.mark.parametrize(
+        "given, expected_option, expected_value", [*case_parse_option]
+    )
+    def test_parse_option(self, parser, given, expected_option, expected_value):
+        section_name = "test_section"
+        parser.section_name = section_name
+        parser._parse_option(given)
+
+        # Check that the internal state of the parser is correct
+        assert parser.section_name == section_name
+        assert parser.in_option_block is False
+        assert parser._all_options[section_name][expected_option] == expected_value
+
+        section_option = parser._config[section_name]["body"][0]
+        assert section_option["option"] == expected_option
+        assert section_option["value"] == expected_value
+        assert section_option["_raw"] == given
+
+    @pytest.mark.parametrize(
+        "option, next_line",
+        [("gcode", "next line"), ("gcode", "    {{% some jinja template %}}")],
+    )
+    def test_parse_multiline_option(self, parser, option, next_line):
+        parser.section_name = "dummy_section"
+        parser.in_option_block = True
+        parser._add_option_to_section_body(option, "", option)
+        parser._parse_multiline_option(option, next_line)
+        cleaned_next_line = next_line.strip().strip("\n")
+
+        assert parser._all_options[parser.section_name] is not None
+        assert parser._all_options[parser.section_name][option] == [cleaned_next_line]
+
+        expected_option: Option = {
+            "is_multiline": True,
+            "option": option,
+            "value": [cleaned_next_line],
+            "_raw": option,
+            "_raw_value": [next_line],
+        }
+        assert parser._config[parser.section_name]["body"] == [expected_option]
+
+    @pytest.mark.parametrize("given", [*case_parse_comment])
+    def test_parse_comment(self, parser, given):
+        parser.section_name = "dummy_section"
+        parser._parse_comment(given)
+
+        # internal state checks after parsing
+        assert parser.in_option_block is False
+
+        expected_option = {
+            "is_multiline": False,
+            "_raw": given,
+            "option": "",
+            "value": "",
+        }
+        assert parser._config[parser.section_name]["body"] == [expected_option]
+
+    @pytest.mark.parametrize("given", ["# header line", "; another header line"])
+    def test_parse_header_comment(self, parser, given):
+        parser.section_name = ""
+        parser._parse_comment(given)
+
+        assert parser.in_option_block is False
+        assert parser._header == [given]

tests/features/line_type_detection/data/case_line_is_comment.py

@@ -0,0 +1,9 @@
+testcases = [
+    ("# an arbitrary comment", True),
+    ("; another arbitrary comment", True),
+    ("  ; indented comment", True),
+    ("  # indented comment", True),
+    ("not_a: comment", False),
+    ("also_not_a= comment", False),
+    ("[definitely_not_a_comment]", False),
+]

tests/features/line_type_detection/data/case_line_is_empty.py

@@ -0,0 +1,9 @@
+testcases = [
+    ("", True),
+    (" ", True),
+    ("not empty", False),
+    ("  # indented comment", False),
+    ("not: empty", False),
+    ("also_not= empty", False),
+    ("[definitely_not_empty]", False),
+]

tests/features/line_type_detection/data/case_line_is_multiline_option.py

@@ -0,0 +1,17 @@
+testcases = [
+    ("valid_option:", True),
+    ("valid_option:\n", True),
+    ("valid_option: ; inline comment", True),
+    ("valid_option: # inline comment", True),
+    ("valid_option :", True),
+    ("valid_option=", True),
+    ("valid_option= ", True),
+    ("valid_option =", True),
+    ("valid_option = ", True),
+    ("invalid_option ==", False),
+    ("invalid_option :=", False),
+    ("not_a_valid_option", False),
+    ("", False),
+    ("# that's a comment", False),
+    ("; that's a comment", False),
+]

tests/features/line_type_detection/data/case_line_is_option.py

@@ -0,0 +1,30 @@
+testcases = [
+    ("valid_option: value", True),
+    ("valid_option: value\n", True),
+    ("valid_option: value ; inline comment", True),
+    ("valid_option: value # inline comment", True),
+    ("valid_option: value # inline comment\n", True),
+    ("valid_option : value", True),
+    ("valid_option :value", True),
+    ("valid_option= value", True),
+    ("valid_option = value", True),
+    ("valid_option =value", True),
+    ("invalid_option:", False),
+    ("invalid_option=", False),
+    ("invalid_option:: value", False),
+    ("invalid_option :: value", False),
+    ("invalid_option ::value", False),
+    ("invalid_option== value", False),
+    ("invalid_option == value", False),
+    ("invalid_option ==value", False),
+    ("invalid_option:= value", False),
+    ("invalid_option := value", False),
+    ("invalid_option :=value", False),
+    ("[that_is_a_section]", False),
+    ("[that_is_section two]", False),
+    ("not_a_valid_option", False),
+    ("description: homing!", True),
+    ("description: inline macro :-)", True),
+    ("path: %GCODES_DIR%", True),
+    ("serial = /dev/serial/by-id/<your-mcu-id>", True),
+]

tests/features/line_type_detection/data/case_line_is_section.py

@@ -0,0 +1,6 @@
+testcases = [
+    ("[example_section]", True),
+    ("[example_section two]", True),
+    ("not_a_valid_section", False),
+    ("section: invalid", False),
+]

tests/features/line_type_detection/test_line_type_detection.py

@@ -0,0 +1,37 @@
+import pytest
+from data.case_line_is_comment import testcases as case_line_is_comment
+from data.case_line_is_empty import testcases as case_line_is_empty
+from data.case_line_is_multiline_option import (
+    testcases as case_line_is_multiline_option,
+)
+from data.case_line_is_option import testcases as case_line_is_option
+from data.case_line_is_section import testcases as case_line_is_section
+
+from src.simple_config_parser.simple_config_parser import SimpleConfigParser
+
+
+@pytest.fixture
+def parser():
+    return SimpleConfigParser()
+
+
+class TestLineTypeDetection:
+    @pytest.mark.parametrize("given, expected", [*case_line_is_section])
+    def test_line_is_section(self, parser, given, expected):
+        assert parser._is_section(given) is expected
+
+    @pytest.mark.parametrize("given, expected", [*case_line_is_option])
+    def test_line_is_option(self, parser, given, expected):
+        assert parser._is_option(given) is expected
+
+    @pytest.mark.parametrize("given, expected", [*case_line_is_multiline_option])
+    def test_line_is_multiline_option(self, parser, given, expected):
+        assert parser._is_multiline_option(given) is expected
+
+    @pytest.mark.parametrize("given, expected", [*case_line_is_comment])
+    def test_line_is_comment(self, parser, given, expected):
+        assert parser._is_comment(given) is expected
+
+    @pytest.mark.parametrize("given, expected", [*case_line_is_empty])
+    def test_line_is_empty(self, parser, given, expected):
+        assert parser._is_empty_line(given) is expected

tests/features/public_api/test_public_api.py

@@ -0,0 +1,196 @@
+import pytest
+
+from src.simple_config_parser.simple_config_parser import (
+    DuplicateSectionError,
+    NoOptionError,
+    NoSectionError,
+    SimpleConfigParser,
+)
+
+
+@pytest.fixture
+def parser():
+    return SimpleConfigParser()
+
+
+class TestPublicAPI:
+    def test_has_section(self, parser):
+        parser._all_sections = ["section1"]
+        assert parser.has_section("section1") is True
+
+    @pytest.mark.parametrize("section", ["section1", "section2", "section three"])
+    def test_add_section(self, parser, section):
+        parser.add_section(section)
+
+        assert section in parser._all_sections
+        assert parser._all_options[section] == {}
+
+        cfg_section = {"_raw": f"\n[{section}]\n", "body": []}
+        assert parser._config[section] == cfg_section
+
+    @pytest.mark.parametrize("section", ["section1", "section2", "section three"])
+    def test_add_existing_section(self, parser, section):
+        parser._all_sections = [section]
+
+        with pytest.raises(DuplicateSectionError):
+            parser.add_section(section)
+
+        assert parser._all_sections == [section]
+
+    @pytest.mark.parametrize("section", ["section1", "section2", "section three"])
+    def test_remove_section(self, parser, section):
+        parser.add_section(section)
+        parser.remove_section(section)
+
+        assert section not in parser._all_sections
+        assert section not in parser._all_options
+        assert section not in parser._config
+
+    @pytest.mark.parametrize("section", ["section1", "section2", "section three"])
+    def test_remove_non_existing_section(self, parser, section):
+        with pytest.raises(NoSectionError):
+            parser.remove_section(section)
+
+    def test_get_all_sections(self, parser):
+        parser.add_section("section1")
+        parser.add_section("section2")
+        parser.add_section("section three")
+
+        assert parser.sections() == ["section1", "section2", "section three"]
+
+    def test_has_option(self, parser):
+        parser.add_section("section1")
+        parser.set("section1", "option1", "value1")
+
+        assert parser.has_option("section1", "option1") is True
+
+    @pytest.mark.parametrize(
+        "section, option, value",
+        [
+            ("section1", "option1", "value1"),
+            ("section2", "option2", "value2"),
+            ("section three", "option3", "value three"),
+        ],
+    )
+    def test_set_new_option(self, parser, section, option, value):
+        parser.add_section(section)
+        parser.set(section, option, value)
+
+        assert section in parser._all_sections
+        assert option in parser._all_options[section]
+        assert parser._all_options[section][option] == value
+
+        assert parser._config[section]["body"][0]["is_multiline"] is False
+        assert parser._config[section]["body"][0]["option"] == option
+        assert parser._config[section]["body"][0]["value"] == value
+        assert parser._config[section]["body"][0]["_raw"] == f"{option}: {value}\n"
+
+    def test_set_existing_option(self, parser):
+        section, option, value1, value2 = "section1", "option1", "value1", "value2"
+
+        parser.add_section(section)
+        parser.set(section, option, value1)
+        parser.set(section, option, value2)
+
+        assert parser._all_options[section][option] == value2
+        assert parser._config[section]["body"][0]["is_multiline"] is False
+        assert parser._config[section]["body"][0]["option"] == option
+        assert parser._config[section]["body"][0]["value"] == value2
+        assert parser._config[section]["body"][0]["_raw"] == f"{option}: {value2}\n"
+
+    def test_set_new_multiline_option(self, parser):
+        section, option, value = "section1", "option1", "value1\nvalue2\nvalue3"
+
+        parser.add_section(section)
+        parser.set(section, option, value)
+
+        assert parser._config[section]["body"][0]["is_multiline"] is True
+        assert parser._config[section]["body"][0]["option"] == option
+
+        values = ["value1", "value2", "value3"]
+        raw_values = ["  value1\n", "  value2\n", "  value3\n"]
+        assert parser._config[section]["body"][0]["value"] == values
+        assert parser._config[section]["body"][0]["_raw"] == f"{option}:\n"
+        assert parser._config[section]["body"][0]["_raw_value"] == raw_values
+        assert parser._all_options[section][option] == values
+
+    def test_set_option_of_non_existing_section(self, parser):
+        with pytest.raises(NoSectionError):
+            parser.set("section1", "option1", "value1")
+
+    def test_remove_option(self, parser):
+        section, option, value = "section1", "option1", "value1"
+
+        parser.add_section(section)
+        parser.set(section, option, value)
+        parser.remove_option(section, option)
+
+        assert option not in parser._all_options[section]
+        assert option not in parser._config[section]["body"]
+
+    def test_remove_non_existing_option(self, parser):
+        parser.add_section("section1")
+        with pytest.raises(NoOptionError):
+            parser.remove_option("section1", "option1")
+
+    def test_remove_option_of_non_existing_section(self, parser):
+        with pytest.raises(NoSectionError):
+            parser.remove_option("section1", "option1")
+
+    def test_get_option(self, parser):
+        parser.add_section("section1")
+        parser.add_section("section2")
+        parser.set("section1", "option1", "value1")
+        parser.set("section2", "option2", "value2")
+        parser.set("section2", "option3", "value two")
+
+        assert parser.get("section1", "option1") == "value1"
+        assert parser.get("section2", "option2") == "value2"
+        assert parser.get("section2", "option3") == "value two"
+
+    def test_get_option_of_non_existing_section(self, parser):
+        with pytest.raises(NoSectionError):
+            parser.get("section1", "option1")
+
+    def test_get_option_of_non_existing_option(self, parser):
+        parser.add_section("section1")
+        with pytest.raises(NoOptionError):
+            parser.get("section1", "option1")
+
+    def test_get_option_fallback(self, parser):
+        parser.add_section("section1")
+        assert parser.get("section1", "option1", "fallback_value") == "fallback_value"
+
+    def test_get_options(self, parser):
+        parser.add_section("section1")
+        parser.set("section1", "option1", "value1")
+        parser.set("section1", "option2", "value2")
+        parser.set("section1", "option3", "value3")
+
+        options = {"option1": "value1", "option2": "value2", "option3": "value3"}
+        assert parser.options("section1") == options
+
+    def test_get_option_as_int(self, parser):
+        parser.add_section("section1")
+        parser.set("section1", "option1", "1")
+
+        option = parser.getint("section1", "option1")
+        assert isinstance(option, int) is True
+
+    def test_get_option_as_float(self, parser):
+        parser.add_section("section1")
+        parser.set("section1", "option1", "1.234")
+
+        option = parser.getfloat("section1", "option1")
+        assert isinstance(option, float) is True
+
+    @pytest.mark.parametrize(
+        "value",
+        ["True", "true", "on", "1", "yes", "False", "false", "off", "0", "no"],
+    )
+    def test_get_option_as_boolean(self, parser, value):
+        parser.add_section("section1")
+        parser.set("section1", "option1", value)
+
+        option = parser.getboolean("section1", "option1")
+        assert isinstance(option, bool) is True