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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym_csle_stopping_game
-Version: 0.6.1
+Version: 0.6.2
 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.2}/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.2
+	csle-common>=0.6.2
+	csle-attacker>=0.6.2
+	csle-defender>=0.6.2
+	csle-collector>=0.6.2
 python_requires = >=3.8
 package_dir = 
 	=src

gym_csle_stopping_game-0.6.2/src/gym_csle_stopping_game/__version__.py

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

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

@@ -42,7 +42,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 +72,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 +83,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)
@@ -437,6 +435,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.2}/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.2
 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.2}/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.2}/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.2
+csle-common>=0.6.2
+csle-attacker>=0.6.2
+csle-defender>=0.6.2
+csle-collector>=0.6.2
 
 [testing]
 pytest>=6.0

gym_csle_stopping_game-0.6.2/tests/test_stopping_game_env.py

@@ -0,0 +1,428 @@
+from typing import Dict, Any
+import pytest
+from unittest.mock import patch, MagicMock
+from gym.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)
+
+    def test_emulation_evaluation(self) -> None:
+        """
+        Tests the function for evaluating a strategy profile in the emulation environment
+        
+        :return: None
+        """
+        StoppingGameEnv(self.config)

gym_csle_stopping_game-0.6.2/tests/test_stopping_game_mdp_attacker_env.py

