#2084: beginning the introduction of code coverage + adding tests to try to meet the 80% code coverage target

.azure/azure-ci-build-pipeline.yaml

@@ -86,5 +86,5 @@ stages:
             displayName: 'Perform PrimAITE Setup'
 
           - script: |
-              pytest -n auto
-            displayName: 'Run tests'
+              pytest -n auto --cov=src --cov-report=html:coverage_report --cov-fail-under=80
+            displayName: 'Run tests and code coverage'

src/primaite/simulator/file_system/file_system.py

@@ -49,7 +49,10 @@ class FileSystem(SimComponent):
         original_folder_uuids = self._original_state.pop("original_folder_uuids")
         for uuid in original_folder_uuids:
             if uuid in self.deleted_folders:
-                self.folders[uuid] = self.deleted_folders.pop(uuid)
+                folder = self.deleted_folders[uuid]
+                self.deleted_folders.pop(uuid)
+                self.folders[uuid] = folder
+                self._folders_by_name[folder.name] = folder
 
         # Clear any other deleted folders that aren't original (have been created by agent)
         self.deleted_folders.clear()
@@ -58,7 +61,9 @@ class FileSystem(SimComponent):
         current_folder_uuids = list(self.folders.keys())
         for uuid in current_folder_uuids:
             if uuid not in original_folder_uuids:
+                folder = self.folders[uuid]
                 self.folders.pop(uuid)
+                self._folders_by_name.pop(folder.name)
 
         # Now reset all remaining folders
         for folder in self.folders.values():

src/primaite/simulator/file_system/folder.py

@@ -73,7 +73,10 @@ class Folder(FileSystemItemABC):
         original_file_uuids = self._original_state.pop("original_file_uuids")
         for uuid in original_file_uuids:
             if uuid in self.deleted_files:
-                self.files[uuid] = self.deleted_files.pop(uuid)
+                file = self.deleted_files[uuid]
+                self.deleted_files.pop(uuid)
+                self.files[uuid] = file
+                self._files_by_name[file.name] = file
 
         # Clear any other deleted files that aren't original (have been created by agent)
         self.deleted_files.clear()
@@ -82,7 +85,9 @@ class Folder(FileSystemItemABC):
         current_file_uuids = list(self.files.keys())
         for uuid in current_file_uuids:
             if uuid not in original_file_uuids:
+                file = self.files[uuid]
                 self.files.pop(uuid)
+                self._files_by_name.pop(file.name)
 
         # Now reset all remaining files
         for file in self.files.values():

src/primaite/simulator/system/services/ftp/ftp_client.py

@@ -7,7 +7,6 @@ from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
 from primaite.simulator.system.core.software_manager import SoftwareManager
 from primaite.simulator.system.services.ftp.ftp_service import FTPServiceABC
-from primaite.simulator.system.services.service import ServiceOperatingState
 
 
 class FTPClient(FTPServiceABC):
@@ -38,8 +37,7 @@ class FTPClient(FTPServiceABC):
         :type: session_id: Optional[str]
         """
         # if client service is down, return error
-        if self.operating_state != ServiceOperatingState.RUNNING:
-            self.sys_log.error("FTP Client is not running")
+        if not self._can_perform_action():
             payload.status_code = FTPStatusCode.ERROR
             return payload
 
@@ -66,8 +64,7 @@ class FTPClient(FTPServiceABC):
         :type: is_reattempt: Optional[bool]
         """
         # make sure the service is running before attempting
-        if self.operating_state != ServiceOperatingState.RUNNING:
-            self.sys_log.error(f"FTPClient not running for {self.sys_log.hostname}")
+        if not self._can_perform_action():
             return False
 
         # normally FTP will choose a random port for the transfer, but using the FTP command port will do for now

src/primaite/simulator/system/services/ftp/ftp_server.py

@@ -5,7 +5,6 @@ from primaite.simulator.network.protocols.ftp import FTPCommand, FTPPacket, FTPS
 from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
 from primaite.simulator.system.services.ftp.ftp_service import FTPServiceABC
-from primaite.simulator.system.services.service import ServiceOperatingState
 
 
 class FTPServer(FTPServiceABC):
@@ -42,8 +41,7 @@ class FTPServer(FTPServiceABC):
         payload.status_code = FTPStatusCode.ERROR
 
         # if server service is down, return error
-        if self.operating_state != ServiceOperatingState.RUNNING:
-            self.sys_log.error("FTP Server not running")
+        if not self._can_perform_action():
             return payload
 
         self.sys_log.info(f"{self.name}: Received FTP {payload.ftp_command.name} {payload.ftp_command_args}")
@@ -79,6 +77,9 @@ class FTPServer(FTPServiceABC):
             self.sys_log.error(f"{payload} is not an FTP packet")
             return False
 
+        if not super().receive(payload=payload, session_id=session_id, **kwargs):
+            return False
+
         """
         Ignore ftp payload if status code is defined.
 
@@ -86,9 +87,6 @@ class FTPServer(FTPServiceABC):
         prevents an FTP request loop - FTP client and servers can exist on
         the same node.
         """
