gym-csle-stopping-game 0.6.1__tar.gz → 0.6.3__tar.gz

{gym_csle_stopping_game-0.6.1 → gym_csle_stopping_game-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym_csle_stopping_game
-Version: 0.6.1
+Version: 0.6.3
 Summary: OpenAI gym reinforcement learning environment of a Dynkin (Optimal stopping) game in CSLE
 Author: Kim Hammar
 Author-email: hammar.kim@gmail.com

{gym_csle_stopping_game-0.6.1 → gym_csle_stopping_game-0.6.3}/setup.cfg

@@ -20,11 +20,11 @@ classifiers =
 [options]
 install_requires = 
 	gymnasium>=0.27.1
-	csle-base>=0.6.1
-	csle-common>=0.6.1
-	csle-attacker>=0.6.1
-	csle-defender>=0.6.1
-	csle-collector>=0.6.1
+	csle-base>=0.6.3
+	csle-common>=0.6.3
+	csle-attacker>=0.6.3
+	csle-defender>=0.6.3
+	csle-collector>=0.6.3
 python_requires = >=3.8
 package_dir = 
 	=src

gym_csle_stopping_game-0.6.3/src/gym_csle_stopping_game/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.6.3'

{gym_csle_stopping_game-0.6.1 → gym_csle_stopping_game-0.6.3}/src/gym_csle_stopping_game/envs/stopping_game_env.py

@@ -7,24 +7,10 @@ import math
 import csle_common.constants.constants as constants
 from csle_common.dao.simulation_config.base_env import BaseEnv
 from csle_common.dao.simulation_config.simulation_trace import SimulationTrace
-from csle_common.dao.training.policy import Policy
-from csle_common.dao.emulation_config.emulation_env_state import EmulationEnvState
-from csle_common.dao.emulation_config.emulation_env_config import EmulationEnvConfig
-from csle_common.dao.simulation_config.simulation_env_config import SimulationEnvConfig
-from csle_common.dao.emulation_config.emulation_simulation_trace import EmulationSimulationTrace
-from csle_common.dao.emulation_action.attacker.emulation_attacker_stopping_actions \
-    import EmulationAttackerStoppingActions
-from csle_common.dao.emulation_action.attacker.emulation_attacker_action import EmulationAttackerAction
-from csle_common.dao.emulation_action.defender.emulation_defender_stopping_actions \
-    import EmulationDefenderStoppingActions
-from csle_common.metastore.metastore_facade import MetastoreFacade
-from csle_common.logging.log import Logger
-from csle_system_identification.emulator import Emulator
 from gym_csle_stopping_game.util.stopping_game_util import StoppingGameUtil
 from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
 from gym_csle_stopping_game.dao.stopping_game_state import StoppingGameState
 import gym_csle_stopping_game.constants.constants as env_constants
-from csle_common.dao.emulation_config.emulation_trace import EmulationTrace
 
 
 class StoppingGameEnv(BaseEnv):
@@ -42,7 +28,6 @@ class StoppingGameEnv(BaseEnv):
 
         # Initialize environment state
         self.state = StoppingGameState(b1=self.config.b1, L=self.config.L)
-
         # Setup spaces
         self.attacker_observation_space = self.config.attacker_observation_space()
         self.defender_observation_space = self.config.defender_observation_space()
@@ -73,7 +58,7 @@ class StoppingGameEnv(BaseEnv):
         a1, a2_profile = action_profile
         pi2, a2 = a2_profile
         assert pi2.shape[0] == len(self.config.S)
-        assert pi2.shape[1] == len(self.config.A1)
+        assert pi2.shape[1] == len(self.config.A2)
         done = False
         info: Dict[str, Any] = {}
 
@@ -84,8 +69,7 @@ class StoppingGameEnv(BaseEnv):
         else:
             # Compute r, s', b',o'
             r = self.config.R[self.state.l - 1][a1][a2][self.state.s]
-            self.state.s = StoppingGameUtil.sample_next_state(l=self.state.l, a1=a1, a2=a2,
-                                                              T=self.config.T,
+            self.state.s = StoppingGameUtil.sample_next_state(l=self.state.l, a1=a1, a2=a2, T=self.config.T,
                                                               S=self.config.S, s=self.state.s)
             o = StoppingGameUtil.sample_next_observation(Z=self.config.Z,
                                                          O=self.config.O, s_prime=self.state.s)
@@ -246,95 +230,6 @@ class StoppingGameEnv(BaseEnv):
         info[env_constants.ENV_METRICS.TIME_STEP] = self.state.t
         return (defender_obs, attacker_obs), info
 
-    @staticmethod
-    def emulation_evaluation(env: "StoppingGameEnv", n_episodes: int, intrusion_seq: List[EmulationAttackerAction],
-                             defender_policy: Policy,
-                             attacker_policy: Policy,
-                             emulation_env_config: EmulationEnvConfig,
-                             simulation_env_config: SimulationEnvConfig
-                             ) -> List[EmulationSimulationTrace]:
-        """
-        Utility function for evaluating a strategy profile in the emulation environment
-
-        :param env: the environment to use for evaluation
-        :param n_episodes: the number of evaluation episodes
-        :param intrusion_seq: the intrusion sequence for the evaluation (sequence of attacker actions)
-        :param defender_policy: the defender policy for the evaluation
-        :param attacker_policy: the attacker policy for the evaluation
-        :param emulation_env_config: configuration of the emulation environment for the evaluation
-        :param simulation_env_config: configuration of the simulation environment for the evaluation
-        :return: traces with the evaluation results
-        """
-        logger = Logger.__call__().get_logger()
-        traces = []
-        s = EmulationEnvState(emulation_env_config=emulation_env_config)
-        s.initialize_defender_machines()
-        for i in range(n_episodes):
-            done = False
-            defender_obs_space = simulation_env_config.joint_observation_space_config.observation_spaces[0]
-            b = env.state.b1
-            o, _ = env.reset()
-            (d_obs, a_obs) = o
-            t = 0
-            s.reset()
-            emulation_trace = EmulationTrace(initial_attacker_observation_state=s.attacker_obs_state,
-                                             initial_defender_observation_state=s.defender_obs_state,
-                                             emulation_name=emulation_env_config.name)
-            simulation_trace = SimulationTrace(simulation_env=env.config.env_name)
-            while not done:
-                a1 = defender_policy.action(d_obs)
-                a2 = attacker_policy.action(a_obs)
-                o, r, done, info, _ = env.step((a1, a2))
-                (d_obs, a_obs) = o
-                r_1, r_2 = r
-                logger.debug(f"a1:{a1}, a2:{a2}, d_obs:{d_obs}, a_obs:{a_obs}, r:{r}, done:{done}, info: {info}")
-                if a1 == 0:
-                    defender_action = EmulationDefenderStoppingActions.CONTINUE(index=-1)
-                else:
-                    defender_action = EmulationDefenderStoppingActions.CONTINUE(index=-1)
-                if env.state.s == 1:
-                    if t >= len(intrusion_seq):
-                        t = 0
-                    attacker_action = intrusion_seq[t]
-                else:
-                    attacker_action = EmulationAttackerStoppingActions.CONTINUE(index=-1)
-                emulation_trace, s = Emulator.run_actions(
-                    s=s,
-                    emulation_env_config=emulation_env_config, attacker_action=attacker_action,
-                    defender_action=defender_action, trace=emulation_trace,
-                    sleep_time=emulation_env_config.kafka_config.time_step_len_seconds)
-                o_components = [s.defender_obs_state.snort_ids_alert_counters.severe_alerts,
-                                s.defender_obs_state.snort_ids_alert_counters.warning_alerts,
-                                s.defender_obs_state.aggregated_host_metrics.num_failed_login_attempts]
-                o_components_str = ",".join(list(map(lambda x: str(x), o_components)))
-                logger.debug(f"o_components:{o_components}")
-                logger.debug(f"observation_id_to_observation_vector_inv:"
-                             f"{defender_obs_space.observation_id_to_observation_vector_inv}")
-                logger.debug(f"observation_id_to_observation_vector_inv:"
-                             f"{o_components_str in defender_obs_space.observation_id_to_observation_vector_inv}")
-                emulation_o = 0
-                if o_components_str in defender_obs_space.observation_id_to_observation_vector_inv:
-                    emulation_o = defender_obs_space.observation_id_to_observation_vector_inv[o_components_str]
-                logger.debug(f"o:{emulation_o}")
-                b = StoppingGameUtil.next_belief(o=emulation_o, a1=a1, b=b, pi2=a2, config=env.config,
-                                                 l=env.state.l, a2=a2)
-                d_obs[1] = b[1]
-                a_obs[1] = b[1]
-                logger.debug(f"b:{b}")
-                simulation_trace.defender_rewards.append(r_1)
-                simulation_trace.attacker_rewards.append(r_2)
-                simulation_trace.attacker_actions.append(a2)
-                simulation_trace.defender_actions.append(a1)
-                simulation_trace.infos.append(info)
-                simulation_trace.states.append(s)
-                simulation_trace.beliefs.append(b[1])
-                simulation_trace.infrastructure_metrics.append(emulation_o)
-
-            em_sim_trace = EmulationSimulationTrace(emulation_trace=emulation_trace, simulation_trace=simulation_trace)
-            MetastoreFacade.save_emulation_simulation_trace(em_sim_trace)
-            traces.append(em_sim_trace)
-        return traces
-
     def render(self, mode: str = 'human'):
         """
         Renders the environment.  Supported rendering modes: (1) human; and (2) rgb_array
@@ -437,6 +332,8 @@ class StoppingGameEnv(BaseEnv):
         :param l: the number of stops remaining
         :return: the observation
         """
+        if not history:
+            raise ValueError("History must not be empty")
         return [history[-1]]
 
     def generate_random_particles(self, o: int, num_particles: int) -> List[int]:

{gym_csle_stopping_game-0.6.1 → gym_csle_stopping_game-0.6.3}/src/gym_csle_stopping_game/envs/stopping_game_pomdp_defender_env.py

@@ -4,12 +4,7 @@ import numpy.typing as npt
 from csle_common.dao.simulation_config.base_env import BaseEnv
 from gym_csle_stopping_game.dao.stopping_game_defender_pomdp_config import StoppingGameDefenderPomdpConfig
 from csle_common.dao.simulation_config.simulation_trace import SimulationTrace
-from csle_common.dao.training.policy import Policy
-from csle_common.dao.emulation_config.emulation_env_config import EmulationEnvConfig
-from csle_common.dao.simulation_config.simulation_env_config import SimulationEnvConfig
-from csle_common.dao.emulation_config.emulation_simulation_trace import EmulationSimulationTrace
 from csle_common.dao.emulation_config.emulation_trace import EmulationTrace
-from csle_common.dao.emulation_action.attacker.emulation_attacker_action import EmulationAttackerAction
 from gym_csle_stopping_game.envs.stopping_game_env import StoppingGameEnv
 from gym_csle_stopping_game.util.stopping_game_util import StoppingGameUtil
 
@@ -103,28 +98,6 @@ class StoppingGamePomdpDefenderEnv(BaseEnv):
         defender_obs = o[0]
         return defender_obs, r[0], d, info
 
-    @staticmethod
-    def emulation_evaluation(env: "StoppingGamePomdpDefenderEnv",
-                             n_episodes: int, intrusion_seq: List[EmulationAttackerAction],
-                             defender_policy: Policy,
-                             emulation_env_config: EmulationEnvConfig, simulation_env_config: SimulationEnvConfig) \
-            -> List[EmulationSimulationTrace]:
-        """
-        Utility function for evaluating policies in the emulation environment
-
-        :param env: the environment to use for evaluation
-        :param n_episodes: the number of episodes to use for evaluation
-        :param intrusion_seq: the sequence of intrusion actions to use for evaluation
-        :param defender_policy: the defender policy to use for evaluation
-        :param emulation_env_config: the configuration of the emulation environment to use for evaluation
-        :param simulation_env_config: the configuration of the simulation environment to use for evaluation
-        :return: traces with the evaluation results
-        """
-        return StoppingGameEnv.emulation_evaluation(
-            env=env.stopping_game_env, n_episodes=n_episodes, intrusion_seq=intrusion_seq,
-            defender_policy=defender_policy, attacker_policy=env.static_attacker_strategy,
-            emulation_env_config=emulation_env_config, simulation_env_config=simulation_env_config)
-
     def is_defense_action_legal(self, defense_action_id: int) -> bool:
         """
         Checks whether a defender action in the environment is legal or not

{gym_csle_stopping_game-0.6.1 → gym_csle_stopping_game-0.6.3}/src/gym_csle_stopping_game.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym-csle-stopping-game
-Version: 0.6.1
+Version: 0.6.3
 Summary: OpenAI gym reinforcement learning environment of a Dynkin (Optimal stopping) game in CSLE
 Author: Kim Hammar
 Author-email: hammar.kim@gmail.com

{gym_csle_stopping_game-0.6.1 → gym_csle_stopping_game-0.6.3}/src/gym_csle_stopping_game.egg-info/SOURCES.txt

@@ -23,4 +23,7 @@ src/gym_csle_stopping_game/envs/stopping_game_pomdp_defender_env.py
 src/gym_csle_stopping_game/util/__init__.py
 src/gym_csle_stopping_game/util/stopping_game_util.py
 tests/test_stopping_game_dao.py
+tests/test_stopping_game_env.py
+tests/test_stopping_game_mdp_attacker_env.py
+tests/test_stopping_game_pomdp_defender_env.py
 tests/test_stopping_game_util.py

{gym_csle_stopping_game-0.6.1 → gym_csle_stopping_game-0.6.3}/src/gym_csle_stopping_game.egg-info/requires.txt

@@ -1,9 +1,9 @@
 gymnasium>=0.27.1
-csle-base>=0.6.1
-csle-common>=0.6.1
-csle-attacker>=0.6.1
-csle-defender>=0.6.1
-csle-collector>=0.6.1
+csle-base>=0.6.3
+csle-common>=0.6.3
+csle-attacker>=0.6.3
+csle-defender>=0.6.3
+csle-collector>=0.6.3
 
 [testing]
 pytest>=6.0

gym_csle_stopping_game-0.6.3/tests/test_stopping_game_env.py

@@ -0,0 +1,420 @@
+from typing import Dict, Any
+import pytest
+from unittest.mock import patch, MagicMock
+from gymnasium.spaces import Box, Discrete
+import numpy as np
+from gym_csle_stopping_game.envs.stopping_game_env import StoppingGameEnv
+from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
+from gym_csle_stopping_game.dao.stopping_game_state import StoppingGameState
+import gym_csle_stopping_game.constants.constants as env_constants
+from csle_common.constants import constants
+
+
+class TestStoppingGameEnvSuite:
+    """
+    Test suite for stopping_game_env.py
+    """
+
+    @pytest.fixture(autouse=True)
+    def setup_env(self) -> None:
+        """
+        Sets up the configuration of the stopping game
+        
+        :return: None
+        """
+        env_name = "test_env"
+        T = np.array([[[0.1, 0.9], [0.4, 0.6]], [[0.7, 0.3], [0.2, 0.8]]])
+        O = np.array([0, 1])
+        Z = np.array([[[0.8, 0.2], [0.5, 0.5]], [[0.4, 0.6], [0.9, 0.1]]])
+        R = np.zeros((2, 3, 3, 3))
+        S = np.array([0, 1, 2])
+        A1 = np.array([0, 1, 2])
+        A2 = np.array([0, 1, 2])
+        L = 2
+        R_INT = 1
+        R_COST = 2
+        R_SLA = 3
+        R_ST = 4
+        b1 = np.array([0.6, 0.4])
+        save_dir = "save_directory"
+        checkpoint_traces_freq = 100
+        gamma = 0.9
+        compute_beliefs = True
+        save_trace = True
+        self.config = StoppingGameConfig(
+            env_name,
+            T,
+            O,
+            Z,
+            R,
+            S,
+            A1,
+            A2,
+            L,
+            R_INT,
+            R_COST,
+            R_SLA,
+            R_ST,
+            b1,
+            save_dir,
+            checkpoint_traces_freq,
+            gamma,
+            compute_beliefs,
+            save_trace,
+        )
+
+    def test_stopping_game_init_(self) -> None:
+        """
+        Tests the initializing function
+
+        :return: None
+        """
+        T = np.array([[[0.1, 0.9], [0.4, 0.6]], [[0.7, 0.3], [0.2, 0.8]]])
+        O = np.array([0, 1])
+        A1 = np.array([0, 1, 2])
+        A2 = np.array([0, 1, 2])
+        L = 2
+        b1 = np.array([0.6, 0.4])
+        attacker_observation_space = Box(
+            low=np.array([0.0, 0.0, 0.0]),
+            high=np.array([float(L), 1.0, 2.0]),
+            dtype=np.float64,
+        )
+        defender_observation_space = Box(
+            low=np.array([0.0, 0.0]),
+            high=np.array([float(L), 1.0]),
+            dtype=np.float64,
+        )
+        attacker_action_space = Discrete(len(A2))
+        defender_action_space = Discrete(len(A1))
+
+        assert self.config.T.any() == T.any()
+        assert self.config.O.any() == O.any()
+        assert self.config.b1.any() == b1.any()
+        assert self.config.L == L
+
+        env = StoppingGameEnv(self.config)
+        assert env.config == self.config
+        assert env.attacker_observation_space.low.any() == attacker_observation_space.low.any()
+        assert env.defender_observation_space.low.any() == defender_observation_space.low.any()
+        assert env.attacker_action_space.n == attacker_action_space.n
+        assert env.defender_action_space.n == defender_action_space.n
+        assert env.traces == []
+
+        with patch("gym_csle_stopping_game.dao.stopping_game_state.StoppingGameState") as MockStoppingGameState:
+            MockStoppingGameState(b1=self.config.b1, L=self.config.L)
+            with patch("gym_csle_stopping_game.util.stopping_game_util.StoppingGameUtil.sample_initial_state"
+                       ) as MockSampleInitialState:
+                MockSampleInitialState.return_value = 0
+                StoppingGameEnv(self.config)
+                MockSampleInitialState.assert_called()
+                MockStoppingGameState.assert_called_once_with(b1=self.config.b1, L=self.config.L)
+
+        with patch("csle_common.dao.simulation_config.simulation_trace.SimulationTrace") as MockSimulationTrace:
+            MockSimulationTrace(self.config.env_name).return_value
+            StoppingGameEnv(self.config)
+            MockSimulationTrace.assert_called_once_with(self.config.env_name)
+
+    def test_mean(self) -> None:
+        """
+        Tests the utility function for getting the mean of a vector
+
+        :return: None
+        """
+        test_cases = [
+            ([], 0),  # Test case for an empty vector
+            ([5], 0),  # Test case for a vector with a single element
+            ([0.2, 0.3, 0.5], 1.3),  # Test case for a vector with multiple elements
+        ]
+        for prob_vector, expected_mean in test_cases:
+            result = StoppingGameEnv(self.config).mean(prob_vector)
+            assert result == expected_mean
+
+    def test_weighted_intrusion_prediction_distance(self) -> None:
+        """
+        Tests the function of computing the weighed intrusion start time prediction distance
+        """
+        # Test case when first_stop is before intrusion_start
+        result1 = StoppingGameEnv(self.config).weighted_intrusion_prediction_distance(5, 3)
+        assert result1 == 0
+
+        # Test case when first_stop is after intrusion_start
+        result2 = StoppingGameEnv(self.config).weighted_intrusion_prediction_distance(3, 5)
+        assert result2 == 0.95
+
+        # Test case when first_stop is equal to intrusion_start
+        result3 = StoppingGameEnv(self.config).weighted_intrusion_prediction_distance(3, 3)
+        assert result3 == 0
+
+    def test_reset(self) -> None:
+        """
+        Tests the reset function for reseting the environment state
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        env.state = MagicMock()
+        env.state.l = 10
+        env.state.s = "initial_state"
+        env.state.t = 0
+        env.state.attacker_observation.return_value = np.array([1, 2, 3])
+        env.state.defender_observation.return_value = np.array([4, 5, 6])
+
+        env.trace = MagicMock()
+        env.trace.attacker_rewards = [1]
+        env.traces = []
+        # Call the reset method
+        observation, info = env.reset()
+        # Assertions
+        assert env.state.reset.called, "State's reset method was not called."
+        assert env.trace.simulation_env == self.config.env_name, "Trace was not initialized correctly."
+        assert observation[0].all() == np.array([4, 5, 6]).all(), "Observation does not match expected values."
+        assert info[env_constants.ENV_METRICS.STOPS_REMAINING] == env.state.l, \
+            "Stops remaining does not match expected value."
+        assert info[env_constants.ENV_METRICS.STATE] == env.state.s, "State info does not match expected value."
+        assert info[env_constants.ENV_METRICS.OBSERVATION] == 0, "Observation info does not match expected value."
+        assert info[env_constants.ENV_METRICS.TIME_STEP] == env.state.t, "Time step info does not match expected value."
+
+        # Check if trace was appended correctly
+        if len(env.trace.attacker_rewards) > 0:
+            assert env.traces[-1] == env.trace, "Trace was not appended correctly."
+
+    def test_render(self) -> None:
+        """
+        Tests the function of rendering the environment
+
+        :return: None
+        """
+        with pytest.raises(NotImplementedError):
+            StoppingGameEnv(self.config).render()
+
+    def test_is_defense_action_legal(self) -> None:
+        """
+        Tests the function of checking whether a defender action in the environment is legal or not
+
+        :return: None
+        """
+        assert StoppingGameEnv(self.config).is_defense_action_legal(1)
+
+    def test_is_attack_action_legal(self) -> None:
+        """
+        Tests the function of checking whether an attacker action in the environment is legal or not
+
+        :return: None
+        """
+        assert StoppingGameEnv(self.config).is_attack_action_legal(1)
+
+    def test_get_traces(self) -> None:
+        """
+        Tests the function of getting the list of simulation traces
+
+        :return: None
+        """
+        assert StoppingGameEnv(self.config).get_traces() == StoppingGameEnv(self.config).traces
+
+    def test_reset_traces(self) -> None:
+        """
+        Tests the function of resetting the list  of traces
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        env.traces = ["trace1", "trace2"]
+        env.reset_traces()
+        assert env.traces == []
+
+    def test_checkpoint_traces(self) -> None:
+        """
+        Tests the function of checkpointing agent traces
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        fixed_timestamp = 123
+        with patch("time.time", return_value=fixed_timestamp):
+            with patch(
+                    "csle_common.dao.simulation_config.simulation_trace.SimulationTrace.save_traces"
+            ) as mock_save_traces:
+                env.traces = ["trace1", "trace2"]
+                env._StoppingGameEnv__checkpoint_traces()
+                mock_save_traces.assert_called_once_with(
+                    traces_save_dir=constants.LOGGING.DEFAULT_LOG_DIR,
+                    traces=env.traces,
+                    traces_file=f"taus{fixed_timestamp}.json",
+                )
+
+    def test_set_model(self) -> None:
+        """
+        Tests the function of setting the model
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        mock_model = MagicMock()
+        env.set_model(mock_model)
+        assert env.model == mock_model
+
+    def test_set_state(self) -> None:
+        """
+        Tests the function of setting the state
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        env.state = MagicMock()
+
+        mock_state = MagicMock(spec=StoppingGameState)
+        env.set_state(mock_state)
+        assert env.state == mock_state
+
+        state_int = 5
+        env.set_state(state_int)
+        assert env.state.s == state_int
+        assert env.state.l == self.config.L
+
+        state_tuple = (3, 7)
+        env.set_state(state_tuple)
+        assert env.state.s == state_tuple[0]
+        assert env.state.l == state_tuple[1]
+
+        with pytest.raises(ValueError):
+            env.set_state([1, 2, 3])  # type: ignore
+
+    def test_is_state_terminal(self) -> None:
+        """
+        Tests the function of checking whether a given state is terminal or not
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        env.state = MagicMock()
+
+        mock_state = MagicMock(spec=StoppingGameState)
+        mock_state.s = 2
+        assert env.is_state_terminal(mock_state)
+        mock_state.s = 1
+        assert not env.is_state_terminal(mock_state)
+        state_int = 2
+        assert env.is_state_terminal(state_int)
+        state_int = 1
+        assert not env.is_state_terminal(state_int)
+        state_tuple = (2, 5)
+        assert env.is_state_terminal(state_tuple)
+        state_tuple = (1, 5)
+        assert not env.is_state_terminal(state_tuple)
+
+        with pytest.raises(ValueError):
+            env.is_state_terminal([1, 2, 3]) # type: ignore
+
+    def test_get_observation_from_history(self) -> None:
+        """
+        Tests the function of getting a hidden observation based on a history
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        history = [1, 2, 3, 4, 5]
+        pi2 = np.array([0.1, 0.9])
+        l = 3
+        observation = env.get_observation_from_history(history, pi2, l)
+        assert observation == [5]
+
+        history = []
+        with pytest.raises(ValueError, match="History must not be empty"):
+            env.get_observation_from_history(history, pi2, l)
+
+    def test_generate_random_particles(self) -> None:
+        """
+        Tests the funtion of generating a random list of state particles from a given observation
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        num_particles = 10
+        particles = env.generate_random_particles(o=1, num_particles=num_particles)
+        assert len(particles) == num_particles
+        assert all(p in [0, 1] for p in particles)
+
+        num_particles = 0
+        particles = env.generate_random_particles(o=1, num_particles=num_particles)
+        assert len(particles) == num_particles
+
+    def test_step(self) -> None:
+        """
+        Tests the funtion of taking a step in the environment by executing  the given action
+
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        env.state = MagicMock()
+        env.state.s = 1
+        env.state.l = 2
+        env.state.t = 0
+        env.state.attacker_observation.return_value = np.array([1, 2, 3])
+        env.state.defender_observation.return_value = np.array([4, 5, 6])
+        env.state.b = np.array([0.5, 0.5, 0.0])
+
+        env.trace = MagicMock()
+        env.trace.defender_rewards = []
+        env.trace.attacker_rewards = []
+        env.trace.attacker_actions = []
+        env.trace.defender_actions = []
+        env.trace.infos = []
+        env.trace.states = []
+        env.trace.beliefs = []
+        env.trace.infrastructure_metrics = []
+        env.trace.attacker_observations = []
+        env.trace.defender_observations = []
+
+        with patch("gym_csle_stopping_game.util.stopping_game_util.StoppingGameUtil.sample_next_state",
+                   return_value=2):
+            with patch("gym_csle_stopping_game.util.stopping_game_util.StoppingGameUtil.sample_next_observation",
+                       return_value=1):
+                with patch("gym_csle_stopping_game.util.stopping_game_util.StoppingGameUtil.next_belief",
+                           return_value=np.array([0.3, 0.7, 0.0])):
+                    action_profile = (
+                        1,
+                        (
+                            np.array(
+                                [[0.2, 0.8, 0.0], [0.6, 0.4, 0.0], [0.5, 0.5, 0.0]]
+                            ),
+                            2,
+                        ),
+                    )
+                    observations, rewards, terminated, truncated, info = env.step(
+                        action_profile
+                    )
+
+                    assert (observations[0] == np.array([4, 5, 6])).all(), "Incorrect defender observations"
+                    assert (observations[1] == np.array([1, 2, 3])).all(), "Incorrect attacker observations"
+                    assert rewards == (0, 0)
+                    assert not terminated
+                    assert not truncated
+                    assert env.trace.defender_rewards[-1] == 0
+                    assert env.trace.attacker_rewards[-1] == 0
+                    assert env.trace.attacker_actions[-1] == 2
+                    assert env.trace.defender_actions[-1] == 1
+                    assert env.trace.infos[-1] == info
+                    assert env.trace.states[-1] == 2
+                    print(env.trace.beliefs)
+                    assert env.trace.beliefs[-1] == 0.7
+                    assert env.trace.infrastructure_metrics[-1] == 1
+                    assert (env.trace.attacker_observations[-1] == np.array([1, 2, 3])).all()
+                    assert (env.trace.defender_observations[-1] == np.array([4, 5, 6])).all()
+
+    def test_info(self) -> None:
+        """
+        Tests the function of adding the cumulative reward and episode length to the info dict
+        
+        :return: None
+        """
+        env = StoppingGameEnv(self.config)
+        env.trace = MagicMock()
+        env.trace.defender_rewards = [1, 2]
+        env.trace.attacker_actions = [0, 1]
+        env.trace.defender_actions = [0, 1]
+        env.trace.states = [0, 1]
+        env.trace.infrastructure_metrics = [0, 1]
+        info: Dict[str, Any] = {}
+        updated_info = env._info(info)
+        assert updated_info[env_constants.ENV_METRICS.RETURN] == sum(env.trace.defender_rewards)