Merge origin/dev into feature/1859

tests/conftest.py

@@ -13,6 +13,7 @@ from primaite.session.session import PrimaiteSession
 # from primaite.primaite_session import PrimaiteSession
 from primaite.simulator.network.container import Network
 from primaite.simulator.network.networks import arcd_uc2_network
+from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
 from primaite.simulator.system.applications.application import Application
 from primaite.simulator.system.core.sys_log import SysLog
@@ -34,6 +35,12 @@ from primaite.simulator.network.hardware.base import Node
 class TestService(Service):
     """Test Service class"""
 
+    def __init__(self, **kwargs):
+        kwargs["name"] = "TestService"
+        kwargs["port"] = Port.HTTP
+        kwargs["protocol"] = IPProtocol.TCP
+        super().__init__(**kwargs)
+
     def receive(self, payload: Any, session_id: str, **kwargs) -> bool:
         pass
 
@@ -41,6 +48,12 @@ class TestService(Service):
 class TestApplication(Application):
     """Test Application class"""
 
+    def __init__(self, **kwargs):
+        kwargs["name"] = "TestApplication"
+        kwargs["port"] = Port.HTTP
+        kwargs["protocol"] = IPProtocol.TCP
+        super().__init__(**kwargs)
+
     def describe_state(self) -> Dict:
         pass
 
@@ -57,6 +70,11 @@ def service(file_system) -> TestService:
     )
 
 
+@pytest.fixture(scope="function")
+def service_class():
+    return TestService
+
+
 @pytest.fixture(scope="function")
 def application(file_system) -> TestApplication:
     return TestApplication(
@@ -64,6 +82,11 @@ def application(file_system) -> TestApplication:
     )
 
 
+@pytest.fixture(scope="function")
+def application_class():
+    return TestApplication
+
+
 @pytest.fixture(scope="function")
 def file_system() -> FileSystem:
     return Node(hostname="fs_node").file_system

tests/e2e_integration_tests/test_uc2_data_manipulation_scenario.py

@@ -23,6 +23,7 @@ def test_data_manipulation(uc2_network):
 
     # Now we run the DataManipulationBot
     db_manipulation_bot.run()
+    db_manipulation_bot.attack()
 
     # Now check that the DB client on the web_server cannot query the users table on the database
     assert not db_client.query("SELECT")

tests/integration_tests/system/test_application_on_node.py

