fix(tests): start local agent be default

update all test cases(which requires 2 agents) to use node-local as second agent
remove redundant agent configs and use the controller machine for local agent operations
simplify test setups by removing unnecessary agent configuration

current progress:

- [x] monitor-wildcard-unit-changes
- [x] proxy-service-start
- [x] bluechi-reset-failed
- [x] monitor-multiple-nodes-and-units
- [x] monitor-system-status 3 agents
- [x] bluechi-nodes-statuses
- [x] bluechi-is-oneline-system
- [x] bluechi-reset-failed
- [x] bluechi-reset-failed-node
- [x] proxy-service-stop-target
- [x] proxy-service-stop-requesting
- [x] proxy-service-stop-bluechi-dep
- [x] bluechi-list-units-on-all-nodes
- [x] monitor-wildcard-node-reconnect
- [x] bluechi-is-online-system-monitor
- [x] monitor-multiple-nodes-and-units
- [x] proxy-service-fails-on-execstart
- [x] proxy-service-fails-on-typo-in-file
- [x] proxy-service-multiple-services-one-node
- [x] service-fails-on-non-existent-service
- [x] service-stop-requesting-with-unneeded
- [x] multiple-services-multiple-nodes
- [x] propagate-target-service-failure
- [x] socket-activation-parallel

- use global constant for node-ctrl name

Fixes: #1042

Author: dracher

tests/bluechi_test/constants.py

@@ -0,0 +1,6 @@
+#
+# Copyright Contributors to the Eclipse BlueChi project
+#
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+NODE_CTRL_NAME = "node-ctrl"

tests/bluechi_test/test.py

@@ -14,6 +14,7 @@
 from bluechi_test.client import ContainerClient, SSHClient
 from bluechi_test.command import Command
 from bluechi_test.config import BluechiAgentConfig, BluechiControllerConfig
