Improve tests

Add tests for all python files.

Author: WimDeMeester

pydeepskylog/logging_config.py

@@ -2,8 +2,11 @@
 import logging
 
 def configure_logging(level: int = logging.INFO) -> None:
+    if not isinstance(level, int):
+        raise ValueError("Log level must be an integer from the logging module.")
     logging.basicConfig(
         level=level,
         format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S"
+        datefmt="%Y-%m-%d %H:%M:%S",
+        force=True
     )

pydeepskylog/tests/test_config.py

@@ -0,0 +1,39 @@
+import unittest
+from pydeepskylog.config import ContrastReserveConfig
+
+class TestContrastReserveConfig(unittest.TestCase):
+    def test_angle_type_and_length(self):
+        self.assertIsInstance(ContrastReserveConfig.ANGLE, list)
+        self.assertEqual(len(ContrastReserveConfig.ANGLE), ContrastReserveConfig.ANGLE_SIZE)
+        for val in ContrastReserveConfig.ANGLE:
+            self.assertIsInstance(val, float)
+
+    def test_ltc_type_and_shape(self):
+        self.assertIsInstance(ContrastReserveConfig.LTC, list)
+        self.assertEqual(len(ContrastReserveConfig.LTC), ContrastReserveConfig.LTC_SIZE)
+        for row in ContrastReserveConfig.LTC:
+            self.assertIsInstance(row, list)
+            self.assertEqual(len(row), len(ContrastReserveConfig.ANGLE) + 1)
+            self.assertIsInstance(row[0], int)
+            for val in row[1:]:
+                self.assertIsInstance(val, float)
+
+    def test_ltc_edge_values(self):
+        # Check first and last row/column values
+        self.assertEqual(ContrastReserveConfig.LTC[0][0], 4)
+        self.assertEqual(ContrastReserveConfig.LTC[-1][0], 27)
+        self.assertIsInstance(ContrastReserveConfig.LTC[0][-1], float)
+        self.assertIsInstance(ContrastReserveConfig.LTC[-1][-1], float)
+
+    def test_angle_out_of_bounds(self):
+        with self.assertRaises(IndexError):
+            _ = ContrastReserveConfig.ANGLE[ContrastReserveConfig.ANGLE_SIZE]
+        with self.assertRaises(IndexError):
+            _ = ContrastReserveConfig.LTC[ContrastReserveConfig.LTC_SIZE]
+
+    def test_ltc_row_length(self):
+        for row in ContrastReserveConfig.LTC:
+            self.assertEqual(len(row), len(ContrastReserveConfig.ANGLE) + 1)
+
+if __name__ == "__main__":
+    unittest.main()

pydeepskylog/tests/test_exceptions.py

@@ -0,0 +1,49 @@
+import unittest
+from pydeepskylog.exceptions import (
+    PyDeepSkyLogError,
+    APIConnectionError,
+    APITimeoutError,
+    APIAuthenticationError,
+    APIResponseError,
+    InvalidParameterError,
+)
+
+class TestExceptions(unittest.TestCase):
+    def test_pydeepskylogerror_inheritance(self):
+        with self.assertRaises(PyDeepSkyLogError):
+            raise PyDeepSkyLogError("Base error")
+
+    def test_api_connection_error(self):
+        with self.assertRaises(APIConnectionError):
+            raise APIConnectionError("Connection failed")
+
+    def test_api_timeout_error(self):
+        with self.assertRaises(APITimeoutError):
+            raise APITimeoutError("Timeout")
+
+    def test_api_authentication_error(self):
+        with self.assertRaises(APIAuthenticationError):
+            raise APIAuthenticationError("Auth failed")
+
+    def test_api_response_error(self):
+        with self.assertRaises(APIResponseError):
+            raise APIResponseError("Bad response")
+
+    def test_invalid_parameter_error(self):
+        with self.assertRaises(InvalidParameterError):
+            raise InvalidParameterError("Invalid parameter")
+
+    def test_inheritance_chain(self):
+        # All custom exceptions should inherit from PyDeepSkyLogError and Exception
+        for exc in [
+            APIConnectionError,
+            APITimeoutError,
+            APIAuthenticationError,
+            APIResponseError,
+            InvalidParameterError,
+        ]:
+            self.assertTrue(issubclass(exc, PyDeepSkyLogError))
+            self.assertTrue(issubclass(exc, Exception))
+
+if __name__ == "__main__":
+    unittest.main()