@@ -0,0 +1,121 @@
+from typing import Tuple
+
+import pytest
+
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
+from primaite.simulator.network.hardware.nodes.computer import Computer
+from primaite.simulator.system.applications.application import Application, ApplicationOperatingState
+
+
+@pytest.fixture(scope="function")
+def populated_node(application_class) -> Tuple[Application, Computer]:
+    computer: Computer = Computer(
+        hostname="test_computer",
+        ip_address="192.168.1.2",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
+    )
+    computer.software_manager.install(application_class)
+
+    app = computer.software_manager.software["TestApplication"]
+    app.run()
+
+    return app, computer
+
+
+def test_service_on_offline_node(application_class):
+    """Test to check that the service cannot be interacted with when node it is on is off."""
+    computer: Computer = Computer(
+        hostname="test_computer",
+        ip_address="192.168.1.2",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
+    )
+    computer.software_manager.install(application_class)
+
+    app: Application = computer.software_manager.software["TestApplication"]
+
+    computer.power_off()
+
+    for i in range(computer.shut_down_duration + 1):
+        computer.apply_timestep(timestep=i)
+
+    assert computer.operating_state is NodeOperatingState.OFF
+    assert app.operating_state is ApplicationOperatingState.CLOSED
+
+    app.run()
+    assert app.operating_state is ApplicationOperatingState.CLOSED
+
+
+def test_server_turns_off_service(populated_node):
+    """Check that the service is turned off when the server is turned off"""
+    app, computer = populated_node
+
+    assert computer.operating_state is NodeOperatingState.ON
+    assert app.operating_state is ApplicationOperatingState.RUNNING
+
+    computer.power_off()
+
+    for i in range(computer.shut_down_duration + 1):
+        computer.apply_timestep(timestep=i)
+
+    assert computer.operating_state is NodeOperatingState.OFF
+    assert app.operating_state is ApplicationOperatingState.CLOSED
+
+
+def test_service_cannot_be_turned_on_when_server_is_off(populated_node):
+    """Check that the service cannot be started when the server is off."""
+    app, computer = populated_node
+
+    assert computer.operating_state is NodeOperatingState.ON
+    assert app.operating_state is ApplicationOperatingState.RUNNING
+
+    computer.power_off()
+
+    for i in range(computer.shut_down_duration + 1):
+        computer.apply_timestep(timestep=i)
+
+    assert computer.operating_state is NodeOperatingState.OFF
+    assert app.operating_state is ApplicationOperatingState.CLOSED
+
+    app.run()
+
+    assert computer.operating_state is NodeOperatingState.OFF
+    assert app.operating_state is ApplicationOperatingState.CLOSED
+
+
+def test_server_turns_on_service(populated_node):
+    """Check that turning on the server turns on service."""
+    app, computer = populated_node
+
+    assert computer.operating_state is NodeOperatingState.ON
+    assert app.operating_state is ApplicationOperatingState.RUNNING
+
+    computer.power_off()
+
+    for i in range(computer.shut_down_duration + 1):
+        computer.apply_timestep(timestep=i)
+
+    assert computer.operating_state is NodeOperatingState.OFF
+    assert app.operating_state is ApplicationOperatingState.CLOSED
+
+    computer.power_on()
+
+    for i in range(computer.start_up_duration + 1):
+        computer.apply_timestep(timestep=i)
+
+    assert computer.operating_state is NodeOperatingState.ON
+    assert app.operating_state is ApplicationOperatingState.RUNNING
+
+    computer.start_up_duration = 0
+    computer.shut_down_duration = 0
+
+    computer.power_off()
+    assert computer.operating_state is NodeOperatingState.OFF
+    assert app.operating_state is ApplicationOperatingState.CLOSED
+
+    computer.power_on()
+    assert computer.operating_state is NodeOperatingState.ON
+    assert app.operating_state is ApplicationOperatingState.RUNNING

tests/integration_tests/system/test_database_on_node.py

@@ -1,9 +1,11 @@
 from ipaddress import IPv4Address
 
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
 from primaite.simulator.network.hardware.nodes.server import Server
 from primaite.simulator.system.applications.database_client import DatabaseClient
 from primaite.simulator.system.services.database.database_service import DatabaseService
 from primaite.simulator.system.services.ftp.ftp_server import FTPServer
+from primaite.simulator.system.services.service import ServiceOperatingState
 
 
 def test_database_client_server_connection(uc2_network):
@@ -55,7 +57,8 @@ def test_database_client_query(uc2_network):
     """Tests DB query across the network returns HTTP status 200 and date."""
     web_server: Server = uc2_network.get_node_by_hostname("web_server")
     db_client: DatabaseClient = web_server.software_manager.software["DatabaseClient"]
-    db_client.connect()
+
+    assert db_client.connected
 
     assert db_client.query("SELECT")
 
@@ -92,3 +95,28 @@ def test_restore_backup(uc2_network):
     assert db_service.restore_backup() is True
 
     assert db_service.file_system.get_file(folder_name="database", file_name="database.db") is not None
+
+
+def test_database_client_cannot_query_offline_database_server(uc2_network):
+    """Tests DB query across the network returns HTTP status 404 when db server is offline."""
+    db_server: Server = uc2_network.get_node_by_hostname("database_server")
+    db_service: DatabaseService = db_server.software_manager.software["DatabaseService"]
+
+    assert db_server.operating_state is NodeOperatingState.ON
+    assert db_service.operating_state is ServiceOperatingState.RUNNING
+
+    web_server: Server = uc2_network.get_node_by_hostname("web_server")
+    db_client: DatabaseClient = web_server.software_manager.software["DatabaseClient"]
+    assert db_client.connected
+
+    assert db_client.query("SELECT") is True
+
+    db_server.power_off()
+
+    for i in range(db_server.shut_down_duration + 1):
+        uc2_network.apply_timestep(timestep=i)
+
+    assert db_server.operating_state is NodeOperatingState.OFF
+    assert db_service.operating_state is ServiceOperatingState.STOPPED
+
+    assert db_client.query("SELECT") is False

