additional test cases for entropy.py this ensures coverage of orientational_entropy_calculation function

Author: harryswift01

CodeEntropy/entropy.py

@@ -822,7 +822,7 @@ def orientational_entropy_calculation(self, neighbours_dict):
         # Replaced molecule with neighbour as this is what the for loop uses
         S_or_total = 0
         for neighbour in neighbours_dict:  # we are going through neighbours
-            if neighbour in []:  # water molecules - call POSEIDON functions
+            if neighbour in ["H2O"]:  # water molecules - call POSEIDON functions
                 pass  # TODO temporary until function is written
             else:
                 # the bound ligand is always going to be a neighbour
@@ -835,16 +835,16 @@ def orientational_entropy_calculation(self, neighbours_dict):
                     f"S_or_component (log(omega)) for neighbour {neighbour}: "
                     f"{S_or_component}"
                 )
-                S_or_component *= self.GAS_CONST
+                S_or_component *= self._GAS_CONST
                 logger.debug(
                     f"S_or_component after multiplying by GAS_CONST for neighbour "
                     f"{neighbour}: {S_or_component}"
                 )
-            S_or_total += S_or_component
-            logger.debug(
-                f"S_or_total after adding component for neighbour {neighbour}: "
-                f"{S_or_total}"
-            )
+                S_or_total += S_or_component
+                logger.debug(
+                    f"S_or_total after adding component for neighbour {neighbour}: "
+                    f"{S_or_total}"
+                )
         # TODO for future releases
         # implement a case for molecules with hydrogen bonds but to a lesser
         # extent than water

tests/test_CodeEntropy/test_entropy.py

@@ -1,3 +1,4 @@
+import math
 import os
 import shutil
 import tempfile
@@ -1197,6 +1198,46 @@ def test_orientational_entropy_init(self):
         self.assertEqual(oe._args.temperature, 300)
         self.assertEqual(oe._args.bin_width, 0.1)
 
+    def test_orientational_entropy_calculation(self):
+        """
+        Tests that `orientational_entropy_calculation` correctly computes the total
+        orientational entropy for a given dictionary of neighboring species using
+        the internal gas constant.
+        """
+        # Setup a mock neighbours dictionary
+        neighbours_dict = {
+            "ligandA": 2,
+            "ligandB": 3,
+        }
+
+        # Create an instance of OrientationalEntropy with dummy dependencies
+        oe = OrientationalEntropy(None, None, None, None, None)
+
+        # Run the method
+        result = oe.orientational_entropy_calculation(neighbours_dict)
+
+        # Manually compute expected result using the class's internal gas constant
+        expected = (
+            math.log(math.sqrt((2**3) * math.pi))
+            + math.log(math.sqrt((3**3) * math.pi))
+        ) * oe._GAS_CONST
+
+        # Assert the result is as expected
+        self.assertAlmostEqual(result, expected, places=6)
+
+    def test_orientational_entropy_water_branch_is_covered(self):
+        """
+        Tests that the placeholder branch for water molecules is executed to ensure
+        coverage of the `if neighbour in [...]` block.
+        """
+        neighbours_dict = {"H2O": 1}  # Matches the condition exactly
+
+        oe = OrientationalEntropy(None, None, None, None, None)
+        result = oe.orientational_entropy_calculation(neighbours_dict)
+
+        # Since the logic is skipped, total entropy should be 0.0
+        self.assertEqual(result, 0.0)
+
 
 if __name__ == "__main__":
     unittest.main()