Add pytest test suite with conftest, test_grid, test_block, test_game

Author: mcode-bot

tests/conftest.py

@@ -0,0 +1,17 @@
+import sys
+import os
+from unittest.mock import MagicMock
+
+# Set dummy SDL drivers so pygame.init() doesn't error on headless/audio-less systems
+os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
+os.environ.setdefault("SDL_AUDIODRIVER", "dummy")
+
+import pygame
+pygame.init()
+
+# Patch mixer before game is imported so Game.__init__ doesn't need real audio hardware
+pygame.mixer.Sound = MagicMock(return_value=MagicMock())
+pygame.mixer.music = MagicMock()
+
+# Add repo root to sys.path so all source modules are importable
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

tests/test_block.py

@@ -0,0 +1,77 @@
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from blocks import LBlock
+from position import Position
+
+
+def test_move_updates_offsets():
+    block = LBlock()
+    # LBlock.__init__ calls move(0, 3) so reset offsets first
+    block.row_offset = 0
+    block.column_offset = 0
+    block.move(2, 3)
+    assert block.row_offset == 2
+    assert block.column_offset == 3
+
+
+def test_move_accumulates():
+    block = LBlock()
+    block.row_offset = 0
+    block.column_offset = 0
+    block.move(1, 0)
+    block.move(2, 0)
+    assert block.row_offset == 3
+
+
+def test_get_cell_positions_applies_offset():
+    block = LBlock()
+    # Reset to known zero offsets, then apply a single offset
+    block.row_offset = 0
+    block.column_offset = 0
+    block.rotation_state = 0
+
+    # Get base positions (no offset)
+    base_positions = [
+        Position(p.row, p.column) for p in block.cells[0]
+    ]
+
+    block.move(1, 0)
+    moved_positions = block.get_cell_positions()
+
+    for base, moved in zip(base_positions, moved_positions):
+        assert moved.row == base.row + 1
+        assert moved.column == base.column
+
+
+def test_rotate_increments_state():
+    block = LBlock()
+    initial_state = block.rotation_state
+    block.rotate()
+    assert block.rotation_state == initial_state + 1
+
+
+def test_rotate_wraps_around():
+    block = LBlock()
+    num_states = len(block.cells)
+    # Rotate through all states; next rotate should wrap back to 0
+    for _ in range(num_states):
+        block.rotate()
+    assert block.rotation_state == 0
+
+
+def test_undo_rotation_decrements_state():
+    block = LBlock()
+    block.rotation_state = 2
+    block.undo_rotation()
+    assert block.rotation_state == 1
+
+
+def test_undo_rotation_wraps_around():
+    block = LBlock()
+    block.rotation_state = 0
+    block.undo_rotation()
+    # Should wrap to the last valid state
+    assert block.rotation_state == len(block.cells) - 1

tests/test_game.py

@@ -0,0 +1,85 @@
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+# conftest.py has already patched pygame.mixer before this import
+from game import Game
+from blocks import IBlock, JBlock, LBlock, OBlock, SBlock, TBlock, ZBlock
+
+ALL_BLOCK_TYPES = {IBlock, JBlock, LBlock, OBlock, SBlock, TBlock, ZBlock}
+
+
+def test_initial_score_is_zero():
+    game = Game()
+    assert game.score == 0
+
+
+def test_initial_game_over_is_false():
+    game = Game()
+    assert game.game_over is False
+
+
+def test_update_score_one_line():
+    game = Game()
+    game.update_score(1, 0)
+    assert game.score == 100
+
+
+def test_update_score_two_lines():
+    game = Game()
+    game.update_score(2, 0)
+    assert game.score == 300
+
+
+def test_update_score_three_lines():
+    game = Game()
+    game.update_score(3, 0)
+    assert game.score == 500
+
+
+def test_update_score_move_down():
+    game = Game()
+    game.update_score(0, 5)
+    assert game.score == 5
+
+
+def test_update_score_no_lines():
+    game = Game()
+    game.update_score(0, 0)
+    assert game.score == 0
+
+
+def test_get_random_block_removes_from_bag():
+    game = Game()
+    # After __init__, two blocks have already been drawn (current_block and next_block).
+    # Reset the bag to a full set of 7 to get a predictable starting count.
+    from blocks import IBlock, JBlock, LBlock, OBlock, SBlock, TBlock, ZBlock
+    game.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
+    game.get_random_block()
+    assert len(game.blocks) == 6
+
+
+def test_get_random_block_refills_bag():
+    game = Game()
+    # Drain all 7 blocks from a fresh bag
+    game.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
+    for _ in range(7):
+        game.get_random_block()
+    # Bag is now empty; next call must refill and return a block
+    assert len(game.blocks) == 0
+    block = game.get_random_block()
+    # After refill and one removal, bag has 6 items
+    assert block is not None
+    assert len(game.blocks) == 6
+
+
+def test_get_random_block_all_7_types():
+    game = Game()
+    # Start with a fresh, full bag
+    game.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
+    drawn_types = set()
+    for _ in range(7):
+        block = game.get_random_block()
+        drawn_types.add(type(block))
+    assert drawn_types == ALL_BLOCK_TYPES

