Merge branch 'dev' into feature/2041_2042-Add-NTP-Services

2023-12-04 11:23:35 +00:00
parent 40d596c373 2203877302
commit 39694fcec2
101 changed files with 3803 additions and 1047 deletions
--- a/tests/integration_tests/network/test_link_connection.py
+++ b/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)
--- a/tests/integration_tests/network/test_network_creation.py
+++ b/tests/integration_tests/network/test_network_creation.py
@@ -2,6 +2,28 @@ import pytest

 from primaite.simulator.network.container import Network
 from primaite.simulator.network.hardware.base import NIC, Node
+from primaite.simulator.network.hardware.nodes.computer import Computer
+from primaite.simulator.network.hardware.nodes.server import Server
+from primaite.simulator.network.networks import client_server_routed
+
+
+def test_network(example_network):
+    network: Network = example_network
+    client_1: Computer = network.get_node_by_hostname("client_1")
+    client_2: Computer = network.get_node_by_hostname("client_2")
+    server_1: Server = network.get_node_by_hostname("server_1")
+    server_2: Server = network.get_node_by_hostname("server_2")
+
+    assert client_1.ping(client_2.ethernet_port[1].ip_address)
+    assert client_2.ping(client_1.ethernet_port[1].ip_address)
+
+    assert server_1.ping(server_2.ethernet_port[1].ip_address)
+    assert server_2.ping(server_1.ethernet_port[1].ip_address)
+
+    assert client_1.ping(server_1.ethernet_port[1].ip_address)
+    assert client_2.ping(server_1.ethernet_port[1].ip_address)
+    assert client_1.ping(server_2.ethernet_port[1].ip_address)
+    assert client_2.ping(server_2.ethernet_port[1].ip_address)


 def test_adding_removing_nodes():
--- a/tests/integration_tests/system/test_application_on_node.py
+++ b/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.get("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.get("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
--- a/tests/integration_tests/system/test_database_on_node.py
+++ b/tests/integration_tests/system/test_database_on_node.py
@@ -1,17 +1,19 @@
 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):
    web_server: Server = uc2_network.get_node_by_hostname("web_server")
-    db_client: DatabaseClient = web_server.software_manager.software["DatabaseClient"]
+    db_client: DatabaseClient = web_server.software_manager.software.get("DatabaseClient")

    db_server: Server = uc2_network.get_node_by_hostname("database_server")
-    db_service: DatabaseService = db_server.software_manager.software["DatabaseService"]
+    db_service: DatabaseService = db_server.software_manager.software.get("DatabaseService")

    assert len(db_service.connections) == 1

@@ -21,10 +23,10 @@ def test_database_client_server_connection(uc2_network):

 def test_database_client_server_correct_password(uc2_network):
    web_server: Server = uc2_network.get_node_by_hostname("web_server")
-    db_client: DatabaseClient = web_server.software_manager.software["DatabaseClient"]
+    db_client: DatabaseClient = web_server.software_manager.software.get("DatabaseClient")

    db_server: Server = uc2_network.get_node_by_hostname("database_server")
-    db_service: DatabaseService = db_server.software_manager.software["DatabaseService"]
+    db_service: DatabaseService = db_server.software_manager.software.get("DatabaseService")

    db_client.disconnect()

@@ -38,10 +40,10 @@ def test_database_client_server_correct_password(uc2_network):

 def test_database_client_server_incorrect_password(uc2_network):
    web_server: Server = uc2_network.get_node_by_hostname("web_server")
-    db_client: DatabaseClient = web_server.software_manager.software["DatabaseClient"]
+    db_client: DatabaseClient = web_server.software_manager.software.get("DatabaseClient")

    db_server: Server = uc2_network.get_node_by_hostname("database_server")
-    db_service: DatabaseService = db_server.software_manager.software["DatabaseService"]
+    db_service: DatabaseService = db_server.software_manager.software.get("DatabaseService")

    db_client.disconnect()
    db_client.configure(server_ip_address=IPv4Address("192.168.1.14"), server_password="54321")
@@ -54,8 +56,9 @@ def test_database_client_server_incorrect_password(uc2_network):
 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()
+    db_client: DatabaseClient = web_server.software_manager.software.get("DatabaseClient")
+
+    assert db_client.connected

    assert db_client.query("SELECT")

@@ -63,13 +66,13 @@ def test_database_client_query(uc2_network):
 def test_create_database_backup(uc2_network):
    """Run the backup_database method and check if the FTP server has the relevant file."""
    db_server: Server = uc2_network.get_node_by_hostname("database_server")
-    db_service: DatabaseService = db_server.software_manager.software["DatabaseService"]
+    db_service: DatabaseService = db_server.software_manager.software.get("DatabaseService")

    # back up should be created
    assert db_service.backup_database() is True

    backup_server: Server = uc2_network.get_node_by_hostname("backup_server")
-    ftp_server: FTPServer = backup_server.software_manager.software["FTPServer"]
+    ftp_server: FTPServer = backup_server.software_manager.software.get("FTPServer")

    # backup file should exist in the backup server
    assert ftp_server.file_system.get_file(folder_name=db_service.uuid, file_name="database.db") is not None
@@ -78,7 +81,7 @@ def test_create_database_backup(uc2_network):
 def test_restore_backup(uc2_network):
    """Run the restore_backup method and check if the backup is properly restored."""
    db_server: Server = uc2_network.get_node_by_hostname("database_server")
-    db_service: DatabaseService = db_server.software_manager.software["DatabaseService"]
+    db_service: DatabaseService = db_server.software_manager.software.get("DatabaseService")

    # create a back up
    assert db_service.backup_database() is True
