tests(test_1_unmapped_vdevice_access.py): add new test that validates…

… the UnmappedVDevice access check and working with different VDevices mappings through a balder session

tests/vdevice/test_1_unmapped_vdevice_access/env/lib/connections.py

@@ -0,0 +1,6 @@
+import balder
+
+
+class MySimplySharedMemoryConnection(balder.Connection):
+    """This is a simply shared memory connection"""
+    pass

tests/vdevice/test_1_unmapped_vdevice_access/env/lib/features.py

@@ -0,0 +1,47 @@
+import balder
+
+
+class ProvidesANumberFeature(balder.Feature):
+
+    the_number = 0
+
+    def set_number(self, number):
+        """user method that allows to set the number"""
+        self.the_number = number
+
+    def get_number(self):
+        """returns the set number"""
+        raise NotImplementedError("has to be implemented in subclass")
+
+    def sends_the_number(self):
+        """sends the set number"""
+        raise NotImplementedError("has to be implemented in subclass")
+
+
+class AddCalculateFeature(balder.Feature):
+    """
+    note: Although this feature has two vdevices that define a number provider, please note that multiple vdevice
+    mappings are not yet supported.
+    """
+
+    all_numbers = []
+
+    class ANumberProviderDevice1(balder.VDevice):
+        provider = ProvidesANumberFeature()
+
+    class ANumberProviderDevice2(balder.VDevice):
+        provider = ProvidesANumberFeature()
+
+    def get_numbers(self):
+        """this method get all the single numbers that should be calculated"""
+        raise NotImplementedError("has to be implemented in subclass")
+
+    def add_numbers(self):
+        """this method adds all the numbers"""
+        raise NotImplementedError("has to be implemented in subclass")
+
+    def get_number_of_provider_1(self):
+        return self.ANumberProviderDevice1.provider.get_number()
+
+    def get_number_of_provider_2(self):
+        return self.ANumberProviderDevice2.provider.get_number()

tests/vdevice/test_1_unmapped_vdevice_access/env/lib/utils.py

@@ -0,0 +1,6 @@
+
+
+class SharedObj:
+    """this class simulates a basic shared memory"""
+
+    shared_mem_list = []

tests/vdevice/test_1_unmapped_vdevice_access/env/scenarios/scenario_adding_no_mapping.py

@@ -0,0 +1,32 @@
+import logging
+import balder
+from ..lib.features import AddCalculateFeature, ProvidesANumberFeature
+from balder.exceptions import AccessToUnmappedVDeviceException
+
+
+logger = logging.getLogger(__name__)
+
+
+class ScenarioAddingNoMapping(balder.Scenario):
+
+    class Calculator(balder.Device):
+        adds = AddCalculateFeature()
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberOneDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberTwoDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    def test_add_two_numbers(self):
+        self.NumberOneDevice.number.set_number(3)
+        self.NumberTwoDevice.number.set_number(4)
+
+        self.NumberOneDevice.number.sends_the_number()
+        self.NumberTwoDevice.number.sends_the_number()
+
+        self.Calculator.adds.get_numbers()
+        result = self.Calculator.adds.add_numbers()
+        assert result == 7, "result is not as expected"

tests/vdevice/test_1_unmapped_vdevice_access/env/scenarios/scenario_adding_vdevice1_with_one_mapped.py

