Hashable Configurations (#789)

Co-authored-by: Florian Sattler <[email protected]>

tests/base/test_configuration.py

@@ -7,6 +7,7 @@
     DummyConfiguration,
     ConfigurationImpl,
     ConfigurationOptionImpl,
+    FrozenConfiguration,
 )
 
 
@@ -74,6 +75,66 @@ def test_to_str(self) -> None:
 
         self.assertEqual(str(config), config.dump_to_string())
 
+    def test_equality_same(self) -> None:
+        """Test to compare configuration to each other."""
+        config = ConfigurationImpl()
+        config.add_config_option(ConfigurationOptionImpl("foo", 42))
+        config_2 = ConfigurationImpl()
+        config_2.add_config_option(ConfigurationOptionImpl("foo", 42))
+
+        self.assertTrue(config == config_2)
+        self.assertFalse(config != config_2)
+
+    def test_equality_different(self) -> None:
+        """Test to compare configuration to to each other."""
+        config = ConfigurationImpl()
+        config.add_config_option(ConfigurationOptionImpl("foo", 42))
+        config_2 = ConfigurationImpl()
+        config_2.add_config_option(ConfigurationOptionImpl("foo", False))
+
+        self.assertFalse(config == config_2)
+        self.assertTrue(config != config_2)
+
+    def test_equality_mapping(self) -> None:
+        """Test to compare configuration to a mapping."""
+        config = ConfigurationImpl()
+        config.add_config_option(ConfigurationOptionImpl("foo", 42))
+
+        mapping_identical = {"foo": 42}
+        mapping_not_identical = {"foo": 43}
+        mapping_interpreted = {"foo": True}
+        mapping_not_interpreted = {"foo": False}
+
+        self.assertTrue(config == mapping_identical)
+        self.assertFalse(config != mapping_identical)
+
+        self.assertFalse(config == mapping_not_identical)
+        self.assertTrue(config != mapping_not_identical)
+
+        self.assertTrue(config == mapping_interpreted)
+        self.assertFalse(config != mapping_interpreted)
+
+        self.assertFalse(config == mapping_not_interpreted)
+        self.assertTrue(config != mapping_not_interpreted)
+
+        config_2 = ConfigurationImpl()
+        config_2.add_config_option(ConfigurationOptionImpl("foo", False))
+
+        self.assertFalse(config_2 == mapping_interpreted)
+        self.assertTrue(config_2 != mapping_interpreted)
+
+        self.assertTrue(config_2 == mapping_not_interpreted)
+        self.assertFalse(config_2 != mapping_not_interpreted)
+
+    def test_equality_othertypes(self) -> None:
+        """Test to compare configuration to each other."""
+        config = ConfigurationImpl()
+        config.add_config_option(ConfigurationOptionImpl("foo", 42))
+        other_object = 42
+
+        self.assertFalse(config == other_object)
+        self.assertTrue(config != other_object)
+
 
 class TestDummyConfiguration(unittest.TestCase):
     """Test if the Dummy Configuration does not allow any interface usage."""
@@ -106,3 +167,36 @@ def test_crash_dump_to_string(self) -> None:
         with self.assertRaises(AssertionError):
             d_config = DummyConfiguration()
             d_config.dump_to_string()
+
+    def test_crash_freeze(self) -> None:
+        with self.assertRaises(AssertionError):
+            d_config = DummyConfiguration()
+            d_config.freeze()
+
+    def test_crash_unfreeze(self) -> None:
+        with self.assertRaises(AssertionError):
+            d_config = DummyConfiguration()
+            d_config.unfreeze()
+
+
+class TestFrozenConfiguration(unittest.TestCase):
+    """Test freeze and unfreeze methods of a FrozenConfiguration."""
+
+    def test_freeze_and_unfreeze(self) -> None:
+        config = ConfigurationImpl()
+        config.add_config_option(ConfigurationOptionImpl("foo", 42))
+        frozen_config = config.freeze()
+
+        self.assertTrue(isinstance(frozen_config, FrozenConfiguration))
+        self.assertTrue(frozen_config == config)
+        self.assertTrue(frozen_config is frozen_config.freeze())
+        self.assertFalse(frozen_config is config)
+
+        with self.assertRaises(NotImplementedError):
+            frozen_config.add_config_option(ConfigurationOptionImpl("foo", 42))
+
+        unfrozen_config = frozen_config.unfreeze()
+        self.assertTrue(isinstance(unfrozen_config, ConfigurationImpl))
+        self.assertTrue(unfrozen_config == config)
+        self.assertTrue(unfrozen_config is unfrozen_config.unfreeze())
+        self.assertFalse(unfrozen_config is frozen_config)

tests/mapping/test_configuration_map.py

@@ -91,9 +91,11 @@ def test_inter_configs(self) -> None:
         config_map.add_configuration(test_config_2)
         config_map.add_configuration(test_config_3)
 
-        self.assertEqual(3, len(config_map.configurations()))
-        self.assertSetEqual({test_config_1, test_config_2, test_config_3},
-                            set(config_map.configurations()))
+        configurations = config_map.configurations()
+        self.assertEqual(3, len(configurations))
+        self.assertIn(test_config_1, configurations)
+        self.assertIn(test_config_2, configurations)
+        self.assertIn(test_config_3, configurations)
 
     def test_inter_id_config_tuples(self) -> None:
         """Test if we can iterate over all id configuration pairs."""
@@ -106,10 +108,11 @@ def test_inter_id_config_tuples(self) -> None:
         config_map.add_configuration(test_config_2)
         config_map.add_configuration(test_config_3)
 
-        self.assertEqual(3, len(config_map.id_config_tuples()))
-        self.assertSetEqual({(0, test_config_1), (1, test_config_2),
-                             (2, test_config_3)},
-                            set(config_map.id_config_tuples()))
+        id_config_tuples = config_map.id_config_tuples()
+        self.assertEqual(3, len(id_config_tuples))
+        self.assertIn((0, test_config_1), id_config_tuples)
+        self.assertIn((1, test_config_2), id_config_tuples)
+        self.assertIn((2, test_config_3), id_config_tuples)
 
 
 class TestConfigurationMapStoreAndLoad(unittest.TestCase):