@@ -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.get("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.get("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
--- a/tests/integration_tests/system/test_dns_client_server.py
+++ b/tests/integration_tests/system/test_dns_client_server.py
@@ -1,3 +1,9 @@
+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
 from primaite.simulator.system.services.dns.dns_client import DNSClient
@@ -5,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.get("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.get("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
@@ -24,3 +49,35 @@ 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(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
+
+    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 = {}
+
+    server.power_off()
+
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
+
+    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
+    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
--- a/tests/integration_tests/system/test_ftp_client_server.py
+++ b/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,15 +10,28 @@ 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.get("FTPClient")
+    ftp_client.start()
+
+    # Install FTP Server service on server
+    server.software_manager.install(FTPServer)
+    ftp_server: FTPServer = server.software_manager.software.get("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: 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.operating_state == ServiceOperatingState.RUNNING
@@ -28,21 +44,17 @@ 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.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: 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.operating_state == ServiceOperatingState.RUNNING
@@ -55,8 +67,41 @@ def test_ftp_client_retrieve_file_from_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,
    )

    # 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(ftp_client_and_ftp_server):
+    """Test checks to make sure that the client can't do anything when the server is offline."""
+    ftp_client, computer, ftp_server, server = ftp_client_and_ftp_server
+
+    assert ftp_client.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server.operating_state == ServiceOperatingState.RUNNING
+
+    # create file on ftp server
+    ftp_server.file_system.create_file(file_name="test_file.txt", folder_name="file_share")
+
+    server.power_off()
+
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
+
+    assert ftp_client.operating_state == ServiceOperatingState.RUNNING
+    assert ftp_server.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=server.nics.get(next(iter(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
--- a/tests/integration_tests/system/test_service_on_node.py
+++ b/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.get("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.get("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
--- a/tests/integration_tests/system/test_web_client_server.py
+++ b/tests/integration_tests/system/test_web_client_server.py
@@ -1,52 +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.service import ServiceOperatingState
+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()
-    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("http://arcd.com/") is True
+    # Install Web Browser on computer
+    computer.software_manager.install(WebBrowser)
+    web_browser: WebBrowser = computer.software_manager.software.get("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.get("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.get("WebServer")
+    web_server_service.start()
+
+    # Install DNS Server service on server
+    server.software_manager.install(DNSServer)
+    dns_server: DNSServer = server.software_manager.software.get("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("http://arcd.com/users/") 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 = web_server.nics.get(next(iter(web_server.nics))).ip_address
+    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

-    assert web_client.operating_state == ApplicationOperatingState.RUNNING
+    assert web_browser_app.get_webpage() is True

-    assert web_client.get_webpage(f"http://{web_server_ip}/users/") 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

-    # latest reponse 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(web_client_and_web_server):
+    """Test to see that the web server does not respond when the server is off."""
+    web_browser_app, computer, web_server_service, server = web_client_and_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_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
+
+    server.power_off()
+
+    server.power_off()
+
+    for i in range(server.shut_down_duration + 1):
+        server.apply_timestep(timestep=i)
+
+    # node should be off
+    assert server.operating_state is NodeOperatingState.OFF
+
+    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(web_client_and_web_server):
+    web_browser_app, computer, web_server_service, server = web_client_and_web_server
+
+    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_browser_app.latest_response.status_code == HttpStatusCode.OK
+
+    web_browser_app.close()
+
+    # node should be off
+    assert web_browser_app.operating_state is ApplicationOperatingState.CLOSED
+
+    assert web_browser_app.get_webpage() is False
--- a/tests/integration_tests/system/test_web_client_server_and_database.py
+++ b/tests/integration_tests/system/test_web_client_server_and_database.py
@@ -0,0 +1,108 @@
+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.router import ACLAction, Router
+from primaite.simulator.network.hardware.nodes.server import Server
+from primaite.simulator.network.transmission.transport_layer import Port
+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(example_network) -> Tuple[Computer, Server, Server]:
+    # add rules to network router
+    router_1: Router = example_network.get_node_by_hostname("router_1")
+    router_1.acl.add_rule(
+        action=ACLAction.PERMIT, src_port=Port.POSTGRES_SERVER, dst_port=Port.POSTGRES_SERVER, position=0
+    )
+
+    # Allow DNS requests
+    router_1.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.DNS, dst_port=Port.DNS, position=1)
+
+    # Allow FTP requests
+    router_1.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.FTP, dst_port=Port.FTP, position=2)
+
+    # Open port 80 for web server
+    router_1.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.HTTP, dst_port=Port.HTTP, position=3)
+
+    # Create Computer
+    computer: Computer = example_network.get_node_by_hostname("client_1")
+
+    # Create Web Server
+    web_server: Server = example_network.get_node_by_hostname("server_1")
+
+    # Create Database Server
+    db_server = example_network.get_node_by_hostname("server_2")
+
+    # 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.get("DatabaseService")
+    db_service.start()
+
+    # Install Web Browser on computer
+    computer.software_manager.install(WebBrowser)
+    web_browser: WebBrowser = computer.software_manager.software.get("WebBrowser")
+    web_browser.target_url = "http://arcd.com/users/"
+    web_browser.run()
+
+    # Install DNS Client service on computer
+    computer.software_manager.install(DNSClient)
+    dns_client: DNSClient = computer.software_manager.software.get("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.get("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.get("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.get("DatabaseClient")
+    db_client.server_ip_address = IPv4Address(db_server_nic.ip_address)  # set IP address of Database Server
+    db_client.run()
+    assert dns_client.check_domain_exists("arcd.com")
+    assert db_client.connect()
+
+    return computer, web_server, db_server
+
+
+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.get("WebBrowser")
+
+    assert web_browser.get_webpage()