tests/test_grid.py

@@ -0,0 +1,110 @@
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from grid import Grid
+
+
+def test_is_inside_valid():
+    grid = Grid()
+    # All corners and a middle cell should be inside
+    assert grid.is_inside(0, 0) is True
+    assert grid.is_inside(19, 9) is True
+    assert grid.is_inside(0, 9) is True
+    assert grid.is_inside(19, 0) is True
+    assert grid.is_inside(10, 5) is True
+
+
+def test_is_inside_invalid():
+    grid = Grid()
+    assert grid.is_inside(-1, 0) is False
+    assert grid.is_inside(20, 0) is False
+    assert grid.is_inside(0, -1) is False
+    assert grid.is_inside(0, 10) is False
+
+
+def test_is_empty_returns_true_for_zero():
+    grid = Grid()
+    # Fresh grid cells are all 0, so they should be empty
+    assert grid.is_empty(0, 0) is True
+    assert grid.is_empty(10, 5) is True
+    assert grid.is_empty(19, 9) is True
+
+
+def test_is_empty_returns_false_for_nonzero():
+    grid = Grid()
+    grid.grid[5][3] = 1
+    assert grid.is_empty(5, 3) is False
+
+
+def test_is_row_full_false_when_empty():
+    grid = Grid()
+    assert grid.is_row_full(0) is False
+    assert grid.is_row_full(10) is False
+    assert grid.is_row_full(19) is False
+
+
+def test_is_row_full_true_when_all_filled():
+    grid = Grid()
+    for col in range(grid.num_cols):
+        grid.grid[7][col] = 1
+    assert grid.is_row_full(7) is True
+
+
+def test_clear_row():
+    grid = Grid()
+    # Fill row 5 with non-zero values
+    for col in range(grid.num_cols):
+        grid.grid[5][col] = 3
+    grid.clear_row(5)
+    for col in range(grid.num_cols):
+        assert grid.grid[5][col] == 0
+
+
+def test_move_row_down():
+    grid = Grid()
+    # Place a distinct pattern in row 3
+    for col in range(grid.num_cols):
+        grid.grid[3][col] = col + 1  # values 1..10
+    grid.move_row_down(3, 2)
+    # Row 3+2=5 should now contain the old row 3 values
+    for col in range(grid.num_cols):
+        assert grid.grid[5][col] == col + 1
+    # Row 3 should be cleared
+    for col in range(grid.num_cols):
+        assert grid.grid[3][col] == 0
+
+
+def test_clear_full_rows_single():
+    grid = Grid()
+    # Fill the bottom row completely
+    for col in range(grid.num_cols):
+        grid.grid[19][col] = 1
+    cleared = grid.clear_full_rows()
+    assert cleared == 1
+    # Row 19 should now be empty
+    for col in range(grid.num_cols):
+        assert grid.grid[19][col] == 0
+
+
+def test_clear_full_rows_multiple():
+    grid = Grid()
+    # Fill bottom two rows completely
+    for col in range(grid.num_cols):
+        grid.grid[18][col] = 2
+        grid.grid[19][col] = 1
+    cleared = grid.clear_full_rows()
+    assert cleared == 2
+
+
+def test_reset():
+    grid = Grid()
+    # Set some cells
+    grid.grid[0][0] = 5
+    grid.grid[10][5] = 3
+    grid.grid[19][9] = 7
+    grid.reset()
+    for row in range(grid.num_rows):
+        for col in range(grid.num_cols):
+            assert grid.grid[row][col] == 0