Tests for Penn Mobile Games backend.

Author: bliu8

backend/tests/games/__init__.py

@@ -0,0 +1,71 @@
+from io import StringIO
+from unittest import mock
+
+from django.core.management import call_command
+from django.test import TestCase
+from django.utils import timezone
+
+from games.models import Game
+
+
+# 190 words spanning lengths 3–7 to exercise all freq buckets
+MOCK_BOARD = [["a", "b", "c", "d", "e"]] * 5
+MOCK_SEED = "garden"
+MOCK_SOLS = (
+    ["cat", "bat", "rat", "hat", "mat", "sat", "fat", "pat", "vat", "lat"] * 10  # 100 × len-3
+    + ["cats", "bats", "rats", "hats", "mats"] * 10                               #  50 × len-4
+    + ["table", "cable", "fable", "sable"] * 5                                    #  20 × len-5
+    + ["garden"] * 10                                                              #  10 × len-6
+    + ["gardens"] * 10                                                             #  10 × len-7
+)  # total: 190
+
+
+def mock_generate_good_game():
+    return MOCK_BOARD, MOCK_SEED, MOCK_SOLS
+
+
+class TestGenerateGameCommand(TestCase):
+    @mock.patch(
+        "games.management.commands.generate_game.generate_good_game", mock_generate_good_game
+    )
+    def test_creates_game_for_today(self):
+        call_command("generate_game")
+        self.assertTrue(Game.objects.filter(date=timezone.localdate()).exists())
+
+    @mock.patch(
+        "games.management.commands.generate_game.generate_good_game", mock_generate_good_game
+    )
+    def test_saves_correct_board_seed_and_words(self):
+        call_command("generate_game")
+        game = Game.objects.get(date=timezone.localdate())
+        self.assertEqual(MOCK_BOARD, game.board)
+        self.assertEqual(MOCK_SEED, game.seed)
+        self.assertEqual(MOCK_SOLS, game.possible_words)
+
+    @mock.patch(
+        "games.management.commands.generate_game.generate_good_game", mock_generate_good_game
+    )
+    def test_computes_word_freqs_by_length(self):
+        call_command("generate_game")
+        game = Game.objects.get(date=timezone.localdate())
+        # Django JSONField round-trips integer keys as strings
+        expected = {"3": 0, "4": 0, "5": 0, "6": 0, "7": 0, "8": 0}
+        for w in MOCK_SOLS:
+            expected[str(len(w))] += 1
+        self.assertEqual(expected, game.freqs)
+
+    @mock.patch(
+        "games.management.commands.generate_game.generate_good_game", mock_generate_good_game
+    )
+    def test_running_twice_updates_same_record(self):
+        call_command("generate_game")
+        call_command("generate_game")
+        self.assertEqual(1, Game.objects.filter(date=timezone.localdate()).count())
+
+    @mock.patch(
+        "games.management.commands.generate_game.generate_good_game", mock_generate_good_game
+    )
+    def test_prints_success_message(self):
+        out = StringIO()
+        call_command("generate_game", stdout=out)
+        self.assertIn("Game generated successfully", out.getvalue())

backend/tests/games/test_commands.py

