ci(coverage): adding mandatory 80% level of coverage for diff (#239)

Author: guzmud

.github/workflows/coverage.yml

@@ -27,10 +27,10 @@ jobs:
           uv venv && uv pip install -e '.[dev]' coverage
 
       - name: Run tests with coverage
-        run: uv run coverage run -m pytest
+        run: uv run coverage run -m pytest --junitxml="junit.xml"
 
       - name: Print coverage summary
-        run: uv run coverage report -m --fail-under=70
+        run: uv run coverage report -m --fail-under=80
 
       - name: Generate coverage XML
         run: uv run coverage xml -o coverage.xml
@@ -40,6 +40,12 @@ jobs:
         uses: codecov/codecov-action@v7
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          flags: connectors
           fail_ci_if_error: false
           verbose: true
+
+      - name: Upload test results to Codecov
+        if: ${{ !cancelled() && hashFiles('junit.xml') != '' }}
+        uses: codecov/codecov-action@v7
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          report_type: test_results

.gitignore

@@ -70,6 +70,7 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 cover/
+junit.xml
 
 # Translations
 *.mo
@@ -136,4 +137,4 @@ dmypy.json
 cython_debug/
 
 # testing
-test.py
+test.py

CONTRIBUTING.md

@@ -19,6 +19,15 @@ developing features or fixing bugs yourself.
 * If you are interested in contributing code, fork the repository, create a
   branch, and open a pull request.
 
+## Code quality and testing
+
+In order to maintain a certain standard regarding code quality, this repository CI will run various tools against expectations:
+- `isort` will be used to check for proper imports sorting, and the CI will fail if the checks fail
+- `black` will be used to check for proper code formatting, and the CI will fail if the checks fail
+- `flake8` will be used to check for proper code styling, and the CI will fail if the checks fail
+- `pytest` will be used to run various levels of testing, and the CI will fail if the tests fail
+- `coverage` with `codecov` will be used to check for proper code coverage, and the CI will fail if the level is below 80% for the current diff (a warning will be emitted if the level falls below 80% for the overall project)
+
 <!-- filigran-conventions:start -->
 ## Commit, pull request & issue conventions
 

codecov.yml

@@ -0,0 +1,19 @@
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+        informational: true
+    patch:
+      default:
+        target: 80%
+        informational: false
+
+comment:
+  layout: "diff, files, condensed_footer"
+  hide_project_coverage: true # set to true
+  require_changes: "coverage_drop AND uncovered_patch"
+
+ignore:
+  # Ignore any folder whose name starts with "test" anywhere in the tree
+  - "**/test*/**"

pyproject.toml

@@ -106,3 +106,6 @@ warn_unused_ignores = true
 omit = [
     "test/*",
 ]
+
+[tool.coverage.report]
+fail_under = 80

test/backends/test_backend.py

@@ -1,8 +1,38 @@
 import unittest
+from unittest.mock import MagicMock
 
 from pyoaev.backends import backend as module
 
 
+class TestTokenAuth(unittest.TestCase):
+    def test_auto_bearer_token(self):
+        request = MagicMock()
+        request.headers = dict()
+        token = "my-secret-token"
+
+        token_auth = module.TokenAuth(token=token)
+
+        _request = token_auth(request)
+
+        self.assertEqual(
+            _request.headers["Authorization"],
+            f"Bearer {token}",
+        )
+
+
+class TestRequestsReponse(unittest.TestCase):
+    def test_init_and_properties(self):
+        response = MagicMock()
+
+        rr = module.RequestsResponse(response)
+
+        self.assertEqual(response, rr.response)
+        self.assertEqual(response.status_code, rr.status_code)
+        self.assertEqual(response.headers, rr.headers)
+        self.assertEqual(response.content, rr.content)
+        self.assertEqual(response.reason, rr.reason)
+
+
 class TestRequestsBackend(unittest.TestCase):
     def test_no_cookie_allowed(self):
         backend = module.RequestsBackend()

test/configuration/test_configuration.py

@@ -2,7 +2,12 @@
 import unittest
 from unittest.mock import patch
 
+from pydantic_settings import BaseSettings
+
 from pyoaev.configuration import Configuration
+from pyoaev.configuration.connector_config_schema_generator import (
+    ConnectorConfigSchemaGenerator,
+)
 
 TEST_CONFIG_HINTS = {
     "string_config_direct": {"data": "this is string_config_direct"},
@@ -252,6 +257,23 @@ def test_when_bool_config_has_default_when_key_is_not_found_return_default(self)
 
         self.assertEqual(value, True)
 
+    def test_configuration_schema_generation(self):
+        config_obj = Configuration(
+            config_hints=TEST_CONFIG_HINTS,
+            config_base_model=BaseSettings(),
+        )
+
+        _schema = config_obj.schema()
+
+        self.assertEqual(
+            _schema,
+            BaseSettings.model_json_schema(
+                by_alias=False,
+                schema_generator=ConnectorConfigSchemaGenerator,
+                mode="validation",
+            ),
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

test/daemons/test_base_daemon.py

@@ -51,17 +51,21 @@ def bound_method(self):
     )
 
 
+@unittest.mock.patch("argparse.ArgumentParser")
 class TestBaseDaemon(unittest.TestCase):
-    def test_when_no_callback_when_complete_config_ctor_ok(self):
+    def test_when_no_callback_when_complete_config_ctor_ok(self, _):
         daemon = DaemonForTest(configuration=TEST_DAEMON_CONFIGURATION)
 
         self.assertIsInstance(daemon, BaseDaemon)
 
-    def test_when_no_callback_when_lacking_config_key_ctor_throws(self):
+    def test_when_no_callback_when_lacking_config_key_ctor_throws(self, _):
         with self.assertRaises(Exception):
             DaemonForTest(configuration=Configuration(config_hints={}))
 
-    def test_when_no_callback_daemon_cant_start(self):
+    def test_when_no_callback_daemon_cant_start(self, m_argparser):
+        m_argparser.return_value.parse_args.return_value = unittest.mock.MagicMock(
+            dump_config_schema=False
+        )
         daemon, mock_setup, mock_start_loop, _ = create_mock_daemon()
 
         with self.assertRaises(OpenAEVError):
@@ -70,23 +74,26 @@ def test_when_no_callback_daemon_cant_start(self):
         mock_setup.assert_not_called()
         mock_start_loop.assert_not_called()
 
-    def test_when_callback_daemon_can_start(self):
+    def test_when_callback_daemon_can_start(self, m_argparser):
+        m_argparser.return_value.parse_args.return_value = unittest.mock.MagicMock(
+            dump_config_schema=False
+        )
         daemon, mock_setup, mock_start_loop, _ = create_mock_daemon(lambda: None)
 
         daemon.start()
 
         mock_setup.assert_called_once()
         mock_start_loop.assert_called_once()
 
-    def test_when_callback_is_bound_method_daemon_can_call(self):
+    def test_when_callback_is_bound_method_daemon_can_call(self, _):
         daemon, mock_setup, mock_start_loop, inner_mock_func = create_mock_daemon()
         daemon.set_callback(daemon.bound_method)
 
         daemon._try_callback()
 
         inner_mock_func.assert_called_once()
 
-    def test_when_callback_is_func_with_collector_parameter_daemon_can_call(self):
+    def test_when_callback_is_func_with_collector_parameter_daemon_can_call(self, _):
         daemon, mock_setup, mock_start_loop, _ = create_mock_daemon()
         inner_mock_func = unittest.mock.MagicMock()
         daemon.set_callback(lambda collector: inner_mock_func())
@@ -95,7 +102,7 @@ def test_when_callback_is_func_with_collector_parameter_daemon_can_call(self):
 
         inner_mock_func.assert_called_once()
 
-    def test_when_callback_is_func_with_other_parameter_daemon_cant_call(self):
+    def test_when_callback_is_func_with_other_parameter_daemon_cant_call(self, _):
         daemon, mock_setup, mock_start_loop, _ = create_mock_daemon()
         inner_mock_func = unittest.mock.MagicMock()
         daemon.set_callback(lambda other_parameter: inner_mock_func())

test/test_base.py

@@ -0,0 +1,70 @@
+import unittest
+from unittest.mock import MagicMock, sentinel
+
+import pyoaev.base as module
+
+
+class TestRESTObject(unittest.TestCase):
+    def test_restobject_minimal_init(self):
+        manager = MagicMock()
+        manager.parent_attrs = {"parentkey1": "parentvalue1"}
+        attrs = {"key1": "value1"}
+        created_from_list = sentinel._created_from_list
+
+        rest_object = module.RESTObject(
+            manager, attrs, created_from_list=created_from_list
+        )
+
+        self.assertEqual(rest_object.manager, manager)
+        self.assertEqual(rest_object._attrs, attrs)
+        self.assertEqual(rest_object._created_from_list, created_from_list)
+        self.assertEqual(rest_object._updated_attrs, {})
+        self.assertEqual(rest_object._parent_attrs, manager.parent_attrs)
+        self.assertEqual(
+            str(rest_object), "<class 'pyoaev.base.RESTObject'> => {'key1': 'value1'}"
+        )
+
+        # properties
+        self.assertEqual(
+            rest_object.attributes, {"key1": "value1", "parentkey1": "parentvalue1"}
+        )
+        self.assertIsNone(rest_object.encoded_id)
+
+    def test_restobject_failed_init(self):
+        manager = MagicMock()
+        attrs = MagicMock()
+        created_from_list = sentinel._created_from_list
+
+        with self.assertRaises(module.OpenAEVParsingError):
+            module.RESTObject(manager, attrs, created_from_list=created_from_list)
+
+    def test_restobject_to_json(self):
+        manager = MagicMock()
+        manager.parent_attrs = {"parentkey1": "parentvalue1"}
+        attrs = {"key1": "value1"}
+        created_from_list = sentinel._created_from_list
+
+        rest_object = module.RESTObject(
+            manager, attrs, created_from_list=created_from_list
+        )
+
+        jsondata = rest_object.to_json()
+
+        self.assertEqual(jsondata, '{"key1": "value1"}')
+        self.assertNotIn("parentkey1", jsondata)
+
+    def test_restobject_get_id(self):
+        manager = MagicMock()
+        manager.parent_attrs = {"parentkey1": "parentvalue1"}
+        attrs = {"key1": "value1"}
+        created_from_list = sentinel._created_from_list
+
+        rest_object = module.RESTObject(
+            manager, attrs, created_from_list=created_from_list
+        )
+
+        self.assertIsNone(rest_object.get_id())
+
+        rest_object._update_attrs({"_id_attr": "my_id"})
+
+        self.assertIsNone(rest_object.get_id())

test/test_exceptions.py

@@ -0,0 +1,62 @@
+import unittest
+from unittest.mock import MagicMock
+
+import pyoaev.exceptions as module
+
+
+class TestExceptions(unittest.TestCase):
+    def test_openaeverror_init(self):
+        error_message = MagicMock()
+        response_code = MagicMock()
+        response_body = MagicMock()
+
+        exception = module.OpenAEVError(error_message, response_code, response_body)
+
+        self.assertEqual(exception.response_code, response_code)
+        self.assertEqual(exception.response_body, response_body)
+        self.assertEqual(exception.error_message, error_message.decode.return_value)
+
+    def test_openaeverror_init_auto_decode(self):
+        response_code = MagicMock()
+        response_body = MagicMock()
+
+        exception = module.OpenAEVError(b"test", response_code, response_body)
+
+        self.assertEqual(exception.error_message, "test")
+
+        exception = module.OpenAEVError("test", response_code, response_body)
+
+        self.assertEqual(exception.error_message, "test")
+
+    def test_openaeverror_strcast_no_message(self):
+        error_message = None
+        response_code = 418
+        response_body = MagicMock()
+
+        exception = module.OpenAEVError(error_message, response_code, response_body)
+
+        strdata = str(exception)
+
+        self.assertEqual(strdata, "418: Unknown error")
+
+    def test_openaeverror_strcast_no_message_no_code(self):
+        error_message = None
+        response_code = None
+        response_body = MagicMock()
+
+        exception = module.OpenAEVError(error_message, response_code, response_body)
+
+        strdata = str(exception)
+
+        self.assertEqual(strdata, "Unknown error")
+
+    def test_openaeverror_strcast_with_body(self):
+        error_message = None
+        response_code = 418
+        response_body = b'{"message": "I am a teapot"}'
+
+        exception = module.OpenAEVError(error_message, response_code, response_body)
+
+        strdata = str(exception)
+
+        self.assertEqual(strdata, "418: I am a teapot")