HeroesOfDomainDrivenDesign.EventSourcing.DCB.Kotlin.Axon5.Spring/src/test/kotlin/com/dddheroes/heroesofddd/calendar/write/finishday/FinishDaySpringSliceTest.kt at main · MateuszNaKodach/HeroesOfDomainDrivenDesign.EventSourcing.DCB.Kotlin.Axon5.Spring · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package com.dddheroes.heroesofddd.calendar.write.finishday

import com.dddheroes.heroesofddd.HeroesAxonSpringBootTest
import com.dddheroes.heroesofddd.calendar.events.DayFinished
import com.dddheroes.heroesofddd.calendar.events.DayStarted
import com.dddheroes.heroesofddd.calendar.write.CalendarId
import com.dddheroes.heroesofddd.calendar.write.Day
import com.dddheroes.heroesofddd.calendar.write.Month
import com.dddheroes.heroesofddd.calendar.write.Week
import com.dddheroes.sdk.application.CommandHandlerResult
import org.axonframework.extensions.kotlin.AxonMetadata
import org.axonframework.test.fixture.*
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.TestPropertySource
import java.util.*

@TestPropertySource(properties = ["slices.calendar.write.finishday.enabled=true"])
@HeroesAxonSpringBootTest
internal class FinishDaySpringSliceTest @Autowired constructor(
    private val sliceUnderTest: AxonTestFixture
) {

    private val gameId: String = UUID.randomUUID().toString()
    private val playerId: String = UUID.randomUUID().toString()

    private val calendarId = CalendarId.random()

    @Test
    fun `given day started, when finish that day, then DayFinished`() {
        sliceUnderTest.Scenario {
            Given {
                event(DayStarted(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
            } When {
                command(FinishDay(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
            } Then {
                resultMessagePayload(CommandHandlerResult.Success)
                events(DayFinished(calendarId, month = Month(1), week = Week(1), day = Day(1)))
                allEventsHaveMetadata(gameMetadata)
            }
        }
    }

    @Test
    fun `given no day started, when finish day, then failure`() {
        sliceUnderTest.Scenario {
            Given {
                noPriorActivity()
            } When {
                command(FinishDay(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
            } Then {
                resultMessagePayload(CommandHandlerResult.Failure("Can only finish current day"))
                noEvents()
            }
        }
    }

    @Test
    fun `given day started, when finish different day, then failure`() {
        sliceUnderTest.Scenario {
            Given {
                event(DayStarted(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
            } When {
                command(FinishDay(calendarId, month = Month(1), week = Week(1), day = Day(2)), gameMetadata)
            } Then {
                resultMessagePayload(CommandHandlerResult.Failure("Can only finish current day"))
                noEvents()
            }
        }
    }

    @Test
    fun `given day already finished, when finish same day again, then failure`() {
        sliceUnderTest.Scenario {
            Given {
                event(DayStarted(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
                event(DayFinished(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
            } When {
                command(FinishDay(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
            } Then {
                resultMessagePayload(CommandHandlerResult.Failure("Can only finish current day"))
                noEvents()
            }
        }
    }

    @Test
    fun `given second day started, when finish second day, then DayFinished`() {
        sliceUnderTest.Scenario {
            Given {
                event(DayStarted(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
                event(DayFinished(calendarId, month = Month(1), week = Week(1), day = Day(1)), gameMetadata)
                event(DayStarted(calendarId, month = Month(1), week = Week(1), day = Day(2)), gameMetadata)
            } When {
                command(FinishDay(calendarId, month = Month(1), week = Week(1), day = Day(2)), gameMetadata)
            } Then {
                resultMessagePayload(CommandHandlerResult.Success)
                events(DayFinished(calendarId, month = Month(1), week = Week(1), day = Day(2)))
            }
        }
    }

    private val gameMetadata = AxonMetadata.with("gameId", gameId)
        .and("playerId", playerId)

}