Fix: GameControllerTest

src/test/java/it/polimi/ingsw/gc14/Controller/GameControllerTest.java

@@ -1,5 +1,6 @@
 package it.polimi.ingsw.gc14.Controller;
 
+import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCard;
 import it.polimi.ingsw.gc14.Model.Game;
 import it.polimi.ingsw.gc14.Model.GamePackage.GameStages;
@@ -14,6 +15,111 @@ import static org.junit.jupiter.api.Assertions.*;
 
 class GameControllerTest {
 
+    private Game createStartedGame() {
+        Game game = new Game(3);
+        GameController controller = new GameController(game);
+
+        assertTrue(controller.addPlayer("Giorgio"));
+        assertTrue(controller.addPlayer("Marco"));
+        assertTrue(controller.addPlayer("Luca"));
+
+        return game;
+    }
+
+    private Queue<Player> completeSlotChoice(Game game, GameController controller) {
+        Queue<Player> order = new LinkedList<>();
+
+        for (int i = 0; i < 3; i++) {
+            Player current = game.getCurrentState().getCurrentPlayer();
+            order.add(current);
+
+            assertTrue(controller.slotChoice(current.getUserName(), i));
+        }
+
+        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+
+        return order;
+    }
+
+    private int firstNonEventIndex(List<TribeCard> cards) {
+        for (int i = 0; i < cards.size(); i++) {
+            if (!cards.get(i).IsEventCard()) {
+                return i;
+            }
+        }
+
+        fail("No non-event tribe card available.");
+        return -1;
+    }
+
+    private int firstEventIndexOrMinusOne(List<TribeCard> cards) {
+        for (int i = 0; i < cards.size(); i++) {
+            if (cards.get(i).IsEventCard()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    private int firstNonEventIndexOrMinusOne(List<TribeCard> cards) {
+        for (int i = 0; i < cards.size(); i++) {
+            if (!cards.get(i).IsEventCard()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    private void giveOptionalEffectToAllPlayers(Game game) {
+        Player first = game.getPlayerByUsername("Giorgio");
+        Player second = game.getPlayerByUsername("Marco");
+        Player third = game.getPlayerByUsername("Luca");
+
+        assertNotNull(first);
+        assertNotNull(second);
+        assertNotNull(third);
+
+        first.buildingCards.add(new BuildingCard(12, 1, 1, 0));
+        second.buildingCards.add(new BuildingCard(12, 1, 1, 0));
+        third.buildingCards.add(new BuildingCard(12, 1, 1, 0));
+    }
+
+    private void resolveActionsUntilOptionalCardEffect(Game game, GameController controller) {
+        int guard = 0;
+
+        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 20) {
+            guard++;
+
+            Player current = game.getCurrentState().getCurrentPlayer();
+            assertNotNull(current);
+
+            if (game.getCurrentState().getNLower() > 0) {
+                int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
+
+                if (index == -1) {
+                    fail("No non-event lower tribe card available.");
+                }
+
+                assertTrue(controller.drawLowerTribeCard(current.getUserName(), index));
+            } else if (game.getCurrentState().getNUpper() > 0) {
+                int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
+
+                if (index == -1) {
+                    fail("No non-event upper tribe card available.");
+                }
+
+                assertTrue(controller.drawUpperTribeCard(current.getUserName(), index));
+            } else {
+                fail("Current player has no remaining upper or lower draws.");
+            }
+        }
+
+        assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+    }
+
+
     @Test
     void addPlayer() {
         Game game = new Game(3);
@@ -47,23 +153,15 @@ class GameControllerTest {
 
     @Test
     void slotChoice() {
-        Game game = new Game(3);
+        Game game = createStartedGame();
         GameController controller = new GameController(game);
 
-        assertTrue(controller.addPlayer("Giorgio"));
-        assertTrue(controller.addPlayer("Marco"));
-        assertTrue(controller.addPlayer("Luca"));
-
         String cur = game.getCurrentState().getCurrentPlayer().getUserName();
         String other = cur.equals("Giorgio") ? "Marco" : "Giorgio";
+
         assertFalse(controller.slotChoice(other, 0));
 
-        Queue<Player> order = new LinkedList<>();
+        Queue<Player> order = completeSlotChoice(game, controller);
-        for (int i = 0; i < 3; i++)  {
-            Player p = game.getCurrentState().getCurrentPlayer();
-            order.add(p);
-            assertTrue(controller.slotChoice(p.getUserName(), i));
-        }
 
         assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
         assertEquals(order.poll(), game.getCurrentState().getCurrentPlayer());
@@ -71,66 +169,43 @@ class GameControllerTest {
 
     @Test
     void drawLowerTribeCard() {
-        Game game = new Game(3);
+        Game game = createStartedGame();
         GameController controller = new GameController(game);
 
-        assertTrue(controller.addPlayer("Giorgio"));
+        Queue<Player> order = completeSlotChoice(game, controller);
-        assertTrue(controller.addPlayer("Marco"));
-        assertTrue(controller.addPlayer("Luca"));
-
-        Queue<Player> order = new LinkedList<>();
-        for (int i = 0; i < 3; i++) {
-            Player p = game.getCurrentState().getCurrentPlayer();
-            order.add(p);
-            assertTrue(controller.slotChoice(p.getUserName(), i));
-        }
 
         Player first = order.poll();
         assertEquals(first, game.getCurrentState().getCurrentPlayer());
 
         List<TribeCard> cards = game.getLowerListTribeCards();
-        int idx = cards.indexOf(
+        int idx = firstNonEventIndex(cards);
-                cards.stream()
-                        .filter(c -> !c.IsEventCard())
-                        .findFirst()
-                        .orElseThrow()
-        );
 
         Player wrongPlayer = order.peek();
         assertNotNull(wrongPlayer);
 
+        assertFalse(controller.drawLowerTribeCard(wrongPlayer.getUserName(), idx));
+
         int before = first.getTotCharacters();
+
         assertTrue(controller.drawLowerTribeCard(first.getUserName(), idx));
+
         assertEquals(before + 1, first.getTotCharacters());
     }
 
     @Test
     void drawUpperTribeCard() {
-        Game game = new Game(3);
+        Game game = createStartedGame();
         GameController controller = new GameController(game);
 
-        assertTrue(controller.addPlayer("Giorgio"));
+        completeSlotChoice(game, controller);
-        assertTrue(controller.addPlayer("Marco"));
-        assertTrue(controller.addPlayer("Luca"));
-
-        for (int i = 0; i < 3; i++) {
-            Player p = game.getCurrentState().getCurrentPlayer();
-            assertTrue(controller.slotChoice(p.getUserName(), i));
-        }
-
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
 
         while (game.getCurrentState().getNUpper() == 0) {
             assertTrue(game.getCurrentState().getNLower() > 0);
 
             Player current = game.getCurrentState().getCurrentPlayer();
+
             List<TribeCard> lower = game.getLowerListTribeCards();
-            int lowerIdx = lower.indexOf(
+            int lowerIdx = firstNonEventIndex(lower);
-                    lower.stream()
-                            .filter(c -> !c.IsEventCard())
-                            .findFirst()
-                            .orElseThrow()
-            );
 
             assertTrue(controller.drawLowerTribeCard(current.getUserName(), lowerIdx));
         }
@@ -139,12 +214,7 @@ class GameControllerTest {
         int beforeTot = current.getTotCharacters();
 
         List<TribeCard> upper = game.getUpperListTribeCards();
-        int upperIdx = upper.indexOf(
+        int upperIdx = firstNonEventIndex(upper);
-                upper.stream()
-                        .filter(c -> !c.IsEventCard())
-                        .findFirst()
-                        .orElseThrow()
-        );
 
         assertTrue(controller.drawUpperTribeCard(current.getUserName(), upperIdx));
         assertEquals(beforeTot + 1, current.getTotCharacters());
@@ -152,31 +222,18 @@ class GameControllerTest {
 
     @Test
     void drawUpperBuildingCard() {
-        Game game = new Game(3);
+        Game game = createStartedGame();
         GameController controller = new GameController(game);
 
-        assertTrue(controller.addPlayer("Giacomo"));
+        completeSlotChoice(game, controller);
-        assertTrue(controller.addPlayer("Marco"));
-        assertTrue(controller.addPlayer("Luca"));
-
-        for (int i = 0; i < 3; i++) {
-            Player p = game.getCurrentState().getCurrentPlayer();
-            assertTrue(controller.slotChoice(p.getUserName(), i));
-        }
-
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
 
         while (game.getCurrentState().getNUpper() == 0) {
             assertTrue(game.getCurrentState().getNLower() > 0);
 
             Player current = game.getCurrentState().getCurrentPlayer();
+
             List<TribeCard> lower = game.getLowerListTribeCards();
-            int lowerIdx = lower.indexOf(
+            int lowerIdx = firstNonEventIndex(lower);
-                    lower.stream()
-                            .filter(c -> !c.IsEventCard())
-                            .findFirst()
-                            .orElseThrow()
-            );
 
             assertTrue(controller.drawLowerTribeCard(current.getUserName(), lowerIdx));
         }
@@ -186,43 +243,214 @@ class GameControllerTest {
         assertFalse(controller.drawUpperBuildingCard(current.getUserName(), 0));
 
         current.addFood(100);
+        int foodBefore = current.getFoodValue();
+        int buildingsBefore = current.buildingCards.size();
+
         assertTrue(controller.drawUpperBuildingCard(current.getUserName(), 0));
+
+        assertTrue(current.getFoodValue() < foodBefore);
+        assertEquals(buildingsBefore + 1, current.buildingCards.size());
     }
 
-        @Test
+    @Test
-        void drawLowerBuildingCard() {
+    void drawingByIndexThroughController() {
-            Game game = new Game(3);
+        Game game = new Game(3);
-            GameController controller = new GameController(game);
+        GameController controller = new GameController(game);
 
-            assertTrue(controller.addPlayer("Giacomo"));
+        assertTrue(controller.addPlayer("p1"));
-            assertTrue(controller.addPlayer("Marco"));
+        assertTrue(controller.addPlayer("p2"));
-            assertTrue(controller.addPlayer("Luca"));
+        assertFalse(controller.addPlayer("p2"));
+        assertTrue(controller.addPlayer("p3"));
 
-            for (int i = 0; i < 3; i++) {
+        Queue<Player> players = new LinkedList<>();
-                Player p = game.getCurrentState().getCurrentPlayer();
+
-                assertTrue(controller.slotChoice(p.getUserName(), i));
+        for (int i = 0; i < 3; i++) {
+            Player current = game.getCurrentState().getCurrentPlayer();
+            players.add(current);
+
+            assertTrue(controller.slotChoice(current.getUserName(), i));
+        }
+
+        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+
+        Player tempPlayer = players.poll();
+        assertNotNull(tempPlayer);
+        assertEquals(tempPlayer, game.getCurrentState().getCurrentPlayer());
+
+        List<TribeCard> cards = game.getLowerListTribeCards();
+        int index = firstNonEventIndex(cards);
+
+        assertTrue(controller.drawLowerTribeCard(tempPlayer.getUserName(), index));
+
+        tempPlayer = players.poll();
+        assertNotNull(tempPlayer);
+        assertEquals(tempPlayer, game.getCurrentState().getCurrentPlayer());
+
+        while (game.getCurrentState().getNUpper() > 1) {
+            cards = game.getUpperListTribeCards();
+
+            index = firstNonEventIndexOrMinusOne(cards);
+
+            if (index == -1) {
+                break;
             }
 
-            String cur = game.getCurrentState().getCurrentPlayer().getUserName();
+            int before = tempPlayer.getTotCharacters();
-            assertFalse(controller.drawLowerBuildingCard(cur, 0));
+
+            assertTrue(controller.drawUpperTribeCard(tempPlayer.getUserName(), index));
+
+            assertEquals(before + 1, tempPlayer.getTotCharacters());
+        }
+
+        cards = game.getUpperListTribeCards();
+
+        int eventIndex = firstEventIndexOrMinusOne(cards);
+
+        if (eventIndex != -1) {
+            assertFalse(controller.drawUpperTribeCard(tempPlayer.getUserName(), eventIndex));
+        }
+
+        tempPlayer.addFood(100);
+
+        assertFalse(controller.drawUpperBuildingCard(tempPlayer.getUserName(), 999));
+
+        if (!game.getUpperListBuilding().isEmpty() && game.getCurrentState().getNUpper() > 0) {
+            assertTrue(controller.drawUpperBuildingCard(tempPlayer.getUserName(), 0));
+        }
+
+        cards = game.getUpperListTribeCards();
+
+        int nonEventIndex = firstNonEventIndexOrMinusOne(cards);
+
+        if (nonEventIndex != -1) {
+            assertFalse(controller.drawUpperTribeCard(tempPlayer.getUserName(), nonEventIndex));
+        }
     }
 
-        @Test
+    @Test
-        void pickOptionalCards() {
+    void drawLowerBuildingCardShouldReturnFalseForUnavailableLowerBuildingCard() {
-            Game game = new Game(3);
+        Game game = createStartedGame();
-            GameController controller = new GameController(game);
+        GameController controller = new GameController(game);
 
-            assertTrue(controller.addPlayer("Giacomo"));
+        completeSlotChoice(game, controller);
-            assertTrue(controller.addPlayer("Marco"));
-            assertTrue(controller.addPlayer("Luca"));
 
-            for (int i = 0; i < 3; i++) {
+        Player current = game.getCurrentState().getCurrentPlayer();
-                Player p = game.getCurrentState().getCurrentPlayer();
-                assertTrue(controller.slotChoice(p.getUserName(), i));
-            }
 
-            String cur = game.getCurrentState().getCurrentPlayer().getUserName();
+        assertFalse(controller.drawLowerBuildingCard(current.getUserName(), 0));
-            assertFalse(controller.pickOptionalTribeCard(cur, 0));
+    }
-            assertFalse(controller.pickOptionalBuildingCard(cur, 0));
+
+    @Test
+    void pickOptionalCardsShouldReturnFalseOutsideOptionalCardEffectState() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        completeSlotChoice(game, controller);
+
+        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+
+        String cur = game.getCurrentState().getCurrentPlayer().getUserName();
+
+        assertFalse(controller.pickOptionalTribeCard(cur, 0));
+        assertFalse(controller.pickOptionalBuildingCard(cur, 0));
+    }
+
+    @Test
+    void pickOptionalTribeCardShouldWorkDuringOptionalCardEffectState() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        giveOptionalEffectToAllPlayers(game);
+
+        completeSlotChoice(game, controller);
+        resolveActionsUntilOptionalCardEffect(game, controller);
+
+        Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(optionalPlayer);
+
+        assertTrue(optionalPlayer.buildingCards.stream()
+                .anyMatch(building -> building.getEffectId() == 12));
+
+        List<TribeCard> upperCards = game.getUpperListTribeCards();
+        int index = firstNonEventIndex(upperCards);
+
+        int charactersBefore = optionalPlayer.getTotCharacters();
+
+        assertTrue(controller.pickOptionalTribeCard(optionalPlayer.getUserName(), index));
+
+        assertEquals(charactersBefore + 1, optionalPlayer.getTotCharacters());
+    }
+
+    @Test
+    void pickOptionalBuildingCardShouldWorkDuringOptionalCardEffectState() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        giveOptionalEffectToAllPlayers(game);
+
+        completeSlotChoice(game, controller);
+        resolveActionsUntilOptionalCardEffect(game, controller);
+
+        Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(optionalPlayer);
+
+        assertTrue(optionalPlayer.buildingCards.stream()
+                .anyMatch(building -> building.getEffectId() == 12));
+
+        assertFalse(game.getUpperListBuilding().isEmpty());
+
+        optionalPlayer.addFood(100);
+
+        int foodBefore = optionalPlayer.getFoodValue();
+        int buildingsBefore = optionalPlayer.buildingCards.size();
+
+        assertTrue(controller.pickOptionalBuildingCard(optionalPlayer.getUserName(), 0));
+
+        assertTrue(optionalPlayer.getFoodValue() < foodBefore);
+        assertEquals(buildingsBefore + 1, optionalPlayer.buildingCards.size());
+    }
+
+    @Test
+    void addPlayerShouldRejectDuplicateUsername() {
+        Game game = new Game(3);
+        GameController controller = new GameController(game);
+
+        assertTrue(controller.addPlayer("Giorgio"));
+        assertFalse(controller.addPlayer("Giorgio"));
+    }
+
+    @Test
+    void drawingMethodsShouldReturnFalseForInvalidIndexes() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        completeSlotChoice(game, controller);
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        String username = current.getUserName();
+
+        assertFalse(controller.drawLowerTribeCard(username, -1));
+        assertFalse(controller.drawLowerTribeCard(username, 999));
+
+        assertFalse(controller.drawUpperTribeCard(username, -1));
+        assertFalse(controller.drawUpperTribeCard(username, 999));
+
+        assertFalse(controller.drawLowerBuildingCard(username, -1));
+        assertFalse(controller.drawLowerBuildingCard(username, 999));
+
+        assertFalse(controller.drawUpperBuildingCard(username, -1));
+        assertFalse(controller.drawUpperBuildingCard(username, 999));
+    }
+
+    @Test
+    void slotChoiceShouldReturnFalseForAlreadyOccupiedSlot() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        Player first = game.getCurrentState().getCurrentPlayer();
+        assertTrue(controller.slotChoice(first.getUserName(), 0));
+
+        Player second = game.getCurrentState().getCurrentPlayer();
+
+        assertFalse(controller.slotChoice(second.getUserName(), 0));
     }
 }