Add win validation

server/src/test/kotlin/tdt4240/netrunner/server/controllers/gamesim/ValidateGameFlowTests.kt

 package tdt4240.netrunner.server.controllers.gamesim
 
-import org.junit.jupiter.api.assertDoesNotThrow
 import org.slf4j.LoggerFactory
+import tdt4240.netrunner.model.game.components.dynamic.PositionComponent
 import tdt4240.netrunner.model.game.components.dynamic.VelocityComponent
 import tdt4240.netrunner.model.game.components.living.PlayerComponent
-import tdt4240.netrunner.model.response.StatusCode
 import tdt4240.netrunner.server.ServerLauncher
 import tdt4240.netrunner.server.controllers.GameServerEndpointController
+import tdt4240.netrunner.server.game.GameRoom
 import tdt4240.netrunner.server.util.AsyncAssert
 import tdt4240.netrunner.server.util.initSocket
-import tdt4240.netrunner.server.util.joinMatch
+import tdt4240.netrunner.server.util.joinForUid
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
@@ -36,42 +36,11 @@ class ValidateGameFlowTests {
     @Test
     fun testJump() {
         val control = AtomicBoolean(false)
-        lateinit var p1uid: String
-        lateinit var p2uid: String
-
         val c1 = initSocket(server.port)
-        c1.joinMatch("JoeMama") {
-            if (it.status != StatusCode.OK) {
-                logger.error("Didn't receive StatusCode OK: {}", it.message)
-            } else {
-                p1uid = it.message
-                control.set(true)
-            }
-        }
-        AsyncAssert.waitFor(true, property = control::get,
-            message = "If this throws, user 1 likely didn't get their UID")
-
-        control.set(false)
         val c2 = initSocket(server.port)
-        c2.joinMatch("PickleRick") {
 
-            if (it.status != StatusCode.OK) {
-                logger.error("Didn't receive StatusCode OK: {}", it.message)
-            } else {
-                p2uid = it.message
-                control.set(true)
-            }
-        }
-        AsyncAssert.waitFor(true, property = control::get,
-            message = "If this throws, user 2 likely didn't get their UID")
-        assertDoesNotThrow {
-            // Dummy, worthless, always false statement, but it forcibly checks whether
-            // the variables have been initialised, because you apparently can't do
-            // ::p1uid.isInitialized with local variables :facedesk:
-            // This checks both in one go. If this is the source of an error, congrats,
-            // the UIDs haven't been initialised to a non-empty value.
-            p1uid == p2uid
-        }
+        val p1uid = c1.joinForUid("JoeMama")
+        val p2uid = c2.joinForUid("PickleRick")
 
         val room = gameController.queuedGames.elementAt(0)
         room.forceStart = true
@@ -113,6 +82,70 @@ class ValidateGameFlowTests {
             // do it here.
             assertTrue(pv.velocity.x > 0f)
         }
+    }
+
+    @Test
+    fun validateGameWin() {
+        val control = AtomicBoolean(false)
+        val c1 = initSocket(server.port)
+        val c2 = initSocket(server.port)
+
+        val p1uid = c1.joinForUid("JoeMama")
+        val p2uid = c2.joinForUid("PickleRick")
+
+        val room = gameController.queuedGames.elementAt(0)
+        room.forceStart = true
+
+        // wait for the game to actually start
+        control.set(false)
+        c1.once("game-started") {
+            control.set(true)
+        }
+        AsyncAssert.waitFor(true, sleep = 1000, property = control::get,
+                message = "If this throws, the game-started event was not received")
+
+        control.set(false)
+
+        val players = room.ecs.getEntitiesByComponent(PlayerComponent::class.java)
+        for (player in players) {
+            val pc = player.getComponent(PlayerComponent::class.java)
+            val pos = player.getComponent(PositionComponent::class.java)
+
+            assertNotNull(pc)
+            assertNotNull(pos)
+
+            if (pc.uid == p1uid) {
+                // Give p1 a second worth of advantage
+                pos.pos.x = GameRoom.STANDARD_FIELD_LENGTH.toFloat() - 1600f
+            } else {
+                // Move p2 right behind for leaderboard testing
+                pos.pos.x = GameRoom.STANDARD_FIELD_LENGTH.toFloat() - 2400f
+            }
+            assertEquals(0, pc.finishPosition)
+        }
+
+        val p2 = players.map {
+            it.getComponent(PlayerComponent::class.java)!!
+        }.first {
+            it.uid == p2uid
+        }
+
+        AsyncAssert.waitFor(true, sleep = 1000, property = {
+            p2.finishPosition != 0
+        }, message = "If this throws, the server was most likely unable to finish game processing in a sane amount of time")
+
+        for (player in players) {
+            val pc = player.getComponent(PlayerComponent::class.java)
+
+            assertNotNull(pc)
+
+            if (pc.uid == p1uid) {
+                assertEquals(1,pc.finishPosition)
+            } else {
+                assertEquals(2, pc.finishPosition)
+            }
+        }
+
 
     }
 

server/src/test/kotlin/tdt4240/netrunner/server/util/SocketUtil.kt

@@ -4,11 +4,18 @@ import io.socket.client.Ack
 import io.socket.client.IO
 import io.socket.client.Socket
 import io.socket.engineio.client.transports.WebSocket
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import tdt4240.netrunner.model.game.data.PlayerColor
 import tdt4240.netrunner.model.requests.JoinGameRequest
+import tdt4240.netrunner.model.response.StatusCode
 import tdt4240.netrunner.model.response.StatusResponse
 import tdt4240.netrunner.model.util.gsonImpl
 import java.net.URI
+import java.util.concurrent.atomic.AtomicBoolean
+
+private val Socket.logger: Logger
+    get() = LoggerFactory.getLogger(Socket::class.java)
 
 fun Socket.leaveMatch(also: ((res: StatusResponse) -> Unit)?) {
     emit("leave-matchmaking", Ack {
@@ -26,6 +33,23 @@ fun Socket.joinMatch(username: String, also: ((res: StatusResponse) -> Unit)?) {
     })
 }
 
+fun Socket.joinForUid(username: String): String {
+    val control = AtomicBoolean(false)
+    lateinit var uid: String
+
+    joinMatch("JoeMama") {
+        if (it.status != StatusCode.OK) {
+            this.logger.error("Didn't receive StatusCode OK: {}", it.message)
+        } else {
+            uid = it.message
+            control.set(true)
+        }
+    }
+    AsyncAssert.waitFor(true, property = control::get,
+            message = "If this throws, the user \"${username}\" likely didn't receive a UID")
+    return uid
+}
+
 fun initSocket(port: Int): Socket {
     val client = IO.socket(URI("ws://127.0.0.1:$port"), IO.Options.builder()
             // Force websocket transport rather than polling