init plugin

tests/qgis/test_env_var_parser.py

@@ -0,0 +1,76 @@
+import os
+import unittest
+
+from gn_tools.toolbelt.env_var_parser import EnvVarParser
+
+
+class TestEnvVarParser(unittest.TestCase):
+    """Unit tests for EnvVarParser."""
+
+    def setUp(self) -> None:
+        """Prepare the test environment before each test."""
+        self.env_backup = dict(os.environ)  # Backup environment variables
+
+    def tearDown(self) -> None:
+        """Restore the original environment variables after each test."""
+        os.environ.clear()
+        os.environ.update(self.env_backup)
+
+    def test_int_conversion(self) -> None:
+        """Test integer conversion from environment variable"""
+        os.environ["MY_INT"] = "42"
+        self.assertEqual(EnvVarParser.get_env_var("MY_INT", 0), 42)
+
+    def test_float_conversion(self) -> None:
+        """Test float conversion from environment variable"""
+        os.environ["MY_FLOAT"] = "3.14"
+        self.assertEqual(EnvVarParser.get_env_var("MY_FLOAT", 0.0), 3.14)
+
+    def test_bool_conversion_true(self) -> None:
+        """Test bool conversion from environment variable"""
+        for true_value in ["1", "true", "yes", "on"]:
+            os.environ["MY_BOOL"] = true_value
+            self.assertTrue(EnvVarParser.get_env_var("MY_BOOL", False))
+
+    def test_bool_conversion_false(self) -> None:
+        """Test bool conversion from environment variable"""
+        for false_value in ["0", "false", "no", "off"]:
+            os.environ["MY_BOOL"] = false_value
+            self.assertFalse(EnvVarParser.get_env_var("MY_BOOL", True))
+
+    def test_bool_invalid_defaults_to_original(self) -> None:
+        """Test invalid bool conversion from environment variable"""
+        os.environ["MY_BOOL"] = "maybe"
+        self.assertFalse(
+            EnvVarParser.get_env_var("MY_BOOL", False)
+        )  # Default should remain
+
+    def test_string_conversion(self) -> None:
+        """Test string conversion from environment variable"""
+        os.environ["MY_STRING"] = "Hello, World!"
+        self.assertEqual(
+            EnvVarParser.get_env_var("MY_STRING", "default"), "Hello, World!"
+        )
+
+    def test_default_value_when_env_missing(self) -> None:
+        """Test default value is used when environment variable is missing"""
+        self.assertEqual(EnvVarParser.get_env_var("MISSING_INT", 99), 99)
+
+    def test_invalid_int_fallback_to_default(self) -> None:
+        """Test default value used when the environment variable is not a valid int"""
+        os.environ["MY_INT"] = "not_an_int"
+        self.assertEqual(EnvVarParser.get_env_var("MY_INT", 10), 10)
+
+    def test_invalid_float_fallback_to_default(self) -> None:
+        """Test default value used when the environment variable is not a valid float"""
+        os.environ["MY_FLOAT"] = "not_a_float"
+        self.assertEqual(EnvVarParser.get_env_var("MY_FLOAT", 1.23), 1.23)
+
+    def test_unsupported_type(self) -> None:
+        """Test exception is raised when the type expected is not supported"""
+        os.environ["INT_LIST"] = "1,2,3,4"
+        self.assertRaises(TypeError, EnvVarParser.get_env_var, "INT_LIST", [1, 2, 3, 4])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/qgis/test_plg_preferences.py

