add unit tests, achieving 100% coverage

README.md

@@ -40,7 +40,7 @@ print(cube.history)
 ### Perform basic moves
 
 ```python
-# shuffle the cube using 1000 random moves
+# shuffle the cube using 1000 random moves (random shuffling resets the history)
 cube.shuffle(num_moves=1000, seed=0)
 
 # rotate it in some way

src/rubik/cube.py

@@ -37,7 +37,13 @@ class Cube:
 
     def to(self, device: str | torch.device) -> "Cube":
         device = torch.device(device)
-        dtype = torch.int16 if device == torch.device("cpu") else torch.float32
+        dtype = (
+            self.state.dtype
+            if self.state.device == device
+            else torch.int16
+            if device == torch.device("cpu")
+            else torch.float32
+        )
         self.coordinates = self.coordinates.to(device=device, dtype=dtype)
         self.state = self.state.to(device=device, dtype=dtype)
         self.actions = self.actions.to(device=device, dtype=dtype)
@@ -84,15 +90,9 @@ class Cube:
         """
         actions = parse_actions_str(moves)
         tensors = [self.actions[*action].to(torch.float32) for action in actions]
-        result = reduce(lambda A, B: A @ B, tensors).to(torch.int16)
+        result = reduce(lambda A, B: B @ A, tensors).to(torch.int16).coalesce()
         return dict(result.indices().transpose(0, 1).tolist())
 
-    def solve(self, policy: str) -> None:
-        """
-        Apply the specified solving policy to the cube.
-        """
-        raise NotImplementedError
-
     def __str__(self):
         """
         Compute a string representation of a cube.

tests/unit/test_cube.py

@@ -1,5 +1,6 @@
 import pytest
 
+import torch
 
 from rubik.cube import Cube
 
@@ -27,3 +28,79 @@ class TestCube:
         )
         assert cube.state.shape == (6 * (size**2), 7), f"'state' has incorrect shape {cube.state.shape}"
         assert len(cube.history) == 0, "'history' field should be empty"
+
+    @pytest.mark.parametrize("device", ["cpu"])
+    def test_to(self, device: str | torch.device):
+        cube = Cube(colors=["U", "L", "C", "R", "B", "D"], size=3)
+        cube_2 = cube.to(device)
+        assert torch.equal(cube.state, cube_2.state), "cube has different state after calling 'to' method"
+
+    def test_reset_history(self):
+        cube = Cube(colors=["U", "L", "C", "R", "B", "D"], size=3)
+        cube.rotate("X2 X1i Y1i Z1i Y0 Z0i X2 X1i Y1i Z1i Y0 Z0i")
+        cube.reset_history()
+        assert cube.history == [], "method 'reset_history' does not flush content"
+
+    @pytest.mark.parametrize("num_moves, seed", [[50, 42]])
+    def test_shuffle(self, num_moves: int, seed: int):
+        cube = Cube(colors=["U", "L", "C", "R", "B", "D"], size=3)
+        cube_state = cube.state.clone()
+        cube.shuffle(num_moves, seed)
+        assert cube.history == [], "method 'shuffle' does not flush content"
+        assert not torch.equal(cube_state, cube.state), "method 'shuffle' does not change state"
+
+    @pytest.mark.parametrize(
+        "moves",
+        [
+            "X2 X1i Y1i Z1i Y0 Z0i X2 X1i Y1i Z1i Y0 Z0i",
+            "X2 X1i Y1i Z1i Y0 Z0i X2 X1i Y1i Z1i Y0 Z0i" * 2,
+        ],
+    )
+    def test_rotate(self, moves: str):
+        cube = Cube(colors=["U", "L", "C", "R", "B", "D"], size=3)
+        cube_state = cube.state.clone()
+        cube.rotate(moves)
+        assert cube.history != [], "method 'rotate' does not update history"
+        assert not torch.equal(cube_state, cube.state), "method 'rotate' does not change state"
+
+    @pytest.mark.parametrize(
+        "axis, slice, inverse",
+        [
+            [0, 2, 0],
+            [1, 1, 1],
+            [2, 0, 0],
+        ],
+    )
+    def test_rotate_once(self, axis: int, slice: int, inverse: int):
+        cube = Cube(colors=["U", "L", "C", "R", "B", "D"], size=3)
+        cube_state = cube.state.clone()
+        cube.rotate_once(axis, slice, inverse)
+        assert cube.history == [[axis, slice, inverse]], "method 'rotate_once' does not update history"
+        assert not torch.equal(cube_state, cube.state), "method 'rotate_once' does not change state"
+
+    @pytest.mark.parametrize(
+        "moves",
+        [
+            "X2 X1i Y1i",
+            "X2 X1i Y1i Z1i Y0 Z0i X2 X1i Y1i Z1i Y0 Z0i " * 2,
+        ],
+    )
+    def test_compute_changes(self, moves: str):
+        cube = Cube(colors=["U", "L", "C", "R", "B", "D"], size=3)
+        facets = cube.state.argmax(dim=-1).to(torch.int16).tolist()
+        changes = cube.compute_changes(moves)
+
+        # apply changes induced by moves using the permutation dict returned by 'compute_changes'
+        expected = [facets[changes.get(i, i)] for i in range(len(facets))]
+
+        # apply changes induced by moves using the optimized 'rotate' method
+        cube.rotate(moves)
+        observed = cube.state.argmax(dim=-1).to(torch.int16).tolist()
+
+        # assert the tow are identical
+        assert expected == observed, "method 'compute_changes' does not behave correctly: "
+
+    def test__str__(self):
+        cube = Cube(colors=["U", "L", "C", "R", "B", "D"], size=3)
+        repr = str(cube)
+        assert len(repr), "__str__ method returns an empty representation"