#917 - Synced with dev (at the point of random red agent)

tests/config/test_random_red_main_config.yaml

@@ -0,0 +1,112 @@
+# Training Config File
+
+# Sets which agent algorithm framework will be used.
+# Options are:
+# "SB3" (Stable Baselines3)
+# "RLLIB" (Ray RLlib)
+# "CUSTOM" (Custom Agent)
+agent_framework: CUSTOM
+
+# Sets which Agent class will be used.
+# Options are:
+# "A2C" (Advantage Actor Critic coupled with either SB3 or RLLIB agent_framework)
+# "PPO" (Proximal Policy Optimization coupled with either SB3 or RLLIB agent_framework)
+# "HARDCODED" (The HardCoded agents coupled with an ACL or NODE action_type)
+# "DO_NOTHING" (The DoNothing agents coupled with an ACL or NODE action_type)
+# "RANDOM" (primaite.agents.simple.RandomAgent)
+# "DUMMY" (primaite.agents.simple.DummyAgent)
+agent_identifier: DUMMY
+
+# Sets whether Red Agent POL and IER is randomised.
+# Options are:
+# True
+# False
+random_red_agent: True
+
+# Sets How the Action Space is defined:
+# "NODE"
+# "ACL"
+# "ANY" node and acl actions
+action_type: NODE
+# Number of episodes to run per session
+num_episodes: 2
+# Number of time_steps per episode
+num_steps: 15
+# Time delay between steps (for generic agents)
+time_delay: 1
+
+# Type of session to be run (TRAINING or EVALUATION)
+session_type: EVAL
+# Determine whether to load an agent from file
+load_agent: False
+# File path and file name of agent if you're loading one in
+agent_load_file: C:\[Path]\[agent_saved_filename.zip]
+
+# Environment config values
+# The high value for the observation space
+observation_space_high_value: 1000000000
+
+# Reward values
+# Generic
+all_ok: 0
+# Node Hardware State
+off_should_be_on: -10
+off_should_be_resetting: -5
+on_should_be_off: -2
+on_should_be_resetting: -5
+resetting_should_be_on: -5
+resetting_should_be_off: -2
+resetting: -3
+# Node Software or Service State
+good_should_be_patching: 2
+good_should_be_compromised: 5
+good_should_be_overwhelmed: 5
+patching_should_be_good: -5
+patching_should_be_compromised: 2
+patching_should_be_overwhelmed: 2
+patching: -3
+compromised_should_be_good: -20
+compromised_should_be_patching: -20
+compromised_should_be_overwhelmed: -20
+compromised: -20
+overwhelmed_should_be_good: -20
+overwhelmed_should_be_patching: -20
+overwhelmed_should_be_compromised: -20
+overwhelmed: -20
+# Node File System State
+good_should_be_repairing: 2
+good_should_be_restoring: 2
+good_should_be_corrupt: 5
+good_should_be_destroyed: 10
+repairing_should_be_good: -5
+repairing_should_be_restoring: 2
+repairing_should_be_corrupt: 2
+repairing_should_be_destroyed: 0
+repairing: -3
+restoring_should_be_good: -10
+restoring_should_be_repairing: -2
+restoring_should_be_corrupt: 1
+restoring_should_be_destroyed: 2
+restoring: -6
+corrupt_should_be_good: -10
+corrupt_should_be_repairing: -10
+corrupt_should_be_restoring: -10
+corrupt_should_be_destroyed: 2
+corrupt: -10
+destroyed_should_be_good: -20
+destroyed_should_be_repairing: -20
+destroyed_should_be_restoring: -20
+destroyed_should_be_corrupt: -20
+destroyed: -20
+scanning: -2
+# IER status
+red_ier_running: -5
+green_ier_blocked: -10
+
+# Patching / Reset durations
+os_patching_duration: 5            # The time taken to patch the OS
+node_reset_duration: 5             # The time taken to reset a node (hardware)
+service_patching_duration: 5       # The time taken to patch a service
+file_system_repairing_limit: 5      # The time take to repair the file system
+file_system_restoring_limit: 5      # The time take to restore the file system
+file_system_scanning_limit: 5       # The time taken to scan the file system

tests/test_red_random_agent_behaviour.py

@@ -1,68 +1,29 @@
-from datetime import datetime
+import pytest
 
 from primaite.config.lay_down_config import data_manipulation_config_path
-from primaite.environment.primaite_env import Primaite
 from primaite.nodes.node_state_instruction_red import NodeStateInstructionRed
 from tests import TEST_CONFIG_ROOT
-from tests.conftest import _get_temp_session_path
 
-
-def run_generic(env, config_values):
-    """Run against a generic agent."""
-    # Reset the environment at the start of the episode
-    env.reset()
-    for episode in range(0, config_values.num_episodes):
-        for step in range(0, config_values.num_steps):
-            # Send the observation space to the agent to get an action
-            # TEMP - random action for now
-            # action = env.blue_agent_action(obs)
-            # action = env.action_space.sample()
-            action = 0
-
-            # Run the simulation step on the live environment
-            obs, reward, done, info = env.step(action)
-
-            # Break if done is True
-            if done:
-                break
-
-        # Reset the environment at the end of the episode
-        env.reset()
-
-    env.close()
-
-
-def test_random_red_agent_behaviour():
-    """
-    Test that hardware state is penalised at each step.
-
-    When the initial state is OFF compared to reference state which is ON.
-    """
+@pytest.mark.parametrize(
+    "temp_primaite_session",
+    [
+        [
+            TEST_CONFIG_ROOT / "test_random_red_main_config.yaml",
+            data_manipulation_config_path(),
+        ]
+    ],
+    indirect=True,
+)
+def test_random_red_agent_behaviour(temp_primaite_session):
+    """Test that red agent POL is randomised each episode."""
     list_of_node_instructions = []
 
-    # RUN TWICE so we can make sure that red agent is randomised
-    for i in range(2):
-        """Takes a config path and returns the created instance of Primaite."""
-        session_timestamp: datetime = datetime.now()
-        session_path = _get_temp_session_path(session_timestamp)
+    with temp_primaite_session as session:
+        session.evaluate()
+        list_of_node_instructions.append(session.env.red_node_pol)
 
-        timestamp_str = session_timestamp.strftime("%Y-%m-%d_%H-%M-%S")
-        env = Primaite(
-            training_config_path=TEST_CONFIG_ROOT
-            / "one_node_states_on_off_main_config.yaml",
-            lay_down_config_path=data_manipulation_config_path(),
-            transaction_list=[],
-            session_path=session_path,
-            timestamp_str=timestamp_str,
-        )
-        # set red_agent_
-        env.training_config.random_red_agent = True
-        training_config = env.training_config
-        training_config.num_steps = env.episode_steps
-
-        run_generic(env, training_config)
-        # add red pol instructions to list
-        list_of_node_instructions.append(env.red_node_pol)
+        session.evaluate()
+        list_of_node_instructions.append(session.env.red_node_pol)
 
     # compare instructions to make sure that red instructions are truly random
     for index, instruction in enumerate(list_of_node_instructions):
@@ -73,5 +34,4 @@ def test_random_red_agent_behaviour():
             print(f"{key} end step: {instruction.get_end_step()}")
             print(f"{key} target node id: {instruction.get_target_node_id()}")
             print("")
-
     assert list_of_node_instructions[0].__ne__(list_of_node_instructions[1])