test(server): move prepareRoomRequest into LobbyRequestTest

Author: xeruf

server/test/sc/server/network/LobbyRequestTest.kt

@@ -4,7 +4,6 @@ import io.kotest.assertions.timing.eventually
 import io.kotest.assertions.until.Interval
 import io.kotest.assertions.until.fibonacci
 import io.kotest.assertions.withClue
-import io.kotest.core.spec.IsolationMode
 import io.kotest.core.spec.style.WordSpec
 import io.kotest.matchers.collections.shouldBeEmpty
 import io.kotest.matchers.collections.shouldHaveSize
@@ -27,7 +26,6 @@ suspend fun await(clue: String? = null, duration: Duration = 1.seconds, interval
 
 @ExperimentalTime
 class LobbyRequestTest: WordSpec({
-    isolationMode = IsolationMode.SingleInstance
     "A Lobby with connected clients" When {
         val lobby = autoClose(TestLobby())
         val players = Array(3) { lobby.connectClient("localhost", lobby.serverPort) }
@@ -42,53 +40,54 @@ class LobbyRequestTest: WordSpec({
             }
         }
         val admin = players[0]
-        "preparing a paused game" should {
+        "a game is prepared paused" should {
             val listener = TestLobbyClientListener()
             admin.addListener(listener)
             admin.authenticate(PASSWORD)
 
-            "prepare the GameRoom" {
-                admin.prepareGame(TestPlugin.TEST_PLUGIN_UUID, true)
-                await { listener.gamePreparedReceived shouldBe true }
-                lobby.games shouldHaveSize 2
-            }
+            admin.prepareGame(TestPlugin.TEST_PLUGIN_UUID, true)
+            await("GameRoom prepared") { listener.gamePreparedReceived shouldBe true }
+            lobby.games shouldHaveSize 1
 
             val roomId = listener.prepareGameResponse.roomId
             val room = lobby.findRoom(roomId)
-            "create an empty paused game" {
+            withClue("GameRoom is empty and paused") {
                 room.clients.shouldBeEmpty()
                 room.isPauseRequested shouldBe true
             }
 
             val observer = admin.observeAndControl(roomId, true)
-            await { listener.observedReceived shouldBe true }
+            await("Game observed") { println(listener); listener.observedReceived shouldBe true }
 
-            "let players join by reservation" {
-                val reservations = listener.prepareGameResponse.reservations
-                players[1].joinPreparedGame(reservations[0])
-                players[2].joinPreparedGame(reservations[1])
-                await { room.status shouldBe GameRoom.GameStatus.ACTIVE }
-            }
+            val reservations = listener.prepareGameResponse.reservations
+            players[1].joinPreparedGame(reservations[0])
+            await("First player joined") { room.clients shouldHaveSize 1 }
+            players[2].joinPreparedGame(reservations[1])
+            await("Players join, Game start") { room.status shouldBe GameRoom.GameStatus.ACTIVE }
 
             val playerListeners = room.slots.map { slot ->
                 PlayerListener().also { listener -> slot.role.player.addPlayerListener(listener) }
             }
-            "start game on unpause" {
+            "terminate when a Move is received while still paused" {
+                players[1].sendMessageToRoom(roomId, TestMove(0))
+                await("Terminates") { room.status shouldBe GameRoom.GameStatus.OVER }
+            }
+            "play game on unpause" {
                 observer.unpause()
                 await { room.isPauseRequested shouldBe false }
-            }
-            val game = room.game as TestGame
-            "accept moves" {
-                playerListeners[0].waitForMessage(MoveRequest::class)
-                players[1].sendMessageToRoom(roomId, TestMove(32))
-                await { game.currentState.state shouldBe 32 }
-                playerListeners[1].waitForMessage(MoveRequest::class)
-                players[2].sendMessageToRoom(roomId, TestMove(54))
-                await { game.currentState.state shouldBe 54 }
-            }
-            "terminate when wrong player sends a move" {
+                val game = room.game as TestGame
+                withClue("Processes moves") {
+                    playerListeners[0].waitForMessage(MoveRequest::class)
+                    players[1].sendMessageToRoom(roomId, TestMove(32))
+                    await { game.currentState.state shouldBe 32 }
+                    playerListeners[1].waitForMessage(MoveRequest::class)
+                    players[2].sendMessageToRoom(roomId, TestMove(54))
+                    await { game.currentState.state shouldBe 54 }
+                }
                 players[2].sendMessageToRoom(roomId, TestMove(0))
-                await { room.status shouldBe GameRoom.GameStatus.OVER }
+                await("Terminate after wrong player sent a turn") {
+                    room.status shouldBe GameRoom.GameStatus.OVER
+                }
             }
         }
     }

server/test/sc/server/network/RequestTest.kt

@@ -1,5 +1,6 @@
 package sc.server.network
 
+import io.kotest.matchers.ints.shouldBeLessThanOrEqual
 import io.kotest.matchers.shouldBe
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
@@ -54,21 +55,6 @@ class RequestTest: RealServerTest() {
         assertFalse(clients[1].isAdministrator)
     }
 
-    @Test
-    fun prepareRoomRequest() {
-        player1.authenticate(PASSWORD)
-        player1.prepareGame(TestPlugin.TEST_PLUGIN_UUID, true)
-        val listener = TestPreparedGameResponseListener()
-        player1.addListener(listener)
-        
-        Thread.sleep(200)
-        assertNotNull(listener.response)
-        
-        assertEquals(1, lobby.games.size.toLong())
-        assertEquals(0, lobby.games.iterator().next().clients.size.toLong())
-        assertTrue(lobby.games.iterator().next().isPauseRequested)
-    }
-    
     @Test
     fun joinPreparedRoomRequest() {
         player1.authenticate(PASSWORD)
@@ -185,7 +171,7 @@ class RequestTest: RealServerTest() {
         await("Admin observing") { listener.observedReceived }
 
         player2.joinRoomRequest(TestPlugin.TEST_PLUGIN_UUID)
-        await("Second player joins and game starts", 1.seconds) { room.status == GameRoom.GameStatus.ACTIVE }
+        await("Second player joins and game starts") { room.status == GameRoom.GameStatus.ACTIVE }
         room.slots[1].role.player.addPlayerListener(p2Listener)
 
         // TODO the section above duplicates the one of the previous test, clean that up
@@ -196,10 +182,6 @@ class RequestTest: RealServerTest() {
 
         p1Listener.waitForMessage(WelcomeMessage::class)
 
-        // TODO enabling this should result in a GameLogicException
-        // player1.sendMessageToRoom(room.getId(), new TestMove(1));
-        // Thread.sleep(100);
-        
         // Request a move from the first player
         admin.send(StepRequest(room.id))
         TestHelper.waitUntilTrue({ listener.newStateReceived }, 2000)
@@ -209,6 +191,9 @@ class RequestTest: RealServerTest() {
         player1.sendMessageToRoom(room.id, TestMove(1));
         TestHelper.waitUntilTrue({ listener.newStateReceived }, 2000)
 
+        // might have received a WelcomeMessage
+        p2Listener.clearMessages() shouldBeLessThanOrEqual 1
+        
         admin.send(StepRequest(room.id))
         // Wait for second players turn
         p2Listener.waitForMessage(MoveRequest::class)