Rationalize module names

12 files changed, 0 insertions, 1203 deletions

diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/SevenWondersTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/SevenWondersTest.kt
deleted file mode 100644
index 01de366a..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/SevenWondersTest.kt
+++ /dev/null
@@ -1,145 +0,0 @@
-package org.luxons.sevenwonders
-
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.luxons.sevenwonders.test.api.SevenWondersClient
-import org.luxons.sevenwonders.test.api.SevenWondersSession
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
-import org.springframework.boot.web.server.LocalServerPort
-import org.springframework.test.context.junit4.SpringRunner
-import java.util.concurrent.TimeUnit
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertNull
-
-@RunWith(SpringRunner::class)
-@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
-class SevenWondersTest {
-
-    @LocalServerPort
-    private val randomServerPort: Int = 0
-
-    private lateinit var client: SevenWondersClient
-
-    private lateinit var serverUrl: String
-
-    @Before
-    fun setUpClientAndUrl() {
-        client = SevenWondersClient()
-        serverUrl = "ws://localhost:$randomServerPort"
-    }
-
-    private fun disconnect(vararg sessions: SevenWondersSession) {
-        for (session in sessions) {
-            session.disconnect()
-        }
-    }
-
-    @Test
-    fun chooseName() {
-        val session = client.connect(serverUrl)
-        val playerName = "Test User"
-        val player = session.chooseName(playerName)
-        assertNotNull(player)
-        assertEquals(playerName, player.displayName)
-        session.disconnect()
-    }
-
-    private fun newPlayer(name: String): SevenWondersSession {
-        val otherSession = client.connect(serverUrl)
-        otherSession.chooseName(name)
-        return otherSession
-    }
-
-    @Test
-    fun lobbySubscription_ignoredForOutsiders() {
-        val ownerSession = newPlayer("GameOwner")
-        val session1 = newPlayer("Player1")
-        val session2 = newPlayer("Player2")
-        val gameName = "Test Game"
-        val lobby = ownerSession.createGame(gameName)
-        session1.joinGame(lobby.id)
-        session2.joinGame(lobby.id)
-
-        val outsiderSession = newPlayer("Outsider")
-        val session = outsiderSession.jackstompSession
-        val started = session.subscribeEmptyMsgs("/topic/lobby/" + lobby.id + "/started")
-
-        ownerSession.startGame(lobby.id)
-        val nothing = started.next(1, TimeUnit.SECONDS)
-        assertNull(nothing)
-        disconnect(ownerSession, session1, session2, outsiderSession)
-    }
-
-    @Test
-    fun createGame_success() {
-        val ownerSession = newPlayer("GameOwner")
-
-        val gameName = "Test Game"
-        val lobby = ownerSession.createGame(gameName)
-        assertNotNull(lobby)
-        assertEquals(gameName, lobby.name)
-
-        disconnect(ownerSession)
-    }
-
-    @Test
-    fun createGame_seenByConnectedPlayers() {
-        val otherSession = newPlayer("OtherPlayer")
-        val games = otherSession.watchGames()
-
-        var receivedLobbies = games.next()
-        assertNotNull(receivedLobbies)
-        assertEquals(0, receivedLobbies.size)
-
-        val ownerSession = newPlayer("GameOwner")
-        val gameName = "Test Game"
-        val createdLobby = ownerSession.createGame(gameName)
-
-        receivedLobbies = games.next()
-        assertNotNull(receivedLobbies)
-        assertEquals(1, receivedLobbies.size)
-        val receivedLobby = receivedLobbies[0]
-        assertEquals(createdLobby.id, receivedLobby.id)
-        assertEquals(createdLobby.name, receivedLobby.name)
-
-        disconnect(ownerSession, otherSession)
-    }
-
-    @Test
-    fun startGame_3players() {
-        val session1 = newPlayer("Player1")
-        val session2 = newPlayer("Player2")
-
-        val lobby = session1.createGame("Test Game")
-        session2.joinGame(lobby.id)
-
-        val session3 = newPlayer("Player3")
-        session3.joinGame(lobby.id)
-
-        session1.startGame(lobby.id)
-
-        val turns1 = session1.watchTurns()
-        val turns2 = session2.watchTurns()
-        val turns3 = session3.watchTurns()
-        session1.sayReady()
-        session2.sayReady()
-        session3.sayReady()
-        val turn1 = turns1.next()
-        val turn2 = turns2.next()
-        val turn3 = turns3.next()
-        assertNotNull(turn1)
-        assertNotNull(turn2)
-        assertNotNull(turn3)
-
-        disconnect(session1, session2, session3)
-    }
-
-    @After
-    fun tearDown() {
-        client.stop()
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/GameBrowserControllerTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/GameBrowserControllerTest.kt
deleted file mode 100644
index 343b7f34..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/GameBrowserControllerTest.kt
+++ /dev/null
@@ -1,124 +0,0 @@
-package org.luxons.sevenwonders.controllers
-
-import org.junit.Before
-import org.junit.Test
-import org.luxons.sevenwonders.actions.CreateGameAction
-import org.luxons.sevenwonders.actions.JoinGameAction
-import org.luxons.sevenwonders.api.toDTO
-import org.luxons.sevenwonders.controllers.GameBrowserController.UserAlreadyInGameException
-import org.luxons.sevenwonders.repositories.LobbyRepository
-import org.luxons.sevenwonders.repositories.PlayerNotFoundException
-import org.luxons.sevenwonders.repositories.PlayerRepository
-import org.luxons.sevenwonders.test.mockSimpMessagingTemplate
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-
-class GameBrowserControllerTest {
-
-    private lateinit var playerRepository: PlayerRepository
-
-    private lateinit var gameBrowserController: GameBrowserController
-
-    @Before
-    fun setUp() {
-        playerRepository = PlayerRepository()
-        val lobbyRepository = LobbyRepository()
-        val template = mockSimpMessagingTemplate()
-        val lobbyController = LobbyController(lobbyRepository, playerRepository, template)
-        gameBrowserController = GameBrowserController(lobbyController, lobbyRepository, playerRepository, template)
-    }
-
-    @Test
-    fun listGames_initiallyEmpty() {
-        val principal = TestPrincipal("testuser")
-        val games = gameBrowserController.listGames(principal)
-        assertTrue(games.isEmpty())
-    }
-
-    @Test
-    fun createGame_success() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val principal = TestPrincipal("testuser")
-
-        val action = CreateGameAction("Test Game")
-
-        val createdLobby = gameBrowserController.createGame(action, principal)
-
-        assertEquals("Test Game", createdLobby.name)
-
-        val games = gameBrowserController.listGames(principal)
-        assertFalse(games.isEmpty())
-        val lobby = games.iterator().next()
-        assertEquals(lobby, createdLobby)
-        assertEquals(player.toDTO(principal.name), lobby.players[0])
-    }
-
-    @Test
-    fun createGame_failsForUnknownPlayer() {
-        val principal = TestPrincipal("unknown")
-        val action = CreateGameAction("Test Game")
-
-        assertFailsWith<PlayerNotFoundException> {
-            gameBrowserController.createGame(action, principal)
-        }
-    }
-
-    @Test
-    fun createGame_failsWhenAlreadyInGame() {
-        playerRepository.createOrUpdate("testuser", "Test User")
-        val principal = TestPrincipal("testuser")
-
-        val createGameAction1 = CreateGameAction("Test Game 1")
-
-        // auto-enters the game
-        gameBrowserController.createGame(createGameAction1, principal)
-
-        val createGameAction2 = CreateGameAction("Test Game 2")
-
-        // already in a game
-        assertFailsWith<UserAlreadyInGameException> {
-            gameBrowserController.createGame(createGameAction2, principal)
-        }
-    }
-
-    @Test
-    fun joinGame_success() {
-        val owner = playerRepository.createOrUpdate("testowner", "Test User Owner")
-        val ownerPrincipal = TestPrincipal("testowner")
-        val createGameAction = CreateGameAction("Test Game")
-
-        val createdLobby = gameBrowserController.createGame(createGameAction, ownerPrincipal)
-        assertEquals(owner.toDTO(ownerPrincipal.name), createdLobby.players[0])
-
-        val joiner = playerRepository.createOrUpdate("testjoiner", "Test User Joiner")
-        val joinerPrincipal = TestPrincipal("testjoiner")
-        val joinGameAction = JoinGameAction(createdLobby.id)
-
-        val joinedLobby = gameBrowserController.joinGame(joinGameAction, joinerPrincipal)
-
-        assertEquals(owner.toDTO(joinerPrincipal.name), joinedLobby.players[0])
-        assertEquals(joiner.toDTO(joinerPrincipal.name), joinedLobby.players[1])
-    }
-
-    @Test
-    fun joinGame_failsWhenAlreadyInGame() {
-        playerRepository.createOrUpdate("testowner", "Test User Owner")
-        val ownerPrincipal = TestPrincipal("testowner")
-        val createGameAction = CreateGameAction("Test Game")
-
-        val createdLobby = gameBrowserController.createGame(createGameAction, ownerPrincipal)
-
-        playerRepository.createOrUpdate("testjoiner", "Test User Joiner")
-        val joinerPrincipal = TestPrincipal("testjoiner")
-        val joinGameAction = JoinGameAction(createdLobby.id)
-
-        // joins the game
-        gameBrowserController.joinGame(joinGameAction, joinerPrincipal)
-        // should fail because already in a game
-        assertFailsWith<UserAlreadyInGameException> {
-            gameBrowserController.joinGame(joinGameAction, joinerPrincipal)
-        }
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/HomeControllerTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/HomeControllerTest.kt
deleted file mode 100644
index 3374a025..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/HomeControllerTest.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.luxons.sevenwonders.controllers
-
-import org.junit.Test
-import org.luxons.sevenwonders.actions.ChooseNameAction
-import org.luxons.sevenwonders.repositories.PlayerRepository
-import kotlin.test.assertEquals
-
-class HomeControllerTest {
-
-    @Test
-    fun chooseName() {
-        val playerRepository = PlayerRepository()
-        val homeController = HomeController(playerRepository)
-
-        val action = ChooseNameAction("Test User")
-        val principal = TestPrincipal("testuser")
-
-        val player = homeController.chooseName(action, principal)
-
-        assertEquals("testuser", player.username)
-        assertEquals("Test User", player.displayName)
-        assertEquals(false, player.isGameOwner)
-        assertEquals(true, player.isUser)
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/LobbyControllerTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/LobbyControllerTest.kt
deleted file mode 100644
index a140e000..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/LobbyControllerTest.kt
+++ /dev/null
@@ -1,217 +0,0 @@
-package org.luxons.sevenwonders.controllers
-
-import org.junit.Before
-import org.junit.Test
-import org.luxons.sevenwonders.actions.ReorderPlayersAction
-import org.luxons.sevenwonders.actions.UpdateSettingsAction
-import org.luxons.sevenwonders.game.api.CustomizableSettings
-import org.luxons.sevenwonders.game.api.WonderSidePickMethod.ALL_A
-import org.luxons.sevenwonders.lobby.Lobby
-import org.luxons.sevenwonders.lobby.Player
-import org.luxons.sevenwonders.lobby.PlayerIsNotOwnerException
-import org.luxons.sevenwonders.lobby.PlayerNotInLobbyException
-import org.luxons.sevenwonders.lobby.State
-import org.luxons.sevenwonders.repositories.LobbyRepository
-import org.luxons.sevenwonders.repositories.PlayerNotFoundException
-import org.luxons.sevenwonders.repositories.PlayerRepository
-import org.luxons.sevenwonders.test.mockSimpMessagingTemplate
-import java.util.HashMap
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertFalse
-import kotlin.test.assertSame
-import kotlin.test.assertTrue
-
-class LobbyControllerTest {
-
-    private lateinit var playerRepository: PlayerRepository
-
-    private lateinit var lobbyRepository: LobbyRepository
-
-    private lateinit var lobbyController: LobbyController
-
-    @Before
-    fun setUp() {
-        val template = mockSimpMessagingTemplate()
-        playerRepository = PlayerRepository()
-        lobbyRepository = LobbyRepository()
-        lobbyController = LobbyController(lobbyRepository, playerRepository, template)
-    }
-
-    @Test
-    fun init_succeeds() {
-        val owner = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", owner)
-
-        assertTrue(lobby.getPlayers().contains(owner))
-        assertSame(lobby, owner.lobby)
-        assertEquals(owner, lobby.owner)
-        assertTrue(owner.isInLobby)
-        assertFalse(owner.isInGame)
-    }
-
-    @Test
-    fun leave_failsWhenPlayerDoesNotExist() {
-        val principal = TestPrincipal("I don't exist")
-
-        assertFailsWith<PlayerNotFoundException> {
-            lobbyController.leave(principal)
-        }
-    }
-
-    @Test
-    fun leave_failsWhenNotInLobby() {
-        playerRepository.createOrUpdate("testuser", "Test User")
-        val principal = TestPrincipal("testuser")
-
-        assertFailsWith<PlayerNotInLobbyException> {
-            lobbyController.leave(principal)
-        }
-    }
-
-    @Test
-    fun leave_succeedsWhenInALobby_asOwner() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-
-        val principal = TestPrincipal("testuser")
-        lobbyController.leave(principal)
-
-        assertFalse(lobbyRepository.list().contains(lobby))
-        assertFalse(player.isInLobby)
-        assertFalse(player.isInGame)
-    }
-
-    @Test
-    fun leave_succeedsWhenInALobby_asPeasant() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-        val player2 = addPlayer(lobby, "testuser2")
-
-        val principal = TestPrincipal("testuser2")
-        lobbyController.leave(principal)
-
-        assertFalse(lobby.getPlayers().contains(player2))
-        assertFalse(player2.isInLobby)
-        assertFalse(player2.isInGame)
-    }
-
-    @Test
-    fun reorderPlayers_succeedsForOwner() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-
-        val player2 = addPlayer(lobby, "testuser2")
-        val player3 = addPlayer(lobby, "testuser3")
-        val player4 = addPlayer(lobby, "testuser4")
-
-        val players = listOf(player, player2, player3, player4)
-        assertEquals(players, lobby.getPlayers())
-
-        val reorderedPlayers = listOf(player3, player, player2, player4)
-        val playerNames = reorderedPlayers.map { it.username }
-        val reorderPlayersAction = ReorderPlayersAction(playerNames)
-
-        val principal = TestPrincipal("testuser")
-        lobbyController.reorderPlayers(reorderPlayersAction, principal)
-
-        assertEquals(reorderedPlayers, lobby.getPlayers())
-    }
-
-    @Test
-    fun reorderPlayers_failsForPeasant() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-
-        val player2 = addPlayer(lobby, "testuser2")
-        val player3 = addPlayer(lobby, "testuser3")
-
-        val reorderedPlayers = listOf(player3, player, player2)
-        val playerNames = reorderedPlayers.map { it.username }
-        val reorderPlayersAction = ReorderPlayersAction(playerNames)
-
-        val principal = TestPrincipal("testuser2")
-
-        assertFailsWith<PlayerIsNotOwnerException> {
-            lobbyController.reorderPlayers(reorderPlayersAction, principal)
-        }
-    }
-
-    @Test
-    fun updateSettings_succeedsForOwner() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-
-        addPlayer(lobby, "testuser2")
-        addPlayer(lobby, "testuser3")
-        addPlayer(lobby, "testuser4")
-
-        assertEquals(CustomizableSettings(), lobby.settings)
-
-        val newSettings = CustomizableSettings(12L, 5, ALL_A, 5, 5, 4, 10, 2, HashMap())
-        val updateSettingsAction = UpdateSettingsAction(newSettings)
-
-        val principal = TestPrincipal("testuser")
-        lobbyController.updateSettings(updateSettingsAction, principal)
-
-        assertEquals(newSettings, lobby.settings)
-    }
-
-    @Test
-    fun updateSettings_failsForPeasant() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-
-        addPlayer(lobby, "testuser2")
-        addPlayer(lobby, "testuser3")
-
-        val updateSettingsAction = UpdateSettingsAction(CustomizableSettings())
-
-        val principal = TestPrincipal("testuser2")
-
-        assertFailsWith<PlayerIsNotOwnerException> {
-            lobbyController.updateSettings(updateSettingsAction, principal)
-        }
-    }
-
-    @Test
-    fun startGame_succeedsForOwner() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-
-        addPlayer(lobby, "testuser2")
-        addPlayer(lobby, "testuser3")
-        addPlayer(lobby, "testuser4")
-
-        val principal = TestPrincipal("testuser")
-        lobbyController.startGame(principal)
-
-        assertSame(State.PLAYING, lobby.state)
-    }
-
-    @Test
-    fun startGame_failsForPeasant() {
-        val player = playerRepository.createOrUpdate("testuser", "Test User")
-        val lobby = lobbyRepository.create("Test Game", player)
-
-        addPlayer(lobby, "testuser2")
-        addPlayer(lobby, "testuser3")
-
-        val principal = TestPrincipal("testuser2")
-
-        assertFailsWith<PlayerIsNotOwnerException> {
-            lobbyController.startGame(principal)
-        }
-    }
-
-    private fun addPlayer(lobby: Lobby, username: String): Player {
-        val player = playerRepository.createOrUpdate(username, username)
-        lobby.addPlayer(player)
-
-        assertTrue(lobby.getPlayers().contains(player))
-        assertSame(lobby, player.lobby)
-        assertTrue(player.isInLobby)
-        assertFalse(player.isInGame)
-        return player
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/TestPrincipal.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/TestPrincipal.kt
deleted file mode 100644
index 76b0f8fa..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/controllers/TestPrincipal.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package org.luxons.sevenwonders.controllers
-
-import java.security.Principal
-
-internal class TestPrincipal(private val name: String) : Principal {
-
-    override fun getName(): String = name
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/lobby/LobbyTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/lobby/LobbyTest.kt
deleted file mode 100644
index 967a97e2..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/lobby/LobbyTest.kt
+++ /dev/null
@@ -1,266 +0,0 @@
-package org.luxons.sevenwonders.lobby
-
-import org.junit.Assume.assumeTrue
-import org.junit.Before
-import org.junit.BeforeClass
-import org.junit.Test
-import org.junit.experimental.theories.DataPoints
-import org.junit.experimental.theories.Theories
-import org.junit.experimental.theories.Theory
-import org.junit.runner.RunWith
-import org.luxons.sevenwonders.game.api.CustomizableSettings
-import org.luxons.sevenwonders.game.data.GameDefinition
-import org.luxons.sevenwonders.lobby.Lobby.GameAlreadyStartedException
-import org.luxons.sevenwonders.lobby.Lobby.PlayerListMismatchException
-import org.luxons.sevenwonders.lobby.Lobby.PlayerNameAlreadyUsedException
-import org.luxons.sevenwonders.lobby.Lobby.PlayerOverflowException
-import org.luxons.sevenwonders.lobby.Lobby.PlayerUnderflowException
-import org.luxons.sevenwonders.lobby.Lobby.UnknownPlayerException
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertFalse
-import kotlin.test.assertNotNull
-import kotlin.test.assertSame
-import kotlin.test.assertTrue
-
-@RunWith(Theories::class)
-class LobbyTest {
-
-    private lateinit var gameOwner: Player
-
-    private lateinit var lobby: Lobby
-
-    @Before
-    fun setUp() {
-        gameOwner = Player("gameowner", "Game owner")
-        lobby = Lobby(0, "Test Game", gameOwner, gameDefinition)
-    }
-
-    @Test
-    fun testId() {
-        val lobby = Lobby(5, "Test Game", gameOwner, gameDefinition)
-        assertEquals(5, lobby.id)
-    }
-
-    @Test
-    fun testName() {
-        val lobby = Lobby(5, "Test Game", gameOwner, gameDefinition)
-        assertEquals("Test Game", lobby.name)
-    }
-
-    @Test
-    fun testOwner() {
-        val lobby = Lobby(5, "Test Game", gameOwner, gameDefinition)
-        assertSame(gameOwner, lobby.getPlayers()[0])
-        assertSame(lobby, gameOwner.lobby)
-    }
-
-    @Test
-    fun isOwner_falseWhenNull() {
-        assertFalse(lobby.isOwner(null))
-    }
-
-    @Test
-    fun isOwner_falseWhenEmptyString() {
-        assertFalse(lobby.isOwner(""))
-    }
-
-    @Test
-    fun isOwner_falseWhenGarbageString() {
-        assertFalse(lobby.isOwner("this is garbage"))
-    }
-
-    @Test
-    fun isOwner_trueWhenOwnerUsername() {
-        assertTrue(lobby.isOwner(gameOwner.username))
-    }
-
-    @Test
-    fun isOwner_falseWhenOtherPlayerName() {
-        val player = Player("testuser", "Test User")
-        lobby.addPlayer(player)
-        assertFalse(lobby.isOwner(player.username))
-    }
-
-    @Test
-    fun addPlayer_success() {
-        val player = Player("testuser", "Test User")
-        lobby.addPlayer(player)
-        assertTrue(lobby.containsUser("testuser"))
-        assertSame(lobby, player.lobby)
-    }
-
-    @Test
-    fun addPlayer_failsOnSameName() {
-        val player = Player("testuser", "Test User")
-        val player2 = Player("testuser2", "Test User")
-        lobby.addPlayer(player)
-        assertFailsWith<PlayerNameAlreadyUsedException> {
-            lobby.addPlayer(player2)
-        }
-    }
-
-    @Test
-    fun addPlayer_playerOverflowWhenTooMany() {
-        assertFailsWith<PlayerOverflowException> {
-            // the owner + the max number gives an overflow
-            addPlayers(gameDefinition.maxPlayers)
-        }
-    }
-
-    @Test
-    fun addPlayer_failWhenGameStarted() {
-        // total with owner is the minimum
-        addPlayers(gameDefinition.minPlayers - 1)
-        lobby.startGame()
-        assertFailsWith<GameAlreadyStartedException> {
-            lobby.addPlayer(Player("soonerNextTime", "The Late Guy"))
-        }
-    }
-
-    private fun addPlayers(nbPlayers: Int) {
-        repeat(nbPlayers) {
-            val player = Player("testuser$it", "Test User $it")
-            lobby.addPlayer(player)
-        }
-    }
-
-    @Test
-    fun removePlayer_failsWhenNotPresent() {
-        assertFailsWith<UnknownPlayerException> {
-            lobby.removePlayer("anyname")
-        }
-    }
-
-    @Test
-    fun removePlayer_success() {
-        val player = Player("testuser", "Test User")
-        lobby.addPlayer(player)
-        assertTrue(player.isInLobby)
-        assertFalse(player.isInGame)
-
-        lobby.removePlayer("testuser")
-        assertFalse(lobby.containsUser("testuser"))
-        assertFalse(player.isInLobby)
-        assertFalse(player.isInGame)
-    }
-
-    @Test
-    fun reorderPlayers_success() {
-        val player1 = Player("testuser1", "Test User 1")
-        val player2 = Player("testuser2", "Test User 2")
-        val player3 = Player("testuser3", "Test User 3")
-        lobby.addPlayer(player1)
-        lobby.addPlayer(player2)
-        lobby.addPlayer(player3)
-
-        val reorderedUsernames = listOf("testuser3", "gameowner", "testuser1", "testuser2")
-        lobby.reorderPlayers(reorderedUsernames)
-
-        assertEquals(reorderedUsernames, lobby.getPlayers().map { it.username })
-    }
-
-    @Test
-    fun reorderPlayers_failsOnUnknownPlayer() {
-        val player1 = Player("testuser1", "Test User 1")
-        val player2 = Player("testuser2", "Test User 2")
-        lobby.addPlayer(player1)
-        lobby.addPlayer(player2)
-
-        assertFailsWith<PlayerListMismatchException> {
-            lobby.reorderPlayers(listOf("unknown", "testuser2", "gameowner"))
-        }
-    }
-
-    @Test
-    fun reorderPlayers_failsOnExtraPlayer() {
-        val player1 = Player("testuser1", "Test User 1")
-        val player2 = Player("testuser2", "Test User 2")
-        lobby.addPlayer(player1)
-        lobby.addPlayer(player2)
-
-        assertFailsWith<PlayerListMismatchException> {
-            lobby.reorderPlayers(listOf("testuser2", "onemore", "testuser1", "gameowner"))
-        }
-    }
-
-    @Test
-    fun reorderPlayers_failsOnMissingPlayer() {
-        val player1 = Player("testuser1", "Test User 1")
-        val player2 = Player("testuser2", "Test User 2")
-        lobby.addPlayer(player1)
-        lobby.addPlayer(player2)
-
-        assertFailsWith<PlayerListMismatchException> {
-            lobby.reorderPlayers(listOf("testuser2", "gameowner"))
-        }
-    }
-
-    @Theory
-    fun startGame_failsBelowMinPlayers(nbPlayers: Int) {
-        assumeTrue(nbPlayers < gameDefinition.minPlayers)
-
-        // there is already the owner
-        addPlayers(nbPlayers - 1)
-
-        assertFailsWith<PlayerUnderflowException> {
-            lobby.startGame()
-        }
-    }
-
-    @Theory
-    fun startGame_succeedsAboveMinPlayers(nbPlayers: Int) {
-        assumeTrue(nbPlayers >= gameDefinition.minPlayers)
-        assumeTrue(nbPlayers <= gameDefinition.maxPlayers)
-        // there is already the owner
-        addPlayers(nbPlayers - 1)
-
-        assertEquals(nbPlayers, lobby.getPlayers().size)
-        lobby.getPlayers().forEach {
-            assertSame(lobby, it.lobby)
-            assertTrue(it.isInLobby)
-            assertFalse(it.isInGame)
-        }
-
-        val game = lobby.startGame()
-        assertNotNull(game)
-        lobby.getPlayers().forEachIndexed { index, it ->
-            assertSame(index, it.index)
-            assertSame(lobby, it.lobby)
-            assertSame(game, it.game)
-            assertTrue(it.isInLobby)
-            assertTrue(it.isInGame)
-        }
-    }
-
-    @Test
-    fun startGame_switchesState() {
-        assertEquals(State.LOBBY, lobby.state)
-        // there is already the owner
-        addPlayers(gameDefinition.minPlayers - 1)
-        lobby.startGame()
-        assertEquals(State.PLAYING, lobby.state)
-    }
-
-    @Test
-    fun setSettings() {
-        val settings = CustomizableSettings()
-        lobby.settings = settings
-        assertSame(settings, lobby.settings)
-    }
-
-    companion object {
-
-        private lateinit var gameDefinition: GameDefinition
-
-        @JvmStatic
-        @DataPoints
-        fun nbPlayers(): IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-
-        @JvmStatic
-        @BeforeClass
-        fun loadDefinition() {
-            gameDefinition = GameDefinition.load()
-        }
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/repositories/LobbyRepositoryTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/repositories/LobbyRepositoryTest.kt
deleted file mode 100644
index 446feee6..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/repositories/LobbyRepositoryTest.kt
+++ /dev/null
@@ -1,78 +0,0 @@
-package org.luxons.sevenwonders.repositories
-
-import org.junit.Before
-import org.junit.Test
-import org.luxons.sevenwonders.lobby.Player
-import kotlin.test.assertFailsWith
-import kotlin.test.assertNotNull
-import kotlin.test.assertSame
-import kotlin.test.assertTrue
-import kotlin.test.fail
-
-class LobbyRepositoryTest {
-
-    private lateinit var repository: LobbyRepository
-
-    @Before
-    fun setUp() {
-        repository = LobbyRepository()
-    }
-
-    @Test
-    fun list_initiallyEmpty() {
-        assertTrue(repository.list().isEmpty())
-    }
-
-    @Test
-    fun list_returnsAllLobbies() {
-        val owner = Player("owner", "The Owner")
-        val lobby1 = repository.create("Test Name 1", owner)
-        val lobby2 = repository.create("Test Name 2", owner)
-        assertTrue(repository.list().contains(lobby1))
-        assertTrue(repository.list().contains(lobby2))
-    }
-
-    @Test
-    fun create_withCorrectOwner() {
-        val owner = Player("owner", "The Owner")
-        val lobby = repository.create("Test Name", owner)
-        assertTrue(lobby.isOwner(owner.username))
-    }
-
-    @Test
-    fun find_failsOnUnknownId() {
-        assertFailsWith<LobbyNotFoundException> {
-            repository.find(123)
-        }
-    }
-
-    @Test
-    fun find_returnsTheSameObject() {
-        val owner = Player("owner", "The Owner")
-        val lobby1 = repository.create("Test Name 1", owner)
-        val lobby2 = repository.create("Test Name 2", owner)
-        assertSame(lobby1, repository.find(lobby1.id))
-        assertSame(lobby2, repository.find(lobby2.id))
-    }
-
-    @Test
-    fun remove_failsOnUnknownId() {
-        assertFailsWith<LobbyNotFoundException> {
-            repository.remove(123)
-        }
-    }
-
-    @Test
-    fun remove_succeeds() {
-        val owner = Player("owner", "The Owner")
-        val lobby1 = repository.create("Test Name 1", owner)
-        assertNotNull(repository.find(lobby1.id))
-        repository.remove(lobby1.id)
-        try {
-            repository.find(lobby1.id)
-            fail() // the call to find() should have failed
-        } catch (e: LobbyNotFoundException) {
-            // the lobby has been properly removed
-        }
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/repositories/PlayerRepositoryTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/repositories/PlayerRepositoryTest.kt
deleted file mode 100644
index aeedc54c..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/repositories/PlayerRepositoryTest.kt
+++ /dev/null
@@ -1,75 +0,0 @@
-package org.luxons.sevenwonders.repositories
-
-import org.junit.Before
-import org.junit.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertFalse
-import kotlin.test.assertSame
-import kotlin.test.assertTrue
-
-class PlayerRepositoryTest {
-
-    private lateinit var repository: PlayerRepository
-
-    @Before
-    fun setUp() {
-        repository = PlayerRepository()
-    }
-
-    @Test
-    fun contains_falseIfNoUserAdded() {
-        assertFalse(repository.contains("anyUsername"))
-    }
-
-    @Test
-    fun contains_trueForCreatedPlayer() {
-        repository.createOrUpdate("player1", "Player 1")
-        assertTrue(repository.contains("player1"))
-    }
-
-    @Test
-    fun createOrUpdate_createsProperly() {
-        val player1 = repository.createOrUpdate("player1", "Player 1")
-        assertEquals("player1", player1.username)
-        assertEquals("Player 1", player1.displayName)
-    }
-
-    @Test
-    fun createOrUpdate_updatesDisplayName() {
-        val player1 = repository.createOrUpdate("player1", "Player 1")
-        val player1Updated = repository.createOrUpdate("player1", "Much Better Name")
-        assertSame(player1, player1Updated)
-        assertEquals("Much Better Name", player1Updated.displayName)
-    }
-
-    @Test
-    fun find_failsOnUnknownUsername() {
-        assertFailsWith<PlayerNotFoundException> {
-            repository.find("anyUsername")
-        }
-    }
-
-    @Test
-    fun find_returnsTheSameObject() {
-        val player1 = repository.createOrUpdate("player1", "Player 1")
-        val player2 = repository.createOrUpdate("player2", "Player 2")
-        assertSame(player1, repository.find("player1"))
-        assertSame(player2, repository.find("player2"))
-    }
-
-    @Test
-    fun remove_failsOnUnknownUsername() {
-        assertFailsWith<PlayerNotFoundException> {
-            repository.remove("anyUsername")
-        }
-    }
-
-    @Test
-    fun remove_succeeds() {
-        repository.createOrUpdate("player1", "Player 1")
-        assertTrue(repository.contains("player1"))
-        repository.remove("player1")
-        assertFalse(repository.contains("player1"))
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/test/TestUtils.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/test/TestUtils.kt
deleted file mode 100644
index 9f328c5f..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/test/TestUtils.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.luxons.sevenwonders.test
-
-import org.springframework.messaging.Message
-import org.springframework.messaging.MessageChannel
-import org.springframework.messaging.simp.SimpMessagingTemplate
-
-fun mockSimpMessagingTemplate(): SimpMessagingTemplate = SimpMessagingTemplate(object : MessageChannel {
-    override fun send(message: Message<*>): Boolean = true
-    override fun send(message: Message<*>, timeout: Long): Boolean = true
-})
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/test/api/SevenWondersClient.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/test/api/SevenWondersClient.kt
deleted file mode 100644
index ee5827cc..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/test/api/SevenWondersClient.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-package org.luxons.sevenwonders.test.api
-
-import com.fasterxml.jackson.databind.module.SimpleModule
-import com.fasterxml.jackson.module.kotlin.KotlinModule
-import org.hildan.jackstomp.JackstompClient
-import org.luxons.sevenwonders.config.SEVEN_WONDERS_WS_ENDPOINT
-import org.luxons.sevenwonders.game.resources.MutableResources
-import org.luxons.sevenwonders.game.resources.Resources
-import org.springframework.messaging.converter.MappingJackson2MessageConverter
-import java.util.concurrent.ExecutionException
-import java.util.concurrent.TimeoutException
-
-class SevenWondersClient {
-
-    private val client: JackstompClient
-
-    init {
-        val customMappingsModule = SimpleModule("ConcreteResourcesDeserializationModule")
-        customMappingsModule.addAbstractTypeMapping(Resources::class.java, MutableResources::class.java)
-
-        val mappingJackson2MessageConverter = MappingJackson2MessageConverter()
-        mappingJackson2MessageConverter.objectMapper.registerModule(customMappingsModule)
-        mappingJackson2MessageConverter.objectMapper.registerModule(KotlinModule())
-
-        client = JackstompClient()
-        client.webSocketClient.messageConverter = mappingJackson2MessageConverter
-    }
-
-    @Throws(InterruptedException::class, ExecutionException::class, TimeoutException::class)
-    fun connect(serverUrl: String): SevenWondersSession {
-        val session = client.syncConnect(serverUrl + SEVEN_WONDERS_WS_ENDPOINT)
-        return SevenWondersSession(session)
-    }
-
-    fun stop() {
-        client.stop()
-    }
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/test/api/SevenWondersSession.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/test/api/SevenWondersSession.kt
deleted file mode 100644
index 70031a71..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/test/api/SevenWondersSession.kt
+++ /dev/null
@@ -1,70 +0,0 @@
-package org.luxons.sevenwonders.test.api
-
-import org.hildan.jackstomp.Channel
-import org.hildan.jackstomp.JackstompSession
-import org.luxons.sevenwonders.actions.ChooseNameAction
-import org.luxons.sevenwonders.actions.CreateGameAction
-import org.luxons.sevenwonders.actions.JoinGameAction
-import org.luxons.sevenwonders.api.LobbyDTO
-import org.luxons.sevenwonders.api.PlayerDTO
-import org.luxons.sevenwonders.errors.ErrorDTO
-import org.luxons.sevenwonders.game.api.PlayerTurnInfo
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertTrue
-
-class SevenWondersSession(val jackstompSession: JackstompSession) {
-
-    fun disconnect() {
-        jackstompSession.disconnect()
-    }
-
-    fun watchErrors(): Channel<ErrorDTO> = jackstompSession.subscribe("/user/queue/errors", ErrorDTO::class.java)
-
-    @Throws(InterruptedException::class)
-    fun chooseName(displayName: String): PlayerDTO {
-        val action = ChooseNameAction(displayName)
-        return jackstompSession.request(action, PlayerDTO::class.java, "/app/chooseName", "/user/queue/nameChoice")
-    }
-
-    fun watchGames(): Channel<Array<LobbyDTO>> {
-        return jackstompSession.subscribe("/topic/games", Array<LobbyDTO>::class.java)
-    }
-
-    @Throws(InterruptedException::class)
-    fun createGame(gameName: String): LobbyDTO {
-        val action = CreateGameAction(gameName)
-        return jackstompSession.request(action, LobbyDTO::class.java, "/app/lobby/create", "/user/queue/lobby/joined")
-    }
-
-    @Throws(InterruptedException::class)
-    fun joinGame(gameId: Long): LobbyDTO {
-        val action = JoinGameAction(gameId)
-        val lobby =
-            jackstompSession.request(action, LobbyDTO::class.java, "/app/lobby/join", "/user/queue/lobby/joined")
-        assertNotNull(lobby)
-        assertEquals(gameId, lobby.id)
-        return lobby
-    }
-
-    fun watchLobbyUpdates(gameId: Long): Channel<LobbyDTO> =
-        jackstompSession.subscribe("/topic/lobby/$gameId/updated", LobbyDTO::class.java)
-
-    fun watchLobbyStart(gameId: Long): Channel<LobbyDTO> =
-        jackstompSession.subscribe("/topic/lobby/$gameId/started", LobbyDTO::class.java)
-
-    @Throws(InterruptedException::class)
-    fun startGame(gameId: Long) {
-        val sendDestination = "/app/lobby/startGame"
-        val receiveDestination = "/topic/lobby/$gameId/started"
-        val received = jackstompSession.request(null, sendDestination, receiveDestination)
-        assertTrue(received)
-    }
-
-    fun sayReady() {
-        jackstompSession.send("/app/game/sayReady", "")
-    }
-
-    fun watchTurns(): Channel<PlayerTurnInfo> =
-        jackstompSession.subscribe("/user/queue/game/turn", PlayerTurnInfo::class.java)
-}
diff --git a/backend/src/test/kotlin/org/luxons/sevenwonders/validation/DestinationAccessValidatorTest.kt b/backend/src/test/kotlin/org/luxons/sevenwonders/validation/DestinationAccessValidatorTest.kt
deleted file mode 100644
index 85d03e99..00000000
--- a/backend/src/test/kotlin/org/luxons/sevenwonders/validation/DestinationAccessValidatorTest.kt
+++ /dev/null
@@ -1,147 +0,0 @@
-package org.luxons.sevenwonders.validation
-
-import org.junit.Before
-import org.junit.Test
-import org.luxons.sevenwonders.lobby.Lobby
-import org.luxons.sevenwonders.lobby.Player
-import org.luxons.sevenwonders.repositories.LobbyNotFoundException
-import org.luxons.sevenwonders.repositories.LobbyRepository
-import kotlin.test.assertFailsWith
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-
-class DestinationAccessValidatorTest {
-
-    private lateinit var lobbyRepository: LobbyRepository
-
-    private lateinit var destinationAccessValidator: DestinationAccessValidator
-
-    @Before
-    fun setup() {
-        lobbyRepository = LobbyRepository()
-        destinationAccessValidator = DestinationAccessValidator(lobbyRepository)
-    }
-
-    private fun createLobby(gameName: String, ownerUsername: String, vararg otherPlayers: String): Lobby {
-        val owner = Player(ownerUsername, ownerUsername)
-        val lobby = lobbyRepository.create(gameName, owner)
-        for (playerName in otherPlayers) {
-            val player = Player(playerName, playerName)
-            lobby.addPlayer(player)
-        }
-        return lobby
-    }
-
-    private fun createGame(gameName: String, ownerUsername: String, vararg otherPlayers: String) {
-        val lobby = createLobby(gameName, ownerUsername, *otherPlayers)
-        lobby.startGame()
-    }
-
-    @Test
-    fun validate_failsOnNullUser() {
-        assertFalse(destinationAccessValidator.hasAccess(null, "doesNotMatter"))
-    }
-
-    @Test
-    fun validate_successWhenNoReference() {
-        assertTrue(destinationAccessValidator.hasAccess("", ""))
-        assertTrue(destinationAccessValidator.hasAccess("", "test"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "test"))
-    }
-
-    @Test
-    fun validate_successWhenNoRefFollows() {
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/game/"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/lobby/"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "prefix/game/"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "prefix/lobby/"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/game//suffix"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/lobby//suffix"))
-    }
-
-    @Test
-    fun validate_successWhenRefIsNotANumber() {
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/game/notANumber"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/lobby/notANumber"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "prefix/game/notANumber"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "prefix/lobby/notANumber"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/game/notANumber/suffix"))
-        assertTrue(destinationAccessValidator.hasAccess("testUser", "/lobby/notANumber/suffix"))
-    }
-
-    @Test
-    fun validate_failWhenNoLobbyExist() {
-        assertFailsWith<LobbyNotFoundException> {
-            destinationAccessValidator.hasAccess("", "/lobby/0")
-        }
-    }
-
-    @Test
-    fun validate_failWhenNoGameExist() {
-        assertFailsWith<LobbyNotFoundException> {
-            destinationAccessValidator.hasAccess("", "/game/0")
-        }
-    }
-
-    @Test
-    fun validate_failWhenReferencedLobbyDoesNotExist() {
-        createLobby("Test Game", "ownerUser1")
-        createLobby("Test Game 2", "ownerUser2")
-        assertFailsWith<LobbyNotFoundException> {
-            destinationAccessValidator.hasAccess("doesNotMatter", "/lobby/3")
-        }
-    }
-
-    @Test
-    fun validate_failWhenReferencedGameDoesNotExist() {
-        createGame("Test Game 1", "user1", "user2", "user3")
-        createGame("Test Game 2", "user4", "user5", "user6")
-        assertFailsWith<LobbyNotFoundException> {
-            destinationAccessValidator.hasAccess("doesNotMatter", "/game/3")
-        }
-    }
-
-    @Test
-    fun validate_failWhenUserIsNotPartOfReferencedLobby() {
-        createLobby("Test Game", "ownerUser")
-        destinationAccessValidator.hasAccess("userNotInLobby", "/lobby/0")
-    }
-
-    @Test
-    fun validate_failWhenUserIsNotPartOfReferencedGame() {
-        createGame("Test Game", "ownerUser", "otherUser1", "otherUser2")
-        destinationAccessValidator.hasAccess("userNotInGame", "/game/0")
-    }
-
-    @Test
-    fun validate_successWhenUserIsOwnerOfReferencedLobby() {
-        createLobby("Test Game 1", "user1")
-        assertTrue(destinationAccessValidator.hasAccess("user1", "/lobby/0"))
-        createLobby("Test Game 2", "user2")
-        assertTrue(destinationAccessValidator.hasAccess("user2", "/lobby/1"))
-    }
-
-    @Test
-    fun validate_successWhenUserIsMemberOfReferencedLobby() {
-        createLobby("Test Game 1", "user1", "user2")
-        assertTrue(destinationAccessValidator.hasAccess("user2", "/lobby/0"))
-        createLobby("Test Game 2", "user3", "user4")
-        assertTrue(destinationAccessValidator.hasAccess("user4", "/lobby/1"))
-    }
-
-    @Test
-    fun validate_successWhenUserIsOwnerOfReferencedGame() {
-        createGame("Test Game 1", "owner1", "user2", "user3")
-        assertTrue(destinationAccessValidator.hasAccess("owner1", "/game/0"))
-        createGame("Test Game 2", "owner4", "user5", "user6")
-        assertTrue(destinationAccessValidator.hasAccess("owner4", "/game/1"))
-    }
-
-    @Test
-    fun validate_successWhenUserIsMemberOfReferencedGame() {
-        createGame("Test Game 1", "owner1", "user2", "user3")
-        assertTrue(destinationAccessValidator.hasAccess("user2", "/game/0"))
-        createGame("Test Game 2", "owner4", "user5", "user6")
-        assertTrue(destinationAccessValidator.hasAccess("user6", "/game/1"))
-    }
-}