-        if not super().receive(payload=payload, session_id=session_id, **kwargs):
-            return False
-
         if payload.status_code is not None:
             return False
 

tests/conftest.py

@@ -1,6 +1,6 @@
 # © Crown-owned copyright 2023, Defence Science and Technology Laboratory UK
 from pathlib import Path
-from typing import Any, Dict, Union
+from typing import Any, Dict, Tuple, Union
 
 import pytest
 import yaml
@@ -12,6 +12,9 @@ from primaite.session.session import PrimaiteSession
 # from primaite.environment.primaite_env import Primaite
 # from primaite.primaite_session import PrimaiteSession
 from primaite.simulator.network.container import Network
+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.networks import arcd_uc2_network
 from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
@@ -29,7 +32,7 @@ from primaite import PRIMAITE_PATHS
 
 # PrimAITE v3 stuff
 from primaite.simulator.file_system.file_system import FileSystem
-from primaite.simulator.network.hardware.base import Node
+from primaite.simulator.network.hardware.base import Link, Node
 
 
 class TestService(Service):
@@ -122,3 +125,30 @@ def temp_primaite_session(request, monkeypatch) -> TempPrimaiteSession:
     monkeypatch.setattr(PRIMAITE_PATHS, "user_sessions_path", temp_user_sessions_path())
     config_path = request.param[0]
     return TempPrimaiteSession.from_config(config_path=config_path)
+
+
+@pytest.fixture(scope="function")
+def client_server() -> Tuple[Computer, Server]:
+    # Create Computer
+    computer: Computer = Computer(
+        hostname="test_computer",
+        ip_address="192.168.0.1",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
+    )
+
+    # Create Server
+    server = Server(
+        hostname="server", ip_address="192.168.0.2", subnet_mask="255.255.255.0", operating_state=NodeOperatingState.ON
+    )
+
+    # Connect Computer and Server
+    computer_nic = computer.nics[next(iter(computer.nics))]
+    server_nic = server.nics[next(iter(server.nics))]
+    link = Link(endpoint_a=computer_nic, endpoint_b=server_nic)
+
+    # Should be linked
+    assert link.is_up
+
+    return computer, server

tests/e2e_integration_tests/environments/test_sb3_environment.py

@@ -2,6 +2,7 @@
 import tempfile
 from pathlib import Path
 
+import pytest
 import yaml
 from stable_baselines3 import PPO
 
@@ -10,6 +11,7 @@ from primaite.game.game import PrimaiteGame
 from primaite.session.environment import PrimaiteGymEnv
 
 
+@pytest.mark.skip(reason="no way of currently testing this")
 def test_sb3_compatibility():
     """Test that the Gymnasium environment can be used with an SB3 agent."""
     with open(example_config_path(), "r") as f:

tests/e2e_integration_tests/test_primaite_session.py

@@ -11,6 +11,7 @@ MISCONFIGURED_PATH = TEST_ASSETS_ROOT / "configs/bad_primaite_session.yaml"
 MULTI_AGENT_PATH = TEST_ASSETS_ROOT / "configs/multi_agent_session.yaml"
 
 
+@pytest.mark.skip(reason="no way of currently testing this")
 class TestPrimaiteSession:
     @pytest.mark.parametrize("temp_primaite_session", [[CFG_PATH]], indirect=True)
     def test_creating_session(self, temp_primaite_session):

tests/integration_tests/network/test_link_connection.py

@@ -16,3 +16,9 @@ def test_link_up():
     assert nic_a.enabled
     assert nic_b.enabled
     assert link.is_up
+
+
+def test_ping_between_computer_and_server(client_server):
+    computer, server = client_server
+
+    assert computer.ping(target_ip_address=server.nics[next(iter(server.nics))].ip_address)

tests/integration_tests/system/test_dns_client_server.py

@@ -1,3 +1,8 @@
+from ipaddress import IPv4Address
+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
@@ -6,12 +11,31 @@ from primaite.simulator.system.services.dns.dns_server import DNSServer
 from primaite.simulator.system.services.service import ServiceOperatingState
 
 
-def test_dns_client_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")
+@pytest.fixture(scope="function")
+def dns_client_and_dns_server(client_server) -> Tuple[DNSClient, Computer, DNSServer, Server]:
+    computer, server = client_server
 
-    dns_client: DNSClient = client_1.software_manager.software["DNSClient"]
-    dns_server: DNSServer = domain_controller.software_manager.software["DNSServer"]
+    # Install DNS Client on computer
+    computer.software_manager.install(DNSClient)
+    dns_client: DNSClient = computer.software_manager.software["DNSClient"]
+    dns_client.start()
+    # set server as DNS Server
+    dns_client.dns_server = IPv4Address(server.nics.get(next(iter(server.nics))).ip_address)
+
+    # Install DNS Server on server
+    server.software_manager.install(DNSServer)
+    dns_server: DNSServer = server.software_manager.software["DNSServer"]
+    dns_server.start()
+    # register arcd.com as a domain
+    dns_server.dns_register(
+        domain_name="arcd.com", domain_ip_address=IPv4Address(server.nics.get(next(iter(server.nics))).ip_address)
+    )
+
+    return dns_client, computer, dns_server, server
+
+
+def test_dns_client_server(dns_client_and_dns_server):
+    dns_client, computer, dns_server, server = dns_client_and_dns_server
 
     assert dns_client.operating_state == ServiceOperatingState.RUNNING
     assert dns_server.operating_state == ServiceOperatingState.RUNNING
