Implemented unittests for Job and its components

Author: JohannesGaessler

src/ja/common/docker_context.py

@@ -24,6 +24,12 @@ def __init__(self, source_path: str, mount_path: str):
         self._source_path = source_path
         self._mount_path = mount_path
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, MountPoint):
+            return self.source_path == other.source_path and self.mount_path == other.mount_path
+        else:
+            return False
+
     @property
     def source_path(self) -> str:
         """!
@@ -55,6 +61,12 @@ class IDockerContext(Serializable, ABC):
     run a job in.
     """
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, IDockerContext):
+            return self.dockerfile_source == other.dockerfile_source and self.mount_points == other.mount_points
+        else:
+            return False
+
     @property
     @abstractmethod
     def dockerfile_source(self) -> str:
@@ -103,7 +115,7 @@ def to_dict(self) -> Dict[str, object]:
         return _dict
 
     @classmethod
-    def from_dict(cls, property_dict: Dict[str, object]) -> "IDockerContext":
+    def from_dict(cls, property_dict: Dict[str, object]) -> IDockerContext:
         _dockerfile_source = cls._get_str_from_dict(property_dict=property_dict, key="dockerfile_source")
 
         _property: object = cls._get_from_dict(property_dict=property_dict, key="mount_points")
@@ -120,9 +132,9 @@ def from_dict(cls, property_dict: Dict[str, object]) -> "IDockerContext":
                     key="mount_points", expected_type="List[MountPoint]",
                     actual_type="List[object]"
                 )
-                _mount_point_list.append(MountPoint.from_dict(
-                    cast(Dict[str, object], _object)
-                ))
+            _mount_point_list.append(MountPoint.from_dict(
+                cast(Dict[str, object], _object)
+            ))
         cls._assert_all_properties_used(property_dict)
         return DockerContext(dockerfile_source=_dockerfile_source, mount_points=_mount_point_list)
 
@@ -134,15 +146,22 @@ class DockerConstraints(Serializable):
     def __init__(self, cpu_threads: int = -1, memory: int = 1):
         """!
         Create a new set of Docker constraints.
-        @param cpu_threads Initial value of @cpu_threads.
-        @param memory The value of @memory.
+        @param cpu_threads Initial value of @cpu_threads. -1 if unknown. Must be > 0 if set to exact number.
+        @param memory The value of @memory, must be > 0.
         """
         self._cpu_threads = -1
-        self.cpu_threads = cpu_threads
+        if cpu_threads != -1:
+            self.cpu_threads = cpu_threads
         if memory < 1:
             raise ValueError("Cannot set memory to %s because this value is < 1." % memory)
         self._memory = memory
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, DockerConstraints):
+            return self.cpu_threads == other.cpu_threads and self.memory == other.memory
+        else:
+            return False
+
     @property
     def cpu_threads(self) -> int:
         """!
@@ -161,9 +180,10 @@ def cpu_threads(self, count_threads: int) -> None:
         """
         if self._cpu_threads != -1:
             raise RuntimeError("cpu_threads can only be set once.")
-        if count_threads < 1:
+        elif count_threads < 1:
             raise ValueError("Cannot set cpu_threads to %s because this value is < 1." % count_threads)
-        self._cpu_threads = count_threads
+        else:
+            self._cpu_threads = count_threads
 
     @property
     def memory(self) -> int:

src/ja/common/job.py

@@ -43,6 +43,14 @@ def __init__(self,
         self._is_preemptible = is_preemtible
         self._special_resources = special_resources
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, JobSchedulingConstraints):
+            return self.priority == other.priority \
+                and self.is_preemptible == other.is_preemptible \
+                and self.special_resources == other.special_resources
+        else:
+            return False
+
     @property
     def priority(self) -> JobPriority:
         """!
@@ -74,7 +82,7 @@ def to_dict(self) -> Dict[str, object]:
     @classmethod
     def from_dict(cls, property_dict: Dict[str, object]) -> "JobSchedulingConstraints":
         _priority = JobPriority(cls._get_from_dict(property_dict=property_dict, key="priority"))
-        _is_preemtible = cls._get_bool_from_dict(property_dict=property_dict, key="is_preemtible")
+        _is_preemtible = cls._get_bool_from_dict(property_dict=property_dict, key="is_preemptible")
         _special_resources = cls._get_str_list_from_dict(property_dict=property_dict, key="special_resources")
 
         cls._assert_all_properties_used(property_dict)
@@ -108,6 +116,19 @@ def __init__(self,
         self._docker_constraints = docker_constraints
         self._label = label
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Job):
+            return self.uid == other.uid \
+                and self.status == other.status \
+                and self.owner_id == other.owner_id \
+                and self.email == other.email \
+                and self.scheduling_constraints == other.scheduling_constraints \
+                and self.docker_context == other.docker_context \
+                and self.docker_constraints == other.docker_constraints \
+                and self.label == other.label
+        else:
+            return False
+
     @property
     def uid(self) -> str:
         """!