pydeepskylog/tests/test_logging.py

@@ -0,0 +1,33 @@
+import unittest
+import logging
+from pydeepskylog import logging_config
+
+class TestLoggingConfig(unittest.TestCase):
+    def setUp(self):
+        # Remove all handlers before each test
+        for handler in logging.root.handlers[:]:
+            logging.root.removeHandler(handler)
+        logging.root.setLevel(logging.NOTSET)
+
+    def test_configure_logging_default(self):
+        # Should not raise
+        logging_config.configure_logging()
+
+    def test_configure_logging_custom_level(self):
+        # Should not raise for valid custom level
+        logging_config.configure_logging(logging.DEBUG)
+        self.assertEqual(logging.getLogger().getEffectiveLevel(), logging.DEBUG)
+
+    def test_configure_logging_multiple_calls(self):
+        # Should not raise if called multiple times
+        logging_config.configure_logging(logging.WARNING)
+        logging_config.configure_logging(logging.ERROR)
+        self.assertEqual(logging.getLogger().getEffectiveLevel(), logging.ERROR)
+
+    def test_configure_logging_invalid_level(self):
+        # Should raise ValueError for invalid log level
+        with self.assertRaises(ValueError):
+            logging_config.configure_logging("not_a_level")
+
+if __name__ == "__main__":
+    unittest.main()

pydeepskylog/tests/test_validation.py

@@ -0,0 +1,63 @@
+import unittest
+from pydeepskylog.validation import (
+    validate_number, validate_positive, validate_in_range, validate_sequence
+)
+from pydeepskylog.exceptions import InvalidParameterError
+
+class TestValidation(unittest.TestCase):
+    def test_validate_number_valid(self):
+        validate_number(1, "test")
+        validate_number(1.5, "test")
+        validate_number(None, "test", allow_none=True)
+
+    def test_validate_number_invalid(self):
+        with self.assertRaises(InvalidParameterError):
+            validate_number("a", "test")
+        with self.assertRaises(InvalidParameterError):
+            validate_number(None, "test", allow_none=False)
+
+    def test_validate_positive_valid(self):
+        validate_positive(1, "test")
+        validate_positive(1.5, "test")
+        validate_positive(0.1, "test")
+        validate_positive(None, "test", allow_none=True)
+
+    def test_validate_positive_invalid(self):
+        with self.assertRaises(InvalidParameterError):
+            validate_positive(-1, "test")
+        with self.assertRaises(InvalidParameterError):
+            validate_positive(0, "test")
+        with self.assertRaises(InvalidParameterError):
+            validate_positive("a", "test")
+        with self.assertRaises(InvalidParameterError):
+            validate_positive(None, "test", allow_none=False)
+
+    def test_validate_in_range_valid(self):
+        validate_in_range(5, "test", 0, 10)
+        validate_in_range(0, "test", 0, 10)
+        validate_in_range(10, "test", 0, 10)
+
+    def test_validate_in_range_invalid(self):
+        with self.assertRaises(InvalidParameterError):
+            validate_in_range(-1, "test", 0, 10)
+        with self.assertRaises(InvalidParameterError):
+            validate_in_range(11, "test", 0, 10)
+        with self.assertRaises(InvalidParameterError):
+            validate_in_range("a", "test", 0, 10)
+
+    def test_validate_sequence_valid(self):
+        validate_sequence([1.0, 2.0, 3.0], "test")
+        validate_sequence((1.0, 2.0), "test")
+        validate_sequence([], "test")
+        validate_sequence([1, 2], "test", item_type=int)
+
+    def test_validate_sequence_invalid(self):
+        with self.assertRaises(InvalidParameterError):
+            validate_sequence("not a sequence", "test")
+        with self.assertRaises(InvalidParameterError):
+            validate_sequence([1, "a"], "test")
+        with self.assertRaises(InvalidParameterError):
+            validate_sequence([1.0, 2], "test", item_type=int)
+
+if __name__ == "__main__":
+    unittest.main()