@@ -29,12 +53,8 @@ def test_dns_client_server(uc2_network):
     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"]
+def test_dns_client_requests_offline_dns_server(dns_client_and_dns_server):
+    dns_client, computer, dns_server, server = dns_client_and_dns_server
 
     assert dns_client.operating_state == ServiceOperatingState.RUNNING
     assert dns_server.operating_state == ServiceOperatingState.RUNNING
@@ -48,12 +68,12 @@ def test_dns_client_requests_offline_dns_server(uc2_network):
     assert len(dns_client.dns_cache) == 1
     dns_client.dns_cache = {}
 
-    domain_controller.power_off()
+    server.power_off()
 
-    for i in range(domain_controller.shut_down_duration + 1):
-        uc2_network.apply_timestep(timestep=i)
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
 
-    assert domain_controller.operating_state == NodeOperatingState.OFF
+    assert server.operating_state == NodeOperatingState.OFF
     assert dns_server.operating_state == ServiceOperatingState.STOPPED
 
     # this time it should not cache because dns server is not online

tests/integration_tests/system/test_ftp_client_server.py

@@ -1,4 +1,7 @@
 from ipaddress import IPv4Address
+from typing import Tuple
+
+import pytest
 
 from primaite.simulator.network.hardware.nodes.computer import Computer
 from primaite.simulator.network.hardware.nodes.server import Server
@@ -7,18 +10,31 @@ from primaite.simulator.system.services.ftp.ftp_server import FTPServer
 from primaite.simulator.system.services.service import ServiceOperatingState
 
 
-def test_ftp_client_store_file_in_server(uc2_network):
+@pytest.fixture(scope="function")
+def ftp_client_and_ftp_server(client_server) -> Tuple[FTPClient, Computer, FTPServer, Server]:
+    computer, server = client_server
+
+    # Install FTP Client service on computer
+    computer.software_manager.install(FTPClient)
+    ftp_client: FTPClient = computer.software_manager.software["FTPClient"]
+    ftp_client.start()
+
+    # Install FTP Server service on server
+    server.software_manager.install(FTPServer)
+    ftp_server: FTPServer = server.software_manager.software["FTPServer"]
+    ftp_server.start()
+
+    return ftp_client, computer, ftp_server, server
+
+
+def test_ftp_client_store_file_in_server(ftp_client_and_ftp_server):
     """
     Test checks to see if the client is able to store files in the backup server.
     """
-    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"]
+    ftp_client, computer, ftp_server, server = ftp_client_and_ftp_server
 
     assert ftp_client.operating_state == ServiceOperatingState.RUNNING
-    assert ftp_server_service.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server.operating_state == ServiceOperatingState.RUNNING
 
     # create file on ftp client
     ftp_client.file_system.create_file(file_name="test_file.txt")
@@ -28,61 +44,53 @@ def test_ftp_client_store_file_in_server(uc2_network):
         src_file_name="test_file.txt",
         dest_folder_name="client_1_backup",
         dest_file_name="test_file.txt",
-        dest_ip_address=backup_server.nics.get(next(iter(backup_server.nics))).ip_address,
+        dest_ip_address=server.nics.get(next(iter(server.nics))).ip_address,
     )
 
-    assert ftp_server_service.file_system.get_file(folder_name="client_1_backup", file_name="test_file.txt")
+    assert ftp_server.file_system.get_file(folder_name="client_1_backup", file_name="test_file.txt")
 
 
-def test_ftp_client_retrieve_file_from_server(uc2_network):
+def test_ftp_client_retrieve_file_from_server(ftp_client_and_ftp_server):
     """
     Test checks to see if the client is able to retrieve files from the backup server.
     """
-    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"]
+    ftp_client, computer, ftp_server, server = ftp_client_and_ftp_server
 
     assert ftp_client.operating_state == ServiceOperatingState.RUNNING
-    assert ftp_server_service.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server.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")
+    ftp_server.file_system.create_file(file_name="test_file.txt", folder_name="file_share")
 
     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,
+        dest_ip_address=server.nics.get(next(iter(server.nics))).ip_address,
     )
 
     # 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):