@@ -0,0 +1,138 @@
+from collections import Counter
+
+from django.test import SimpleTestCase
+
+from games.generator import (
+    MIN_LEN,
+    MAX_LEN,
+    MIN_TOTAL_WORDS,
+    SIX_LETTER_WORDS,
+    WORD_SET,
+    generate_game,
+    generate_good_game,
+    neighbors,
+    solve_game,
+)
+
+
+class TestNeighbors(SimpleTestCase):
+    """Tests the neighbors() grid adjacency helper (used on a 5x5 board, n=4)."""
+
+    def test_corner_has_three_neighbors(self):
+        result = list(neighbors(4, 0, 0))
+        self.assertEqual(3, len(result))
+
+    def test_edge_has_five_neighbors(self):
+        # top edge, not a corner
+        result = list(neighbors(4, 2, 0))
+        self.assertEqual(5, len(result))
+
+    def test_center_has_eight_neighbors(self):
+        result = list(neighbors(4, 2, 2))
+        self.assertEqual(8, len(result))
+
+    def test_all_neighbors_within_bounds(self):
+        for x in range(5):
+            for y in range(5):
+                for xx, yy in neighbors(4, x, y):
+                    self.assertGreaterEqual(xx, 0)
+                    self.assertLessEqual(xx, 4)
+                    self.assertGreaterEqual(yy, 0)
+                    self.assertLessEqual(yy, 4)
+
+    def test_no_self_in_neighbors(self):
+        for x in range(5):
+            for y in range(5):
+                self.assertNotIn((x, y), list(neighbors(4, x, y)))
+
+
+class TestGenerateGame(SimpleTestCase):
+    def setUp(self):
+        self.game, self.seed = generate_game()
+
+    def test_board_is_5x5(self):
+        self.assertEqual(5, len(self.game))
+        for row in self.game:
+            self.assertEqual(5, len(row))
+
+    def test_all_cells_are_single_lowercase_letters(self):
+        for row in self.game:
+            for cell in row:
+                self.assertEqual(1, len(cell))
+                self.assertTrue(cell.isalpha())
+                self.assertEqual(cell, cell.lower())
+
+    def test_seed_is_six_letter_word(self):
+        self.assertEqual(6, len(self.seed))
+
+    def test_seed_comes_from_word_list(self):
+        self.assertIn(self.seed, SIX_LETTER_WORDS)
+
+    def test_seed_letters_present_on_board(self):
+        flat = [cell for row in self.game for cell in row]
+        board_counts = Counter(flat)
+        for letter, count in Counter(self.seed).items():
+            self.assertGreaterEqual(
+                board_counts[letter],
+                count,
+                f"Letter '{letter}' from seed not sufficiently present on board",
+            )
+
+
+class TestSolveGame(SimpleTestCase):
+    def setUp(self):
+        self.game, _ = generate_game()
+        self.sols = solve_game(self.game)
+
+    def test_all_words_in_word_set(self):
+        for word in self.sols:
+            self.assertIn(word, WORD_SET, f"'{word}' is not a valid word")
+
+    def test_all_words_within_length_limits(self):
+        for word in self.sols:
+            self.assertGreaterEqual(len(word), MIN_LEN)
+            self.assertLessEqual(len(word), MAX_LEN)
+
+    def test_no_duplicate_words(self):
+        self.assertEqual(len(self.sols), len(set(self.sols)))
+
+    def test_results_sorted_by_length_desc_then_alpha(self):
+        for i in range(len(self.sols) - 1):
+            a, b = self.sols[i], self.sols[i + 1]
+            if len(a) == len(b):
+                self.assertLessEqual(a, b, f"Alphabetical order violated: {a!r} before {b!r}")
+            else:
+                self.assertGreater(
+                    len(a), len(b), f"Length order violated: {a!r} (len {len(a)}) before {b!r} (len {len(b)})"
+                )
+
+    def test_empty_like_board_returns_only_valid_words(self):
+        # A board filled with a single rare letter should return no spurious words
+        board = [["z"] * 5 for _ in range(5)]
+        result = solve_game(board)
+        for word in result:
+            self.assertIn(word, WORD_SET)
+
+
+class TestGenerateGoodGame(SimpleTestCase):
+    """End-to-end test for the full game generation pipeline."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.game, cls.seed, cls.sols = generate_good_game()
+
+    def test_board_is_5x5(self):
+        self.assertEqual(5, len(self.game))
+        for row in self.game:
+            self.assertEqual(5, len(row))
+
+    def test_meets_minimum_word_count(self):
+        self.assertGreaterEqual(len(self.sols), MIN_TOTAL_WORDS)
+
+    def test_all_solutions_are_valid_words(self):
+        for word in self.sols:
+            self.assertIn(word, WORD_SET)
+
+    def test_seed_comes_from_word_list(self):
+        self.assertIn(self.seed, SIX_LETTER_WORDS)

backend/tests/games/test_generator.py

@@ -0,0 +1,135 @@
+import datetime
+
+from django.contrib.auth import get_user_model
+from django.db import IntegrityError
+from django.test import TestCase
+from django.utils import timezone
+
+from games.models import Game, LeaderboardEntry
+from games.serializers import GameDetailSerializer, GameSerializer
+
+
+User = get_user_model()
+
+DATE = datetime.date(2024, 3, 15)
+BOARD = [["a", "b", "c", "d", "e"]] * 5
+POSSIBLE_WORDS = ["cat", "dog", "fog", "log", "lag"]
+SEED = "garden"
+
+
+class TestGameModel(TestCase):
+    def test_str_representation(self):
+        game = Game.objects.create(date=DATE, board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED)
+        self.assertEqual(str(DATE), str(game))
+
+    def test_get_today_returns_todays_game(self):
+        game = Game.objects.create(
+            date=timezone.localdate(), board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED
+        )
+        self.assertEqual(game, Game.get_today())
+
+    def test_get_today_returns_none_when_no_game(self):
+        self.assertIsNone(Game.get_today())
+
+    def test_get_today_ignores_other_dates(self):
+        Game.objects.create(date=DATE, board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED)
+        self.assertIsNone(Game.get_today())
+
+    def test_freqs_field_round_trips(self):
+        freqs = {"3": 10, "4": 8, "5": 5, "6": 2, "7": 1, "8": 0}
+        game = Game.objects.create(
+            date=DATE, board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED, freqs=freqs
+        )
+        game.refresh_from_db()
+        self.assertEqual(freqs, game.freqs)
+
+    def test_freqs_defaults_to_empty_dict(self):
+        game = Game.objects.create(date=DATE, board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED)
+        self.assertEqual({}, game.freqs)
+
+
+class TestLeaderboardEntryModel(TestCase):
+    def setUp(self):
+        self.user1 = User.objects.create_user("user1", "user1@seas.upenn.edu", "pass")
+        self.user2 = User.objects.create_user("user2", "user2@seas.upenn.edu", "pass")
+        self.game = Game.objects.create(
+            date=DATE, board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED
+        )
+
+    def test_create_entry_stores_all_fields(self):
+        entry = LeaderboardEntry.objects.create(
+            game=self.game, user=self.user1, score=300, words_found=3
+        )
+        self.assertEqual(300, entry.score)
+        self.assertEqual(3, entry.words_found)
+        self.assertEqual(self.game, entry.game)
+        self.assertEqual(self.user1, entry.user)
+        self.assertIsNotNone(entry.submitted_at)
+
+    def test_unique_constraint_same_user_same_game(self):
+        LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=300, words_found=3)
+        with self.assertRaises(IntegrityError):
+            LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=400, words_found=4)
+
+    def test_different_users_same_game_allowed(self):
+        LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=300, words_found=3)
+        LeaderboardEntry.objects.create(game=self.game, user=self.user2, score=400, words_found=4)
+        self.assertEqual(2, LeaderboardEntry.objects.count())
+
+    def test_same_user_different_games_allowed(self):
+        game2 = Game.objects.create(
+            date=datetime.date(2024, 3, 16), board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED
+        )
+        LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=300, words_found=3)
+        LeaderboardEntry.objects.create(game=game2, user=self.user1, score=400, words_found=4)
+        self.assertEqual(2, LeaderboardEntry.objects.count())
+
+    def test_default_ordering_by_score_descending(self):
+        LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=200, words_found=2)
+        LeaderboardEntry.objects.create(game=self.game, user=self.user2, score=500, words_found=5)
+        entries = list(LeaderboardEntry.objects.all())
+        self.assertEqual(500, entries[0].score)
+        self.assertEqual(200, entries[1].score)
+
+    def test_tiebreaker_fewer_words_ranks_higher(self):
+        LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=300, words_found=5)
+        LeaderboardEntry.objects.create(game=self.game, user=self.user2, score=300, words_found=2)
+        entries = list(LeaderboardEntry.objects.all())
+        self.assertEqual(self.user2, entries[0].user)
+        self.assertEqual(2, entries[0].words_found)
+
+    def test_cascade_delete_on_game_delete(self):
+        LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=300, words_found=3)
+        self.game.delete()
+        self.assertEqual(0, LeaderboardEntry.objects.count())
+
+    def test_cascade_delete_on_user_delete(self):
+        LeaderboardEntry.objects.create(game=self.game, user=self.user1, score=300, words_found=3)
+        self.user1.delete()
+        self.assertEqual(0, LeaderboardEntry.objects.count())
+
+
+class TestGameSerializer(TestCase):
+    def setUp(self):
+        self.game = Game.objects.create(
+            date=DATE, board=BOARD, possible_words=POSSIBLE_WORDS, seed=SEED,
+            freqs={"3": 5, "4": 3},
+        )
+
+    def test_public_serializer_exposes_expected_fields(self):
+        data = GameSerializer(self.game).data
+        self.assertIn("date", data)
+        self.assertIn("board", data)
+        self.assertIn("possible_words", data)
+
+    def test_public_serializer_hides_seed_and_freqs(self):
+        data = GameSerializer(self.game).data
+        self.assertNotIn("seed", data)
+        self.assertNotIn("freqs", data)
+
+    def test_detail_serializer_exposes_seed_and_freqs(self):
+        data = GameDetailSerializer(self.game).data
+        self.assertIn("seed", data)
+        self.assertIn("freqs", data)
+        self.assertEqual(SEED, data["seed"])
+        self.assertEqual({"3": 5, "4": 3}, data["freqs"])