tests/integration_tests/system/test_dns_client_server.py

@@ -1,3 +1,4 @@
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
 from primaite.simulator.network.hardware.nodes.computer import Computer
 from primaite.simulator.network.hardware.nodes.server import Server
 from primaite.simulator.system.services.dns.dns_client import DNSClient
@@ -24,3 +25,39 @@ def test_dns_client_server(uc2_network):
     # arcd.com is registered in dns server and should be saved to cache
     assert dns_client.check_domain_exists(target_domain="arcd.com")
     assert dns_client.dns_cache.get("arcd.com", None) is not None
+
+    assert len(dns_client.dns_cache) == 1
+
+
+def test_dns_client_requests_offline_dns_server(uc2_network):
+    client_1: Computer = uc2_network.get_node_by_hostname("client_1")
+    domain_controller: Server = uc2_network.get_node_by_hostname("domain_controller")
+
+    dns_client: DNSClient = client_1.software_manager.software["DNSClient"]
+    dns_server: DNSServer = domain_controller.software_manager.software["DNSServer"]
+
+    assert dns_client.operating_state == ServiceOperatingState.RUNNING
+    assert dns_server.operating_state == ServiceOperatingState.RUNNING
+
+    dns_server.show()
+
+    # arcd.com is registered in dns server
+    assert dns_client.check_domain_exists(target_domain="arcd.com")
+    assert dns_client.dns_cache.get("arcd.com", None) is not None
+
+    assert len(dns_client.dns_cache) == 1
+    dns_client.dns_cache = {}
+
+    domain_controller.power_off()
+
+    for i in range(domain_controller.shut_down_duration + 1):
+        uc2_network.apply_timestep(timestep=i)
+
+    assert domain_controller.operating_state == NodeOperatingState.OFF
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED
+
+    # this time it should not cache because dns server is not online
+    assert dns_client.check_domain_exists(target_domain="arcd.com") is False
+    assert dns_client.dns_cache.get("arcd.com", None) is None
+
+    assert len(dns_client.dns_cache) == 0

tests/integration_tests/system/test_ftp_client_server.py

@@ -15,10 +15,10 @@ def test_ftp_client_store_file_in_server(uc2_network):
     backup_server: Server = uc2_network.get_node_by_hostname("backup_server")
 
     ftp_client: FTPClient = client_1.software_manager.software["FTPClient"]
-    ftp_server: FTPServer = backup_server.software_manager.software["FTPServer"]
+    ftp_server_service: FTPServer = backup_server.software_manager.software["FTPServer"]
 
     assert ftp_client.operating_state == ServiceOperatingState.RUNNING
-    assert ftp_server.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server_service.operating_state == ServiceOperatingState.RUNNING
 
     # create file on ftp client
     ftp_client.file_system.create_file(file_name="test_file.txt")
@@ -31,7 +31,7 @@ def test_ftp_client_store_file_in_server(uc2_network):
         dest_ip_address=backup_server.nics.get(next(iter(backup_server.nics))).ip_address,
     )
 
-    assert ftp_server.file_system.get_file(folder_name="client_1_backup", file_name="test_file.txt")
+    assert ftp_server_service.file_system.get_file(folder_name="client_1_backup", file_name="test_file.txt")
 
 
 def test_ftp_client_retrieve_file_from_server(uc2_network):
@@ -42,13 +42,13 @@ def test_ftp_client_retrieve_file_from_server(uc2_network):
     backup_server: Server = uc2_network.get_node_by_hostname("backup_server")
 
     ftp_client: FTPClient = client_1.software_manager.software["FTPClient"]
-    ftp_server: FTPServer = backup_server.software_manager.software["FTPServer"]
+    ftp_server_service: FTPServer = backup_server.software_manager.software["FTPServer"]
 
     assert ftp_client.operating_state == ServiceOperatingState.RUNNING
-    assert ftp_server.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server_service.operating_state == ServiceOperatingState.RUNNING
 
     # create file on ftp server
