Added InterNodeOrchestrator tests and optimized imports.

motey/orchestrator/inter_node_orchestrator.py

@@ -38,8 +38,8 @@ def __init__(self, logger, valmanager, service_repository, capability_repository
         self.capability_repository = capability_repository
         self.node_repository = node_repository
         self.communication_manager = communication_manager
-        self.blueprint_stream = ServiceEndpoint.yaml_post_stream.subscribe(self.instantiate_service)
-        self.blueprint_stream = ServiceEndpoint.yaml_delete_stream.subscribe(self.terminate_service)
+        self.yaml_post_stream = ServiceEndpoint.yaml_post_stream.subscribe(self.instantiate_service)
+        self.yaml_delete_stream = ServiceEndpoint.yaml_delete_stream.subscribe(self.terminate_service)
 
     def instantiate_service(self, service):
         """
@@ -101,7 +101,7 @@ def deploy_service(self, service):
         """
         for image in service.images:
             image.id = self.communication_manager.deploy_image(image)
-        # store new image id
+        # TODO: store new image id
         self.service_repository.update(dict(service))
 
     def get_service_status(self, service):
@@ -118,14 +118,14 @@ def get_service_status(self, service):
             image_status_list.append(image_status)
 
         if ImageState.ERROR in image_status_list:
-            service.state = ServiceState.ERROR
             self.terminate_service(service=service)
+            service.state = ServiceState.ERROR
         elif ImageState.TERMINATED in image_status_list:
-            service.state = ServiceState.TERMINATED
             self.terminate_service(service=service)
+            service.state = ServiceState.TERMINATED
         elif ImageState.STOPPING in image_status_list:
-            service.state = ServiceState.STOPPING
             self.terminate_service(service=service)
+            service.state = ServiceState.STOPPING
         elif ImageState.INSTANTIATING in image_status_list:
             service.state = ServiceState.INSTANTIATING
         elif ImageState.INITIAL in image_status_list:
@@ -139,18 +139,18 @@ def get_service_status(self, service):
         self.service_repository.update(dict(service))
         return service.state
 
-    def compare_capabilities(self, needed_capabilities, node_capabilities):
+    def compare_capabilities(self, needed_capabilities_list, node_capabilities_dict):
         """
         Compares two dicts with capabilities.
 
-        :param needed_capabilities: the capabilities to compare with
-        :type needed_capabilities: dict
-        :param node_capabilities: the capabilties to check
-        :type node_capabilities: dict
+        :param needed_capabilities_list: the capabilities to compare with
+        :type needed_capabilities_list: list
+        :param node_capabilities_dict: the capabilties to check
+        :type node_capabilities_dict: list
         :return: True if all capabilities are fulfilled, otherwiese False
         """
-        for capability in needed_capabilities:
-            for node_capability in node_capabilities:
+        for capability in needed_capabilities_list:
+            for node_capability in node_capabilities_dict:
                 if node_capability['capability'] == capability:
                     # found them
                     break
@@ -169,7 +169,7 @@ def find_node(self, image):
         """
         for node in self.node_repository.all():
             capabilities = self.communication_manager.request_capabilities(node['ip'])
-            if self.compare_capabilities(needed_capabilities=image.capabilities, node_capabilities=capabilities):
+            if self.compare_capabilities(needed_capabilities_list=image.capabilities, node_capabilities_dict=capabilities):
                 return node
         return None
 

tests/capabilityengine/test_capability_engine.py

@@ -1,12 +1,13 @@
 import unittest
 from unittest import mock
 
+from rx.subjects import Subject
+
 from motey.capabilityengine.capability_engine import CapabilityEngine
 from motey.communication.communication_manager import CommunicationManager
 from motey.models.capability import Capability
 from motey.repositories.capability_repository import CapabilityRepository
 from motey.utils.logger import Logger
-from rx.subjects import Subject
 
 
 class TestCapabilityEngine(unittest.TestCase):

tests/models/test_schemas.py

@@ -1,10 +1,10 @@
 import unittest
 
+from jsonschema import ValidationError
 from jsonschema import validate
 
 from motey.models.schemas import blueprint_yaml_schema
 from motey.models.schemas import capability_json_schema
-from jsonschema import ValidationError
 
 
 class TestSchemas(unittest.TestCase):

tests/orchestrator/test_inter_node_orchestrator.py

@@ -0,0 +1,234 @@
+import unittest
+from unittest import mock
+
+from rx.subjects import Subject
+
+from motey.communication.communication_manager import CommunicationManager
+from motey.models.image import Image
+from motey.models.image_state import ImageState
+from motey.models.service import Service
+from motey.models.service_state import ServiceState
+from motey.orchestrator import inter_node_orchestrator
+from motey.repositories.capability_repository import CapabilityRepository
+from motey.repositories.nodes_repository import NodesRepository
+from motey.repositories.service_repository import ServiceRepository
+from motey.utils.logger import Logger
+from motey.val.valmanager import VALManager
+
+
+class TestInterNodeOrchestrator(unittest.TestCase):
+    @classmethod
+    def setUp(self):
+        inter_node_orchestrator.ServiceEndpoint = mock.Mock(inter_node_orchestrator.ServiceEndpoint)
+        inter_node_orchestrator.get_own_ip = mock.MagicMock(return_value='127.0.0.42')
+
+        self.test_image = Image(name='test image name', engine='test engine', capabilities=['first', 'second', 'third'])
+        self.test_service = Service(service_name='test service name', images=[self.test_image])
+
+        self.logger = mock.Mock(Logger)
+        self.valmanager = mock.Mock(VALManager)
+        self.service_repository = mock.Mock(ServiceRepository)
+        self.capability_repository = mock.Mock(CapabilityRepository)
+        self.node_repository = mock.Mock(NodesRepository)
+        self.communication_manager = mock.Mock(CommunicationManager)
+
+        self.inter_node_orchestrator = inter_node_orchestrator.InterNodeOrchestrator(
+            logger=self.logger,
+            valmanager=self.valmanager,
+            service_repository=self.service_repository,
+            capability_repository=self.capability_repository,
+            node_repository=self.node_repository,
+            communication_manager=self.communication_manager
+        )
+
+        self.inter_node_orchestrator.yaml_post_stream = mock.Mock(Subject)
+        self.inter_node_orchestrator.yaml_delete_stream = mock.Mock(Subject)
+
+    def test_instantiate_service_without_image_capabilities(self):
+        test_image = Image(name='test image name', engine='test engine')
+        test_service = Service(service_name='test service name', images=[test_image])
+
+        self.inter_node_orchestrator.instantiate_service(service=test_service)
+
+        self.assertTrue(self.service_repository.add.called)
+        self.assertTrue(self.service_repository.update.called)
+        self.assertTrue(self.communication_manager.deploy_image.called)
+
+    def test_instantiate_service_capabilities_equal(self):
+        self.capability_repository.has = mock.MagicMock(return_value=True)
+
+        self.inter_node_orchestrator.instantiate_service(service=self.test_service)
+
+        self.assertTrue(self.service_repository.add.called)
+        self.assertTrue(self.capability_repository.has.called)
+        self.assertTrue(self.service_repository.update.called)
+        self.assertTrue(self.communication_manager.deploy_image.called)
+
+    def test_instantiate_service_capabilities_unequal_but_external_node(self):
+        self.capability_repository.has = mock.MagicMock(return_value=False)
+        test_node = {'ip': '127.0.0.23'}
+        self.node_repository.all = mock.MagicMock(return_value=[test_node])
+        self.communication_manager.request_capabilities = mock.MagicMock(
+            return_value=[{'capability': 'first'}, {'capability': 'second'}, {'capability': 'third'}])
+
+        self.inter_node_orchestrator.instantiate_service(service=self.test_service)
+
+        self.assertTrue(self.service_repository.add.called)
+        self.assertTrue(self.capability_repository.has.called)
+        self.assertTrue(self.service_repository.update.called)
+        self.assertTrue(self.communication_manager.deploy_image.called)
+
+    def test_instantiate_service_capabilities_unequal_no_external_node(self):
+        self.capability_repository.has = mock.MagicMock(return_value=False)
+        test_node = {'ip': '127.0.0.23'}
+        self.node_repository.all = mock.MagicMock(return_value=[test_node])
+        self.communication_manager.request_capabilities = mock.MagicMock(
+            return_value=[{'capability': 'wrong'}, {'capability': 'also wrong'}])
+
+        self.inter_node_orchestrator.instantiate_service(service=self.test_service)
+
+        self.assertTrue(self.service_repository.add.called)
+        self.assertTrue(self.capability_repository.has.called)
+        self.assertTrue(self.service_repository.update.called)
+        self.assertFalse(self.communication_manager.deploy_image.called)
+
+    def test_deploy_service(self):
+        self.communication_manager.deploy_image = mock.MagicMock(return_value='abc123')
+        self.service_repository.update = mock.MagicMock(return_value=None)
+
+        self.inter_node_orchestrator.deploy_service(service=self.test_service)
+
+        self.assertTrue(self.communication_manager.deploy_image.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_get_service_status_state_error(self):
+        self.communication_manager.request_image_status = mock.MagicMock(return_value=ImageState.ERROR)
+
+        result = self.inter_node_orchestrator.get_service_status(service=self.test_service)
+
+        self.assertEqual(result, ServiceState.ERROR)
+        self.assertTrue(self.communication_manager.request_image_status.called)
+        self.assertTrue(self.communication_manager.terminate_image.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_get_service_status_state_terminated(self):
+        self.communication_manager.request_image_status = mock.MagicMock(return_value=ImageState.TERMINATED)
+
+        result = self.inter_node_orchestrator.get_service_status(service=self.test_service)
+
+        self.assertEqual(result, ServiceState.TERMINATED)
+        self.assertTrue(self.communication_manager.request_image_status.called)
+        self.assertTrue(self.communication_manager.terminate_image.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_get_service_status_state_stopping(self):
+        self.communication_manager.request_image_status = mock.MagicMock(return_value=ImageState.STOPPING)
+
+        result = self.inter_node_orchestrator.get_service_status(service=self.test_service)
+
+        self.assertEqual(result, ServiceState.STOPPING)
+        self.assertTrue(self.communication_manager.request_image_status.called)
+        self.assertTrue(self.communication_manager.terminate_image.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_get_service_status_state_instantiating(self):
+        self.communication_manager.request_image_status = mock.MagicMock(return_value=ImageState.INSTANTIATING)
+
+        result = self.inter_node_orchestrator.get_service_status(service=self.test_service)
+
+        self.assertEqual(result, ServiceState.INSTANTIATING)
+        self.assertTrue(self.communication_manager.request_image_status.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_get_service_status_state_initial(self):
+        self.communication_manager.request_image_status = mock.MagicMock(return_value=ImageState.INITIAL)
+
+        result = self.inter_node_orchestrator.get_service_status(service=self.test_service)
+
+        self.assertEqual(result, ServiceState.INITIAL)
+        self.assertTrue(self.communication_manager.request_image_status.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_get_service_status_state_running(self):
+        self.communication_manager.request_image_status = mock.MagicMock(return_value=ImageState.RUNNING)
+
+        result = self.inter_node_orchestrator.get_service_status(service=self.test_service)
+
+        self.assertEqual(result, ServiceState.RUNNING)
+        self.assertTrue(self.communication_manager.request_image_status.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_get_service_status_state_unkown(self):
+        self.communication_manager.request_image_status = mock.MagicMock(return_value=999)
+
+        result = self.inter_node_orchestrator.get_service_status(service=self.test_service)
+
+        self.assertEqual(result, ServiceState.ERROR)
+        self.assertTrue(self.communication_manager.request_image_status.called)
+        self.assertTrue(self.service_repository.update.called)
+
+    def test_compare_capabilities_both_equal(self):
+        node_capabilities_dict = [{'capability': 'first'}, {'capability': 'second'}, {'capability': 'third'}]
+
+        result = self.inter_node_orchestrator.compare_capabilities(
+            needed_capabilities_list=self.test_image.capabilities,
+            node_capabilities_dict=node_capabilities_dict)
+
+        self.assertTrue(result)
+
+    def test_compare_capabilities_both_unequal(self):
+        node_capabilities_dict = [{'capability': 'wrong'}, {'capability': 'also wrong'}]
+
+        result = self.inter_node_orchestrator.compare_capabilities(
+            needed_capabilities_list=self.test_image.capabilities,
+            node_capabilities_dict=node_capabilities_dict)
+
+        self.assertFalse(result)
+
+    def test_find_node_successfully(self):
+        test_node = {'ip': '127.0.0.42'}
+        self.node_repository.all = mock.MagicMock(return_value=[test_node])
+        self.communication_manager.request_capabilities = mock.MagicMock(
+            return_value=[{'capability': 'first'}, {'capability': 'second'}, {'capability': 'third'}])
+
+        result = self.inter_node_orchestrator.find_node(image=self.test_image)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(test_node['ip'], result['ip'])
+        self.assertTrue(self.node_repository.all.called)
+        self.assertTrue(self.communication_manager.request_capabilities.called)
+
+    def test_find_node_unsuccessfully(self):
+        test_node = {'ip': '127.0.0.42'}
+        self.node_repository.all = mock.MagicMock(return_value=[test_node])
+        self.communication_manager.request_capabilities = mock.MagicMock(
+            return_value=[{'capability': 'wrong'}, {'capability': 'also wrong'}])
+
+        result = self.inter_node_orchestrator.find_node(image=self.test_image)
+
+        self.assertIsNone(result)
+        self.assertTrue(self.node_repository.all.called)
+        self.assertTrue(self.communication_manager.request_capabilities.called)
+
+    def test_terminate_service_service_exist(self):
+        self.service_repository.has = mock.MagicMock(return_value=True)
+
+        self.inter_node_orchestrator.terminate_service(service=self.test_service)
+
+        self.assertTrue(self.service_repository.has.called)
+        self.assertTrue(self.service_repository.update.called)
+        self.assertTrue(self.communication_manager.terminate_image.called)
+
+    def test_terminate_service_service_does_not_exist(self):
+        self.service_repository.has = mock.MagicMock(return_value=False)
+
+        self.inter_node_orchestrator.terminate_service(service=self.test_service)
+
+        self.assertTrue(self.service_repository.has.called)
+        self.assertFalse(self.service_repository.update.called)
+        self.assertFalse(self.communication_manager.terminate_image.called)
+        self.assertTrue(self.logger.error.called)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/repositories/test_capability_repository.py

@@ -1,5 +1,4 @@
 import unittest
-import uuid
 from unittest import mock
 
 from tinydb import TinyDB, Query

tests/repositories/test_service_repository.py

@@ -4,7 +4,6 @@
 
 from tinydb import TinyDB, Query
 
-from motey.models.service import Service
 from motey.repositories import service_repository
 
 

tests/utils/test_network_utils.py

@@ -1,6 +1,6 @@
+import socket as Socket
 import unittest
 from unittest.mock import MagicMock, Mock
-import socket as Socket
 
 from motey.utils import network_utils
 

tests/utils/test_path_helper.py

@@ -1,7 +1,6 @@
-import unittest
-from unittest import mock
 import os
 import sys
+import unittest
 
 from motey.utils.path_helper import absolute_file_path