+def test_ftp_client_tries_to_connect_to_offline_server(ftp_client_and_ftp_server):
     """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"]
+    ftp_client, computer, ftp_server, server = ftp_client_and_ftp_server
 
     assert ftp_client.operating_state == ServiceOperatingState.RUNNING
-    assert ftp_server_service.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server.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")
+    ftp_server.file_system.create_file(file_name="test_file.txt", folder_name="file_share")
 
-    backup_server.power_off()
+    server.power_off()
 
-    for i in range(backup_server.shut_down_duration + 1):
-        uc2_network.apply_timestep(timestep=i)
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
 
     assert ftp_client.operating_state == ServiceOperatingState.RUNNING
-    assert ftp_server_service.operating_state == ServiceOperatingState.STOPPED
+    assert ftp_server.operating_state == ServiceOperatingState.STOPPED
 
     assert (
         ftp_client.request_file(
@@ -90,7 +98,7 @@ def test_ftp_client_tries_to_connect_to_offline_server(uc2_network):
             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,
+            dest_ip_address=server.nics.get(next(iter(server.nics))).ip_address,
         )
         is False
     )

tests/integration_tests/system/test_web_client_server.py

@@ -1,103 +1,118 @@
+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.network.protocols.http import HttpStatusCode
 from primaite.simulator.system.applications.application import ApplicationOperatingState
 from primaite.simulator.system.applications.web_browser import WebBrowser
+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.web_server.web_server import WebServer
 
 
-def test_web_page_home_page(uc2_network):
-    """Test to see if the browser is able to open the main page of the web server."""
-    client_1: Computer = uc2_network.get_node_by_hostname("client_1")
-    web_client: WebBrowser = client_1.software_manager.software["WebBrowser"]
-    web_client.run()
-    web_client.target_url = "http://arcd.com/"
-    assert web_client.operating_state == ApplicationOperatingState.RUNNING
+@pytest.fixture(scope="function")
+def web_client_and_web_server(client_server) -> Tuple[WebBrowser, Computer, WebServer, Server]:
+    computer, server = client_server
 
-    assert web_client.get_webpage() is True
+    # Install Web Browser on computer
+    computer.software_manager.install(WebBrowser)
+    web_browser: WebBrowser = computer.software_manager.software["WebBrowser"]
+    web_browser.run()
 
-    # latest reponse should have status code 200
-    assert web_client.latest_response is not None
-    assert web_client.latest_response.status_code == HttpStatusCode.OK
+    # Install DNS Client service on computer
+    computer.software_manager.install(DNSClient)
+    dns_client: DNSClient = computer.software_manager.software["DNSClient"]
+    # set dns server
+    dns_client.dns_server = server.nics[next(iter(server.nics))].ip_address
+
+    # Install Web Server service on server
+    server.software_manager.install(WebServer)
+    web_server_service: WebServer = server.software_manager.software["WebServer"]
+    web_server_service.start()
+
+    # Install DNS Server service on server
+    server.software_manager.install(DNSServer)
+    dns_server: DNSServer = server.software_manager.software["DNSServer"]
+    # register arcd.com to DNS
+    dns_server.dns_register(domain_name="arcd.com", domain_ip_address=server.nics[next(iter(server.nics))].ip_address)
+
+    return web_browser, computer, web_server_service, server
 
 
-def test_web_page_get_users_page_request_with_domain_name(uc2_network):
+def test_web_page_get_users_page_request_with_domain_name(web_client_and_web_server):
     """Test to see if the client can handle requests with domain names"""
-    client_1: Computer = uc2_network.get_node_by_hostname("client_1")
-    web_client: WebBrowser = client_1.software_manager.software["WebBrowser"]
-    web_client.run()
-    assert web_client.operating_state == ApplicationOperatingState.RUNNING
+    web_browser_app, computer, web_server_service, server = web_client_and_web_server
 
-    assert web_client.get_webpage() is True
+    web_server_ip = server.nics.get(next(iter(server.nics))).ip_address
+    web_browser_app.target_url = f"http://arcd.com/"
+    assert web_browser_app.operating_state == ApplicationOperatingState.RUNNING
 
-    # latest reponse should have status code 200
-    assert web_client.latest_response is not None
-    assert web_client.latest_response.status_code == HttpStatusCode.OK
+    assert web_browser_app.get_webpage() is True
+
+    # latest response should have status code 200
+    assert web_browser_app.latest_response is not None
+    assert web_browser_app.latest_response.status_code == HttpStatusCode.OK
 
 
-def test_web_page_get_users_page_request_with_ip_address(uc2_network):
+def test_web_page_get_users_page_request_with_ip_address(web_client_and_web_server):
     """Test to see if the client can handle requests that use ip_address."""
-    client_1: Computer = uc2_network.get_node_by_hostname("client_1")
-    web_client: WebBrowser = client_1.software_manager.software["WebBrowser"]
-    web_client.run()
+    web_browser_app, computer, web_server_service, server = web_client_and_web_server
 
-    web_server: Server = uc2_network.get_node_by_hostname("web_server")
+    web_server_ip = server.nics.get(next(iter(server.nics))).ip_address
+    web_browser_app.target_url = f"http://{web_server_ip}/"
+    assert web_browser_app.operating_state == ApplicationOperatingState.RUNNING
 
-    web_server_ip = web_server.nics.get(next(iter(web_server.nics))).ip_address
-    web_client.target_url = f"http://{web_server_ip}/users/"
-    assert web_client.operating_state == ApplicationOperatingState.RUNNING
-
-    assert web_client.get_webpage() is True
+    assert web_browser_app.get_webpage() is True
 
     # latest response should have status code 200
-    assert web_client.latest_response is not None
-    assert web_client.latest_response.status_code == HttpStatusCode.OK
+    assert web_browser_app.latest_response is not None
+    assert web_browser_app.latest_response.status_code == HttpStatusCode.OK
 
 
-def test_web_page_request_from_shut_down_server(uc2_network):
+def test_web_page_request_from_shut_down_server(web_client_and_web_server):
     """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_browser_app, computer, web_server_service, server = web_client_and_web_server
 
