testing coverage

Author: e3rd

.github/workflows/run-unittest.yml

@@ -15,4 +15,4 @@ jobs:
       - name: Install dependencies
         run: pip install -e .
       - name: Run tests
-        run: python3 tests.py      
+        run: python3 tests/tests.py

README.md

@@ -1,5 +1,6 @@
 # Mininterface – access to GUI, TUI, CLI and config files
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![Build Status](https://github.com/CZ-NIC/mininterface/actions/workflows/run-unittest.yml/badge.svg)](https://github.com/CZ-NIC/mininterface/actions)
 
 Write the program core, do not bother with the input/output.
 

mininterface/GuiInterface.py

@@ -11,7 +11,7 @@
 
 
 from .common import InterfaceNotAvailable
-from .auxiliary import FormDict, RedirectText, dataclass_to_dict, dict_to_dataclass, recursive_set_focus, normalize_types
+from .auxiliary import FormDict, RedirectText, config_to_dict, config_from_dict, recursive_set_focus, normalize_types
 from .Mininterface import Cancelled, ConfigInstance, Mininterface
 
 
@@ -46,11 +46,11 @@ def ask(self, text: str) -> str:
 
     def ask_args(self) -> ConfigInstance:
         """ Display a window form with all parameters. """
-        params_ = dataclass_to_dict(self.args, self.descriptions)
+        params_ = config_to_dict(self.args, self.descriptions)
 
         # fetch the dict of dicts values from the form back to the namespace of the dataclasses
         data = self.window.run_dialog(params_)
-        dict_to_dataclass(self.args, data)
+        config_from_dict(self.args, data)
         return self.args
 
     def ask_form(self, args: FormDict, title: str = "") -> dict:

mininterface/TuiInterface.py

@@ -1,5 +1,5 @@
 from pprint import pprint
-from .auxiliary import ConfigInstance, FormDict, dataclass_to_dict, dict_to_dataclass
+from .auxiliary import ConfigInstance, FormDict, config_to_dict, config_from_dict
 from .Mininterface import Cancelled, Mininterface
 
 

mininterface/auxiliary.py

@@ -41,9 +41,10 @@ def set_error_text(self, s):
 """ Nested form that can have descriptions (through Value) instead of plain values. """
 
 
-def dataclass_to_dict(args: ConfigInstance, descr: dict, _path="") -> FormDict:
+def config_to_dict(args: ConfigInstance, descr: dict, _path="") -> FormDict:
     """ Convert the dataclass produced by tyro into dict of dicts. """
     main = ""
+    # print(args)# TODO
     params = {main: {}} if not _path else {}
     for param, val in vars(args).items():
         annotation = None
@@ -64,46 +65,66 @@ def dataclass_to_dict(args: ConfigInstance, descr: dict, _path="") -> FormDict:
                 logger.warn(f"Annotation {wanted_type} of `{param}` not supported by Mininterface."
                             "None converted to False.")
         if hasattr(val, "__dict__"):  # nested config hierarchy
-            params[param] = dataclass_to_dict(val, descr, _path=f"{_path}{param}.")
+            params[param] = config_to_dict(val, descr, _path=f"{_path}{param}.")
         elif not _path:  # scalar value in root
             params[main][param] = Value(val, descr.get(param), annotation)
         else:  # scalar value in nested
             params[param] = Value(val, descr.get(f"{_path}{param}"), annotation)
+    # print(params) # TODO
     return params
 
 
 def normalize_types(origin: FormDict, data: dict) -> dict:
     """ Run validators of all Value objects. If fails, outputs info.
         Return corrected data. (Ex: Some values might be nulled from "".)
     """
-    for (group, params), params2 in zip(data.items(), origin.values()):
-        for (key, val), pattern in zip(params.items(), params2.values()):
-            if isinstance(pattern, Value) and pattern.annotation:
-                if val == "" and type(None) in get_args(pattern.annotation):
-                    # The user is not able to set the value to None, they left it empty.
-                    # Cast back to None as None is one of the allowed types.
-                    # Ex: `severity: int | None = None`
-                    data[group][key] = val = None
-                elif pattern.annotation == Optional[int]:
-                    try:
-                        data[group][key] = val = int(val)
-                    except ValueError:
-                        pass
-
-                if not isinstance(val, pattern.annotation):
-                    pattern.set_error_text(f"Type must be `{pattern.annotation}`!")
-                    return False
+    def check(ordict, orkey, orval, dataPos: dict, dataKey, val):
+        if isinstance(orval, Value) and orval.annotation:
+            if val == "" and type(None) in get_args(orval.annotation):
+                # The user is not able to set the value to None, they left it empty.
+                # Cast back to None as None is one of the allowed types.
+                # Ex: `severity: int | None = None`
+                dataPos[dataKey] = val = None
+            elif orval.annotation == Optional[int]:
+                try:
+                    dataPos[dataKey] = val = int(val)
+                except ValueError:
+                    pass
+
+            if not isinstance(val, orval.annotation):
+                orval.set_error_text(f"Type must be `{orval.annotation}`!")
+                raise RuntimeError  # revision needed
+
+        # keep values if revision needed
+        # We merge new data to the origin. If form is re-submitted, the values will stay there.
+        if isinstance(orval, Value):
+            orval.val = val
+        else:
+            ordict[orkey] = val
+
+    try:
+        for (key1, val1), (orkey1, orval1) in zip(data.items(), origin.items()):
+            if isinstance(val1, dict):  # nested config hierarchy
+                # NOTE: This allows only single nested dict.
+                for (key2, val2), (orkey2, orval2) in zip(val1.items(), orval1.items()):
+                    check(orval1, orkey2, orval2, data[key1], key2, val2)
+            else:
+                check(origin, orkey1, orval1, data, key1, val1)
+    except RuntimeError:
+        return False
+
     return data
 
 
-def dict_to_dataclass(args: ConfigInstance, data: dict):
-    """ Convert the dict of dicts from the GUI back into the object holding the configuration. """
+def config_from_dict(args: ConfigInstance, data: dict):
+    """ Fetch back data.
+        Merge the dict of dicts from the GUI back into the object holding the configuration. """
     for group, params in data.items():
         for key, val in params.items():
             if group:
-                setattr(getattr(args, group), key, val)
+                setattr(getattr(args, group), key, val.val if isinstance(val, Value) else val)
             else:
-                setattr(args, key, val)
+                setattr(args, key, val.val if isinstance(val, Value) else val)
 
 
 def get_terminal_size():

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "0.1.1"
+version = "0.4.0"
 description = "A minimal access to GUI, TUI, CLI and config"
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "GPL-3.0-or-later"

tests.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+
+@dataclass
+class SimpleConfig:
+    """Set of options."""
+    test: bool = False
+    """My testing flag"""
+    important_number: int = 4
+    """This number is very important"""
+
+
+@dataclass
+class FurtherConfig1:
+    token: str = "filled"
+    host: str = "example.org"
+
+
+@dataclass
+class NestedDefaultedConfig:
+    further: FurtherConfig1
+
+
+@dataclass
+class FurtherConfig2:
+    token: str
+    host: str = "example.org"
+
+@dataclass
+class NestedMissingConfig:
+    further: FurtherConfig2
+
+
+@dataclass
+class FurtherConfig3:
+    severity: int | None = None
+
+@dataclass
+class OptionalFlagConfig:
+    further: FurtherConfig3
+    msg: str | None = None
+    msg2: str | None = "Default text"