refactoring: Masive refactor to build the V2

.github/workflows/tests.yml

@@ -18,10 +18,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Set up JDK 21
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'
@@ -31,7 +31,7 @@ jobs:
         run: echo "key=gradle-${{ runner.os }}-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}" >> $GITHUB_OUTPUT
 
       - name: Cache Gradle dependencies
-        uses: actions/cache@v6
+        uses: actions/cache@v3
         with:
           path: |
             ~/.gradle/caches
@@ -48,16 +48,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Set up JDK 21
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'
 
       - name: Restore Gradle cache
-        uses: actions/cache@v6
+        uses: actions/cache@v3
         with:
           path: |
             ~/.gradle/caches
@@ -73,7 +73,7 @@ jobs:
         run: ./gradlew ktlintCheck
 
       - name: Publish ktlint report
-        uses: yutailang0119/action-ktlint@v5
+        uses: yutailang0119/action-ktlint@v4
         if: always()
         with:
           report-path: build/reports/ktlint/**/*.xml
@@ -84,16 +84,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Set up JDK 21
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'
 
       - name: Restore Gradle cache
-        uses: actions/cache@v6
+        uses: actions/cache@v3
         with:
           path: |
             ~/.gradle/caches
@@ -106,20 +106,20 @@ jobs:
         run: chmod +x gradlew
 
       - name: Start CI Docker Compose services
-        run: ./gradlew ciComposeUp -Pci
+        run: ./gradlew composeUp -Pci
 
       - name: Run tests
-        run: ./gradlew test -x ciComposeUp -Pci --no-daemon
+        run: ./gradlew test -x composeUp --no-daemon
 
       - name: Upload test reports
         if: always()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: test-results
           path: build/reports/tests/test
 
       - name: Publish Test Report
-        uses: dorny/test-reporter@v3
+        uses: dorny/test-reporter@v1
         if: always()
         with:
           name: JUnit Tests

.run/docker composeUp.run.xml

@@ -1,27 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="docker composeUp" type="GradleRunConfiguration" factoryName="Gradle">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="composeUp" />
-        </list>
-      </option>
-      <option name="vmOptions" />
-    </ExternalSystemSettings>
-    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
-    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
-    <ExternalSystemDebugDisabled>false</ExternalSystemDebugDisabled>
-    <DebugAllEnabled>false</DebugAllEnabled>
-    <RunAsTest>false</RunAsTest>
-    <GradleProfilingDisabled>false</GradleProfilingDisabled>
-    <GradleCoverageDisabled>false</GradleCoverageDisabled>
-    <method v="2" />
-  </configuration>
-</component>

build.gradle.kts

@@ -1,4 +1,3 @@
-import com.avast.gradle.dockercompose.ComposeExtension
 import org.jlleitschuh.gradle.ktlint.KtlintExtension
 
 val ktorVersion: Provider<String> = providers.gradleProperty("ktor_version")
@@ -50,42 +49,29 @@ tasks.withType<Test>().configureEach {
   useJUnitPlatform()
 }
 