+from bluechi_test.constants import NODE_CTRL_NAME
 from bluechi_test.machine import (
     BluechiAgentMachine,
     BluechiControllerMachine,
@@ -51,6 +52,14 @@ def __init__(
 
         self._test_init_time = datetime.datetime.now()
 
+        self.set_bluechi_local_agent_config(
+            BluechiAgentConfig(
+                file_name="agent.conf",
+                node_name=NODE_CTRL_NAME,
+                controller_address="unix:path=/run/bluechi/bluechi.sock",
+            ).deep_copy()
+        )
+
     def set_bluechi_controller_config(self, cfg: BluechiControllerConfig):
         self.bluechi_controller_config = cfg
 
@@ -253,6 +262,9 @@ def setup(
         if self.bluechi_controller_config is None:
             raise Exception("Bluechi Controller configuration not set")
 
+        if self.bluechi_local_agent_config is not None:
+            self.bluechi_controller_config.allowed_node_names.append(NODE_CTRL_NAME)
+
         success = True
         ctrl_container: BluechiControllerMachine = None
         node_container: Dict[str, BluechiAgentMachine] = dict()
@@ -386,6 +398,9 @@ def setup(
         if len(self.available_hosts) < 1:
             raise Exception("No available hosts!")
 
+        if self.bluechi_local_agent_config is not None:
+            self.bluechi_controller_config.allowed_node_names.append(NODE_CTRL_NAME)
+
         success = True
         ctrl_machine: BluechiControllerMachine = None
         agent_machines: Dict[str, BluechiAgentMachine] = dict()

tests/tests/tier0/bluechi-agent-connect-via-controller-address/test_bluechi_agent_connect_via_controller_address.py

@@ -63,6 +63,9 @@ def test_agent_invalid_configuration(
     bluechi_node_default_config: BluechiAgentConfig,
     bluechi_ctrl_default_config: BluechiControllerConfig,
 ):
+    # Disable default local agent on controller node using UDS,
+    # because we test local agent with TCP connection
+    bluechi_test.set_bluechi_local_agent_config(None)
 
     node_foo_cfg = bluechi_node_default_config.deep_copy()
     node_foo_cfg.node_name = NODE_FOO

tests/tests/tier0/bluechi-agent-resolve-fqdn/test_bluechi_agent_resolve_fqdn.py

@@ -46,4 +46,8 @@ def test_agent_resolve_fqdn(
 
     bluechi_test.set_bluechi_controller_config(bluechi_ctrl_default_config)
 
+    # Disable default local agent on controller node using UDS,
+    # because we test local agent with TCP connection
+    bluechi_test.set_bluechi_local_agent_config(None)
+
     bluechi_test.run(verify_resolving_fqdn)

tests/tests/tier0/bluechi-and-agent-on-same-machine/python/is_node_connected.py

@@ -3,16 +3,19 @@
 #
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
+import os
 import unittest
 
 from bluechi.api import Node
 
+NODE_CTRL_NAME = os.getenv("NODE_CTRL_NAME", "node-ctrl")
+
 
 class TestNodeIsConnected(unittest.TestCase):
     def test_node_is_connected(self):
-        n = Node("node-foo")
+        n = Node(NODE_CTRL_NAME)
         assert n.status == "online"
-        assert n.name == "node-foo"
+        assert n.name == NODE_CTRL_NAME
 
 
 if __name__ == "__main__":

tests/tests/tier0/bluechi-and-agent-on-same-machine/test_bluechi_and_agent_on_same_machine.py

@@ -6,17 +6,17 @@
 import os
 from typing import Dict
 
-from bluechi_test.config import BluechiAgentConfig, BluechiControllerConfig
+from bluechi_test.config import BluechiControllerConfig
+from bluechi_test.constants import NODE_CTRL_NAME
 from bluechi_test.machine import BluechiAgentMachine, BluechiControllerMachine
 from bluechi_test.test import BluechiTest
 
-node_foo_name = "node-foo"
-
 
 def exec(ctrl: BluechiControllerMachine, nodes: Dict[str, BluechiAgentMachine]):
 
     assert ctrl.wait_for_unit_state_to_be("bluechi-controller", "active")
     # local bluechi-agent is running, check if it is connected
+    os.environ["NODE_CTRL_NAME"] = NODE_CTRL_NAME
     result, output = ctrl.run_python(os.path.join("python", "is_node_connected.py"))
     if result != 0:
         raise Exception(output)
@@ -25,17 +25,5 @@ def exec(ctrl: BluechiControllerMachine, nodes: Dict[str, BluechiAgentMachine]):
 def test_bluechi_and_agent_on_same_machine(
     bluechi_test: BluechiTest, bluechi_ctrl_default_config: BluechiControllerConfig
 ):
-
-    bluechi_ctrl_default_config.allowed_node_names = [node_foo_name]
-
     bluechi_test.set_bluechi_controller_config(bluechi_ctrl_default_config)
-    # don't add node_foo_config to bluechi_test to prevent it being started
-    # as separate container
-    bluechi_test.set_bluechi_local_agent_config(
-        BluechiAgentConfig(
-            controller_address="unix:path=/run/bluechi/bluechi.sock",
-            node_name=node_foo_name,
-            file_name="agent.conf",
-        ).deep_copy()
-    )
     bluechi_test.run(exec)

tests/tests/tier0/bluechi-anonymous-node/test_anonymous_node.py

@@ -33,6 +33,7 @@ def test_anonymous_node(
     bluechi_ctrl_default_config: BluechiControllerConfig,
     bluechi_node_default_config: BluechiAgentConfig,
 ):
+    bluechi_test.set_bluechi_local_agent_config(None)
 
     node_foo_config = bluechi_node_default_config.deep_copy()
     node_foo_config.node_name = node_foo_name

tests/tests/tier0/bluechi-controller-disable-tcp-enable-uds/test_bluechi_controller_disable_tcp_enable_uds.py

@@ -7,12 +7,13 @@
 from typing import Dict
 
 from bluechi_test.config import BluechiAgentConfig, BluechiControllerConfig
+from bluechi_test.constants import NODE_CTRL_NAME
 from bluechi_test.machine import BluechiAgentMachine, BluechiControllerMachine
 from bluechi_test.test import BluechiTest
 from bluechi_test.util import Timeout
 
 LOGGER = logging.getLogger(__name__)
-NODE_LOCAL = "node-local"
+NODE_LOCAL = NODE_CTRL_NAME
 
 
 def exec(ctrl: BluechiControllerMachine, _: Dict[str, BluechiAgentMachine]):

tests/tests/tier0/bluechi-controller-runs-tcp-and-socket-activation-parallel/test_bluechi_controller_runs_tcp_and_socket_activation_parallel.py

@@ -7,12 +7,13 @@
 from typing import Dict
 
 from bluechi_test.config import BluechiAgentConfig, BluechiControllerConfig
+from bluechi_test.constants import NODE_CTRL_NAME
 from bluechi_test.machine import BluechiAgentMachine, BluechiControllerMachine
 from bluechi_test.test import BluechiTest
 from bluechi_test.util import Timeout
 
 LOGGER = logging.getLogger(__name__)
-NODE_LOCAL = "node-local"
+NODE_LOCAL = NODE_CTRL_NAME
 NODE_REMOTE = "node-remote"
 
 

tests/tests/tier0/bluechi-controller-runs-uds-and-socket-activation-parallel/test_bluechi_controller_runs_uds_and_socket_activation_parallel.py

@@ -7,12 +7,13 @@
 from typing import Dict
 
 from bluechi_test.config import BluechiAgentConfig, BluechiControllerConfig
+from bluechi_test.constants import NODE_CTRL_NAME
 from bluechi_test.machine import BluechiAgentMachine, BluechiControllerMachine
 from bluechi_test.test import BluechiTest
 from bluechi_test.util import Timeout
 
 LOGGER = logging.getLogger(__name__)
-NODE_LOCAL = "node-local"
+NODE_LOCAL = NODE_CTRL_NAME
 
 
 def exec(ctrl: BluechiControllerMachine, _: Dict[str, BluechiAgentMachine]):

tests/tests/tier0/bluechi-controller-socket-activation/python/is_node_connected.py

@@ -3,24 +3,27 @@
 #
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
+import os
 import time
 import unittest
 
 from bluechi_machine_lib.util import Timeout
 
 from bluechi.api import Node
 
-NODE_NAME = "node-foo"
+NODE_CTRL_NAME = os.getenv("NODE_CTRL_NAME", "node-ctrl")
 
 
 class TestNodeIsConnected(unittest.TestCase):
     def test_node_is_connected(self):
 
-        with Timeout(5, f"Timeout while waiting for agent '{NODE_NAME}' to be online"):
+        with Timeout(
+            5, f"Timeout while waiting for agent '{NODE_CTRL_NAME}' to be online"
+        ):
             status = "offline"
             while status != "online":
                 try:
-                    status = Node(NODE_NAME).status
+                    status = Node(NODE_CTRL_NAME).status
                     time.sleep(0.5)
                 except Exception:
                     pass

tests/tests/tier0/bluechi-controller-socket-activation/test_bluechi_controller_socket_activation.py

@@ -7,12 +7,12 @@
 import os
 from typing import Dict
 
-from bluechi_test.config import BluechiAgentConfig, BluechiControllerConfig
+from bluechi_test.config import BluechiControllerConfig
+from bluechi_test.constants import NODE_CTRL_NAME
 from bluechi_test.machine import BluechiAgentMachine, BluechiControllerMachine
 from bluechi_test.test import BluechiTest
 
 LOGGER = logging.getLogger(__name__)
-NODE_FOO = "node-foo"
 
 
 def exec(ctrl: BluechiControllerMachine, _: Dict[str, BluechiAgentMachine]):
@@ -22,21 +22,9 @@ def exec(ctrl: BluechiControllerMachine, _: Dict[str, BluechiAgentMachine]):
     ctrl.systemctl.start_unit("bluechi-controller.socket")
     assert ctrl.wait_for_unit_state_to_be("bluechi-controller.socket", "active")
 
-    agent_config = BluechiAgentConfig(
-        file_name="agent.conf",
-        controller_address="unix:path=/run/bluechi/bluechi.sock",
-        node_name=NODE_FOO,
-    )
-    ctrl.create_file(
-        agent_config.get_confd_dir(),
-        agent_config.file_name,
-        agent_config.serialize(),
-    )
-
-    ctrl.systemctl.start_unit("bluechi-agent.service")
-    ctrl.wait_for_unit_state_to_be("bluechi-agent.service", "active")
     ctrl.wait_for_unit_state_to_be("bluechi-controller.service", "active")
 
+    os.environ["NODE_CTRL_NAME"] = NODE_CTRL_NAME
     result, output = ctrl.run_python(os.path.join("python", "is_node_connected.py"))
     if result != 0:
         raise Exception(output)
@@ -46,7 +34,6 @@ def test_bluechi_controller_socket_activation(
     bluechi_test: BluechiTest,
     bluechi_ctrl_default_config: BluechiControllerConfig,
 ):
-    bluechi_ctrl_default_config.allowed_node_names = [NODE_FOO]
     bluechi_test.set_bluechi_controller_config(bluechi_ctrl_default_config)
 
     bluechi_test.run(exec)

tests/tests/tier0/bluechi-is-online-system-monitor/test_bluechi_is_online_system_monitor.py

@@ -7,14 +7,14 @@
 from typing import Dict
 
 from bluechi_test.config import BluechiAgentConfig, BluechiControllerConfig
+from bluechi_test.constants import NODE_CTRL_NAME
 from bluechi_test.machine import BluechiAgentMachine, BluechiControllerMachine
 from bluechi_test.test import BluechiTest
 from bluechi_test.util import Timeout, get_test_env_value_int
 
 LOGGER = logging.getLogger(__name__)
 
 AGENT_ONE = "agent-one"
-AGENT_TWO = "agent-two"
 SLEEP_DURATION = get_test_env_value_int("SLEEP_DURATION", 2)
 
 
@@ -76,10 +76,10 @@ def exec(ctrl: BluechiControllerMachine, nodes: Dict[str, BluechiAgentMachine]):
     assert nodes[AGENT_ONE].wait_for_unit_state_to_be("bluechi-agent", "active")
 
     # Test 3: Agent-two offline
-    LOGGER.debug("Stopping agent-two.")
-    nodes[AGENT_TWO].systemctl.stop_unit("bluechi-agent")
+    LOGGER.debug(f"Stopping {NODE_CTRL_NAME}.")
+    ctrl.systemctl.stop_unit("bluechi-agent")
 
-    assert nodes[AGENT_TWO].wait_for_unit_state_to_be("bluechi-agent", "inactive")
+    assert ctrl.wait_for_unit_state_to_be("bluechi-agent", "inactive")
 
     monitor_result_test_three = MonitorResult()
     monitor_thread = threading.Thread(
@@ -94,16 +94,16 @@ def exec(ctrl: BluechiControllerMachine, nodes: Dict[str, BluechiAgentMachine]):
     ), "Monitor command should produce output when agent-two is offline."
 
     # Bring agent-two back online
-    LOGGER.debug("Starting agent-two.")
-    nodes[AGENT_TWO].systemctl.start_unit("bluechi-agent")
+    LOGGER.debug(f"Starting {NODE_CTRL_NAME}.")
+    ctrl.systemctl.start_unit("bluechi-agent")
 
     # Test 4: Both agents offline
     LOGGER.debug("Stopping both agents.")
     nodes[AGENT_ONE].systemctl.stop_unit("bluechi-agent")
-    nodes[AGENT_TWO].systemctl.stop_unit("bluechi-agent")
+    ctrl.systemctl.stop_unit("bluechi-agent")
 
     assert nodes[AGENT_ONE].wait_for_unit_state_to_be("bluechi-agent", "inactive")
-    assert nodes[AGENT_TWO].wait_for_unit_state_to_be("bluechi-agent", "inactive")
+    assert ctrl.wait_for_unit_state_to_be("bluechi-agent", "inactive")
 
     monitor_result_test_four = MonitorResult()
     monitor_thread = threading.Thread(
@@ -120,7 +120,7 @@ def exec(ctrl: BluechiControllerMachine, nodes: Dict[str, BluechiAgentMachine]):
     # Bring both agents back online
     LOGGER.debug("Starting both agents.")
     nodes[AGENT_ONE].systemctl.start_unit("bluechi-agent")
-    nodes[AGENT_TWO].systemctl.start_unit("bluechi-agent")
+    ctrl.systemctl.start_unit("bluechi-agent")
 
     # Test 5: Controller offline
     LOGGER.debug("Stopping the controller.")
@@ -147,13 +147,9 @@ def test_bluechi_is_online_system_monitor(
     agent_one_cfg = bluechi_node_default_config.deep_copy()
     agent_one_cfg.node_name = AGENT_ONE
 
-    agent_two_cfg = bluechi_node_default_config.deep_copy()
-    agent_two_cfg.node_name = AGENT_TWO
-
-    bluechi_ctrl_default_config.allowed_node_names = [AGENT_ONE, AGENT_TWO]
+    bluechi_ctrl_default_config.allowed_node_names = [AGENT_ONE]
 
     bluechi_test.set_bluechi_controller_config(bluechi_ctrl_default_config)
     bluechi_test.add_bluechi_agent_config(agent_one_cfg)
-    bluechi_test.add_bluechi_agent_config(agent_two_cfg)
 
     bluechi_test.run(exec)