refactor: divided tests into separate files, added tests for buy_card

Author: stirby

src/lua/api.lua

@@ -644,19 +644,11 @@ API.functions["shop"] = function(args)
     if args.index == nil then
       API.send_error_response(
         "Missing required field: index",
-        ERROR_CODES.INVALID_PARAMETER,
+        ERROR_CODES.MISSING_ARGUMENTS,
         { field = "index" }
       )
       return
     end
-    if type(args.index) ~= "number" or args.index < 0 then
-      API.send_error_response(
-        "Index must be a non-negative number",
-        ERROR_CODES.INVALID_PARAMETER,
-        { index = args.index }
-      )
-      return
-    end
 
     -- Get card index (1-based) and shop area
     local card_pos = args.index + 1
@@ -667,7 +659,7 @@ API.functions["shop"] = function(args)
       API.send_error_response(
         "Card index out of range",
         ERROR_CODES.PARAMETER_OUT_OF_RANGE,
-        { index = args.index, max_index = #area.cards - 1 }
+        { index = args.index, valid_range = "0-" .. tostring(#area.cards - 1) }
       )
       return
     end
@@ -689,7 +681,7 @@ API.functions["shop"] = function(args)
     if not card.ability or not card.ability.set then
       API.send_error_response(
         "Card has no ability set, can't check consumable area",
-        ERROR_CODES.INVALID_ACTION,
+        ERROR_CODES.INVALID_GAME_STATE,
         { index = args.index }
       )
       return
@@ -722,7 +714,7 @@ API.functions["shop"] = function(args)
     if not card_buy_button then
       API.send_error_response(
         "Card has no buy button",
-        ERROR_CODES.INVALID_ACTION,
+        ERROR_CODES.INVALID_GAME_STATE,
         { index = args.index }
       )
       return

src/lua/utils.lua

@@ -365,17 +365,23 @@ function utils.get_game_state()
     }
   end
 
-  local jokers = {}
-  if G.jokers and G.jokers.cards then
-    for i, card in pairs(G.jokers.cards) do
-      jokers[i] = {
-        label = card.label,
-        config = {
-          center = card.config.center,
-          card_limit = G.jokers.card_limit,
-          card_count = G.jokers.card_count,
-        },
-      }
+  local jokers = {
+    cards = {}
+  }
+  if G.jokers then
+
+    jokers.card_limit = G.jokers.card_limit
+    jokers.card_count = G.jokers.card_count
+    if G.jokers.cards then
+      for i, card in pairs(G.jokers.cards) do
+        jokers.cards[i] = {
+          label = card.label,
+          cost = card.cost,
+          config = {
+            center = card.config.center,
+          },
+        }
+      end
     end
   end
 

tests/lua/__init__.py

@@ -0,0 +1,65 @@
+import socket
+from typing import Generator
+
+import pytest
+
+from balatrobot.enums import ErrorCode, State
+
+from ..conftest import assert_error_response, send_and_receive_api_message
+
+
+class TestCashOut:
+    """Tests for the cash_out API endpoint."""
+
+    @pytest.fixture(autouse=True)
+    def setup_and_teardown(
+        self, tcp_client: socket.socket
+    ) -> Generator[None, None, None]:
+        """Set up and tear down each test method."""
+        # Start a run
+        start_run_args = {
+            "deck": "Red Deck",
+            "stake": 1,
+            "challenge": None,
+            "seed": "OOOO155",  # four of a kind in first hand
+        }
+        send_and_receive_api_message(tcp_client, "start_run", start_run_args)
+
+        # Select blind
+        send_and_receive_api_message(
+            tcp_client, "skip_or_select_blind", {"action": "select"}
+        )
+
+        # Play a winning hand (four of a kind) to reach shop
+        game_state = send_and_receive_api_message(
+            tcp_client,
+            "play_hand_or_discard",
+            {"action": "play_hand", "cards": [0, 1, 2, 3]},
+        )
+        assert game_state["state"] == State.ROUND_EVAL.value
+        yield
+        send_and_receive_api_message(tcp_client, "go_to_menu", {})
+
+    def test_cash_out_success(self, tcp_client: socket.socket) -> None:
+        """Test successful cash out returns to shop state."""
+        # Cash out should transition to shop state
+        game_state = send_and_receive_api_message(tcp_client, "cash_out", {})
+
+        # Verify we're in shop state after cash out
+        assert game_state["state"] == State.SHOP.value
+
+    def test_cash_out_invalid_state_error(self, tcp_client: socket.socket) -> None:
+        """Test cash out returns error when not in shop state."""
+        # Go to menu first to ensure we're not in shop state
+        send_and_receive_api_message(tcp_client, "go_to_menu", {})
+
+        # Try to cash out when not in shop - should return error
+        response = send_and_receive_api_message(tcp_client, "cash_out", {})
+
+        # Verify error response
+        assert_error_response(
+            response,
+            "Cannot cash out when not in round evaluation",
+            ["current_state"],
+            ErrorCode.INVALID_GAME_STATE.value,
+        )

tests/lua/endpoints/__init__.py

@@ -0,0 +1,56 @@
+import socket
+from typing import Generator
+
+import pytest
+
+from balatrobot.enums import State
+
+from ..conftest import send_and_receive_api_message
+
+
+class TestGetGameState:
+    """Tests for the get_game_state API endpoint."""
+
+    @pytest.fixture(autouse=True)
+    def setup_and_teardown(
+        self, tcp_client: socket.socket
+    ) -> Generator[None, None, None]:
+        """Set up and tear down each test method."""
+        yield
+        send_and_receive_api_message(tcp_client, "go_to_menu", {})
+
+    def test_get_game_state_response(self, tcp_client: socket.socket) -> None:
+        """Test get_game_state message returns valid JSON game state."""
+        game_state = send_and_receive_api_message(tcp_client, "get_game_state", {})
+        assert isinstance(game_state, dict)
+
+    def test_game_state_structure(self, tcp_client: socket.socket) -> None:
+        """Test that game state contains expected top-level fields."""
+        game_state = send_and_receive_api_message(tcp_client, "get_game_state", {})
+
+        assert isinstance(game_state, dict)
+
+        expected_keys = {"state", "game"}
+        assert expected_keys.issubset(game_state.keys())
+        assert isinstance(game_state["state"], int)
+        assert isinstance(game_state["game"], (dict, type(None)))
+
+    def test_game_state_during_run(self, tcp_client: socket.socket) -> None:
+        """Test getting game state at different points during a run."""
+        # Start a run
+        start_run_args = {
+            "deck": "Red Deck",
+            "stake": 1,
+            "challenge": None,
+            "seed": "EXAMPLE",
+        }
+        initial_state = send_and_receive_api_message(
+            tcp_client, "start_run", start_run_args
+        )
+        assert initial_state["state"] == State.BLIND_SELECT.value
+
+        # Get game state again to ensure it's consistent
+        current_state = send_and_receive_api_message(tcp_client, "get_game_state", {})
+
+        assert current_state["state"] == State.BLIND_SELECT.value
+        assert current_state["state"] == initial_state["state"]

tests/lua/endpoints/test_cash_out.py

@@ -0,0 +1,33 @@
+import socket
+
+from balatrobot.enums import State
+
+from ..conftest import send_and_receive_api_message
+
+
+class TestGoToMenu:
+    """Tests for the go_to_menu API endpoint."""
+
+    def test_go_to_menu(self, tcp_client: socket.socket) -> None:
+        """Test going to the main menu."""
+        game_state = send_and_receive_api_message(tcp_client, "go_to_menu", {})
+        assert game_state["state"] == State.MENU.value
+
+    def test_go_to_menu_from_run(self, tcp_client: socket.socket) -> None:
+        """Test going to menu from within a run."""
+        # First start a run
+        start_run_args = {
+            "deck": "Red Deck",
+            "stake": 1,
+            "challenge": None,
+            "seed": "EXAMPLE",
+        }
+        initial_state = send_and_receive_api_message(
+            tcp_client, "start_run", start_run_args
+        )
+        assert initial_state["state"] == State.BLIND_SELECT.value
+
+        # Now go to menu
+        menu_state = send_and_receive_api_message(tcp_client, "go_to_menu", {})
+
+        assert menu_state["state"] == State.MENU.value