@@ -0,0 +1,61 @@
+import logging
+import balder
+from ..lib.features import AddCalculateFeature, ProvidesANumberFeature
+from balder.exceptions import AccessToUnmappedVDeviceException
+
+
+logger = logging.getLogger(__name__)
+
+
+class ScenarioAddingVDevice1WithOneMapped(balder.Scenario):
+
+    class Calculator(balder.Device):
+        adds = AddCalculateFeature(ANumberProviderDevice1="NumberOneDevice")
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberOneDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberTwoDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    def test_add_two_numbers(self):
+        self.NumberOneDevice.number.set_number(3)
+        self.NumberTwoDevice.number.set_number(4)
+
+        self.NumberOneDevice.number.sends_the_number()
+        self.NumberTwoDevice.number.sends_the_number()
+
+        self.Calculator.adds.get_numbers()
+        result = self.Calculator.adds.add_numbers()
+        assert result == 7, "result is not as expected"
+
+        self.validate_vdevice_references()
+
+    def validate_vdevice_references(self):
+        assert self.Calculator.adds.get_number_of_provider_1() == self.NumberOneDevice.number.get_number(), \
+            f"the currently mapped internal vdevice returns an unexpected value " \
+            f"`{self.Calculator.adds.get_number_of_provider_1()}` " \
+            f"(expected `{self.NumberOneDevice.number.get_number()}`)"
+
+        try:
+            self.Calculator.adds.get_number_of_provider_2()
+            assert False, "provider 2 does return a value -> not allowed, because this VDevice was not mapped"
+        except AccessToUnmappedVDeviceException as exc:
+            logger.info(f'access to unmapped VDevice throws error message: `{str(exc)}`')
+            assert exc.args[0] == "it is not allowed to access the attributes of an unmapped VDevice - " \
+                                  "did you forget to map it?"
+
+    @balder.fixture(level='variation')
+    def fixture_vdevice_access_variation(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()
+
+    @balder.fixture(level='testcase')
+    def fixture_vdevice_access_testcase(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()
+

tests/vdevice/test_1_unmapped_vdevice_access/env/scenarios/scenario_adding_vdevice1_with_two_mapped.py

@@ -0,0 +1,60 @@
+import logging
+import balder
+from ..lib.features import AddCalculateFeature, ProvidesANumberFeature
+from balder.exceptions import AccessToUnmappedVDeviceException
+
+
+logger = logging.getLogger(__name__)
+
+
+class ScenarioAddingVDevice1WithTwoMapped(balder.Scenario):
+
+    class Calculator(balder.Device):
+        adds = AddCalculateFeature(ANumberProviderDevice1="NumberTwoDevice")
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberOneDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberTwoDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    def test_add_two_numbers(self):
+        self.NumberOneDevice.number.set_number(3)
+        self.NumberTwoDevice.number.set_number(4)
+
+        self.NumberOneDevice.number.sends_the_number()
+        self.NumberTwoDevice.number.sends_the_number()
+
+        self.Calculator.adds.get_numbers()
+        result = self.Calculator.adds.add_numbers()
+        assert result == 7, "result is not as expected"
+
+        self.validate_vdevice_references()
+
+    def validate_vdevice_references(self):
+        assert self.Calculator.adds.get_number_of_provider_1() == self.NumberTwoDevice.number.get_number(), \
+            f"the currently mapped internal vdevice returns an unexpected value " \
+            f"`{self.Calculator.adds.get_number_of_provider_1()}` " \
+            f"(expected `{self.NumberTwoDevice.number.get_number()}`)"
+
+        try:
+            self.Calculator.adds.get_number_of_provider_2()
+            assert False, "provider 2 does return a value -> not allowed, because this VDevice was not mapped"
+        except AccessToUnmappedVDeviceException as exc:
+            logger.info(f'access to unmapped VDevice throws error message: `{str(exc)}`')
+            assert exc.args[0] == "it is not allowed to access the attributes of an unmapped VDevice - " \
+                                  "did you forget to map it?"
+
+    @balder.fixture(level='variation')
+    def fixture_vdevice_access_variation(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()
+
+    @balder.fixture(level='testcase')
+    def fixture_vdevice_access_testcase(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()

tests/vdevice/test_1_unmapped_vdevice_access/env/scenarios/scenario_adding_vdevice2_with_one_mapped.py

@@ -0,0 +1,60 @@
+import logging
+import balder
+from ..lib.features import AddCalculateFeature, ProvidesANumberFeature
+from balder.exceptions import AccessToUnmappedVDeviceException
+
+
+logger = logging.getLogger(__name__)
+
+
+class ScenarioAddingVDevice2WithOneMapped(balder.Scenario):
+
+    class Calculator(balder.Device):
+        adds = AddCalculateFeature(ANumberProviderDevice2="NumberOneDevice")
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberOneDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberTwoDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    def test_add_two_numbers(self):
+        self.NumberOneDevice.number.set_number(3)
+        self.NumberTwoDevice.number.set_number(4)
+
+        self.NumberOneDevice.number.sends_the_number()
+        self.NumberTwoDevice.number.sends_the_number()
+
+        self.Calculator.adds.get_numbers()
+        result = self.Calculator.adds.add_numbers()
+        assert result == 7, "result is not as expected"
+
+        self.validate_vdevice_references()
+
+    def validate_vdevice_references(self):
+        assert self.Calculator.adds.get_number_of_provider_2() == self.NumberOneDevice.number.get_number(), \
+            f"the currently mapped internal vdevice returns an unexpected value " \
+            f"`{self.Calculator.adds.get_number_of_provider_2()}` " \
+            f"(expected `{self.NumberOneDevice.number.get_number()}`)"
+
+        try:
+            self.Calculator.adds.get_number_of_provider_1()
+            assert False, "provider 1 does return a value -> not allowed, because this VDevice was not mapped"
+        except AccessToUnmappedVDeviceException as exc:
+            logger.info(f'access to unmapped VDevice throws error message: `{str(exc)}`')
+            assert exc.args[0] == "it is not allowed to access the attributes of an unmapped VDevice - " \
+                                  "did you forget to map it?"
+
+    @balder.fixture(level='variation')
+    def fixture_vdevice_access_variation(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()
+
+    @balder.fixture(level='testcase')
+    def fixture_vdevice_access_testcase(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()

tests/vdevice/test_1_unmapped_vdevice_access/env/scenarios/scenario_adding_vdevice2_with_two_mapped.py

@@ -0,0 +1,60 @@
+import logging
+import balder
+from ..lib.features import AddCalculateFeature, ProvidesANumberFeature
+from balder.exceptions import AccessToUnmappedVDeviceException
+
+
+logger = logging.getLogger(__name__)
+
+
+class ScenarioAddingVDevice2WithTwoMapped(balder.Scenario):
+
+    class Calculator(balder.Device):
+        adds = AddCalculateFeature(ANumberProviderDevice2="NumberTwoDevice")
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberOneDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    @balder.connect(Calculator, over_connection=balder.Connection)
+    class NumberTwoDevice(balder.Device):
+        number = ProvidesANumberFeature()
+
+    def test_add_two_numbers(self):
+        self.NumberOneDevice.number.set_number(3)
+        self.NumberTwoDevice.number.set_number(4)
+
+        self.NumberOneDevice.number.sends_the_number()
+        self.NumberTwoDevice.number.sends_the_number()
+
+        self.Calculator.adds.get_numbers()
+        result = self.Calculator.adds.add_numbers()
+        assert result == 7, "result is not as expected"
+
+        self.validate_vdevice_references()
+
+    def validate_vdevice_references(self):
+        assert self.Calculator.adds.get_number_of_provider_2() == self.NumberTwoDevice.number.get_number(), \
+            f"the currently mapped internal vdevice returns an unexpected value " \
+            f"`{self.Calculator.adds.get_number_of_provider_2()}` " \
+            f"(expected `{self.NumberTwoDevice.number.get_number()}`)"
+
+        try:
+            self.Calculator.adds.get_number_of_provider_1()
+            assert False, "provider 1 does return a value -> not allowed, because this VDevice was not mapped"
+        except AccessToUnmappedVDeviceException as exc:
+            logger.info(f'access to unmapped VDevice throws error message: `{str(exc)}`')
+            assert exc.args[0] == "it is not allowed to access the attributes of an unmapped VDevice - " \
+                                  "did you forget to map it?"
+
+    @balder.fixture(level='variation')
+    def fixture_vdevice_access_variation(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()
+
+    @balder.fixture(level='testcase')
+    def fixture_vdevice_access_testcase(self):
+        self.validate_vdevice_references()
+        yield
+        self.validate_vdevice_references()

tests/vdevice/test_1_unmapped_vdevice_access/env/setups/features_setup.py

@@ -0,0 +1,23 @@
+from ..lib.features import AddCalculateFeature, ProvidesANumberFeature
+from ..lib.utils import SharedObj
+
+
+class PyAddProvideANumber(ProvidesANumberFeature):
+
+    def get_number(self):
+        return self.the_number
+
+    def sends_the_number(self):
+        SharedObj.shared_mem_list.append(self.the_number)
+
+
+class PyAddCalculate(AddCalculateFeature):
+
+    def get_numbers(self):
+        self.all_numbers = SharedObj.shared_mem_list
+
+    def add_numbers(self):
+        result = 0
+        for cur_number in self.all_numbers:
+            result += cur_number
+        return result

tests/vdevice/test_1_unmapped_vdevice_access/env/setups/setup_pythonadd_no_mapping.py

@@ -0,0 +1,22 @@
+import balder
+from ..lib.connections import MySimplySharedMemoryConnection
+from ..lib.utils import SharedObj
+from .features_setup import PyAddCalculate, PyAddProvideANumber
+
+
+class SetupPythonAddNoMapping(balder.Setup):
+
+    class Calculator(balder.Device):
+        calc = PyAddCalculate()
+
+    @balder.connect(Calculator, over_connection=MySimplySharedMemoryConnection)
+    class NumberProviderOne(balder.Device):
+        n = PyAddProvideANumber()
+
+    @balder.connect(Calculator, over_connection=MySimplySharedMemoryConnection)
+    class NumberProviderTwo(balder.Device):
+        n = PyAddProvideANumber()
+
+    @balder.fixture(level="testcase")
+    def cleanup_memory(self):
+        SharedObj.shared_mem_list = []