Merge remote-tracking branch 'origin/dev' into feature/2623-action-masking

tests/integration_tests/game_layer/actions/test_application_request_permission.py

@@ -0,0 +1,54 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+from typing import Tuple
+
+import pytest
+
+from primaite.game.agent.interface import ProxyAgent
+from primaite.game.game import PrimaiteGame
+from primaite.simulator.network.hardware.nodes.host.computer import Computer
+from primaite.simulator.network.hardware.nodes.host.server import Server
+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
+
+
+@pytest.fixture
+def game_and_agent_fixture(game_and_agent):
+    """Create a game with a simple agent that can be controlled by the tests."""
+    game, agent = game_and_agent
+
+    client_1: Computer = game.simulation.network.get_node_by_hostname("client_1")
+    client_1.start_up_duration = 3
+
+    return (game, agent)
+
+
+def test_application_cannot_perform_actions_unless_running(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test the the request permissions prevent any actions unless application is running."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    browser: WebBrowser = client_1.software_manager.software.get("WebBrowser")
+
+    browser.close()
+    assert browser.operating_state == ApplicationOperatingState.CLOSED
+
+    action = ("NODE_APPLICATION_SCAN", {"node_id": 0, "application_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert browser.operating_state == ApplicationOperatingState.CLOSED
+
+    action = ("NODE_APPLICATION_CLOSE", {"node_id": 0, "application_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert browser.operating_state == ApplicationOperatingState.CLOSED
+
+    action = ("NODE_APPLICATION_FIX", {"node_id": 0, "application_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert browser.operating_state == ApplicationOperatingState.CLOSED
+
+    action = ("NODE_APPLICATION_EXECUTE", {"node_id": 0, "application_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert browser.operating_state == ApplicationOperatingState.CLOSED

tests/integration_tests/game_layer/actions/test_file_request_permission.py

@@ -0,0 +1,159 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+import uuid
+from typing import Tuple
+
+import pytest
+
+from primaite.game.agent.interface import ProxyAgent
+from primaite.game.game import PrimaiteGame
+from primaite.simulator.file_system.file_system_item_abc import FileSystemItemHealthStatus
+from primaite.simulator.network.hardware.nodes.host.computer import Computer
+
+
+@pytest.fixture
+def game_and_agent_fixture(game_and_agent):
+    """Create a game with a simple agent that can be controlled by the tests."""
+    game, agent = game_and_agent
+
+    client_1: Computer = game.simulation.network.get_node_by_hostname("client_1")
+    client_1.start_up_duration = 3
+
+    return (game, agent)
+
+
+def test_create_file(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a files to be created."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+
+    random_folder = str(uuid.uuid4())
+    random_file = str(uuid.uuid4())
+
+    assert client_1.file_system.get_file(folder_name=random_folder, file_name=random_file) is None
+
+    action = (
+        "NODE_FILE_CREATE",
+        {"node_id": 0, "folder_name": random_folder, "file_name": random_file},
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert client_1.file_system.get_file(folder_name=random_folder, file_name=random_file) is not None
+
+
+def test_file_delete_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a file to be deleted."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    file = client_1.file_system.get_file(folder_name="downloads", file_name="cat.png")
+    assert file.deleted is False
+
+    action = (
+        "NODE_FILE_DELETE",
+        {"node_id": 0, "folder_id": 0, "file_id": 0},
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert file.deleted
+
+
+def test_file_scan_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a file to be scanned."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    file = client_1.file_system.get_file(folder_name="downloads", file_name="cat.png")
+
+    file.corrupt()
+    assert file.health_status == FileSystemItemHealthStatus.CORRUPT
+    assert file.visible_health_status == FileSystemItemHealthStatus.GOOD
+
+    action = (
+        "NODE_FILE_SCAN",
+        {"node_id": 0, "folder_id": 0, "file_id": 0},
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert file.health_status == FileSystemItemHealthStatus.CORRUPT
+    assert file.visible_health_status == FileSystemItemHealthStatus.CORRUPT
+
+
+def test_file_repair_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a folder to be created."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    file = client_1.file_system.get_file(folder_name="downloads", file_name="cat.png")
+
+    file.corrupt()
+    assert file.health_status == FileSystemItemHealthStatus.CORRUPT
+
+    action = (
+        "NODE_FILE_REPAIR",
+        {"node_id": 0, "folder_id": 0, "file_id": 0},
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert file.health_status == FileSystemItemHealthStatus.GOOD
+
+
+def test_file_restore_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a file to be restored."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    file = client_1.file_system.get_file(folder_name="downloads", file_name="cat.png")
+
+    file.corrupt()
+    assert file.health_status == FileSystemItemHealthStatus.CORRUPT
+
+    action = (
+        "NODE_FILE_RESTORE",
+        {"node_id": 0, "folder_id": 0, "file_id": 0},
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert file.health_status == FileSystemItemHealthStatus.GOOD
+
+
+def test_file_corrupt_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a file to be corrupted."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    file = client_1.file_system.get_file(folder_name="downloads", file_name="cat.png")
+
+    assert file.health_status == FileSystemItemHealthStatus.GOOD
+
+    action = (
+        "NODE_FILE_CORRUPT",
+        {"node_id": 0, "folder_id": 0, "file_id": 0},
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert file.health_status == FileSystemItemHealthStatus.CORRUPT
+
+
+def test_file_access_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a file to be accessed."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    file = client_1.file_system.get_file(folder_name="downloads", file_name="cat.png")
+    assert file.num_access == 0
+
+    action = (
+        "NODE_FILE_ACCESS",
+        {"node_id": 0, "folder_name": file.folder_name, "file_name": file.name},
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert file.num_access == 1

tests/integration_tests/game_layer/actions/test_folder_request_permission.py

@@ -0,0 +1,123 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+import uuid
+from typing import Tuple
+
+import pytest
+
+from primaite.game.agent.interface import ProxyAgent
+from primaite.game.game import PrimaiteGame
+from primaite.simulator.file_system.file_system_item_abc import FileSystemItemHealthStatus
+from primaite.simulator.network.hardware.nodes.host.computer import Computer
+
+
+@pytest.fixture
+def game_and_agent_fixture(game_and_agent):
+    """Create a game with a simple agent that can be controlled by the tests."""
+    game, agent = game_and_agent
+
+    client_1: Computer = game.simulation.network.get_node_by_hostname("client_1")
+    client_1.start_up_duration = 3
+
+    return (game, agent)
+
+
+def test_create_folder(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator allows a folder to be created."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+
+    random_folder = str(uuid.uuid4())
+
+    assert client_1.file_system.get_folder(folder_name=random_folder) is None
+
+    action = (
+        "NODE_FOLDER_CREATE",
+        {
+            "node_id": 0,
+            "folder_name": random_folder,
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert client_1.file_system.get_folder(folder_name=random_folder) is not None
+
+
+def test_folder_scan_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test to make sure that the validator checks if the folder exists before scanning."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+
+    folder = client_1.file_system.get_folder(folder_name="downloads")
+    assert folder.health_status == FileSystemItemHealthStatus.GOOD
+    assert folder.visible_health_status == FileSystemItemHealthStatus.GOOD
+
+    folder.corrupt()
+
+    assert folder.health_status == FileSystemItemHealthStatus.CORRUPT
+    assert folder.visible_health_status == FileSystemItemHealthStatus.GOOD
+
+    action = (
+        "NODE_FOLDER_SCAN",
+        {
+            "node_id": 0,  # client_1,
+            "folder_id": 0,  # downloads
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    for i in range(folder.scan_duration + 1):
+        game.step()
+
+    assert folder.health_status == FileSystemItemHealthStatus.CORRUPT
+    assert folder.visible_health_status == FileSystemItemHealthStatus.CORRUPT
+
+
+def test_folder_repair_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test to make sure that the validator checks if the folder exists before repairing."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+
+    folder = client_1.file_system.get_folder(folder_name="downloads")
+    folder.corrupt()
+    assert folder.health_status == FileSystemItemHealthStatus.CORRUPT
+
+    action = (
+        "NODE_FOLDER_REPAIR",
+        {
+            "node_id": 0,  # client_1,
+            "folder_id": 0,  # downloads
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert folder.health_status == FileSystemItemHealthStatus.GOOD
+
+
+def test_folder_restore_action(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test to make sure that the validator checks if the folder exists before restoring."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+
+    folder = client_1.file_system.get_folder(folder_name="downloads")
+    folder.corrupt()
+
+    assert folder.health_status == FileSystemItemHealthStatus.CORRUPT
+
+    action = (
+        "NODE_FOLDER_RESTORE",
+        {
+            "node_id": 0,  # client_1,
+            "folder_id": 0,  # downloads
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert folder.health_status == FileSystemItemHealthStatus.RESTORING

tests/integration_tests/game_layer/actions/test_nic_request_permission.py

@@ -0,0 +1,95 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+from typing import Tuple
+
+import pytest
+
+from primaite.game.agent.interface import ProxyAgent
+from primaite.game.game import PrimaiteGame
+from primaite.simulator.network.hardware.nodes.host.computer import Computer
+
+
+@pytest.fixture
+def game_and_agent_fixture(game_and_agent):
+    """Create a game with a simple agent that can be controlled by the tests."""
+    game, agent = game_and_agent
+
+    client_1: Computer = game.simulation.network.get_node_by_hostname("client_1")
+    client_1.start_up_duration = 3
+
+    return (game, agent)
+
+
+def test_nic_cannot_be_turned_off_if_not_on(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that a NIC cannot be disabled if it is not enabled."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    nic = client_1.network_interface[1]
+    nic.disable()
+    assert nic.enabled is False
+
+    action = (
+        "HOST_NIC_DISABLE",
+        {
+            "node_id": 0,  # client_1
+            "nic_id": 0,  # the only nic (eth-1)
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert nic.enabled is False
+
+
+def test_nic_cannot_be_turned_on_if_already_on(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that a NIC cannot be enabled if it is already enabled."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    nic = client_1.network_interface[1]
+    assert nic.enabled
+
+    action = (
+        "HOST_NIC_ENABLE",
+        {
+            "node_id": 0,  # client_1
+            "nic_id": 0,  # the only nic (eth-1)
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert nic.enabled
+
+
+def test_that_a_nic_can_be_enabled_and_disabled(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Tests that a NIC can be enabled and disabled."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    nic = client_1.network_interface[1]
+    assert nic.enabled
+
+    action = (
+        "HOST_NIC_DISABLE",
+        {
+            "node_id": 0,  # client_1
+            "nic_id": 0,  # the only nic (eth-1)
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert nic.enabled is False
+
+    action = (
+        "HOST_NIC_ENABLE",
+        {
+            "node_id": 0,  # client_1
+            "nic_id": 0,  # the only nic (eth-1)
+        },
+    )
+    agent.store_action(action)
+    game.step()
+
+    assert nic.enabled

tests/integration_tests/game_layer/actions/test_node_request_permission.py

@@ -1 +1,94 @@
 # © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+from typing import Tuple
+
+import pytest
+
+from primaite.game.agent.interface import ProxyAgent
+from primaite.game.game import PrimaiteGame
+from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
+from primaite.simulator.network.hardware.nodes.host.computer import Computer
+
+
+@pytest.fixture
+def game_and_agent_fixture(game_and_agent):
+    """Create a game with a simple agent that can be controlled by the tests."""
+    game, agent = game_and_agent
+
+    client_1: Computer = game.simulation.network.get_node_by_hostname("client_1")
+    client_1.start_up_duration = 3
+
+    return (game, agent)
+
+
+def test_node_startup_shutdown(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the node can be shut down and started up."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+
+    assert client_1.operating_state == NodeOperatingState.ON
+
+    # turn it off
+    action = ("NODE_SHUTDOWN", {"node_id": 0})
+    agent.store_action(action)
+    game.step()
+
+    assert client_1.operating_state == NodeOperatingState.SHUTTING_DOWN
+
+    for i in range(client_1.shut_down_duration + 1):
+        action = ("DONOTHING", {"node_id": 0})
+        agent.store_action(action)
+        game.step()
+
+    assert client_1.operating_state == NodeOperatingState.OFF
+
+    # turn it on
+    action = ("NODE_STARTUP", {"node_id": 0})
+    agent.store_action(action)
+    game.step()
+
+    assert client_1.operating_state == NodeOperatingState.BOOTING
+
+    for i in range(client_1.start_up_duration + 1):
+        action = ("DONOTHING", {"node_id": 0})
+        agent.store_action(action)
+        game.step()
+
+    assert client_1.operating_state == NodeOperatingState.ON
+
+
+def test_node_cannot_be_started_up_if_node_is_already_on(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that a node cannot be started up if it is already on."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    assert client_1.operating_state == NodeOperatingState.ON
+
+    # turn it on
+    action = ("NODE_STARTUP", {"node_id": 0})
+    agent.store_action(action)
+    game.step()
+
+    assert client_1.operating_state == NodeOperatingState.ON
+
+
+def test_node_cannot_be_shut_down_if_node_is_already_off(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that a node cannot be shut down if it is already off."""
+    game, agent = game_and_agent_fixture
+
+    client_1 = game.simulation.network.get_node_by_hostname("client_1")
+    client_1.power_off()
+
+    for i in range(client_1.shut_down_duration + 1):
+        action = ("DONOTHING", {"node_id": 0})
+        agent.store_action(action)
+        game.step()
+
+    assert client_1.operating_state == NodeOperatingState.OFF
+
+    # turn it ff
+    action = ("NODE_SHUTDOWN", {"node_id": 0})
+    agent.store_action(action)
+    game.step()
+
+    assert client_1.operating_state == NodeOperatingState.OFF

tests/integration_tests/game_layer/actions/test_service_request_permission.py

@@ -0,0 +1,106 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+from typing import Tuple
+
+import pytest
+
+from primaite.game.agent.interface import ProxyAgent
+from primaite.game.game import PrimaiteGame
+from primaite.simulator.network.hardware.nodes.host.computer import Computer
+from primaite.simulator.network.hardware.nodes.host.server import Server
+from primaite.simulator.system.services.service import ServiceOperatingState
+
+
+@pytest.fixture
+def game_and_agent_fixture(game_and_agent):
+    """Create a game with a simple agent that can be controlled by the tests."""
+    game, agent = game_and_agent
+
+    client_1: Computer = game.simulation.network.get_node_by_hostname("client_1")
+    client_1.start_up_duration = 3
+
+    return (game, agent)
+
+
+def test_service_start(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator makes sure that the service is stopped before starting the service."""
+    game, agent = game_and_agent_fixture
+
+    server_1: Server = game.simulation.network.get_node_by_hostname("server_1")
+    dns_server = server_1.software_manager.software.get("DNSServer")
+
+    dns_server.pause()
+    assert dns_server.operating_state == ServiceOperatingState.PAUSED
+
+    action = ("NODE_SERVICE_START", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert dns_server.operating_state == ServiceOperatingState.PAUSED
+
+    dns_server.stop()
+
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED
+
+    action = ("NODE_SERVICE_START", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+
+    assert dns_server.operating_state == ServiceOperatingState.RUNNING
+
+
+def test_service_resume(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test that the validator checks if the service is paused before resuming."""
+    game, agent = game_and_agent_fixture
+
+    server_1: Server = game.simulation.network.get_node_by_hostname("server_1")
+    dns_server = server_1.software_manager.software.get("DNSServer")
+
+    action = ("NODE_SERVICE_RESUME", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert dns_server.operating_state == ServiceOperatingState.RUNNING
+
+    dns_server.pause()
+
+    assert dns_server.operating_state == ServiceOperatingState.PAUSED
+
+    action = ("NODE_SERVICE_RESUME", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+
+    assert dns_server.operating_state == ServiceOperatingState.RUNNING
+
+
+def test_service_cannot_perform_actions_unless_running(game_and_agent_fixture: Tuple[PrimaiteGame, ProxyAgent]):
+    """Test to make sure that the service cannot perform certain actions while not running."""
+    game, agent = game_and_agent_fixture
+
+    server_1: Server = game.simulation.network.get_node_by_hostname("server_1")
+    dns_server = server_1.software_manager.software.get("DNSServer")
+
+    dns_server.stop()
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED
+
+    action = ("NODE_SERVICE_SCAN", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED
+
+    action = ("NODE_SERVICE_PAUSE", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED
+
+    action = ("NODE_SERVICE_RESUME", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED
+
+    action = ("NODE_SERVICE_RESTART", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED
+
+    action = ("NODE_SERVICE_FIX", {"node_id": 1, "service_id": 0})
+    agent.store_action(action)
+    game.step()
+    assert dns_server.operating_state == ServiceOperatingState.STOPPED