@@ -0,0 +1,343 @@
+from gym_csle_stopping_game.envs.stopping_game_mdp_attacker_env import (
+    StoppingGameMdpAttackerEnv,
+)
+from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
+from gym_csle_stopping_game.dao.stopping_game_attacker_mdp_config import (
+    StoppingGameAttackerMdpConfig,
+)
+from gym_csle_stopping_game.envs.stopping_game_env import StoppingGameEnv
+from csle_common.dao.training.policy import Policy
+import pytest
+from unittest.mock import MagicMock
+import numpy as np
+
+
+class TestStoppingGameMdpAttackerEnvSuite:
+    """
+    Test suite for stopping_game_mdp_attacker_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_init_(self) -> None:
+        """
+        Tests the initializing function
+
+        :return: None
+        """
+        # Mock the defender strategy
+        defender_strategy = MagicMock(spec=Policy)
+        # Create the attacker MDP configuration
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        # Initialize the StoppingGameMdpAttackerEnv
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        assert env.config == attacker_mdp_config
+        assert env.observation_space == self.config.attacker_observation_space()
+        assert env.action_space == self.config.attacker_action_space()
+        assert env.static_defender_strategy == defender_strategy
+        # print(env.latest_defender_obs)
+        # assert not env.latest_defender_obs
+        # assert not env.latest_attacker_obs
+        assert not env.model
+        assert not env.viewer
+
+    def test_reset(self) -> None:
+        """
+        Tests the function for reseting the environment state
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        attacker_obs, info = env.reset()
+        assert env.latest_defender_obs.all() == np.array([2, 0.4]).all() # type: ignore
+        assert info == {}
+
+    def test_set_model(self) -> None:
+        """
+        Tests the function for setting the model
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        mock_model = MagicMock()
+        env.set_model(mock_model)
+        assert env.model == mock_model
+
+    def test_set_state(self) -> None:
+        """
+        Tests the function for setting the state
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        assert not env.set_state(1) # type: ignore
+
+    def test_calculate_stage_policy(self) -> None:
+        """
+        Tests the function for calculating the stage policy of a given model and observation
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        env.model = None
+        observation = [1, 0.5]
+        stage_policy = env.calculate_stage_policy(o=observation)
+        expected_stage_policy = np.array([[1.0, 0.0], [1.0, 0.0], [0.5, 0.5]])
+        assert stage_policy.all() == expected_stage_policy.all()
+
+    def test_get_attacker_dist(self) -> None:
+        """
+        Tests the function for getting the attacker's action distribution based on a given observation
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        env.model = None
+        observation = [1, 0.5, 0]
+        with pytest.raises(ValueError, match="Model is None"):
+            env._get_attacker_dist(observation)
+
+    def test_render(self) -> None:
+        """
+        Tests the function for rendering the environment
+        
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        with pytest.raises(NotImplementedError):
+            env.render("human")
+
+    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
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        assert env.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
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        assert env.is_attack_action_legal(1)
+
+    def test_get_traces(self) -> None:
+        """
+        Tests the function of getting the list of simulation traces
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        assert env.get_traces() == StoppingGameEnv(self.config).traces
+
+    def test_reset_traces(self) -> None:
+        """
+        Tests the function of resetting the list  of traces
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        env.traces = ["trace1", "trace2"]
+        env.reset_traces()
+        assert StoppingGameEnv(self.config).traces == []
+
+    def test_generate_random_particles(self) -> None:
+        """
+        Tests the funtion of generating a random list of state particles from a given observation
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_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_get_actions_from_particles(self) -> None:
+        """
+        Tests the function for pruning the set of actions based on the current particle set
+
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        particles = [1, 2, 3]
+        t = 0
+        observation = 0
+        expected_actions = [0, 1, 2]
+        assert (
+            env.get_actions_from_particles(particles, t, observation)
+            == expected_actions
+        )
+
+    def test_step(self) -> None:
+        """
+        Tests the function for taking a step in the environment by executing the given action
+        
+        :return: None
+        """
+        defender_strategy = MagicMock(spec=Policy)
+        attacker_mdp_config = StoppingGameAttackerMdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            defender_strategy=defender_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+
+        env = StoppingGameMdpAttackerEnv(config=attacker_mdp_config)
+        pi2 = np.array([[0.5, 0.5]])
+        with pytest.raises(AssertionError):
+            env.step(pi2)

gym_csle_stopping_game-0.6.2/tests/test_stopping_game_pomdp_defender_env.py

@@ -0,0 +1,336 @@
+from gym_csle_stopping_game.envs.stopping_game_pomdp_defender_env import StoppingGamePomdpDefenderEnv
+from gym_csle_stopping_game.dao.stopping_game_config import StoppingGameConfig
+from gym_csle_stopping_game.dao.stopping_game_defender_pomdp_config import StoppingGameDefenderPomdpConfig
+from gym_csle_stopping_game.envs.stopping_game_env import StoppingGameEnv
+from gym_csle_stopping_game.util.stopping_game_util import StoppingGameUtil
+from csle_common.dao.training.policy import Policy
+from csle_common.dao.training.random_policy import RandomPolicy
+from csle_common.dao.training.player_type import PlayerType
+import pytest
+from unittest.mock import MagicMock
+import numpy as np
+
+
+class TestStoppingGamePomdpDefenderEnvSuite:
+    """
+    Test suite for stopping_game_pomdp_defender_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 = StoppingGameUtil.transition_tensor(L=3, p=0)
+        O = StoppingGameUtil.observation_space(n=100)
+        Z = StoppingGameUtil.observation_tensor(n=100)
+        R = np.zeros((2, 3, 3, 3))
+        S = StoppingGameUtil.state_space()
+        A1 = StoppingGameUtil.defender_actions()
+        A2 = StoppingGameUtil.attacker_actions()
+        L = 2
+        R_INT = 1
+        R_COST = 2
+        R_SLA = 3
+        R_ST = 4
+        b1 = StoppingGameUtil.b1()
+        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_init_(self) -> None:
+        """
+        Tests the initializing function
+
+        :return: None
+        """
+        # Mock the attacker strategy
+        attacker_strategy = MagicMock(spec=Policy)
+        # Create the defender POMDP configuration
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        # Initialize the StoppingGamePomdpDefenderEnv
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        assert env.config == defender_pomdp_config
+        assert env.observation_space == self.config.defender_observation_space()
+        assert env.action_space == self.config.defender_action_space()
+        assert env.static_attacker_strategy == attacker_strategy
+        assert not env.viewer
+
+    def test_reset(self) -> None:
+        """
+        Tests the function for reseting the environment state
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        _, info = env.reset()
+        assert info
+
+    def test_render(self) -> None:
+        """
+        Tests the function for rendering the environment
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        with pytest.raises(NotImplementedError):
+            env.render("human")
+
+    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
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        assert env.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
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        assert env.is_attack_action_legal(1)
+
+    def test_get_traces(self) -> None:
+        """
+        Tests the function of getting the list of simulation traces
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        assert env.get_traces() == StoppingGameEnv(self.config).traces
+
+    def test_reset_traces(self) -> None:
+        """
+        Tests the function of resetting the list  of traces
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        env.traces = ["trace1", "trace2"]
+        env.reset_traces()
+        assert StoppingGameEnv(self.config).traces == []
+
+    def test_set_model(self) -> None:
+        """
+        Tests the function for setting the model
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        mock_model = MagicMock()
+        env.set_model(mock_model)
+        assert env.model == mock_model
+
+    def test_set_state(self) -> None:
+        """
+        Tests the function for setting the state
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        assert env.set_state(1) is None # type: ignore
+
+    def test_get_observation_from_history(self) -> None:
+        """
+        Tests the function for getting a defender observation (belief) from a history
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        history = [1, 2, 3]
+        l = self.config.L
+        pi2 = env.static_attacker_strategy.stage_policy(o=0)
+        assert env.get_observation_from_history(history) == StoppingGameEnv(
+            self.config
+        ).get_observation_from_history(history, pi2, l)
+
+    def test_is_state_terminal(self) -> None:
+        """
+        Tests the funciton for checking whether a state is terminal or not
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        assert env.is_state_terminal(1) == StoppingGameEnv(
+            self.config
+        ).is_state_terminal(1)
+
+    def test_generate_random_particles(self) -> None:
+        """
+        Tests the funtion of generating a random list of state particles from a given observation
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_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_get_actions_from_particles(self) -> None:
+        """
+        Tests the function for pruning the set of actions based on the current particle set
+
+        :return: None
+        """
+        attacker_strategy = MagicMock(spec=Policy)
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        particles = [1, 2, 3]
+        t = 0
+        observation = 0
+        expected_actions = [0, 1]
+        assert env.get_actions_from_particles(particles, t, observation) == expected_actions
+
+    def test_step(self) -> None:
+        """
+        Tests the function for taking a step in the environment by executing the given action
+
+        :return: None
+        """
+        attacker_stage_strategy = np.zeros((3, 2))
+        attacker_stage_strategy[0][0] = 0.9
+        attacker_stage_strategy[0][1] = 0.1
+        attacker_stage_strategy[1][0] = 0.9
+        attacker_stage_strategy[1][1] = 0.1
+        attacker_stage_strategy[2] = attacker_stage_strategy[1]
+        attacker_strategy = RandomPolicy(actions=list(self.config.A2), player_type=PlayerType.ATTACKER,
+                                         stage_policy_tensor=list(attacker_stage_strategy))
+        defender_pomdp_config = StoppingGameDefenderPomdpConfig(
+            env_name="test_env",
+            stopping_game_config=self.config,
+            attacker_strategy=attacker_strategy,
+            stopping_game_name="csle-stopping-game-v1",
+        )
+        env = StoppingGamePomdpDefenderEnv(config=defender_pomdp_config)
+        a1 = 1
+        env.reset()
+        defender_obs, reward, terminated, truncated, info = env.step(a1)
+        assert len(defender_obs) == 2
+        assert isinstance(defender_obs[0], float) # type: ignore
+        assert isinstance(defender_obs[1], float) # type: ignore
+        assert isinstance(reward, float) # type: ignore
+        assert isinstance(terminated, bool) # type: ignore
+        assert isinstance(truncated, bool) # type: ignore
+        assert isinstance(info, dict) # type: ignore

gym_csle_stopping_game-0.6.1/src/gym_csle_stopping_game/__version__.py

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