update ktlint rules

2025-03-14 03:23:16 +01:00
parent 492981bed0
commit b4234a9b37
97 changed files with 2392 additions and 2359 deletions
--- a/src/test/kotlin/eventDemo/app/event/projection/GameStateRepositoryTest.kt
+++ b/src/test/kotlin/eventDemo/app/event/projection/GameStateRepositoryTest.kt
@@ -18,113 +18,113 @@ import kotlin.test.assertNotNull

@OptIn(DelicateCoroutinesApi::class)
 class GameStateRepositoryTest :
-    FunSpec({
-        val player1 = Player("Tesla")
-        val player2 = Player(name = "Einstein")
+  FunSpec({
+    val player1 = Player("Tesla")
+    val player2 = Player(name = "Einstein")

-        test("GameStateRepository should build the projection when a new event occurs") {
-            val aggregateId = GameId()
-            koinApplication { modules(appKoinModule) }.koin.apply {
-                val repo = get<GameStateRepository>()
-                val eventHandler = get<GameEventHandler>()
-                eventHandler
-                    .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player1, version = it) }
-                    .also { event ->
-                        assertNotNull(repo.getUntil(event)).also {
-                            assertNotNull(it.players) shouldBeEqual setOf(player1)
-                        }
-                        assertNotNull(repo.getLast(aggregateId)).also {
-                            assertNotNull(it.players) shouldBeEqual setOf(player1)
-                        }
-                    }
+    test("GameStateRepository should build the projection when a new event occurs") {
+      val aggregateId = GameId()
+      koinApplication { modules(appKoinModule) }.koin.apply {
+        val repo = get<GameStateRepository>()
+        val eventHandler = get<GameEventHandler>()
+        eventHandler
+          .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player1, version = it) }
+          .also { event ->
+            assertNotNull(repo.getUntil(event)).also {
+              assertNotNull(it.players) shouldBeEqual setOf(player1)
            }
-            stopKoin()
-        }
-
-        test("get should build the last version of the state") {
-            val aggregateId = GameId()
-            koinApplication { modules(appKoinModule) }.koin.apply {
-                val repo = get<GameStateRepository>()
-                val eventHandler = get<GameEventHandler>()
-
-                eventHandler
-                    .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player1, version = it) }
-                    .also {
-                        assertNotNull(repo.getLast(aggregateId)).also {
-                            assertNotNull(it.players) shouldBeEqual setOf(player1)
-                        }
-                    }
-
-                eventHandler
-                    .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player2, version = it) }
-                    .also {
-                        assertNotNull(repo.getLast(aggregateId)).also {
-                            assertNotNull(it.players) shouldBeEqual setOf(player1, player2)
-                        }
-                    }
+            assertNotNull(repo.getLast(aggregateId)).also {
+              assertNotNull(it.players) shouldBeEqual setOf(player1)
            }
-        }
+          }
+      }
+      stopKoin()
+    }

-        test("getUntil should build the state until the event") {
-            repeat(10) {
-                val aggregateId = GameId()
-                koinApplication { modules(appKoinModule) }.koin.apply {
-                    val repo = get<GameStateRepository>()
-                    val eventHandler = get<GameEventHandler>()
+    test("get should build the last version of the state") {
+      val aggregateId = GameId()
+      koinApplication { modules(appKoinModule) }.koin.apply {
+        val repo = get<GameStateRepository>()
+        val eventHandler = get<GameEventHandler>()

-                    val event1 =
-                        eventHandler
-                            .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player1, version = it) }
-                            .also { event1 ->
-                                assertNotNull(repo.getUntil(event1)).also {
-                                    assertNotNull(it.players) shouldBeEqual setOf(player1)
-                                }
-                            }
+        eventHandler
+          .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player1, version = it) }
+          .also {
+            assertNotNull(repo.getLast(aggregateId)).also {
+              assertNotNull(it.players) shouldBeEqual setOf(player1)
+            }
+          }

-                    eventHandler
-                        .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player2, version = it) }
-                        .also { event2 ->
-                            assertNotNull(repo.getUntil(event2)).also {
-                                assertNotNull(it.players) shouldBeEqual setOf(player1, player2)
-                            }
-                            assertNotNull(repo.getUntil(event1)).also {
-                                assertNotNull(it.players) shouldBeEqual setOf(player1)
-                            }
-                        }
+        eventHandler
+          .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player2, version = it) }
+          .also {
+            assertNotNull(repo.getLast(aggregateId)).also {
+              assertNotNull(it.players) shouldBeEqual setOf(player1, player2)
+            }
+          }
+      }
+    }
+
+    test("getUntil should build the state until the event") {
+      repeat(10) {
+        val aggregateId = GameId()
+        koinApplication { modules(appKoinModule) }.koin.apply {
+          val repo = get<GameStateRepository>()
+          val eventHandler = get<GameEventHandler>()
+
+          val event1 =
+            eventHandler
+              .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player1, version = it) }
+              .also { event1 ->
+                assertNotNull(repo.getUntil(event1)).also {
+                  assertNotNull(it.players) shouldBeEqual setOf(player1)
                }
+              }
+
+          eventHandler
+            .handle(aggregateId) { NewPlayerEvent(aggregateId = aggregateId, player = player2, version = it) }
+            .also { event2 ->
+              assertNotNull(repo.getUntil(event2)).also {
+                assertNotNull(it.players) shouldBeEqual setOf(player1, player2)
+              }
+              assertNotNull(repo.getUntil(event1)).also {
+                assertNotNull(it.players) shouldBeEqual setOf(player1)
+              }
            }
        }
+      }
+    }

-        test("getUntil should be concurrently secure") {
-            val aggregateId = GameId()
-            koinApplication { modules(appKoinModule) }.koin.apply {
-                val repo = get<GameStateRepository>()
-                val eventHandler = get<GameEventHandler>()
+    test("getUntil should be concurrently secure") {
+      val aggregateId = GameId()
+      koinApplication { modules(appKoinModule) }.koin.apply {
+        val repo = get<GameStateRepository>()
+        val eventHandler = get<GameEventHandler>()

-                (1..10)
-                    .map { r ->
-                        GlobalScope
-                            .launch {
-                                repeat(100) { r2 ->
-                                    val playerX = Player("player$r$r2")
-                                    eventHandler
-                                        .handle(aggregateId) {
-                                            NewPlayerEvent(
-                                                aggregateId = aggregateId,
-                                                player = playerX,
-                                                version = it,
-                                            )
-                                        }
-                                }
-                            }
-                    }.joinAll()
-
-                repo.getLast(aggregateId).run {
-                    lastEventVersion shouldBeEqual 1000
-                    players shouldHaveSize 1000
+        (1..10)
+          .map { r ->
+            GlobalScope
+              .launch {
+                repeat(100) { r2 ->
+                  val playerX = Player("player$r$r2")
+                  eventHandler
+                    .handle(aggregateId) {
+                      NewPlayerEvent(
+                        aggregateId = aggregateId,
+                        player = playerX,
+                        version = it,
+                      )
+                    }
                }
-            }
-        }
+              }
+          }.joinAll()

-        xtest("get should be concurrently secure") { }
-    })
+        repo.getLast(aggregateId).run {
+          lastEventVersion shouldBeEqual 1000
+          players shouldHaveSize 1000
+        }
+      }
+    }
+
+    xtest("get should be concurrently secure") { }
+  })