131 lines
4.5 KiB
Kotlin
131 lines
4.5 KiB
Kotlin
package eventDemo.app.event.projection
|
|
|
|
import eventDemo.app.entity.GameId
|
|
import eventDemo.app.entity.Player
|
|
import eventDemo.app.event.GameEventHandler
|
|
import eventDemo.app.event.event.NewPlayerEvent
|
|
import eventDemo.configuration.appKoinModule
|
|
import io.kotest.core.spec.style.FunSpec
|
|
import io.kotest.matchers.collections.shouldHaveSize
|
|
import io.kotest.matchers.equals.shouldBeEqual
|
|
import kotlinx.coroutines.DelicateCoroutinesApi
|
|
import kotlinx.coroutines.GlobalScope
|
|
import kotlinx.coroutines.joinAll
|
|
import kotlinx.coroutines.launch
|
|
import org.koin.core.context.stopKoin
|
|
import org.koin.dsl.koinApplication
|
|
import kotlin.test.assertNotNull
|
|
|
|
@OptIn(DelicateCoroutinesApi::class)
|
|
class GameStateRepositoryTest :
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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>()
|
|
|
|
(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
|
|
}
|
|
}
|
|
}
|
|
|
|
xtest("get should be concurrently secure") { }
|
|
})
|