@@ -0,0 +1,99 @@
+#! python3  # noqa E265
+
+"""
+    Usage from the repo root folder:
+
+    .. code-block:: bash
+
+        # for whole tests
+        python -m unittest tests.qgis.test_plg_preferences
+        # for specific test
+        python -m unittest tests.qgis.test_plg_preferences.TestPlgPreferences.test_plg_preferences_structure
+"""
+
+# standard library
+import os
+from unittest.mock import patch
+
+from qgis.testing import unittest
+
+# project
+from gn_tools.__about__ import __version__
+from gn_tools.toolbelt.preferences import (
+    PREFIX_ENV_VARIABLE,
+    PlgOptionsManager,
+    PlgSettingsStructure,
+)
+
+# ############################################################################
+# ########## Classes #############
+# ################################
+
+
+class TestPlgPreferences(unittest.TestCase):
+    def test_plg_preferences_structure(self):
+        """Test settings types and default values."""
+        settings = PlgSettingsStructure()
+
+        # global
+        self.assertTrue(hasattr(settings, "debug_mode"))
+        self.assertIsInstance(settings.debug_mode, bool)
+        self.assertEqual(settings.debug_mode, False)
+
+        self.assertTrue(hasattr(settings, "version"))
+        self.assertIsInstance(settings.version, str)
+        self.assertEqual(settings.version, __version__)
+
+
+    def test_bool_env_variable(self):
+        """Test settings with environment value."""
+        manager = PlgOptionsManager()
+        with patch.dict(
+            os.environ, {f"{PREFIX_ENV_VARIABLE}DEBUG_MODE": "true"}, clear=True
+        ):
+            settings = manager.get_plg_settings()
+            self.assertEqual(settings.debug_mode, True)
+
+        with patch.dict(
+            os.environ, {f"{PREFIX_ENV_VARIABLE}DEBUG_MODE": "false"}, clear=True
+        ):
+            settings = manager.get_plg_settings()
+            self.assertEqual(settings.debug_mode, False)
+
+        with patch.dict(
+            os.environ, {f"{PREFIX_ENV_VARIABLE}DEBUG_MODE": "on"}, clear=True
+        ):
+            settings = manager.get_plg_settings()
+            self.assertEqual(settings.debug_mode, True)
+
+        with patch.dict(
+            os.environ, {f"{PREFIX_ENV_VARIABLE}DEBUG_MODE": "off"}, clear=True
+        ):
+            settings = manager.get_plg_settings()
+            self.assertEqual(settings.debug_mode, False)
+
+        with patch.dict(
+            os.environ, {f"{PREFIX_ENV_VARIABLE}DEBUG_MODE": "1"}, clear=True
+        ):
+            settings = manager.get_plg_settings()
+            self.assertEqual(settings.debug_mode, True)
+
+        with patch.dict(
+            os.environ, {f"{PREFIX_ENV_VARIABLE}DEBUG_MODE": "0"}, clear=True
+        ):
+            settings = manager.get_plg_settings()
+            self.assertEqual(settings.debug_mode, False)
+
+        with patch.dict(
+            os.environ,
+            {f"{PREFIX_ENV_VARIABLE}DEBUG_MODE": "invalid_value"},
+            clear=True,
+        ):
+            settings = manager.get_plg_settings()
+            self.assertEqual(settings.debug_mode, False)
+
+# ############################################################################
+# ####### Stand-alone run ########
+# ################################
+if __name__ == "__main__":
+    unittest.main()

tests/qgis/test_processing.py

@@ -0,0 +1,40 @@
+#! python3  # noqa E265
+
+"""
+Usage from the repo root folder:
+
+.. code-block:: bash
+
+    # for whole tests
+    python -m unittest tests.qgis.test_plg_processing
+    # for specific test
+    python -m unittest tests.qgis.test_plg_processing.TestPlgprocessing.test_plg_processing_structure
+"""
+
+# PyQGIS
+from qgis.core import QgsApplication
+from qgis.testing import unittest, start_app
+
+from gn_tools.processing.provider import (
+    GnToolsProvider,
+)
+
+provider = None
+
+
+class TestProcessing(unittest.TestCase):
+    """Tests for processing algorithms."""
+
+    def setUp(self) -> None:
+        """Set up the processing tests."""
+        if not QgsApplication.processingRegistry().providers():
+            self.provider = GnToolsProvider()
+            QgsApplication.processingRegistry().addProvider(self.provider)
+        self.maxDiff = None
+                
+        # Start App needed to run processing on unittest
+        start_app()
+
+    def test_processing_provider(self):
+        """Sample test."""
+        print(f"Processing provider name : {self.provider.name()}")