test(unit/cli): Rework pre-processor binding manager tests

Author: gfieni

tests/unit/cli/conftest.py

@@ -80,23 +80,6 @@ def several_inputs_outputs_stream_socket_without_some_arguments_config(several_i
     return several_inputs_outputs_stream_config
 
 
-@pytest.fixture
-def several_k8s_pre_processors_config():
-    """
-    Configuration with several k8s processors
-    """
-    return load_configuration_from_json_file(file_name='several_k8s_pre_processors_configuration.json')
-
-
-@pytest.fixture
-def several_k8s_pre_processors_without_some_arguments_config():
-    """
-    Configuration with several k8s processors
-    """
-    return load_configuration_from_json_file(
-        file_name='several_k8s_pre_processors_without_some_arguments_configuration.json')
-
-
 @pytest.fixture
 def csv_io_postmortem_config(invalid_csv_io_stream_config):
     """
@@ -419,124 +402,12 @@ def empty_pre_processor_config(pre_processor_complete_configuration):
     return pre_processor_complete_configuration
 
 
-@pytest.fixture(params=['k8s_pre_processor_wrong_binding_configuration.json'])
-def pre_processor_wrong_binding_configuration(request):
-    """
-    Return a dictionary containing wrong bindings with a pre-processor
-    """
-    return load_configuration_from_json_file(file_name=request.param)
-
-
 @pytest.fixture(params=['k8s_pre_processor_with_non_existing_puller_configuration.json'])
 def pre_processor_with_unexisting_puller_configuration(request):
     """
     Return a dictionary containing a pre-processor with a puller that doesn't exist
     """
-    return load_configuration_from_json_file(
-        file_name=request.param)
-
-
-@pytest.fixture(params=['k8s_pre_processor_with_reused_puller_in_bindings_configuration.json'])
-def pre_processor_with_reused_puller_in_bindings_configuration(request):
-    """
-    Return a dictionary containing a pre-processor with a puller that doesn't exist
-    """
-    return load_configuration_from_json_file(
-        file_name=request.param)
-
-
-@pytest.fixture
-def pre_processor_pullers_and_processors_dictionaries(pre_processor_complete_configuration):
-    """
-    Return a dictionary which contains puller actors, a dictionary of processors as well as the pushers
-    """
-    return get_pre_processor_pullers_and_processors_dictionaries_from_configuration(
-        configuration=pre_processor_complete_configuration)
-
-
-def get_pre_processor_pullers_and_processors_dictionaries_from_configuration(configuration: dict) -> (dict, dict, dict):
-    """
-    Return a tuple of dictionaries (pullers, processors) created from the given configuration.
-    :param dict configuration : Dictionary containing the configuration
-    """
-    report_filter = BroadcastReportFilter()
-    puller_generator = PullerGenerator(report_filter=report_filter)
-    pullers = puller_generator.generate(main_config=configuration)
-
-    pusher_generator = PusherGenerator()
-    pushers = pusher_generator.generate(main_config=configuration)
-
-    route_table = RouteTable()
-
-    dispatcher = DispatcherActor('dispatcher', None, pushers, route_table)
-
-    report_filter.register(lambda msg: True, dispatcher.get_proxy())
-
-    processor_generator = PreProcessorGenerator()
-    processors = processor_generator.generate(main_config=configuration)
-
-    return pullers, processors, pushers
-
-
-@pytest.fixture
-def pre_processor_binding_manager(pre_processor_complete_configuration, pre_processor_pullers_and_processors_dictionaries):
-    """
-    Return a ProcessorBindingManager with a Processor
-    """
-    pullers = pre_processor_pullers_and_processors_dictionaries[0]
-    processors = pre_processor_pullers_and_processors_dictionaries[1]
-
-    return PreProcessorBindingManager(
-        config=pre_processor_complete_configuration,
-        pullers=pullers,
-        processors=processors
-    )
-
-
-@pytest.fixture
-def pre_processor_binding_manager_with_wrong_binding_types(pre_processor_wrong_binding_configuration):
-    """
-    Return a PreProcessorBindingManager with wrong target for the pre-processor (a pusher instead of a puller)
-    """
-    _, processors, pushers = get_pre_processor_pullers_and_processors_dictionaries_from_configuration(
-        configuration=pre_processor_wrong_binding_configuration)
-
-    return PreProcessorBindingManager(
-        config=pre_processor_wrong_binding_configuration,
-        pullers=pushers,
-        processors=processors
-    )
-
-
-@pytest.fixture
-def pre_processor_binding_manager_with_unexisting_puller(pre_processor_with_unexisting_puller_configuration):
-    """
-    Return a PreProcessorBindingManager with an unexisting target for the pre-processor (a puller that doesn't exist)
-    """
-    pullers, processors, _ = get_pre_processor_pullers_and_processors_dictionaries_from_configuration(
-        configuration=pre_processor_with_unexisting_puller_configuration)
-
-    return PreProcessorBindingManager(
-        config=pre_processor_with_unexisting_puller_configuration,
-        pullers=pullers,
-        processors=processors
-    )
-
-
-@pytest.fixture
-def pre_processor_binding_manager_with_reused_puller_in_bindings(
-        pre_processor_with_reused_puller_in_bindings_configuration):
-    """
-    Return a PreProcessorBindingManager with a puller used by two different pre-processors
-    """
-    pullers, processors, _ = get_pre_processor_pullers_and_processors_dictionaries_from_configuration(
-        configuration=pre_processor_with_reused_puller_in_bindings_configuration)
-
-    return PreProcessorBindingManager(
-        config=pre_processor_with_reused_puller_in_bindings_configuration,
-        pullers=pullers,
-        processors=processors
-    )
+    return load_configuration_from_json_file(request.param)
 
 
 def get_config_with_longest_argument_names(config: dict, arguments: dict):

tests/unit/cli/test_binding_manager.py

@@ -27,143 +27,161 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-import copy
+from unittest.mock import Mock
 
 import pytest
 
+from powerapi.actor import ActorProxy
 from powerapi.cli.binding_manager import PreProcessorBindingManager
-from powerapi.exception import UnsupportedActorTypeException, UnexistingActorException, TargetActorAlreadyUsed
+from powerapi.cli.generator import PreProcessorGenerator, PullerGenerator
+from powerapi.dispatcher import DispatcherActor
+from powerapi.exception import UnexistingActorException, UnsupportedActorTypeException, TargetActorAlreadyUsed
+from powerapi.filter import BroadcastReportFilter
+from powerapi.processor.processor_actor import PreProcessorActor, ProcessorActor
+from powerapi.puller import PullerActor
 
 
-def test_create_pre_processor_binding_manager_with_actors(pre_processor_complete_configuration, pre_processor_pullers_and_processors_dictionaries):
+class NoopPreprocessor(PreProcessorActor):
     """
-    Test that a PreProcessorBindingManager is correctly created when an actor and a processor dictionary are provided
+    Pre-processor actor that does nothing, for testing purposes.
     """
-    expected_actors_dictionary = copy.copy(pre_processor_pullers_and_processors_dictionaries[0])
-    expected_processors_dictionary = copy.copy(pre_processor_pullers_and_processors_dictionaries[1])
 
-    binding_manager = PreProcessorBindingManager(
-        config=pre_processor_complete_configuration,
-        pullers=pre_processor_pullers_and_processors_dictionaries[0],
-        processors=pre_processor_pullers_and_processors_dictionaries[1]
-    )
 
-    assert binding_manager.actors == expected_actors_dictionary
-    assert binding_manager.processors == expected_processors_dictionary
+@pytest.fixture
+def preprocessor_config():
+    """
+    Fixture that provides a configuration with a socket puller and a no-op pre-processor.
+    """
+    return {
+        'verbose': True,
+        'stream': True,
+        'input': {
+            'pytest-socket-puller': {
+                'type': 'socket',
+                'model': 'HWPCReport',
+                'host': 'localhost',
+                'port': 8889
+            }
+        },
+        'pre-processor': {
+            'pytest-noop-preprocessor': {
+                'type': 'noop',
+                'puller': 'pytest-socket-puller'
+            }
+        }
+    }
 
 
-def test_create_processor_binding_manager_without_actors():
+@pytest.fixture
+def puller_generator() -> PullerGenerator:
     """
-    Test that a ProcessorBindingManager is correctly created without a dictionary
+    Fixture that provides a generator for the puller actors.
     """
-    binding_manager = PreProcessorBindingManager(config={}, pullers=None, processors=None)
+    report_filter = BroadcastReportFilter()
+    report_filter.register(lambda _: True, Mock(actor_name='pytest-dispatcher', actor_type=DispatcherActor, spec=ActorProxy))
 
-    assert len(binding_manager.actors) == 0
-    assert len(binding_manager.processors) == 0
+    generator = PullerGenerator(report_filter)
+    return generator
 
 
-def test_process_bindings_for_pre_processor(pre_processor_complete_configuration, pre_processor_pullers_and_processors_dictionaries):
+@pytest.fixture
+def preprocessor_generator() -> PreProcessorGenerator:
     """
-    Test that the bindings between a puller and a processor are correctly created
+    Fixture to return a preprocessor generator with the noop preprocessor available.
     """
-    pullers = pre_processor_pullers_and_processors_dictionaries[0]
-    processors = pre_processor_pullers_and_processors_dictionaries[1]
-    binding_manager = PreProcessorBindingManager(pre_processor_complete_configuration, pullers, processors)
-
-    dispatchers = list(pullers['one_puller'].report_filter.dispatchers())
-    assert len(dispatchers) == 1
-    assert dispatchers[0].actor_name == 'dispatcher'
+    generator = PreProcessorGenerator()
 
-    binding_manager.process_bindings()
-
-    dispatchers = list(pullers['one_puller'].report_filter.dispatchers())
-    assert len(dispatchers) == 1
-    assert dispatchers[0].actor_name == 'my_processor'
+    def _noop_processor_factory(_) -> ProcessorActor:
+        return NoopPreprocessor('pytest-noop-preprocessor')
 
-    assert len(processors['my_processor'].target_actors) == 1
-    assert processors['my_processor'].target_actors[0].actor_name == 'dispatcher'
+    generator.add_processor_factory('noop', _noop_processor_factory)
+    return generator
 
 
-def test_process_bindings_for_pre_processor_raise_exception_with_wrong_binding_types(pre_processor_binding_manager_with_wrong_binding_types):
+def test_preprocessor_binding_manager_replace_puller_target(puller_generator, preprocessor_generator, preprocessor_config):
     """
-    Test that an exception is raised with a wrong type for the from actor in a binding
+    The binding manager should replace the target of the puller actor from a dispatcher actor to the pre-processor actor.
     """
+    pullers = puller_generator.generate(preprocessor_config)
+    processors = preprocessor_generator.generate(preprocessor_config)
+    binding_manager = PreProcessorBindingManager(preprocessor_config, pullers, processors)
 
-    with pytest.raises(UnsupportedActorTypeException):
-        pre_processor_binding_manager_with_wrong_binding_types.process_bindings()
+    puller = pullers['pytest-socket-puller']
+    assert isinstance(puller, PullerActor)
 
+    puller_target_proxy, = puller.report_filter.dispatchers()
+    assert issubclass(puller_target_proxy.actor_type, DispatcherActor)
+    assert puller_target_proxy.actor_name == 'pytest-dispatcher'
 
-def test_process_bindings_for_pre_processor_raise_exception_with_no_existing_puller(
-        pre_processor_binding_manager_with_unexisting_puller):
-    """
-    Test that an exception is raised with a puller that doesn't exist
-    """
+    binding_manager.process_bindings()
 
-    with pytest.raises(UnexistingActorException):
-        pre_processor_binding_manager_with_unexisting_puller.process_bindings()
+    puller_target_proxy, = puller.report_filter.dispatchers()
+    assert issubclass(puller_target_proxy.actor_type, PreProcessorActor)
+    assert puller_target_proxy.actor_name == 'pytest-noop-preprocessor'
 
 
-def test_process_bindings_for_pre_processor_raise_exception_with_reused_puller_in_bindings(
-        pre_processor_binding_manager_with_reused_puller_in_bindings):
+def test_preprocessor_binding_manager_with_empty_preprocessor_config(puller_generator, preprocessor_config):
     """
-    Test that an exception is raised when the same puller is used by several processors
+    The binding manager should not replace the target of the puller actor when there is no pre-processor configuration.
     """
+    preprocessor_config['pre-processor'] = {}
 
-    with pytest.raises(TargetActorAlreadyUsed):
-        pre_processor_binding_manager_with_reused_puller_in_bindings.process_bindings()
+    pullers = puller_generator.generate(preprocessor_config)
+    processors = {}
+    binding_manager = PreProcessorBindingManager(preprocessor_config, pullers, processors)
 
+    puller = pullers['pytest-socket-puller']
+    assert isinstance(puller, PullerActor)
 
-def test_check_processors_targets_are_unique_raise_exception_with_reused_puller_in_bindings(
-        pre_processor_binding_manager_with_reused_puller_in_bindings):
-    """
-    Test that an exception is raised when the same puller is used by several processors
-    """
-    with pytest.raises(TargetActorAlreadyUsed):
-        pre_processor_binding_manager_with_reused_puller_in_bindings.check_processors_targets_are_unique()
+    puller_target_proxy, = puller.report_filter.dispatchers()
+    assert issubclass(puller_target_proxy.actor_type, DispatcherActor)
+    assert puller_target_proxy.actor_name == 'pytest-dispatcher'
 
+    binding_manager.process_bindings()
 
-def test_check_processors_targets_are_unique_pass_without_reused_puller_in_bindings(
-        pre_processor_binding_manager):
-    """
-    Test that a correct without repeated target passes the validation
-    """
-    try:
-        pre_processor_binding_manager.check_processors_targets_are_unique()
-    except TargetActorAlreadyUsed:
-        pytest.fail("Processors targets are not unique")
+    puller_target_proxy, = puller.report_filter.dispatchers()
+    assert issubclass(puller_target_proxy.actor_type, DispatcherActor)
+    assert puller_target_proxy.actor_name == 'pytest-dispatcher'
 
 
-def check_all_processors_targets(preprocessor_binding_manager: PreProcessorBindingManager):
+def test_preprocessor_binding_manager_with_invalid_puller_name(puller_generator, preprocessor_generator, preprocessor_config):
     """
-    Helper function that checks the processors targets of the given binding manager.
+    The binding manager should raise an exception when the puller name of the pre-processor is invalid.
     """
-    for processor_name, processor in preprocessor_binding_manager.processors.items():
-        preprocessor_binding_manager.check_processor_targets(processor_name, processor)
+    preprocessor_config['pre-processor']['pytest-noop-preprocessor']['puller'] = 'invalid-puller-target'
 
+    pullers = puller_generator.generate(preprocessor_config)
+    processors = preprocessor_generator.generate(preprocessor_config)
+    binding_manager = PreProcessorBindingManager(preprocessor_config, pullers, processors)
 
-def test_check_processor_targets_raise_exception_with_no_existing_puller(pre_processor_binding_manager_with_unexisting_puller):
-    """
-    Test that an exception is raised with a puller that doesn't exist
-    """
     with pytest.raises(UnexistingActorException):
-        check_all_processors_targets(pre_processor_binding_manager_with_unexisting_puller)
+        binding_manager.process_bindings()
 
 
-def test_check_processor_targets_raise_exception_with_raise_exception_with_wrong_binding_types(pre_processor_binding_manager_with_wrong_binding_types):
+def test_preprocessor_binding_manager_with_invalid_puller_type(puller_generator, preprocessor_generator, preprocessor_config):
     """
-    Test that an exception is raised with a puller that doesn't exist
+    The binding manager should raise an exception when the puller type of the pre-processor is invalid.
     """
+    pullers = puller_generator.generate(preprocessor_config)
+    pullers['pytest-socket-puller'] = Mock(name='pytest-socket-puller')
+
+    processors = preprocessor_generator.generate(preprocessor_config)
+    binding_manager = PreProcessorBindingManager(preprocessor_config, pullers, processors)
+
     with pytest.raises(UnsupportedActorTypeException):
-        check_all_processors_targets(pre_processor_binding_manager_with_wrong_binding_types)
+        binding_manager.process_bindings()
 
 
-def test_check_processor_targets_pass_with_correct_targets(pre_processor_binding_manager):
+def test_preprocessor_binding_manager_with_duplicate_target(puller_generator, preprocessor_generator, preprocessor_config):
     """
-    Test that validation of a configuration with existing targets of the correct type
+    The binding manager should raise an exception when multiple pre-processor have the same target.
     """
-    try:
-        check_all_processors_targets(pre_processor_binding_manager)
-    except UnsupportedActorTypeException as e:
-        pytest.fail(f'Unsupported actor type: {e}')
-    except UnexistingActorException as e:
-        pytest.fail(f'Actor does not exist: {e}')
+    pre_processors = preprocessor_config['pre-processor']
+    pre_processors['pytest-noop-preprocessor-duplicate'] = pre_processors['pytest-noop-preprocessor']
+
+    pullers = puller_generator.generate(preprocessor_config)
+    processors = preprocessor_generator.generate(preprocessor_config)
+    binding_manager = PreProcessorBindingManager(preprocessor_config, pullers, processors)
+
+    with pytest.raises(TargetActorAlreadyUsed):
+        binding_manager.process_bindings()