-    web_server: Server = uc2_network.get_node_by_hostname("web_server")
+    web_server_ip = server.nics.get(next(iter(server.nics))).ip_address
+    web_browser_app.target_url = f"http://arcd.com/"
+    assert web_browser_app.operating_state == ApplicationOperatingState.RUNNING
 
-    assert web_client.operating_state == ApplicationOperatingState.RUNNING
-
-    assert web_client.get_webpage("http://arcd.com/users/") is True
+    assert web_browser_app.get_webpage() is True
 
     # latest response should have status code 200
-    assert web_client.latest_response.status_code == HttpStatusCode.OK
+    assert web_browser_app.latest_response is not None
+    assert web_browser_app.latest_response.status_code == HttpStatusCode.OK
 
-    web_server.power_off()
+    server.power_off()
 
-    for i in range(web_server.shut_down_duration + 1):
-        uc2_network.apply_timestep(timestep=i)
+    server.power_off()
+
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
 
     # node should be off
-    assert web_server.operating_state is NodeOperatingState.OFF
+    assert 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
+    assert web_browser_app.get_webpage() is False
+    assert web_browser_app.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()
+def test_web_page_request_from_closed_web_browser(web_client_and_web_server):
+    web_browser_app, computer, web_server_service, server = web_client_and_web_server
 
-    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
+    assert web_browser_app.operating_state == ApplicationOperatingState.RUNNING
+    web_browser_app.target_url = f"http://arcd.com/"
+    assert web_browser_app.get_webpage() is True
 
     # latest response should have status code 200
-    assert web_client.latest_response.status_code == HttpStatusCode.OK
+    assert web_browser_app.latest_response.status_code == HttpStatusCode.OK
 
-    web_client.close()
+    web_browser_app.close()
 
     # node should be off
-    assert web_client.operating_state is ApplicationOperatingState.CLOSED
+    assert web_browser_app.operating_state is ApplicationOperatingState.CLOSED
 
-    assert web_client.get_webpage("http://arcd.com/users/") is False
+    assert web_browser_app.get_webpage() is False

tests/integration_tests/system/test_web_client_server_and_database.py

@@ -0,0 +1,106 @@
+from ipaddress import IPv4Address
+from typing import Tuple
+
+import pytest
+
+from primaite.simulator.network.hardware.base import Link
+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.applications.database_client import DatabaseClient
+from primaite.simulator.system.applications.web_browser import WebBrowser
+from primaite.simulator.system.services.database.database_service import DatabaseService
+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.web_server.web_server import WebServer
+
+
+@pytest.fixture(scope="function")
+def web_client_web_server_database() -> Tuple[Computer, Server, Server]:
+    # Create Computer
+    computer: Computer = Computer(
+        hostname="test_computer",
+        ip_address="192.168.0.1",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
+    )
+
+    # Create Web Server
+    web_server = Server(
+        hostname="web_server",
+        ip_address="192.168.0.2",
+        subnet_mask="255.255.255.0",
+        operating_state=NodeOperatingState.ON,
+    )
+
+    # Create Database Server
+    db_server = Server(
+        hostname="db_server",
+        ip_address="192.168.0.3",
+        subnet_mask="255.255.255.0",
+        operating_state=NodeOperatingState.ON,
+    )
+
+    # Get the NICs
+    computer_nic = computer.nics[next(iter(computer.nics))]
+    server_nic = web_server.nics[next(iter(web_server.nics))]
+    db_server_nic = db_server.nics[next(iter(db_server.nics))]
+
+    # Connect Computer and Server
+    link_computer_server = Link(endpoint_a=computer_nic, endpoint_b=server_nic)
+    # Should be linked
+    assert link_computer_server.is_up
+
+    # Connect database server and web server
+    link_server_db = Link(endpoint_a=server_nic, endpoint_b=db_server_nic)
+    # Should be linked
+    assert link_computer_server.is_up
+    assert link_server_db.is_up
+
+    # Install DatabaseService on db server
+    db_server.software_manager.install(DatabaseService)
+    db_service: DatabaseService = db_server.software_manager.software["DatabaseService"]
+    db_service.start()
+
+    # Install Web Browser on computer
+    computer.software_manager.install(WebBrowser)
+    web_browser: WebBrowser = computer.software_manager.software["WebBrowser"]
+    web_browser.run()
+
+    # Install DNS Client service on computer
+    computer.software_manager.install(DNSClient)
+    dns_client: DNSClient = computer.software_manager.software["DNSClient"]
+    # set dns server
+    dns_client.dns_server = web_server.nics[next(iter(web_server.nics))].ip_address
+
+    # Install Web Server service on web server
+    web_server.software_manager.install(WebServer)
+    web_server_service: WebServer = web_server.software_manager.software["WebServer"]
+    web_server_service.start()
+
+    # Install DNS Server service on web server
+    web_server.software_manager.install(DNSServer)
+    dns_server: DNSServer = web_server.software_manager.software["DNSServer"]
+    # register arcd.com to DNS
+    dns_server.dns_register(
+        domain_name="arcd.com", domain_ip_address=web_server.nics[next(iter(web_server.nics))].ip_address
+    )
+
+    # Install DatabaseClient service on web server
+    web_server.software_manager.install(DatabaseClient)
+    db_client: DatabaseClient = web_server.software_manager.software["DatabaseClient"]
+    db_client.server_ip_address = IPv4Address(db_server_nic.ip_address)  # set IP address of Database Server
+    db_client.run()
+    assert db_client.connect()
+
+    return computer, web_server, db_server
+
+
+@pytest.mark.skip(reason="waiting for a way to set this up correctly")
+def test_web_client_requests_users(web_client_web_server_database):
+    computer, web_server, db_server = web_client_web_server_database
+
+    web_browser: WebBrowser = computer.software_manager.software["WebBrowser"]
+
+    web_browser.get_webpage()