-configure<ComposeExtension> {
+dockerCompose {
-  createNested("test").apply {
+  val composeFile =
-    useComposeFiles.set(listOf("docker/docker-compose-test.yaml"))
+    if (project.hasProperty("ci")) {
+      // Use docker-compose-ci.yaml for the CI
+      "docker/docker-compose-ci.yaml"
+    } else {
+      // Use docker-compose-test.yaml for local tests
+      "docker/docker-compose-test.yaml"
+    }
+  useComposeFiles.set(listOf(composeFile))
   setProjectName("event-demo-test")
 }
-  createNested("dev").apply {
-    useComposeFiles.set(listOf("docker/docker-compose-dev.yaml"))
-    setProjectName("event-demo-dev")
-  }
-  createNested("ci").apply {
-    useComposeFiles.set(listOf("docker/docker-compose-ci.yaml"))
-    setProjectName("event-demo-ci")
-  }
-}
 
 tasks.test {
-  if (project.hasProperty("ci")) {
+  dependsOn("composeUp")
-    dependsOn("ciComposeUp")
+  dockerCompose.useComposeFiles.set(listOf("docker/docker-compose-test.yaml"))
-  } else {
+  dockerCompose.setProjectName("event-demo-test")
-    dependsOn("testComposeUp")
-  }
 }
+
 tasks.named("run") {
-  dependsOn("devComposeUp")
+  dependsOn("composeUp")
-}
+  dockerCompose.useComposeFiles.set(listOf("docker/docker-compose-test.yaml"))
-tasks.composeUp {
+  dockerCompose.setProjectName("event-demo-dev")
-  dependsOn("copyEnv")
-}
-tasks.named("devComposeUp") {
-  dependsOn("copyEnv")
-}
-tasks.named("testComposeUp") {
-  dependsOn("copyEnv")
-}
-tasks.named("ciComposeUp") {
-  dependsOn("copyEnv")
 }
 
 tasks.register<Copy>("copyEnv") {
@@ -102,15 +88,13 @@ tasks.register<Copy>("copyEnv") {
       exclude()
     }
   }
-  val files =
-    buildList {
-      add(File("docker/postgresql.secret"))
-      if (!project.hasProperty("ci")) {
-        add(File("docker/pgadmin.secret"))
-      }
-    }
-  outputs.files(*files.toTypedArray())
   doLast {
+    val files =
+      listOf(
+        File("docker/pgadmin.secret"),
+        File("docker/postgresql.secret"),
+      )
+
     files.forEach {
       if (!it.exists()) {
         it.writeText("changeit")
@@ -118,6 +102,9 @@ tasks.register<Copy>("copyEnv") {
     }
   }
 }
+tasks.composeUp {
+  dependsOn("copyEnv")
+}
 
 dependencies {
   implementation("io.ktor:ktor-server-core-jvm")

docker/docker-compose-ci.yaml

@@ -1,5 +1,6 @@
-name: event-demo-ci
+name: event-demo-test
 include:
   - path:
     - parts/docker-compose-databases.yaml
     - parts/docker-compose-databases-expose.yaml
+    - parts/docker-compose-traefik.yaml

docker/docker-compose-dev.yaml

@@ -1,4 +0,0 @@
-name: event-demo-test
-include:
-  - path:
-    - docker-compose-test.yaml

docker/parts/docker-compose-databases.yaml

@@ -24,6 +24,8 @@ services:
     environment:
       POSTGRES_PASSWORD_FILE: /run/secrets/postgresql_password
       POSTGRES_USER: event-demo
+    secrets:
+      - postgresql_password
     healthcheck:
       test: ["CMD-SHELL", "sh -c 'pg_isready -U event-demo'"]
       interval: 1s
@@ -31,7 +33,6 @@ services:
       retries: 10
     volumes:
       - postgresql_data:/var/lib/postgresql
-      - ../postgresql.secret:/run/secrets/postgresql_password:ro
 
   rabbitmq:
     image: rabbitmq:4-management-alpine
@@ -46,6 +47,10 @@ services:
     volumes:
       - rabbitmq_data:/var/lib/rabbitmq/
 
+secrets:
+  postgresql_password:
+    file: ../postgresql.secret
+
 volumes:
   redis_data:
   redisinsight_data:

docker/parts/docker-compose-tools.yaml

@@ -4,20 +4,10 @@ services:
     environment:
       PGADMIN_DEFAULT_EMAIL: $PGADMIN_DEFAULT_EMAIL
       PGADMIN_DEFAULT_PASSWORD_FILE: /run/secrets/pgadmin_password
-      PGADMIN_CONFIG_SERVER_MODE: 'False'
-      PGADMIN_CONFIG_MASTER_PASSWORD_REQUIRED: 'False'
     secrets:
       - pgadmin_password
     volumes:
       - pgadmin_data:/var/lib/pgadmin
-    configs:
-      - source: pgpass
-        target: /pgpass
-        mode: 0600
-        uid: "5050"
-        gid: "5050"
-      - source: servers_json
-        target: /pgadmin4/servers.json
     labels:
       - "traefik.http.routers.pgadmin.rule=Host(`pgadmin.postgresql.traefik.me`)"
       - "traefik.http.services.pgadmin.loadbalancer.server.port=80"
@@ -34,27 +24,6 @@ services:
       - "traefik.http.routers.rabbitmq-management.service=rabbitmq-management"
       - "traefik.http.services.rabbitmq-management.loadbalancer.server.port=15672"
 
-configs:
-  pgpass:
-    content: |
-      *:*:*:event-demo:changeit
-  servers_json:
-    content: |
-      {
-        "Servers": {
-          "1": {
-            "Name": "Event demo",
-            "Group": "Servers",
-            "Host": "postgresql",
-            "Port": 5432,
-            "MaintenanceDB": "event-demo",
-            "Username": "event-demo",
-            "PassFile": "/pgpass",
-            "SSLMode": "prefer"
-          }
-        }
-      }
-
 secrets:
   pgadmin_password:
     file: ../pgadmin.secret

src/main/kotlin/eventDemo/contexts/game/application/command/handlers/GameEventManager.kt

@@ -37,8 +37,16 @@ abstract class GameEventManager(
     return this
   }
 
-  protected inline fun <reified G : Game> Game.isStatusOrFail(message: String): G =
+  protected fun <G : Game> Game.isStatusOrFail(
-    this as? G ?: throw CommandException(message)
+    kClass: KClass<G>,
+    message: String,
+  ): G {
+    if (kClass.isInstance(this)) {
+      return this as G
+    } else {
+      throw CommandException(message)
+    }
+  }
 
   protected fun <T> retry(
     mapAttempts: Int = 5,

src/main/kotlin/eventDemo/contexts/game/application/command/handlers/JoinTheGameHandler.kt

@@ -20,7 +20,7 @@ class JoinTheGameHandler(
     retry {
       command
         .getGame()
-        .isStatusOrFail<GameCreated>("The game is started")
+        .isStatusOrFail(GameCreated::class, "The game is started")
         .userJoinTheGame(
           userId = command.userId,
           name = user.username,

src/main/kotlin/eventDemo/contexts/game/application/command/handlers/PlayCardHandler.kt

@@ -16,7 +16,7 @@ class PlayCardHandler(
   override fun handle(command: PlayCardCommand) {
     command
       .getGame()
-      .isStatusOrFail<GameStarted>("The game is not started")
+      .isStatusOrFail(GameStarted::class, "The game is not started")
       .playTheCard(
         card = command.payload.card,
         playerId = command.payload.playerId,

src/main/kotlin/eventDemo/contexts/game/application/command/handlers/ReadyToPlayHandler.kt

@@ -16,7 +16,7 @@ class ReadyToPlayHandler(
   override fun handle(command: ReadyToPlayCommand) {
     command
       .getGame()
-      .isStatusOrFail<GameCreated>("The game is started")
+      .isStatusOrFail(GameCreated::class, "The game is started")
       .setReadyPlayer(command.payload.playerId)
       .saveEvents()
       .publishEvents()

src/main/kotlin/eventDemo/contexts/game/application/command/handlers/TakeCartFromDrawPileHandler.kt

@@ -18,7 +18,7 @@ class TakeCartFromDrawPileHandler(
   override fun handle(command: TakeCartFromDrawPileCommand) {
     command
       .getGame()
-      .isStatusOrFail<GameStarted>("The game is not started")
+      .isStatusOrFail(GameStarted::class, "The game is not started")
       .playerTakeCartFromDrawPile(command.payload.playerId, 1)
       .saveEvents()
       .publishEvents()

src/main/kotlin/eventDemo/contexts/game/application/notification/EventToNotification.kt

@@ -24,10 +24,6 @@ import eventDemo.contexts.game.domain.events.PlayerWinEvent
 import eventDemo.contexts.game.domain.game.gameState.Game
 import eventDemo.contexts.game.domain.game.gameState.GameStarted
 import eventDemo.sharedKernel.UserId
-import io.github.oshai.kotlinlogging.KotlinLogging
-import io.github.oshai.kotlinlogging.withLoggingContext
-
-private val logger = KotlinLogging.logger {}
 
 fun GameEvent.toNotification(
   game: Game,
@@ -35,16 +31,15 @@ fun GameEvent.toNotification(
 ): Iterable<Notification> =
   Iterable {
     iterator {
+      val currentPlayerId = game.players.get(currentUserId).id
+
       context(iterator: SequenceScope<Notification>)
       suspend fun Notification.send() {
-        withLoggingContext("notification" to (this).toString()) {
-          logger.info { "Notification sent" }
         iterator.yield(this)
       }
-      }
 
       fun PlayerActionEvent.isFromCurrentUser(): Boolean =
-        game.players.get(currentUserId).id == playerId
+        currentPlayerId != playerId
 
       when (this@toNotification) {
         is GameCreatedEvent -> {
@@ -56,7 +51,7 @@ fun GameEvent.toNotification(
         }
 
         is NewPlayerEvent -> {
-          if (this@toNotification.player.userId != currentUserId) {
+          if (this@toNotification.isFromCurrentUser()) {
             PlayerAsJoinTheGameNotification(
               player = this@toNotification.player,
             ).send()
@@ -90,7 +85,6 @@ fun GameEvent.toNotification(
 
           if (game is GameStarted) {
             ItsTheTurnOfNotification(player = game.nextPlayer)
-              .send()
           }
         }
 
@@ -107,20 +101,21 @@ fun GameEvent.toNotification(
 
           if (game is GameStarted) {
             ItsTheTurnOfNotification(player = game.nextPlayer)
-              .send()
           }
         }
 
         is PlayerReadyEvent -> {
+          if (this@toNotification.isFromCurrentUser()) {
             PlayerWasReadyNotification(
               playerId = this@toNotification.playerId,
-          ).send()
+            )
+          }
         }
 
         is PlayerWinEvent -> {
           PlayerWinNotification(
             playerId = this@toNotification.playerId,
-          ).send()
+          )
         }
       }
     }

src/main/kotlin/eventDemo/contexts/game/application/reaction/ReactionListener.kt

@@ -48,7 +48,7 @@ class ReactionListener(
   }
 
   private fun sendWinnerEvent(game: Game) {
-    if (game is GameStarted && game.lastPlayerId != null) {
+    if (game is GameStarted) {
       val lastPlayerWin =
         game
           .players

src/main/kotlin/eventDemo/contexts/game/domain/events/GameStartedEvent.kt

@@ -4,7 +4,6 @@ import eventDemo.contexts.game.domain.game.DiscardPile
 import eventDemo.contexts.game.domain.game.DrawPile
 import eventDemo.contexts.game.domain.game.GameId
 import eventDemo.contexts.game.domain.game.Player
-import eventDemo.contexts.game.domain.game.PlayerHand
 import eventDemo.contexts.game.infrastructure.persistence.serializers.EventIdSerializer
 import eventDemo.contexts.game.infrastructure.persistence.serializers.PlayerIdSerializer
 import eventDemo.libs.eventSource.EventId
@@ -21,7 +20,6 @@ data class GameStartedEvent(
   override val aggregateId: GameId,
   @Serializable(with = PlayerIdSerializer::class)
   val firstPlayer: Player.PlayerId,
-  val playersHans: Map<Player.PlayerId, PlayerHand>,
   val drawPile: DrawPile,
   val discardPile: DiscardPile,
   override val version: Int,
@@ -30,3 +28,9 @@ data class GameStartedEvent(
   override val eventId: EventId = EventId(UUID.randomUUID())
   override val createdAt: Instant = Clock.System.now()
 }
+
+private var isDisabled = false
+
+internal fun disableShuffleDeck() {
+  isDisabled = true
+}

src/main/kotlin/eventDemo/contexts/game/domain/game/DrawPile.kt

@@ -7,8 +7,6 @@ import kotlinx.serialization.Serializable
 value class DrawPile(
   val cards: Set<Card> = emptySet(),
 ) {
-  val size: Int get() = cards.size
-
   fun take(number: Int): Pair<DrawPile, Set<Card>> =
     cards.drop(number).toDrawPile() to cards.take(number).toSet()
 

src/main/kotlin/eventDemo/contexts/game/domain/game/Player.kt

@@ -25,7 +25,6 @@ data class Player(
   }
 }
 
-@Serializable
 class PlayerList(
   val players: Set<Player> = emptySet(),
 ) : Set<Player> by players {

src/main/kotlin/eventDemo/contexts/game/domain/game/gameState/Game.kt

@@ -39,8 +39,7 @@ sealed interface Game {
 
   companion object {
     fun loadFromHistory(events: Set<GameEvent>): Game =
-      events
+      events.fold(GameInit(events.first().aggregateId)) { game: Game, event ->
-        .fold(GameInit(events.first().aggregateId)) { game: Game, event ->
         game.run {
           when (event) {
             is GameCreatedEvent if this is GameInit -> applyEvent(event)
@@ -61,13 +60,6 @@ sealed interface Game {
             is DrawFilledWithDiscardEvent -> error("Game is end")
           }
         }
-        }.let {
-          when (it) {
-            is GameInit -> it
-            is GameCreated -> it.copy(recordedEvents = emptySet())
-            is GameEnded -> it.copy(recordedEvents = emptySet())
-            is GameStarted -> it.copy(recordedEvents = emptySet())
-          }
       }
   }
 }
@@ -79,3 +71,18 @@ internal fun <T : GameEvent> T.checkState(
   if (!block(this)) throw exception(this)
   return this
 }
+
+/**
+ * recordedEvents versions must be ordered and incremental.
+ */
+internal fun Game.checkRecorderEventsConsistency() {
+  recordedEvents
+    .also { if (it.size != (it.lastOrNull()?.version ?: 0)) throw InconsistentEventVersionException(recordedEvents) }
+    .mapIndexed { index, event ->
+      (index + 1) == event.version
+    }.run {
+      if (any { !it }) {
+        throw InconsistentEventVersionException(recordedEvents)
+      }
+    }
+}

src/main/kotlin/eventDemo/contexts/game/domain/game/gameState/GameCreated.kt

@@ -9,7 +9,6 @@ import eventDemo.contexts.game.domain.game.DiscardPile
 import eventDemo.contexts.game.domain.game.DrawPile
 import eventDemo.contexts.game.domain.game.GameId
 import eventDemo.contexts.game.domain.game.Player
-import eventDemo.contexts.game.domain.game.PlayerHand
 import eventDemo.contexts.game.domain.game.PlayerList
 import eventDemo.contexts.game.domain.game.errors.AllPlayerNotReadyException
 import eventDemo.contexts.game.domain.game.errors.DeckMissingCardsException
@@ -24,28 +23,24 @@ data class GameCreated(
   override val recordedEvents: Set<GameEvent>,
   override val version: Int,
 ) : Game {
+  init {
+    checkRecorderEventsConsistency()
+  }
+
   val allPlayerIsReady: Boolean
     get() {
-      return playersStatus.isNotEmpty() && playersStatus.values.all { it == PlayerStatus.Ready }
+      return playersStatus.values.all { it == PlayerStatus.Ready }
     }
 
   fun startGame(deck: Deck = newDeck().shuffleDeck()): GameStarted {
-    val (drawPile, discardPile, playersHands) =
+    val (drawPile, discardPile) = initPiles(deck)
-      initPiles(deck)
-        .let { (drawPile, discardPile) ->
-          createHandsFromDrawPile(drawPile)
-            .let { (drawPile, playersHands) ->
-              Triple(drawPile, discardPile, playersHands)
-            }
-        }
 
     return GameStartedEvent(
       aggregateId = aggregateId,
-      firstPlayer = players.randomPlayer().id,
+      firstPlayer = players.random().id,
       version = version + 1,
       drawPile = drawPile,
       discardPile = discardPile,
-      playersHans = playersHands,
     ).checkState(
       { players.size > 1 },
       { NeedMorePlayersToStartGameException(players) },
@@ -55,8 +50,7 @@ data class GameCreated(
     ).checkState(
       { deck.size == 108 },
       { DeckMissingCardsException(players, deck) },
-    ).also { if (it.drawPile.size + it.discardPile.size + playersHands.values.sumOf { it.size } != 108) error("missing cards!") }
+    ).run(::applyEvent)
-      .run(::applyEvent)
   }
 
   private fun initPiles(deck: Set<Card>): Pair<DrawPile, DiscardPile> =
@@ -67,20 +61,6 @@ data class GameCreated(
         draw to DiscardPile(cards)
       }
 
-  private fun createHandsFromDrawPile(drawPile: DrawPile) =
-    players
-      .map { it.id }
-      .fold(Pair(drawPile, emptyMap<Player.PlayerId, PlayerHand>())) { (drawAcc, handsAcc), playerId ->
-        drawAcc
-          .take(7)
-          .let { (draw, hand) ->
-            Pair(
-              draw,
-              handsAcc + (playerId to PlayerHand(hand)),
-            )
-          }
-      }
-
   fun userJoinTheGame(
     userId: UserId,
     name: String,
@@ -127,13 +107,8 @@ data class GameCreated(
   internal fun applyEvent(event: GameStartedEvent): GameStarted =
     GameStarted(
       aggregateId = event.aggregateId,
-      players =
+      players = players,
-        players
+      lastPlayerId = event.firstPlayer,
-          .map {
-            it.copy(hand = event.playersHans[it.id] ?: error("Player ${it.id} not found"))
-          }.let { PlayerList(it.toSet()) },
-      lastPlayerId = null,
-      nextPlayerId = event.firstPlayer,
       drawPile = event.drawPile,
       discardPile = event.discardPile,
       version = event.version + 1,
@@ -158,22 +133,7 @@ fun newDeck(): Deck =
         (1..2).map { Card.PassCard(color) }
     }.let {
       it + (1..4).map { Card.Plus4Card() }
-    }.let {
-      it + (1..4).map { Card.ChangeColorCard() }
     }.toSet()
 
-fun Set<Card>.shuffleDeck(): Set<Card> {
+fun Set<Card>.shuffleDeck() =
-  if (isDisabled) return this
+  shuffled().toSet()
-  return shuffled().toSet()
-}
-
-private fun PlayerList.randomPlayer(): Player {
-  if (isDisabled) return first()
-  return random()
-}
-
-private var isDisabled = false
-
-fun disableRandomForTest() {
-  isDisabled = true
-}

src/main/kotlin/eventDemo/contexts/game/domain/game/gameState/GameEnded.kt

@@ -16,5 +16,6 @@ data class GameEnded(
     if (!players.map { it.id }.containsAll(playerWins)) {
       throw IllegalArgumentException("Player ${players.map { it.id }} were not in players")
     }
+    checkRecorderEventsConsistency()
   }
 }

src/main/kotlin/eventDemo/contexts/game/domain/game/gameState/GameStarted.kt

@@ -23,14 +23,41 @@ import eventDemo.contexts.game.domain.game.errors.ThePlayerIsNotInTheGameExcepti
 import eventDemo.contexts.game.domain.game.errors.ThePlayerMustPlayACardException
 import eventDemo.contexts.game.domain.game.gameState.Game.Direction
 
-fun PlayerList.nextPlayerTurn(
+data class GameStarted(
-  lastPlayerId: Player.PlayerId,
+  override val aggregateId: GameId,
-  direction: Direction,
+  override val players: PlayerList,
-): Player.PlayerId {
+  val drawPile: DrawPile,
-  val lastPlayer = get(lastPlayerId)
+  val discardPile: DiscardPile,
-  val playersLastTurn = filter { it.hand.cards.isNotEmpty() || it == lastPlayer }
+  val lastPlayerId: Player.PlayerId,
+  val currentColor: Color,
+  val playedTurnHistory: List<History> = emptyList(),
+  val direction: Direction = Direction.CLOCKWISE,
+  val playerWins: Set<Player.PlayerId> = emptySet(),
+  override val version: Int,
+  override val recordedEvents: Set<GameEvent>,
+) : Game {
+  val playersInGame by lazy { players.filter { it.hand.cards.isNotEmpty() } }
 
-  return playersLastTurn
+  val lastPlayedCard: Card? by lazy { discardPile.topCard }
+
+  val lastPlayed: Player by lazy { players.get(lastPlayerId) }
+
+  init {
+    checkRecorderEventsConsistency()
+  }
+
+  data class History(
+    val playerId: Player.PlayerId,
+    val event: GameEvent,
+    val direction: Direction,
+  )
+
+  val lastPlayer by lazy { players.get(lastPlayerId) }
+
+  val nextPlayer: Player by lazy {
+    val playersLastTurn = players.filter { it.hand.cards.isNotEmpty() || it == lastPlayer }
+
+    playersLastTurn
       .indexOf(lastPlayer)
       .let { lastPlayerIndex ->
         if (direction == Direction.CLOCKWISE) {
@@ -46,37 +73,9 @@ fun PlayerList.nextPlayerTurn(
             lastPlayerIndex - 1
           }
         }
-    }.let { nextPlayerIndex -> elementAt(nextPlayerIndex).id }
+      }.let { nextPlayerIndex -> players.elementAt(nextPlayerIndex) }
   }
 
-data class GameStarted(
-  override val aggregateId: GameId,
-  override val players: PlayerList,
-  val drawPile: DrawPile,
-  val discardPile: DiscardPile,
-  val lastPlayerId: Player.PlayerId?,
-  val nextPlayerId: Player.PlayerId,
-  val currentColor: Color,
-  val playedTurnHistory: List<History> = emptyList(),
-  val direction: Direction = Direction.CLOCKWISE,
-  val playerWins: Set<Player.PlayerId> = emptySet(),
-  override val version: Int,
-  override val recordedEvents: Set<GameEvent>,
-) : Game {
-  val playersInGame by lazy { players.filter { it.hand.cards.isNotEmpty() } }
-
-  val lastPlayedCard: Card? by lazy { discardPile.topCard }
-
-  data class History(
-    val playerId: Player.PlayerId,
-    val event: GameEvent,
-    val direction: Direction,
-  )
-
-  val lastPlayer: Player? by lazy { lastPlayerId?.let { players.get(it) } }
-
-  val nextPlayer: Player by lazy { players.get(nextPlayerId) }
-
   fun canBePlayThisCard(card: Card): Boolean {
     val cardOnBoard = discardPile.topCard ?: return false
     return when (cardOnBoard) {
@@ -145,12 +144,8 @@ data class GameStarted(
   ): GameStarted =
     CardIsPlayedEvent(aggregateId, card, playerId, chosenColor, version + 1)
       .checkPlayerTurn()
-      .checkState({
+      .checkState({ card is Card.CardWithColor && chosenColor != null }, { TheCardIsAColorCardException(playerId) })
-        (card is Card.CardWithColor && chosenColor == null) || card is Card.CardWith4Color
+      .checkState({ card is Card.CardWith4Color && chosenColor == null }, { TheCardHasNoColorException(playerId) })
-      }, { TheCardIsAColorCardException(playerId) })
-      .checkState({
-        (card is Card.CardWith4Color && chosenColor != null) || card is Card.CardWithColor
-      }, { TheCardHasNoColorException(playerId) })
       .run(::applyEvent)
 
   internal fun applyEvent(event: CardIsPlayedEvent): GameStarted =
@@ -172,7 +167,6 @@ data class GameStarted(
         discardPile = discardPile.withNewCard(card = event.card),
         currentColor = color,
         lastPlayerId = event.playerId,
-        nextPlayerId = players.nextPlayerTurn(event.playerId, nextDirectionAfterPlay),
         playedTurnHistory = playedTurnHistory - History(event.playerId, event, direction),
         direction = nextDirectionAfterPlay,
         version = event.version,
@@ -208,8 +202,6 @@ data class GameStarted(
     copy(
       players = players.withNewCardOnPlayerHand(event.playerId, event.takenCards),
       drawPile = drawPile.take(event.takenCards.size).first,
-      lastPlayerId = event.playerId,
-      nextPlayerId = players.nextPlayerTurn(event.playerId, direction),
       version = event.version,
       recordedEvents = recordedEvents + event,
     )

src/main/kotlin/eventDemo/contexts/game/infrastructure/websocket/GameCommandRouteWebSocket.kt

@@ -16,7 +16,7 @@ fun Route.gameWebSocket(channelSubscriber: GameChannelsSubscriber) {
   authenticate {
     webSocket("/games/{id}") {
       channelSubscriber.subscribePlayerToGameChannels(
-        gameId = GameId(UUID.fromString(call.parameters["id"]!!)),
+        gameId = GameId(UUID.nameUUIDFromBytes(call.parameters["id"]?.encodeToByteArray()!!)),
         userId = call.currentUserId,
         incomingCommandChannel = toObjectChannel(incoming),
         sendNotificationChannel = fromFrameChannel(outgoing),

src/main/kotlin/eventDemo/libs/bus/BusInRabbitMQ.kt

@@ -78,11 +78,7 @@ class BusInRabbitMQ<E>(
                 body: ByteArray,
               ) {
                 runBlocking {
-                  val obj = stringToObject(body.toString(Charsets.UTF_8))
+                  block(stringToObject(body.toString(Charsets.UTF_8)))
-                  withLoggingContext("item" to obj.toString()) {
-                    logger.info { "Received delivery of $exchangeName" }
-                  }
-                  block(obj)
                 }
                 channel.basicAck(envelope.deliveryTag, false)
               }

src/test/kotlin/eventDemo/contexts/game/application/GameSimulationTest.kt

@@ -1,8 +1,6 @@
 package eventDemo.contexts.game.application
 
 import eventDemo.Tag
-import eventDemo.contexts.auth.application.eventStores.UserRepository
-import eventDemo.contexts.auth.domain.User
 import eventDemo.contexts.game.application.channels.GameChannelsSubscriber
 import eventDemo.contexts.game.application.command.models.GameCommand
 import eventDemo.contexts.game.application.eventStores.GameRepository
@@ -13,11 +11,11 @@ import eventDemo.contexts.game.application.notification.models.PlayerAsPlayACard
 import eventDemo.contexts.game.application.notification.models.PlayerWasReadyNotification
 import eventDemo.contexts.game.application.notification.models.TheGameWasStartedNotification
 import eventDemo.contexts.game.application.notification.models.WelcomeToTheGameNotification
+import eventDemo.contexts.game.domain.events.disableShuffleDeck
 import eventDemo.contexts.game.domain.game.Card
 import eventDemo.contexts.game.domain.game.GameId
 import eventDemo.contexts.game.domain.game.gameState.Game
 import eventDemo.contexts.game.domain.game.gameState.GameStarted
-import eventDemo.contexts.game.domain.game.gameState.disableRandomForTest
 import eventDemo.testHelpers.CreateGameWithCommandsInChannelsHelpers.createGameWithCommandsInChannels
 import eventDemo.testHelpers.CreateGameWithCommandsInChannelsHelpers.joinTheGame
 import eventDemo.testHelpers.CreateGameWithCommandsInChannelsHelpers.playCard
@@ -27,11 +25,7 @@ import eventDemo.testHelpers.testKoinApplicationWithConfig
 import io.kotest.assertions.nondeterministic.eventually
 import io.kotest.assertions.nondeterministic.until
 import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldContainExactly
 import io.kotest.matchers.equals.shouldBeEqual
-import io.kotest.matchers.equals.shouldEqual
-import io.kotest.matchers.nulls.shouldNotBeNull
-import io.kotest.matchers.types.shouldBeInstanceOf
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
@@ -50,7 +44,7 @@ class GameSimulationTest :
 
     test("Simulation of a game") {
       withTimeout(10.seconds) {
-        disableRandomForTest()
+        disableShuffleDeck()
         val gameId = GameId()
         val user1 = createNewUser("user1")
         val user2 = createNewUser("user2")
@@ -67,11 +61,6 @@ class GameSimulationTest :
 
         testKoinApplicationWithConfig {
           val gameRepository = get<GameRepository>()
-          val userRepository = get<UserRepository>()
-          userRepository.run {
-            save(user1)
-            save(user2)
-          }
 
           gameRepository.create(gameId)
 
@@ -115,9 +104,8 @@ class GameSimulationTest :
           // Player 1 actions
           val player1Job =
             launch {
-              createGameWithCommandsInChannels(channelCommand1, gameId, user1) {
+              createGameWithCommandsInChannels(channelCommand1) { getPlayer ->
-
+                user1.joinTheGame()
-                joinTheGame()
                 player1Notifications.waitNotification<WelcomeToTheGameNotification> {
                   players.map { it.userId }.contains(user1.id)
                 }
@@ -128,38 +116,20 @@ class GameSimulationTest :
                   player.userId == user2.id
                 }
 
-                readyToPlay()
+                getPlayer(user1).readyToPlay()
                 player1Notifications.waitNotification<PlayerWasReadyNotification> {
                   playerId == getPlayer(user2).id
                 }
 
-                playedCard1 =
+                val player1Hand =
-                  player1Notifications
+                  player1Notifications.waitNotification<TheGameWasStartedNotification> { hand.size == 7 }.hand
-                    .waitNotification<TheGameWasStartedNotification> { hand.size == 7 }
-                    .hand
-                    .first()
-                    .apply {
-                      this.shouldBeInstanceOf<Card.NumericCard>()
-                      number shouldEqual 1
-                      color shouldEqual Card.Color.Red
-                    }
 
+                playedCard1 = player1Hand.first()
                 player1Notifications.waitNotification<ItsTheTurnOfNotification> {
-                  if (player.userId == user2.id) error("WRONG PLAYER TURN")
                   player.userId == user1.id
                 }
 
-                game
+                getPlayer(user1).playCard(playedCard1!!, null)
-                  .shouldBeInstanceOf<GameStarted>()
-                  .discardPile
-                  .topCard
-                  .shouldNotBeNull()
-                  .shouldBeInstanceOf<Card.NumericCard> {
-                    it.number shouldEqual 0
-                    it.color shouldEqual Card.Color.Red
-                  }
-
-                playCard(playedCard1!!)
 
                 player1Notifications.waitNotification<ItsTheTurnOfNotification> {
                   player == getPlayer(user2)
@@ -169,18 +139,8 @@ class GameSimulationTest :
                   playerId == getPlayer(user2).id && card == playedCard2
                 }
 
-                playedCard1 =
+                playedCard1 = player1Hand.elementAt(1)
-                  assertInstanceOf<GameStarted>(game)
+                getPlayer(user1).playCard(playedCard1)
-                    .playableCards(currentPlayer.id)
-                    .first()
-
-                playedCard1.run {
-                  this.shouldBeInstanceOf<Card.NumericCard>()
-                  number shouldEqual 2
-                  color shouldEqual Card.Color.Red
-                }
-
-                playCard(playedCard1)
 
                 player1Notifications.waitNotification<ItsTheTurnOfNotification> {
                   player == getPlayer(user2)
@@ -191,11 +151,11 @@ class GameSimulationTest :
           // Player 2 actions
           val player2Job =
             launch {
-              createGameWithCommandsInChannels(channelCommand2, gameId, user2) {
+              createGameWithCommandsInChannels(channelCommand2) { getPlayer ->
                 // wait player 1 has joined the game
                 until(3.seconds) { player1HasJoin }
 
-                joinTheGame()
+                user2.joinTheGame()
 
                 player2Notifications.waitNotification<WelcomeToTheGameNotification> {
                   players.map { it.userId }.contains(user1.id) &&
@@ -203,48 +163,30 @@ class GameSimulationTest :
                 }
                 player2Notifications.waitNotification<PlayerWasReadyNotification> { playerId == getPlayer(user1).id }
 
-                readyToPlay()
+                getPlayer(user2).readyToPlay()
 
-                playedCard2 =
+                val player2Hand =
-                  player2Notifications
+                  player2Notifications.waitNotification<TheGameWasStartedNotification> { hand.size == 7 }.hand
-                    .waitNotification<TheGameWasStartedNotification> { hand.size == 7 }
-                    .hand
-                    .first()
-                    .apply {
-                      this.shouldBeInstanceOf<Card.NumericCard>()
-                      number shouldEqual 8
-                      color shouldEqual Card.Color.Red
-                    }
 
                 player2Notifications.waitNotification<ItsTheTurnOfNotification> {
-                  if (player.userId == user2.id) error("WRONG PLAYER TURN")
                   player.userId == user1.id
                 }
                 player2Notifications.waitNotification<PlayerAsPlayACardNotification> {
                   playerId == getPlayer(user1).id && card == playedCard1
                 }
+                playedCard2 = player2Hand.first()
 
                 player2Notifications.waitNotification<ItsTheTurnOfNotification> {
-                  player == currentPlayer
+                  player == getPlayer(user2)
                 }
 
-                game
+                getPlayer(user2).playCard(playedCard2)
-                  .shouldBeInstanceOf<GameStarted>()
-                  .discardPile
-                  .topCard
-                  .shouldNotBeNull()
-                  .shouldBeInstanceOf<Card.NumericCard> {
-                    it.number shouldEqual 1
-                    it.color shouldEqual Card.Color.Red
-                  }
-
-                playCard(playedCard2)
 
                 player2Notifications.waitNotification<ItsTheTurnOfNotification> {
                   player.userId == user1.id
                 }
                 player2Notifications.waitNotification<PlayerAsPlayACardNotification> {
-                  playerId == currentPlayer.id && card == playedCard2
+                  playerId == getPlayer(user2).id && card == playedCard2
                 }
               }
             }
@@ -258,25 +200,20 @@ class GameSimulationTest :
 
           // Check if the state is correct
           game.aggregateId shouldBeEqual gameId
-          game.players.map { it.userId } shouldContainExactly setOf(user1.id, user2.id)
+          game.players.map { it.id } shouldBeEqual setOf(user1.id, user2.id)
           assertNotNull(game.players.find { it.userId == user1.id })
             .hand.size shouldBeEqual 5
           assertNotNull(game.players.find { it.userId == user2.id })
             .hand.size shouldBeEqual 6
           game.direction shouldBeEqual Game.Direction.CLOCKWISE
-          assertNotNull(game.lastPlayer?.userId) shouldBeEqual user1.id
+          assertNotNull(game.lastPlayed.userId) shouldBeEqual user1
           assertNotNull(game.discardPile.topCard) shouldBeEqual assertNotNull(playedCard1)
         }
       }
     }
   })
 
-context(user: User)
+private suspend inline fun <reified T : Notification> MutableList<Notification>.waitNotification(crossinline block: T.() -> Boolean): T =
-private suspend inline fun <reified T : Notification> MutableList<Notification>.waitNotification(crossinline block: T.() -> Boolean): T {
+  eventually(3.seconds) {
-  println("NOTIFICATION WAITING: ${T::class.simpleName} for user: ${user.username}")
+    filterIsInstance<T>().first { block(it) }
-  return eventually(3.seconds) {
-    filterIsInstance<T>()
-      .first { block(it) }
-      .also { remove(it) }
-  }.also { println("NOTIFICATION RECEIVED: ${T::class.simpleName} for user: ${user.username}") }
   }

src/test/kotlin/eventDemo/contexts/game/application/notification/EventToNotificationSubscriberTest.kt

@@ -1,7 +1,6 @@
 package eventDemo.contexts.game.application.notification
 
 import eventDemo.contexts.auth.application.eventStores.UserEventStoreRepository
-import eventDemo.contexts.auth.application.eventStores.UserRepository
 import eventDemo.contexts.auth.infrastructure.persistence.eventStore.UserEventStoreInMemory
 import eventDemo.contexts.game.application.command.handlers.GameCommandHandlerDispatcher
 import eventDemo.contexts.game.application.command.handlers.JoinTheGameHandler
@@ -15,8 +14,6 @@ import eventDemo.contexts.game.application.notification.models.WelcomeToTheGameN
 import eventDemo.contexts.game.infrastructure.persistence.eventBus.GameEventBusInMemory
 import eventDemo.contexts.game.infrastructure.persistence.eventStore.GameEventStoreInMemory
 import eventDemo.sharedKernel.UserId
-import eventDemo.testHelpers.createNewUser
-import io.kotest.assertions.nondeterministic.eventually
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.collections.shouldContain
 import io.kotest.matchers.equals.shouldEqual
@@ -24,7 +21,6 @@ import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import org.junit.jupiter.api.assertInstanceOf
-import kotlin.time.Duration.Companion.seconds
 
 class EventToNotificationSubscriberTest :
   FunSpec({
@@ -50,12 +46,8 @@ class EventToNotificationSubscriberTest :
 
       val game = gameRepository.create()
 
-      val user1 = createNewUser("user1")
+      val user1 = UserId()
-      val user2 = createNewUser("user2")
+      val user2 = UserId()
-      userRepository.run {
-        save(user1)
-        save(user2)
-      }
 
       val player1Notifications = mutableListOf<Notification>()
       GlobalScope.launch {
@@ -64,22 +56,20 @@ class EventToNotificationSubscriberTest :
         }
       }
 
-      commentDispatcher.dispatch(JoinTheGameCommand(user1.id, JoinTheGameCommand.Payload(game.aggregateId)))
+      commentDispatcher.dispatch(JoinTheGameCommand(user1, JoinTheGameCommand.Payload(game.aggregateId)))
       subscriber
         .subscribeToEventsAndSendNotification(
           game.aggregateId,
-          user2.id,
+          user1,
           notificationChannel,
         ).use {
-          commentDispatcher.dispatch(JoinTheGameCommand(user2.id, JoinTheGameCommand.Payload(game.aggregateId)))
+          commentDispatcher.dispatch(JoinTheGameCommand(user2, JoinTheGameCommand.Payload(game.aggregateId)))
         }
 
-      eventually(duration = 1.seconds) {
+      player1Notifications.size shouldEqual 2
-        player1Notifications.size shouldEqual 1
-      }
       player1Notifications.first().let { notification ->
         assertInstanceOf<WelcomeToTheGameNotification>(notification)
-        notification.players.map { it.userId } shouldContain user2.id
+        notification.players.map { it.userId } shouldContain user1
       }
     }
   })

src/test/kotlin/eventDemo/contexts/game/application/notification/ToNotificationTest.kt

@@ -1,301 +0,0 @@
-package eventDemo.contexts.game.application.notification
-
-import eventDemo.contexts.game.application.notification.models.ItsTheTurnOfNotification
-import eventDemo.contexts.game.application.notification.models.PilesShuffledNotification
-import eventDemo.contexts.game.application.notification.models.PlayerAsPlayACardNotification
-import eventDemo.contexts.game.application.notification.models.PlayerHavePassNotification
-import eventDemo.contexts.game.application.notification.models.PlayerWasReadyNotification
-import eventDemo.contexts.game.application.notification.models.TheGameWasStartedNotification
-import eventDemo.contexts.game.application.notification.models.WelcomeToTheGameNotification
-import eventDemo.contexts.game.application.notification.models.YourNewCardNotification
-import eventDemo.contexts.game.domain.events.CardIsPlayedEvent
-import eventDemo.contexts.game.domain.events.DrawFilledWithDiscardEvent
-import eventDemo.contexts.game.domain.events.GameStartedEvent
-import eventDemo.contexts.game.domain.events.NewPlayerEvent
-import eventDemo.contexts.game.domain.events.PlayerHaveDrawCardEvent
-import eventDemo.contexts.game.domain.events.PlayerReadyEvent
-import eventDemo.contexts.game.domain.game.Card
-import eventDemo.contexts.game.domain.game.DiscardPile
-import eventDemo.contexts.game.domain.game.DrawPile
-import eventDemo.contexts.game.domain.game.GameId
-import eventDemo.contexts.game.domain.game.Player
-import eventDemo.contexts.game.domain.game.PlayerHand
-import eventDemo.contexts.game.domain.game.PlayerList
-import eventDemo.contexts.game.domain.game.gameState.GameCreated
-import eventDemo.contexts.game.domain.game.gameState.GameStarted
-import eventDemo.sharedKernel.UserId
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import org.junit.jupiter.api.assertInstanceOf
-
-class ToNotificationTest :
-  FunSpec({
-    val player1 =
-      Player(
-        name = "Bob",
-        userId = UserId(),
-        hand = PlayerHand(setOf(Card.NumericCard(1, Card.Color.Red))),
-        id = Player.PlayerId(),
-      )
-    val player2 =
-      Player(
-        name = "John",
-        userId = UserId(),
-        hand = PlayerHand(setOf(Card.NumericCard(1, Card.Color.Red))),
-        id = Player.PlayerId(),
-      )
-
-    test("NewPlayerEvent") {
-      val game =
-        GameCreated(
-          aggregateId = GameId(),
-          version = 1,
-          players = PlayerList(setOf(player1)),
-          recordedEvents = setOf(),
-        )
-      NewPlayerEvent(
-        game.aggregateId,
-        version = 2,
-        player = player1,
-      ).toNotification(
-        game = game,
-        currentUserId = player1.userId,
-      ).let {
-        it.toList().size shouldBe 1
-        // Check if the user is
-        assertInstanceOf<WelcomeToTheGameNotification>(it.first()).run {
-          players.size shouldBe 1
-          players.first().name shouldBe "Bob"
-        }
-      }
-    }
-
-    test("PlayerReadyEvent") {
-      val game =
-        GameCreated(
-          aggregateId = GameId(),
-          version = 1,
-          players = PlayerList(setOf(player1)),
-          recordedEvents = setOf(),
-        )
-      PlayerReadyEvent(
-        game.aggregateId,
-        version = 2,
-        playerId = player1.id,
-      ).toNotification(
-        game = game,
-        currentUserId = player1.userId,
-      ).let {
-        it.toList().size shouldBe 1
-        assertInstanceOf<PlayerWasReadyNotification>(it.first()).let {
-          it.playerId shouldBe player1.id
-        }
-      }
-    }
-
-    test("PlayerHaveDrawCardEvent on current player") {
-      val game =
-        GameStarted(
-          aggregateId = GameId(),
-          players = PlayerList(setOf(player1, player2)),
-          drawPile = DrawPile(),
-          discardPile = DiscardPile(),
-          lastPlayerId = player1.id,
-          nextPlayerId = player2.id,
-          currentColor = Card.Color.Red,
-          version = 1,
-          recordedEvents = setOf(),
-        )
-      val card = Card.NumericCard(1, Card.Color.Blue)
-      PlayerHaveDrawCardEvent(
-        game.aggregateId,
-        version = 2,
-        playerId = player1.id,
-        takenCards = setOf(card),
-      ).toNotification(
-        game = game,
-        currentUserId = player1.userId,
-      ).let {
-        it.toList().size shouldBe 2
-        it.toList().let { notifications ->
-          assertInstanceOf<YourNewCardNotification>(notifications.first()).let {
-            it.cards.first() shouldBe card
-          }
-          assertInstanceOf<ItsTheTurnOfNotification>(notifications[1]).let {
-            it.player.id shouldBe player2.id
-          }
-        }
-      }
-    }
-    test("PlayerHaveDrawCardEvent on other player") {
-      val game =
-        GameStarted(
-          aggregateId = GameId(),
-          players = PlayerList(setOf(player1, player2)),
-          drawPile = DrawPile(),
-          discardPile = DiscardPile(),
-          lastPlayerId = player1.id,
-          nextPlayerId = player2.id,
-          currentColor = Card.Color.Red,
-          version = 1,
-          recordedEvents = setOf(),
-        )
-      val card = Card.NumericCard(1, Card.Color.Blue)
-      PlayerHaveDrawCardEvent(
-        game.aggregateId,
-        version = 2,
-        playerId = player1.id,
-        takenCards = setOf(card),
-      ).toNotification(
-        game = game,
-        currentUserId = player2.userId,
-      ).let {
-        it.toList().size shouldBe 2
-        it.toList().let { notifications ->
-          assertInstanceOf<PlayerHavePassNotification>(notifications.first()).let {
-            it.playerId shouldBe player1.id
-          }
-          assertInstanceOf<ItsTheTurnOfNotification>(notifications[1]).let {
-            it.player.id shouldBe player2.id
-          }
-        }
-      }
-    }
-
-    test("CardIsPlayedEvent on current player") {
-      val game =
-        GameStarted(
-          aggregateId = GameId(),
-          players = PlayerList(setOf(player1, player2)),
-          drawPile = DrawPile(),
-          discardPile = DiscardPile(),
-          lastPlayerId = player2.id,
-          nextPlayerId = player1.id,
-          currentColor = Card.Color.Red,
-          version = 1,
-          recordedEvents = setOf(),
-        )
-      val card = Card.NumericCard(1, Card.Color.Blue)
-      CardIsPlayedEvent(
-        game.aggregateId,
-        version = 2,
-        playerId = player1.id,
-        card = card,
-      ).toNotification(
-        game = game,
-        currentUserId = player1.userId,
-      ).toList()
-        .let { notifications ->
-          notifications.size shouldBe 2
-          assertInstanceOf<PlayerAsPlayACardNotification>(notifications.first()).let {
-            it.playerId shouldBe player1.id
-            it.card shouldBe card
-          }
-          assertInstanceOf<ItsTheTurnOfNotification>(notifications[1]).let {
-            it.player.id shouldBe player1.id
-          }
-        }
-    }
-    test("CardIsPlayedEvent on other player") {
-      val game =
-        GameStarted(
-          aggregateId = GameId(),
-          players = PlayerList(setOf(player1, player2)),
-          drawPile = DrawPile(),
-          discardPile = DiscardPile(),
-          lastPlayerId = player1.id,
-          nextPlayerId = player2.id,
-          currentColor = Card.Color.Red,
-          version = 1,
-          recordedEvents = setOf(),
-        )
-      val card = Card.NumericCard(1, Card.Color.Blue)
-      CardIsPlayedEvent(
-        game.aggregateId,
-        version = 2,
-        playerId = player2.id,
-        card = card,
-      ).toNotification(
-        game = game,
-        currentUserId = player1.userId,
-      ).let {
-        it.toList().size shouldBe 2
-        it.toList().let { notifications ->
-          assertInstanceOf<PlayerAsPlayACardNotification>(notifications.first()).let {
-            it.playerId shouldBe player2.id
-            it.card shouldBe card
-          }
-          assertInstanceOf<ItsTheTurnOfNotification>(notifications[1]).let {
-            it.player.id shouldBe player2.id
-          }
-        }
-      }
-    }
-
-    test("DrawFilledWithDiscardEvent") {
-      val game =
-        GameStarted(
-          aggregateId = GameId(),
-          players = PlayerList(setOf(player1, player2)),
-          drawPile = DrawPile(),
-          discardPile = DiscardPile(),
-          lastPlayerId = player1.id,
-          nextPlayerId = player2.id,
-          currentColor = Card.Color.Red,
-          version = 1,
-          recordedEvents = setOf(),
-        )
-      DrawFilledWithDiscardEvent(
-        game.aggregateId,
-        version = 2,
-        newDrawPile = DrawPile(),
-        newDiscardPile = DiscardPile(),
-      ).toNotification(
-        game = game,
-        currentUserId = player1.userId,
-      ).let {
-        it.toList().size shouldBe 1
-        assertInstanceOf<PilesShuffledNotification>(it.first())
-      }
-    }
-
-    test("GameStartedEvent") {
-      val game =
-        GameStarted(
-          aggregateId = GameId(),
-          players = PlayerList(setOf(player1, player2)),
-          drawPile = DrawPile(),
-          discardPile = DiscardPile(),
-          lastPlayerId = player1.id,
-          nextPlayerId = player2.id,
-          currentColor = Card.Color.Red,
-          version = 1,
-          recordedEvents = setOf(),
-        )
-      GameStartedEvent(
-        game.aggregateId,
-        version = 2,
-        firstPlayer = player1.id,
-        playersHans =
-          mapOf(
-            player1.id to player1.hand,
-            player2.id to player2.hand,
-          ),
-        drawPile = DrawPile(),
-        discardPile = DiscardPile(),
-      ).toNotification(
-        game = game,
-        currentUserId = player1.userId,
-      ).toList()
-        .let { notifications ->
-          notifications.size shouldBe 2
-          assertInstanceOf<TheGameWasStartedNotification>(notifications.first()).let {
-            it.hand.size shouldBe 1
-            it.hand.first() shouldBe player1.hand.cards.first()
-          }
-          assertInstanceOf<ItsTheTurnOfNotification>(notifications[1]).let {
-            it.player.id shouldBe player2.id
-          }
-        }
-    }
-  })

src/test/kotlin/eventDemo/contexts/game/domain/game/gameState/GameStartedTest.kt

@@ -11,7 +11,6 @@ import eventDemo.contexts.game.domain.game.GameId
 import eventDemo.contexts.game.domain.game.Player
 import eventDemo.contexts.game.domain.game.PlayerHand
 import eventDemo.contexts.game.domain.game.PlayerList
-import eventDemo.contexts.game.domain.game.gameState.Game.Direction
 import eventDemo.sharedKernel.UserId
 import eventDemo.testHelpers.act
 import eventDemo.testHelpers.assert
@@ -196,12 +195,10 @@ class GameStartedTest :
         val card3 = Card.NumericCard(3, Card.Color.Red)
         assert {
           val player1 = Player("Player 1", UserId())
-          val player2 = Player("Player 2", UserId())
           GameStarted(
             aggregateId = GameId(),
             players = PlayerList(setOf(player1)),
             lastPlayerId = player1.id,
-            nextPlayerId = player2.id,
             drawPile = DrawPile(),
             discardPile =
               DiscardPile(
@@ -247,14 +244,17 @@ class GameStartedTest :
         val card3 = Card.NumericCard(3, Card.Color.Red)
         val card4 = Card.NumericCard(4, Card.Color.Red)
 
-        val player1 = Player("Jo", UserId())
+        val player1 =
-        val player2 = Player("Bob", UserId())
+          Player(
+            "Jo",
+            UserId(),
+            hand = PlayerHand(cards = setOf()),
+          )
         assert {
           GameStarted(
             aggregateId = GameId(),
             players = PlayerList(setOf(player1)),
             lastPlayerId = player1.id,
-            nextPlayerId = player2.id,
             drawPile =
               DrawPile(
                 setOf(
@@ -303,7 +303,6 @@ class GameStartedTest :
             aggregateId = GameId(),
             players = PlayerList(setOf(player1, player2)),
             lastPlayerId = player1.id,
-            nextPlayerId = player2.id,
             drawPile = DrawPile(),
             discardPile = DiscardPile(),
             currentColor = Card.Color.Yellow,
@@ -374,12 +373,10 @@ private fun gameWithCard(
   val player1 = Player("Tesla", UserId(), hand = played1Hand)
   val player2 = Player("Einstein", UserId(), hand = played2Hand)
   val player3 = Player("Curie", UserId(), hand = PlayerHand(setOf(Card.NumericCard(8, Card.Color.Yellow))))
-  val players = PlayerList(setOf(player1, player2, player3))
   return GameStarted(
     aggregateId = GameId(),
-    players = players,
+    players = PlayerList(setOf(player1, player2, player3)),
     lastPlayerId = player3.id,
-    nextPlayerId = players.nextPlayerTurn(player3.id, Direction.CLOCKWISE),
     discardPile = DiscardPile(setOf(onTheDiscardPile)),
     drawPile = DrawPile(),
     currentColor = (onTheDiscardPile as? Card.CardWithColor)?.color ?: chosenColor ?: error("no color"),

src/test/kotlin/eventDemo/contexts/game/domain/game/gameState/NewDeckTest.kt

@@ -1,41 +0,0 @@
-package eventDemo.contexts.game.domain.game.gameState
-
-import eventDemo.contexts.game.domain.game.Card
-import io.kotest.assertions.retry
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.should
-import io.kotest.matchers.shouldBe
-import io.kotest.matchers.shouldNotBe
-import kotlin.time.Duration.Companion.seconds
-
-class NewDeckTest :
-  FunSpec({
-
-    test("newDeck") {
-      newDeck().let {
-        it shouldNotBe null
-        it.filterIsInstance<Card.NumericCard>() shouldHaveSize 76
-        it.filterIsInstance<Card.Plus2Card>() shouldHaveSize 8
-        it.filterIsInstance<Card.ReverseCard>() shouldHaveSize 8
-        it.filterIsInstance<Card.PassCard>() shouldHaveSize 8
-        it.filterIsInstance<Card.Plus4Card>() shouldHaveSize 4
-        it.filterIsInstance<Card.ChangeColorCard>() shouldHaveSize 4
-        it shouldHaveSize 108
-      }
-    }
-
-    test("shuffleDeck") {
-      val deck = (0..9).map { Card.NumericCard(it, Card.Color.Red) }
-      deck.run {
-        this[3].number shouldBe 3
-      }
-      should {
-        retry(maxRetry = 4, timeout = 1.seconds) {
-          deck.shuffled().run {
-            this[3].number shouldNotBe 3
-          }
-        }
-      }
-    }
-  })

src/test/kotlin/eventDemo/contexts/game/intrastructure/rest/GameListRouteTest.kt

@@ -117,8 +117,8 @@ class GameListRouteTest :
               call.body<List<GameList>>().first().let {
                 it.status shouldBeEqual GameList.Status.IS_STARTED
                 it.players shouldHaveSize 2
-                it.players.map { it.userId } shouldContain user1.id
+                it.players.map { it.userId } shouldContain user1
-                it.players.map { it.userId } shouldContain user2.id
+                it.players.map { it.userId } shouldContain user2
                 it.winners shouldHaveSize 0
               }
             }

src/test/kotlin/eventDemo/libs/eventSource/EventStreamTest.kt

@@ -33,10 +33,9 @@ class EventStreamTest :
         block(aggregateId)
       }
 
-    fun Koin.eventStreams(): Map<String, EventStream<EventXTest, IdTest>> =
+    fun Koin.eventStreams(): List<EventStream<EventXTest, IdTest>> =
-      mapOf(
+      listOf(
-        EventStreamInMemory::class.simpleName.toString() to EventStreamInMemory(IdTest()),
+        EventStreamInMemory(IdTest()),
-        EventStreamInPostgresql::class.simpleName.toString() to
         EventStreamInPostgresql(
           IdTest(),
           dataSource = get(),

src/test/kotlin/eventDemo/testHelpers/CreateGameWithCommandsInChannelsHelpers.kt

@@ -9,70 +9,51 @@ import eventDemo.contexts.game.application.eventStores.GameRepository
 import eventDemo.contexts.game.domain.game.Card
 import eventDemo.contexts.game.domain.game.GameId
 import eventDemo.contexts.game.domain.game.Player
-import eventDemo.contexts.game.domain.game.gameState.Game
 import kotlinx.coroutines.channels.Channel
 import org.koin.core.Koin
+import java.util.UUID
 
 object CreateGameWithCommandsInChannelsHelpers {
-  class Data(
-    private val repo: GameRepository,
-    val gameId: GameId,
-    val currentUser: User,
-  ) {
-    fun getPlayer(user: User): Player =
-      game.players.get(user.id)
-
-    val currentPlayer: Player get() = getPlayer(currentUser)
-
-    val game: Game
-      get() = repo.get(gameId)!!
-  }
-
   context(koin: Koin)
   suspend fun <T> createGameWithCommandsInChannels(
     channelCommand: Channel<GameCommand>,
-    gameId: GameId,
+    gameName: String = "testGame${UUID.randomUUID()}",
-    user: User,
+    block: suspend context(Channel<GameCommand>, GameId) ((User) -> Player) -> T,
-    block:
-      suspend context(
-        CreateGameWithCommandsInChannelsHelpers,
-        Channel<GameCommand>,
-        User,
-      ) Data.() -> T,
   ): T {
+    val gameId = GameId(UUID.nameUUIDFromBytes(gameName.encodeToByteArray()))
     val repo = koin.get<GameRepository>()
     repo.getOrCreate(gameId)
 
-    return with(channelCommand) {
+    return with(gameId) {
-      with(user) {
+      with(channelCommand) {
         with(CreateGameWithCommandsInChannelsHelpers) {
-          Data(repo, gameId, user).block()
+          block { user -> repo.get(gameId)!!.players.get(user.id) }
         }
       }
     }
   }
 
-  context(channelCommand: Channel<GameCommand>, data: Data)
+  context(channelCommand: Channel<GameCommand>, gameId: GameId)
-  suspend fun joinTheGame(): JoinTheGameCommand =
+  suspend fun User.joinTheGame(): JoinTheGameCommand =
     JoinTheGameCommand(
-      data.currentUser.id,
+      id,
-      JoinTheGameCommand.Payload(data.gameId),
+      JoinTheGameCommand.Payload(gameId),
     ).also { channelCommand.send(it) }
 
-  context(channelCommand: Channel<GameCommand>, data: Data)
+  context(channelCommand: Channel<GameCommand>, gameId: GameId)
-  suspend fun readyToPlay(): ReadyToPlayCommand =
+  suspend fun Player.readyToPlay(): ReadyToPlayCommand =
     ReadyToPlayCommand(
-      data.currentUser.id,
+      userId,
-      ReadyToPlayCommand.Payload(data.gameId, data.currentPlayer.id),
+      ReadyToPlayCommand.Payload(gameId, id),
     ).also { channelCommand.send(it) }
 
-  context(channelCommand: Channel<GameCommand>, data: Data)
+  context(channelCommand: Channel<GameCommand>, gameId: GameId)
-  suspend fun playCard(
+  suspend fun Player.playCard(
     card: Card,
     chosenColor: Card.Color? = null,
   ): PlayCardCommand =
     PlayCardCommand(
-      data.currentUser.id,
+      userId,
-      PlayCardCommand.Payload(data.gameId, data.currentPlayer.id, card, chosenColor),
+      PlayCardCommand.Payload(gameId, id, card, chosenColor),
     ).also { channelCommand.send(it) }
 }