From 8681d3552565a39ebadbc93200d2d87a8417af6e Mon Sep 17 00:00:00 2001 From: "marcins78@gmail.com" Date: Mon, 31 Dec 2012 22:36:41 +0000 Subject: [PATCH] Testing single elimination recurring queue. --- .../SingleEliminationRecurringQueue.java | 14 +- .../SingleEliminationRecurringQueueTest.java | 182 ++++++++++++++++++ 2 files changed, 189 insertions(+), 7 deletions(-) create mode 100644 gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueueTest.java diff --git a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueue.java b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueue.java index 6d47468de..1edaf3bb2 100644 --- a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueue.java +++ b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueue.java @@ -15,7 +15,7 @@ public class SingleEliminationRecurringQueue implements TournamentQueue { private String _tournamentQueueName; private CollectionType _currencyCollection = CollectionType.MY_CARDS; - private List _players = new ArrayList(); + private Queue _players = new LinkedList(); private Map _playerDecks = new HashMap(); private int _playerCap; @@ -63,27 +63,27 @@ public class SingleEliminationRecurringQueue implements TournamentQueue { @Override public synchronized boolean process(TournamentQueueCallback tournamentQueueCallback) { - if (_players.size() >= _playerCap) { + while (_players.size() >= _playerCap) { String tournamentId = _tournamentIdPrefix + System.currentTimeMillis(); String tournamentName = _tournamentQueueName + " - " + DateUtils.getStringDateWithHour(); - for (String player : _players) + for (int i=0; i<_playerCap; i++) { + String player = _players.poll(); + _playerDecks.remove(player); _tournamentService.addPlayer(tournamentId, player, _playerDecks.get(player)); + } Tournament tournament = _tournamentService.addTournament(tournamentId, null, tournamentName, _format, _collectionType, Tournament.Stage.PLAYING_GAMES, "singleElimination", new Date()); tournamentQueueCallback.createTournament(tournament); - - _players.clear(); - _playerDecks.clear(); } return false; } @Override public synchronized void joinPlayer(CollectionsManager collectionsManager, Player player, LotroDeck deck) { - if (!_players.contains(player.getName()) && _players.size() < _playerCap) { + if (!_players.contains(player.getName())) { if (_cost <= 0 || collectionsManager.removeCurrencyFromPlayerCollection("Joined "+getTournamentQueueName()+" queue", player, _currencyCollection, _cost)) { _players.add(player.getName()); if (_requiresDeck) diff --git a/gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueueTest.java b/gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueueTest.java new file mode 100644 index 000000000..9825dfbc3 --- /dev/null +++ b/gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationRecurringQueueTest.java @@ -0,0 +1,182 @@ +package com.gempukku.lotro.tournament; + +import com.gempukku.lotro.collection.CollectionsManager; +import com.gempukku.lotro.db.vo.CollectionType; +import com.gempukku.lotro.game.Player; +import com.gempukku.lotro.logic.vo.LotroDeck; +import static org.junit.Assert.*; +import org.junit.Test; +import org.mockito.Mockito; + +import java.util.Date; + +public class SingleEliminationRecurringQueueTest { + @Test + public void joiningQueue() { + TournamentService tournamentService = Mockito.mock(TournamentService.class); + + SingleEliminationRecurringQueue queue = new SingleEliminationRecurringQueue(10, "format", CollectionType.MY_CARDS, + "id-", "name-", 2, false, tournamentService); + + Player player = new Player(1, "p1", "u", null); + + CollectionsManager collectionsManager = Mockito.mock(CollectionsManager.class); + Mockito.when(collectionsManager.removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.eq(player), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10))) + .thenReturn(true); + + queue.joinPlayer(collectionsManager, player, null); + + Mockito.verify(collectionsManager).removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.eq(player), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10)); + Mockito.verifyNoMoreInteractions(collectionsManager, tournamentService); + + assertEquals(1, queue.getPlayerCount()); + assertTrue(queue.isPlayerSignedUp("p1")); + } + + @Test + public void leavingQueue() { + TournamentService tournamentService = Mockito.mock(TournamentService.class); + + SingleEliminationRecurringQueue queue = new SingleEliminationRecurringQueue(10, "format", CollectionType.MY_CARDS, + "id-", "name-", 2, false, tournamentService); + + Player player = new Player(1, "p1", "u", null); + + CollectionsManager collectionsManager = Mockito.mock(CollectionsManager.class); + Mockito.when(collectionsManager.removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.eq(player), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10))) + .thenReturn(true); + + queue.joinPlayer(collectionsManager, player, null); + + Mockito.verify(collectionsManager).removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.eq(player), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10)); + + queue.leavePlayer(collectionsManager, player); + Mockito.verify(collectionsManager).addCurrencyToPlayerCollection(Mockito.anyBoolean(), Mockito.anyString(), Mockito.eq(player), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10)); + Mockito.verifyNoMoreInteractions(collectionsManager, tournamentService); + + assertEquals(0, queue.getPlayerCount()); + assertFalse(queue.isPlayerSignedUp("p1")); + } + + @Test + public void cancellingQueue() { + TournamentService tournamentService = Mockito.mock(TournamentService.class); + + SingleEliminationRecurringQueue queue = new SingleEliminationRecurringQueue(10, "format", CollectionType.MY_CARDS, + "id-", "name-", 2, false, tournamentService); + + Player player = new Player(1, "p1", "u", null); + + CollectionsManager collectionsManager = Mockito.mock(CollectionsManager.class); + Mockito.when(collectionsManager.removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.eq(player), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10))) + .thenReturn(true); + + queue.joinPlayer(collectionsManager, player, null); + + Mockito.verify(collectionsManager).removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.eq(player), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10)); + + queue.leaveAllPlayers(collectionsManager); + Mockito.verify(collectionsManager).addCurrencyToPlayerCollection(Mockito.anyBoolean(), Mockito.anyString(), Mockito.eq("p1"), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10)); + Mockito.verifyNoMoreInteractions(collectionsManager, tournamentService); + + assertEquals(0, queue.getPlayerCount()); + assertFalse(queue.isPlayerSignedUp("p1")); + } + + @Test + public void fillingQueue() { + Tournament tournament = Mockito.mock(Tournament.class); + + TournamentService tournamentService = Mockito.mock(TournamentService.class); + Mockito.when(tournamentService.addTournament(Mockito.anyString(), Mockito.eq(null), Mockito.anyString(), Mockito.eq("format"), + Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(Tournament.Stage.PLAYING_GAMES), Mockito.eq("singleElimination"), Mockito.any())) + .thenReturn(tournament); + + SingleEliminationRecurringQueue queue = new SingleEliminationRecurringQueue(10, "format", CollectionType.MY_CARDS, + "id-", "name-", 2, false, tournamentService); + + + Player player1 = new Player(1, "p1", "u", null); + Player player2 = new Player(2, "p2", "u", null); + + CollectionsManager collectionsManager = Mockito.mock(CollectionsManager.class); + Mockito.when(collectionsManager.removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.any(), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10))) + .thenReturn(true); + + queue.joinPlayer(collectionsManager, player1, null); + + TournamentQueueCallback queueCallback = Mockito.mock(TournamentQueueCallback.class); + assertFalse(queue.process(queueCallback)); + + Mockito.verifyNoMoreInteractions(queueCallback); + + queue.joinPlayer(collectionsManager, player2, null); + + assertEquals(2, queue.getPlayerCount()); + + assertFalse(queue.process(queueCallback)); + + assertEquals(0, queue.getPlayerCount()); + assertFalse(queue.isPlayerSignedUp("p1")); + assertFalse(queue.isPlayerSignedUp("p2")); + + Mockito.verify(tournamentService).addTournament(Mockito.anyString(), Mockito.eq(null), Mockito.anyString(), Mockito.eq("format"), + Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(Tournament.Stage.PLAYING_GAMES), Mockito.eq("singleElimination"), Mockito.any()); + + Mockito.verify(tournamentService).addPlayer(Mockito.anyString(), Mockito.eq("p1"), Mockito.eq(null)); + Mockito.verify(tournamentService).addPlayer(Mockito.anyString(), Mockito.eq("p2"), Mockito.eq(null)); + + Mockito.verify(queueCallback).createTournament(tournament); + Mockito.verifyNoMoreInteractions(tournamentService, queueCallback); + } + + @Test + public void overflowingQueue() { + Tournament tournament = Mockito.mock(Tournament.class); + + TournamentService tournamentService = Mockito.mock(TournamentService.class); + Mockito.when(tournamentService.addTournament(Mockito.anyString(), Mockito.eq(null), Mockito.anyString(), Mockito.eq("format"), + Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(Tournament.Stage.PLAYING_GAMES), Mockito.eq("singleElimination"), Mockito.any())) + .thenReturn(tournament); + + SingleEliminationRecurringQueue queue = new SingleEliminationRecurringQueue(10, "format", CollectionType.MY_CARDS, + "id-", "name-", 2, false, tournamentService); + + + Player player1 = new Player(1, "p1", "u", null); + Player player2 = new Player(2, "p2", "u", null); + Player player3 = new Player(3, "p3", "u", null); + + CollectionsManager collectionsManager = Mockito.mock(CollectionsManager.class); + Mockito.when(collectionsManager.removeCurrencyFromPlayerCollection(Mockito.anyString(), Mockito.any(), Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(10))) + .thenReturn(true); + + queue.joinPlayer(collectionsManager, player1, null); + + TournamentQueueCallback queueCallback = Mockito.mock(TournamentQueueCallback.class); + assertFalse(queue.process(queueCallback)); + + Mockito.verifyNoMoreInteractions(queueCallback); + + queue.joinPlayer(collectionsManager, player2, null); + queue.joinPlayer(collectionsManager, player3, null); + + assertEquals(3, queue.getPlayerCount()); + + assertFalse(queue.process(queueCallback)); + + assertEquals(1, queue.getPlayerCount()); + assertFalse(queue.isPlayerSignedUp("p1")); + assertFalse(queue.isPlayerSignedUp("p2")); + assertTrue(queue.isPlayerSignedUp("p3")); + + Mockito.verify(tournamentService).addTournament(Mockito.anyString(), Mockito.eq(null), Mockito.anyString(), Mockito.eq("format"), + Mockito.eq(CollectionType.MY_CARDS), Mockito.eq(Tournament.Stage.PLAYING_GAMES), Mockito.eq("singleElimination"), Mockito.any()); + + Mockito.verify(tournamentService).addPlayer(Mockito.anyString(), Mockito.eq("p1"), Mockito.eq(null)); + Mockito.verify(tournamentService).addPlayer(Mockito.anyString(), Mockito.eq("p2"), Mockito.eq(null)); + + Mockito.verify(queueCallback).createTournament(tournament); + Mockito.verifyNoMoreInteractions(tournamentService, queueCallback); + } +}