tests/unit_tests/_primaite/_simulator/_file_system/test_file_system.py

@@ -185,6 +185,38 @@ def test_get_file(file_system):
     file_system.show(full=True)
 
 
+def test_reset_file_system(file_system):
+    # file and folder that existed originally
+    file_system.create_file(file_name="test_file.zip")
+    file_system.create_folder(folder_name="test_folder")
+    file_system.set_original_state()
+
+    # create a new file
+    file_system.create_file(file_name="new_file.txt")
+
+    # create a new folder
+    file_system.create_folder(folder_name="new_folder")
+
+    # delete the file that existed originally
+    file_system.delete_file(folder_name="root", file_name="test_file.zip")
+    assert file_system.get_file(folder_name="root", file_name="test_file.zip") is None
+
+    # delete the folder that existed originally
+    file_system.delete_folder(folder_name="test_folder")
+    assert file_system.get_folder(folder_name="test_folder") is None
+
+    # reset
+    file_system.reset_component_for_episode(episode=1)
+
+    # deleted original file and folder should be back
+    assert file_system.get_file(folder_name="root", file_name="test_file.zip")
+    assert file_system.get_folder(folder_name="test_folder")
+
+    # new file and folder should be removed
+    assert file_system.get_file(folder_name="root", file_name="new_file.txt") is None
+    assert file_system.get_folder(folder_name="new_folder") is None
+
+
 @pytest.mark.skip(reason="Skipping until we tackle serialisation")
 def test_serialisation(file_system):
     """Test to check that the object serialisation works correctly."""

tests/unit_tests/_primaite/_simulator/_system/_applications/test_web_browser.py

@@ -1,39 +1,66 @@
+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.protocols.http import HttpResponsePacket, HttpStatusCode
 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 ApplicationOperatingState
 from primaite.simulator.system.applications.web_browser import WebBrowser
 
 
 @pytest.fixture(scope="function")