-    ftp_server.file_system.create_file(file_name="test_file.txt", folder_name="file_share")
+    ftp_server_service.file_system.create_file(file_name="test_file.txt", folder_name="file_share")
 
     assert ftp_client.request_file(
         src_folder_name="file_share",
@@ -60,3 +60,40 @@ def test_ftp_client_retrieve_file_from_server(uc2_network):
 
     # client should have retrieved the file
     assert ftp_client.file_system.get_file(folder_name="downloads", file_name="test_file.txt")
+
+
+def test_ftp_client_tries_to_connect_to_offline_server(uc2_network):
+    """Test checks to make sure that the client can't do anything when the server is offline."""
+    client_1: Computer = uc2_network.get_node_by_hostname("client_1")
+    backup_server: Server = uc2_network.get_node_by_hostname("backup_server")
+
+    ftp_client: FTPClient = client_1.software_manager.software["FTPClient"]
+    ftp_server_service: FTPServer = backup_server.software_manager.software["FTPServer"]
+
+    assert ftp_client.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server_service.operating_state == ServiceOperatingState.RUNNING
+
+    # create file on ftp server
+    ftp_server_service.file_system.create_file(file_name="test_file.txt", folder_name="file_share")
+
+    backup_server.power_off()
+
+    for i in range(backup_server.shut_down_duration + 1):
+        uc2_network.apply_timestep(timestep=i)
+
+    assert ftp_client.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server_service.operating_state == ServiceOperatingState.STOPPED
+
+    assert (
+        ftp_client.request_file(
+            src_folder_name="file_share",
+            src_file_name="test_file.txt",
+            dest_folder_name="downloads",
+            dest_file_name="test_file.txt",
+            dest_ip_address=backup_server.nics.get(next(iter(backup_server.nics))).ip_address,
+        )
+        is False
+    )
+
+    # client should have retrieved the file
+    assert ftp_client.file_system.get_file(folder_name="downloads", file_name="test_file.txt") is None

tests/integration_tests/system/test_service_on_node.py

@@ -0,0 +1,129 @@
+from typing import Tuple
+
+import pytest
+
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
+from primaite.simulator.network.hardware.nodes.computer import Computer
+from primaite.simulator.network.hardware.nodes.server import Server
+from primaite.simulator.system.services.service import Service, ServiceOperatingState
+
+
+@pytest.fixture(scope="function")
+def populated_node(
+    service_class,
+) -> Tuple[Server, Service]:
+    server = Server(
+        hostname="server", ip_address="192.168.0.1", subnet_mask="255.255.255.0", operating_state=NodeOperatingState.ON
+    )
+    server.software_manager.install(service_class)
+
+    service = server.software_manager.software["TestService"]
+    service.start()
+
+    return server, service
+
+
+def test_service_on_offline_node(service_class):
+    """Test to check that the service cannot be interacted with when node it is on is off."""
+    computer: Computer = Computer(
+        hostname="test_computer",
+        ip_address="192.168.1.2",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
+    )
+    computer.software_manager.install(service_class)
+
+    service: Service = computer.software_manager.software["TestService"]
+
+    computer.power_off()
+
+    for i in range(computer.shut_down_duration + 1):
+        computer.apply_timestep(timestep=i)
+
+    assert computer.operating_state is NodeOperatingState.OFF
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+    service.start()
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+    service.resume()
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+    service.restart()
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+    service.pause()
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+
+def test_server_turns_off_service(populated_node):
+    """Check that the service is turned off when the server is turned off"""
+    server, service = populated_node
+
+    assert server.operating_state is NodeOperatingState.ON
+    assert service.operating_state is ServiceOperatingState.RUNNING
+
+    server.power_off()
+
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
+
+    assert server.operating_state is NodeOperatingState.OFF
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+
+def test_service_cannot_be_turned_on_when_server_is_off(populated_node):
+    """Check that the service cannot be started when the server is off."""
+    server, service = populated_node
+
+    assert server.operating_state is NodeOperatingState.ON
+    assert service.operating_state is ServiceOperatingState.RUNNING
+
+    server.power_off()
+
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
+
+    assert server.operating_state is NodeOperatingState.OFF
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+    service.start()
+
+    assert server.operating_state is NodeOperatingState.OFF
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+
+def test_server_turns_on_service(populated_node):
+    """Check that turning on the server turns on service."""
+    server, service = populated_node
+
+    assert server.operating_state is NodeOperatingState.ON
+    assert service.operating_state is ServiceOperatingState.RUNNING
+
+    server.power_off()
+
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
+
+    assert server.operating_state is NodeOperatingState.OFF
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+    server.power_on()
+
+    for i in range(server.start_up_duration + 1):
+        server.apply_timestep(timestep=i)
+
+    assert server.operating_state is NodeOperatingState.ON
+    assert service.operating_state is ServiceOperatingState.RUNNING
+
+    server.start_up_duration = 0
+    server.shut_down_duration = 0
+
+    server.power_off()
+    assert server.operating_state is NodeOperatingState.OFF
+    assert service.operating_state is ServiceOperatingState.STOPPED
+
+    server.power_on()
+    assert server.operating_state is NodeOperatingState.ON
+    assert service.operating_state is ServiceOperatingState.RUNNING

tests/integration_tests/system/test_web_client_server.py

@@ -1,3 +1,4 @@
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
 from primaite.simulator.network.hardware.nodes.computer import Computer
 from primaite.simulator.network.hardware.nodes.server import Server
 from primaite.simulator.network.protocols.http import HttpStatusCode
@@ -48,6 +49,55 @@ def test_web_page_get_users_page_request_with_ip_address(uc2_network):
 
     assert web_client.get_webpage() is True
 
-    # latest reponse should have status code 200
+    # latest response should have status code 200
     assert web_client.latest_response is not None
     assert web_client.latest_response.status_code == HttpStatusCode.OK
+
+
+def test_web_page_request_from_shut_down_server(uc2_network):
+    """Test to see that the web server does not respond when the server is off."""
+    client_1: Computer = uc2_network.get_node_by_hostname("client_1")
+    web_client: WebBrowser = client_1.software_manager.software["WebBrowser"]
+    web_client.run()
+
+    web_server: Server = uc2_network.get_node_by_hostname("web_server")
+
+    assert web_client.operating_state == ApplicationOperatingState.RUNNING
+
+    assert web_client.get_webpage("http://arcd.com/users/") is True
+
+    # latest response should have status code 200
+    assert web_client.latest_response.status_code == HttpStatusCode.OK
+
+    web_server.power_off()
+
+    for i in range(web_server.shut_down_duration + 1):
+        uc2_network.apply_timestep(timestep=i)
+
+    # node should be off
+    assert web_server.operating_state is NodeOperatingState.OFF
+
+    assert web_client.get_webpage("http://arcd.com/users/") is False
+    assert web_client.latest_response.status_code == HttpStatusCode.NOT_FOUND
+
+
+def test_web_page_request_from_closed_web_browser(uc2_network):
+    client_1: Computer = uc2_network.get_node_by_hostname("client_1")
+    web_client: WebBrowser = client_1.software_manager.software["WebBrowser"]
+    web_client.run()
+
+    web_server: Server = uc2_network.get_node_by_hostname("web_server")
+
+    assert web_client.operating_state == ApplicationOperatingState.RUNNING
+
+    assert web_client.get_webpage("http://arcd.com/users/") is True
+
+    # latest response should have status code 200
+    assert web_client.latest_response.status_code == HttpStatusCode.OK
+
+    web_client.close()
+
+    # node should be off
+    assert web_client.operating_state is ApplicationOperatingState.CLOSED
+
+    assert web_client.get_webpage("http://arcd.com/users/") is False

tests/unit_tests/_primaite/_simulator/_system/_services/test_dns.py

@@ -3,6 +3,7 @@ from ipaddress import IPv4Address
 import pytest
 
 from primaite.simulator.network.hardware.base import Node
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
 from primaite.simulator.network.hardware.nodes.computer import Computer
 from primaite.simulator.network.hardware.nodes.server import Server
 from primaite.simulator.network.protocols.dns import DNSPacket, DNSReply, DNSRequest
@@ -10,15 +11,19 @@ from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
 from primaite.simulator.system.services.dns.dns_client import DNSClient
 from primaite.simulator.system.services.dns.dns_server import DNSServer
+from primaite.simulator.system.services.service import ServiceOperatingState
 
 
 @pytest.fixture(scope="function")
 def dns_server() -> Node:
     node = Server(
-        hostname="dns_server", ip_address="192.168.1.10", subnet_mask="255.255.255.0", default_gateway="192.168.1.1"
+        hostname="dns_server",
+        ip_address="192.168.1.10",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
     )
     node.software_manager.install(software_class=DNSServer)
-    node.software_manager.software["DNSServer"].start()
     return node
 
 
@@ -50,6 +55,44 @@ def test_create_dns_client(dns_client):
     assert dns_client_service.protocol is IPProtocol.TCP
 
 
+def test_dns_client_add_domain_to_cache_when_not_running(dns_client):
+    dns_client_service: DNSClient = dns_client.software_manager.software["DNSClient"]
+    assert dns_client.operating_state is NodeOperatingState.OFF
+    assert dns_client_service.operating_state is ServiceOperatingState.STOPPED
+
+    assert (
+        dns_client_service.add_domain_to_cache(domain_name="test.com", ip_address=IPv4Address("192.168.1.100")) is False
+    )
+
+    assert dns_client_service.dns_cache.get("test.com") is None
+
+
+def test_dns_client_check_domain_exists_when_not_running(dns_client):
+    dns_client.operating_state = NodeOperatingState.ON
+    dns_client_service: DNSClient = dns_client.software_manager.software["DNSClient"]
+    dns_client_service.start()
+
+    assert dns_client.operating_state is NodeOperatingState.ON
+    assert dns_client_service.operating_state is ServiceOperatingState.RUNNING
+
+    assert (
+        dns_client_service.add_domain_to_cache(domain_name="test.com", ip_address=IPv4Address("192.168.1.100"))
+        is not False
+    )
+
+    assert dns_client_service.check_domain_exists("test.com") is True
+
+    dns_client.power_off()
+
+    for i in range(dns_client.shut_down_duration + 1):
+        dns_client.apply_timestep(timestep=i)
+
+    assert dns_client.operating_state is NodeOperatingState.OFF
+    assert dns_client_service.operating_state is ServiceOperatingState.STOPPED
+
+    assert dns_client_service.check_domain_exists("test.com") is False
+
+
 def test_dns_server_domain_name_registration(dns_server):
     """Test to check if the domain name registration works."""
     dns_server_service: DNSServer = dns_server.software_manager.software["DNSServer"]
@@ -64,7 +107,9 @@ def test_dns_server_domain_name_registration(dns_server):
 
 def test_dns_client_check_domain_in_cache(dns_client):
     """Test to make sure that the check_domain_in_cache returns the correct values."""
+    dns_client.operating_state = NodeOperatingState.ON
     dns_client_service: DNSClient = dns_client.software_manager.software["DNSClient"]
+    dns_client_service.start()
 
     # add a domain to the dns client cache
     dns_client_service.add_domain_to_cache("real-domain.com", IPv4Address("192.168.1.12"))

tests/unit_tests/_primaite/_simulator/_system/_services/test_ftp.py

@@ -3,6 +3,7 @@ from ipaddress import IPv4Address
 import pytest
 
 from primaite.simulator.network.hardware.base import Node
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
 from primaite.simulator.network.hardware.nodes.computer import Computer
 from primaite.simulator.network.hardware.nodes.server import Server
 from primaite.simulator.network.protocols.ftp import FTPCommand, FTPPacket, FTPStatusCode
@@ -15,17 +16,24 @@ from primaite.simulator.system.services.ftp.ftp_server import FTPServer
 @pytest.fixture(scope="function")
 def ftp_server() -> Node:
     node = Server(
-        hostname="ftp_server", ip_address="192.168.1.10", subnet_mask="255.255.255.0", default_gateway="192.168.1.1"
+        hostname="ftp_server",
+        ip_address="192.168.1.10",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
     )
     node.software_manager.install(software_class=FTPServer)
-    node.software_manager.software["FTPServer"].start()
     return node
 
 
 @pytest.fixture(scope="function")
 def ftp_client() -> Node:
     node = Computer(
-        hostname="ftp_client", ip_address="192.168.1.11", subnet_mask="255.255.255.0", default_gateway="192.168.1.1"
+        hostname="ftp_client",
+        ip_address="192.168.1.11",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
     )
     return node