@@ -207,7 +228,7 @@ def to_dict(self) -> Dict[str, object]:
     @classmethod
     def from_dict(cls, property_dict: Dict[str, object]) -> "Job":
         _uid = cls._get_str_from_dict(property_dict=property_dict, key="uid", mandatory=False)
-        _owner_id = cls._get_int_from_dict(property_dict=property_dict, key="uid")
+        _owner_id = cls._get_int_from_dict(property_dict=property_dict, key="owner_id")
         _email = cls._get_str_from_dict(property_dict=property_dict, key="email")
 
         _scheduling_constraints = JobSchedulingConstraints.from_dict(

src/ja/common/message/base.py

@@ -44,21 +44,21 @@ def _assert_all_properties_used(cls, property_dict: Dict[str, object]) -> None:
     def _get_dict_from_dict(
             cls, property_dict: Dict[str, object], key: str, mandatory: bool = True) -> Dict[str, object]:
         _property = cls._get_from_dict(property_dict=property_dict, key=key, mandatory=mandatory)
-        if not isinstance(_property, dict):
+        if mandatory and not isinstance(_property, dict):
             cls._raise_error_wrong_type(key=key, expected_type="dict", actual_type=_property.__class__.__name__)
         return cast(Dict[str, object], _property)
 
     @classmethod
     def _get_str_from_dict(cls, property_dict: Dict[str, object], key: str, mandatory: bool = True) -> str:
         _property = cls._get_from_dict(property_dict=property_dict, key=key, mandatory=mandatory)
-        if not isinstance(_property, str):
+        if mandatory and not isinstance(_property, str):
             cls._raise_error_wrong_type(key=key, expected_type="str", actual_type=_property.__class__.__name__)
         return cast(str, _property)
 
     @classmethod
     def _get_str_list_from_dict(cls, property_dict: Dict[str, object], key: str, mandatory: bool = True) -> List[str]:
         _property = cls._get_from_dict(property_dict=property_dict, key=key, mandatory=mandatory)
-        if not isinstance(_property, list):
+        if mandatory and not isinstance(_property, list):
             cls._raise_error_wrong_type(key=key, expected_type="List[str]", actual_type=_property.__class__.__name__)
         _list = cast(List[object], _property)
         for _element in _list:
@@ -69,14 +69,14 @@ def _get_str_list_from_dict(cls, property_dict: Dict[str, object], key: str, man
     @classmethod
     def _get_int_from_dict(cls, property_dict: Dict[str, object], key: str, mandatory: bool = True) -> int:
         _property = cls._get_from_dict(property_dict=property_dict, key=key, mandatory=mandatory)
-        if not isinstance(_property, int):
+        if mandatory and not isinstance(_property, int):
             cls._raise_error_wrong_type(key=key, expected_type="int", actual_type=_property.__class__.__name__)
         return cast(int, _property)
 
     @classmethod
     def _get_bool_from_dict(cls, property_dict: Dict[str, object], key: str, mandatory: bool = True) -> bool:
         _property = cls._get_from_dict(property_dict=property_dict, key=key, mandatory=mandatory)
-        if not isinstance(_property, bool):
+        if mandatory and not isinstance(_property, bool):
             cls._raise_error_wrong_type(key=key, expected_type="int", actual_type=_property.__class__.__name__)
         return cast(bool, _property)
 

src/setup.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+import unittest
+
+from setuptools import find_packages, setup
+
+
+def discover_ja_tests():
+    _tl = unittest.TestLoader()
+    _ts = _tl.discover('test', 'test*.py')
+    return _ts
+
+
+setup(
+    name='jobadder',
+    version="0.0.1",
+    description='JobAdder: a package for priority-based scheduling of Docker jobs to mwork machines',
+    long_description='',
+    author='Johannes Gäßler, ',  # TODO add everyone else
+    author_email='johannesg@5d6.de, ',  # TODO add everyone else
+    url='https://github.com/DistributedTaskScheduling/JobAdder',
+    packages=find_packages(),
+    package_data={},
+    scripts=[],
+    test_suite='setup.discover_ja_tests',
+    keywords=[],
+    license='GPL3',
+    install_requires=[],
+    classifiers=[],
+)

src/test/__init__.py

@@ -0,0 +1,59 @@
+from copy import deepcopy
+from typing import no_type_check, Dict, List
+
+from ja.common.message.base import Serializable
+
+
+class SerializableTestMixin:
+    """
+    Mixin class for testing sub-classes of Serializable.
+    """
+    def __init__(self) -> None:
+        self._object: Serializable = None
+        self._object_dict: Dict[str, object] = None
+        self._other_object_dict: Dict[str, object] = None
+        self._optional_properties: List[str] = None
+
+    @no_type_check
+    def test_roundtrip(self) -> None:
+        _dict = self._object.to_dict()
+        _recreated_object = self._object.__class__.from_dict(_dict)
+        self.assertTrue(
+            self._object == _recreated_object,
+            msg="Roundtrip failed for %s: recreated object not equal." % self._object.__class__.__name__
+        )
+
+    @no_type_check
+    def test_from_dict(self) -> None:
+        _read_object = self._object.__class__.from_dict(self._object_dict)
+        self.assertTrue(
+            self._object == _read_object,
+            msg="Reading in object failed for %s: read in object not equal." % self._object.__class__.__name__
+        )
+
+    @no_type_check
+    def test_from_other_dict(self) -> None:
+        _read_object = self._object.__class__.from_dict(self._object_dict)
+        _other_read_object = self._object.__class__.from_dict(self._other_object_dict)
+        self.assertFalse(
+            _read_object == _other_read_object,
+            msg="Reading in different objects failed for %s: read in objects are the same."
+                % self._object.__class__.__name__
+        )
+
+    @no_type_check
+    def test_removing_property_raises_error(self) -> None:
+        for _key in list(self._object_dict.keys()):
+            _object_dict_copy = deepcopy(self._object_dict)
+            _object_dict_copy.pop(_key)
+            if _key in self._optional_properties:
+                self._object.__class__.from_dict(_object_dict_copy)
+            else:
+                with self.assertRaises(ValueError):
+                    self._object.__class__.from_dict(_object_dict_copy)
+
+    @no_type_check
+    def test_adding_property_raises_error(self) -> None:
+        self._object_dict["AYY"] = "LAMO"
+        with self.assertRaises(ValueError):
+            self._object.__class__.from_dict(self._object_dict)

src/test/serializable/__init__.py

@@ -0,0 +1,15 @@
+from unittest import TestCase
+
+from ja.common.docker_context import DockerConstraints
+from test.serializable.base import SerializableTestMixin
+
+
+class DockerConstraintsTest(TestCase, SerializableTestMixin):
+    """
+    Class for testing DockerConstraints.
+    """
+    def setUp(self) -> None:
+        self._optional_properties = []
+        self._object = DockerConstraints(cpu_threads=-1, memory=1024)
+        self._object_dict = {"cpu_threads": -1, "memory": 1024}
+        self._other_object_dict = {"cpu_threads": 4, "memory": 1024}

src/test/serializable/base.py

@@ -0,0 +1,32 @@
+from unittest import TestCase
+
+from ja.common.docker_context import DockerContext, MountPoint
+from test.serializable.base import SerializableTestMixin
+
+
+class DockerContextTest(TestCase, SerializableTestMixin):
+    """
+    Class for testing DockerContext.
+    """
+    def setUp(self) -> None:
+        self._optional_properties = []
+        self._object = DockerContext(
+            dockerfile_source="sudo apt install docker",
+            mount_points=[
+                MountPoint(source_path="/home/user", mount_path="/home/user"),
+                MountPoint(source_path="/opt/thing", mount_path="/opt/THING")
+            ]
+        )
+        self._object_dict = {
+            "dockerfile_source": "sudo apt install docker",
+            "mount_points": [
+                {"source_path": "/home/user", "mount_path": "/home/user"},
+                {"source_path": "/opt/thing", "mount_path": "/opt/THING"}
+            ]
+        }
+        self._other_object_dict = {
+            "dockerfile_source": "sudo apt install docker",
+            "mount_points": [
+                {"source_path": "/home/user", "mount_path": "/home/user"},
+            ]
+        }