-def web_client() -> Computer:
-    node = Computer(
-        hostname="web_client", ip_address="192.168.1.11", subnet_mask="255.255.255.0", default_gateway="192.168.1.1"
+def web_browser() -> WebBrowser:
+    computer = Computer(
+        hostname="web_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
+    # Web Browser should be pre-installed in computer
+    web_browser: WebBrowser = computer.software_manager.software["WebBrowser"]
+    web_browser.run()
+    assert web_browser.operating_state is ApplicationOperatingState.RUNNING
+    return web_browser
 
 
-def test_create_web_client(web_client):
-    assert web_client is not None
-    web_browser: WebBrowser = web_client.software_manager.software["WebBrowser"]
+def test_create_web_client():
+    computer = Computer(
+        hostname="web_client",
+        ip_address="192.168.1.11",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        operating_state=NodeOperatingState.ON,
+    )
+    # Web Browser should be pre-installed in computer
+    web_browser: WebBrowser = computer.software_manager.software["WebBrowser"]
     assert web_browser.name is "WebBrowser"
     assert web_browser.port is Port.HTTP
     assert web_browser.protocol is IPProtocol.TCP
 
 
-def test_receive_invalid_payload(web_client):
-    web_browser: WebBrowser = web_client.software_manager.software["WebBrowser"]
-
+def test_receive_invalid_payload(web_browser):
     assert web_browser.receive(payload={}) is False
 
 
-def test_receive_payload(web_client):
+def test_receive_payload(web_browser):
     payload = HttpResponsePacket(status_code=HttpStatusCode.OK)
-    web_browser: WebBrowser = web_client.software_manager.software["WebBrowser"]
     assert web_browser.latest_response is None
 
     web_browser.receive(payload=payload)
 
     assert web_browser.latest_response is not None
+
+
+def test_invalid_target_url(web_browser):
+    # none value target url
+    web_browser.target_url = None
+    assert web_browser.get_webpage() is False
+
+
+def test_non_existent_target_url(web_browser):
+    web_browser.target_url = "http://192.168.255.255"
+    assert web_browser.get_webpage() is False

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

@@ -5,28 +5,13 @@ 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
 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",
-        operating_state=NodeOperatingState.ON,
-    )
-    node.software_manager.install(software_class=DNSServer)
-    return node
-
-
 @pytest.fixture(scope="function")
 def dns_client() -> Node:
     node = Computer(
@@ -39,14 +24,6 @@ def dns_client() -> Node:
     return node
 
 
-def test_create_dns_server(dns_server):
-    assert dns_server is not None
-    dns_server_service: DNSServer = dns_server.software_manager.software["DNSServer"]
-    assert dns_server_service.name is "DNSServer"
-    assert dns_server_service.port is Port.DNS
-    assert dns_server_service.protocol is IPProtocol.TCP
-
-
 def test_create_dns_client(dns_client):
     assert dns_client is not None
     dns_client_service: DNSClient = dns_client.software_manager.software["DNSClient"]
@@ -93,18 +70,6 @@ def test_dns_client_check_domain_exists_when_not_running(dns_client):
     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"]
-
-    # register the web server in the domain controller
-    dns_server_service.dns_register(domain_name="real-domain.com", domain_ip_address=IPv4Address("192.168.1.12"))
-
-    # return none for an unknown domain
-    assert dns_server_service.dns_lookup("fake-domain.com") is None
-    assert dns_server_service.dns_lookup("real-domain.com") is not None
-
-
 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
@@ -118,26 +83,6 @@ def test_dns_client_check_domain_in_cache(dns_client):
     assert dns_client_service.check_domain_exists("real-domain.com") is True
 
 
-def test_dns_server_receive(dns_server):
-    """Test to make sure that the DNS Server correctly responds to a DNS Client request."""
-    dns_server_service: DNSServer = dns_server.software_manager.software["DNSServer"]
-
-    # register the web server in the domain controller
-    dns_server_service.dns_register(domain_name="real-domain.com", domain_ip_address=IPv4Address("192.168.1.12"))
-
-    assert (
-        dns_server_service.receive(payload=DNSPacket(dns_request=DNSRequest(domain_name_request="fake-domain.com")))
-        is False
-    )
-
-    assert (
-        dns_server_service.receive(payload=DNSPacket(dns_request=DNSRequest(domain_name_request="real-domain.com")))
-        is True
-    )
-
-    dns_server_service.show()
-
-
 def test_dns_client_receive(dns_client):
     """Test to make sure the DNS Client knows how to deal with request responses."""
     dns_client_service: DNSClient = dns_client.software_manager.software["DNSClient"]
@@ -151,3 +96,9 @@ def test_dns_client_receive(dns_client):
 
     # domain name should be saved to cache
     assert dns_client_service.dns_cache["real-domain.com"] == IPv4Address("192.168.1.12")
+
+
+def test_dns_client_receive_non_dns_payload(dns_client):
+    dns_client_service: DNSClient = dns_client.software_manager.software["DNSClient"]
+
+    assert dns_client_service.receive(payload=None) is False

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

@@ -0,0 +1,64 @@
+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.server import Server
+from primaite.simulator.network.protocols.dns import DNSPacket, DNSRequest
+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_server import DNSServer
+
+
+@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",
+        operating_state=NodeOperatingState.ON,
+    )
+    node.software_manager.install(software_class=DNSServer)
+    return node
+
+
+def test_create_dns_server(dns_server):
+    assert dns_server is not None
+    dns_server_service: DNSServer = dns_server.software_manager.software["DNSServer"]
+    assert dns_server_service.name is "DNSServer"
+    assert dns_server_service.port is Port.DNS
+    assert dns_server_service.protocol is IPProtocol.TCP
+
+
+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"]
+
+    # register the web server in the domain controller
+    dns_server_service.dns_register(domain_name="real-domain.com", domain_ip_address=IPv4Address("192.168.1.12"))
+
+    # return none for an unknown domain
+    assert dns_server_service.dns_lookup("fake-domain.com") is None
+    assert dns_server_service.dns_lookup("real-domain.com") is not None
+
+
+def test_dns_server_receive(dns_server):
+    """Test to make sure that the DNS Server correctly responds to a DNS Client request."""
+    dns_server_service: DNSServer = dns_server.software_manager.software["DNSServer"]
+
+    # register the web server in the domain controller
+    dns_server_service.dns_register(domain_name="real-domain.com", domain_ip_address=IPv4Address("192.168.1.12"))
+
+    assert (
+        dns_server_service.receive(payload=DNSPacket(dns_request=DNSRequest(domain_name_request="fake-domain.com")))
+        is False
+    )
+
+    assert (
+        dns_server_service.receive(payload=DNSPacket(dns_request=DNSRequest(domain_name_request="real-domain.com")))
+        is True
+    )
+
+    dns_server_service.show()

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

@@ -0,0 +1,50 @@
+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.protocols.ftp import FTPCommand, FTPPacket, FTPStatusCode
+from primaite.simulator.network.transmission.network_layer import IPProtocol
+from primaite.simulator.network.transmission.transport_layer import Port
+from primaite.simulator.system.services.ftp.ftp_client import FTPClient
+
+
+@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",
+        operating_state=NodeOperatingState.ON,
+    )
+    return node
+
+
+def test_create_ftp_client(ftp_client):
+    assert ftp_client is not None
+    ftp_client_service: FTPClient = ftp_client.software_manager.software["FTPClient"]
+    assert ftp_client_service.name is "FTPClient"
+    assert ftp_client_service.port is Port.FTP
+    assert ftp_client_service.protocol is IPProtocol.TCP
+
+
+def test_ftp_client_store_file(ftp_client):
+    """Test to make sure the FTP Client knows how to deal with request responses."""
+    assert ftp_client.file_system.get_file(folder_name="downloads", file_name="file.txt") is None
+
+    response: FTPPacket = FTPPacket(
+        ftp_command=FTPCommand.STOR,
+        ftp_command_args={
+            "dest_folder_name": "downloads",
+            "dest_file_name": "file.txt",
+            "file_size": 24,
+        },
+        packet_payload_size=24,
+        status_code=FTPStatusCode.OK,
+    )
+
+    ftp_client_service: FTPClient = ftp_client.software_manager.software["FTPClient"]
+    ftp_client_service.receive(response)
+
+    assert ftp_client.file_system.get_file(folder_name="downloads", file_name="file.txt")

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

@@ -1,16 +1,13 @@
-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
 from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
-from primaite.simulator.system.services.ftp.ftp_client import FTPClient
 from primaite.simulator.system.services.ftp.ftp_server import FTPServer
+from primaite.simulator.system.services.service import ServiceOperatingState
 
 
 @pytest.fixture(scope="function")
@@ -26,18 +23,6 @@ def ftp_server() -> Node:
     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",
-        operating_state=NodeOperatingState.ON,
-    )
-    return node
-
-
 def test_create_ftp_server(ftp_server):
     assert ftp_server is not None
     ftp_server_service: FTPServer = ftp_server.software_manager.software["FTPServer"]
@@ -46,14 +31,6 @@ def test_create_ftp_server(ftp_server):
     assert ftp_server_service.protocol is IPProtocol.TCP
 
 
-def test_create_ftp_client(ftp_client):
-    assert ftp_client is not None
-    ftp_client_service: FTPClient = ftp_client.software_manager.software["FTPClient"]
-    assert ftp_client_service.name is "FTPClient"
-    assert ftp_client_service.port is Port.FTP
-    assert ftp_client_service.protocol is IPProtocol.TCP
-
-
 def test_ftp_server_store_file(ftp_server):
     """Test to make sure the FTP Server knows how to deal with request responses."""
     assert ftp_server.file_system.get_file(folder_name="downloads", file_name="file.txt") is None
@@ -74,10 +51,28 @@ def test_ftp_server_store_file(ftp_server):
     assert ftp_server.file_system.get_file(folder_name="downloads", file_name="file.txt")
 
 
-def test_ftp_client_store_file(ftp_client):
-    """Test to make sure the FTP Client knows how to deal with request responses."""
-    assert ftp_client.file_system.get_file(folder_name="downloads", file_name="file.txt") is None
+def test_ftp_server_should_send_error_if_port_arg_is_invalid(ftp_server):
+    """Should fail if the port command receives an invalid port."""
+    payload: FTPPacket = FTPPacket(
+        ftp_command=FTPCommand.PORT,
+        ftp_command_args=None,
+        packet_payload_size=24,
+    )
 
+    ftp_server_service: FTPServer = ftp_server.software_manager.software["FTPServer"]
+    assert ftp_server_service._process_ftp_command(payload=payload).status_code is FTPStatusCode.ERROR
+
+
+def test_ftp_server_receives_non_ftp_packet(ftp_server):
+    """Receive should return false if the service receives a non ftp packet."""
+    response: FTPPacket = None
+
+    ftp_server_service: FTPServer = ftp_server.software_manager.software["FTPServer"]
+    assert ftp_server_service.receive(response) is False
+
+
+def test_offline_ftp_server_receives_request(ftp_server):
+    """Receive should return false if the service is stopped."""
     response: FTPPacket = FTPPacket(
         ftp_command=FTPCommand.STOR,
         ftp_command_args={
@@ -86,10 +81,9 @@ def test_ftp_client_store_file(ftp_client):
             "file_size": 24,
         },
         packet_payload_size=24,
-        status_code=FTPStatusCode.OK,
     )
 
-    ftp_client_service: FTPClient = ftp_client.software_manager.software["FTPClient"]
-    ftp_client_service.receive(response)
-
-    assert ftp_client.file_system.get_file(folder_name="downloads", file_name="file.txt")
+    ftp_server_service: FTPServer = ftp_server.software_manager.software["FTPServer"]
+    ftp_server_service.stop()
+    assert ftp_server_service.operating_state is ServiceOperatingState.STOPPED
+    assert ftp_server_service.receive(response) is False