working E2E test for party mode

alyssaruth · Mar 6, 2024 · a9df8e2 · a9df8e2
1 parent f6d2e7a
commit a9df8e2
Show file tree

Hide file tree

Showing 9 changed files with 97 additions and 79 deletions.
diff --git a/src/main/kotlin/dartzee/game/state/X01PlayerState.kt b/src/main/kotlin/dartzee/game/state/X01PlayerState.kt
@@ -15,7 +15,8 @@ data class X01PlayerState(
     override var isActive: Boolean = false
 ) : AbstractPlayerState<X01PlayerState>() {
     override fun getScoreSoFar(): Int {
-        val hasFinished = completedRounds.isNotEmpty() && isFinishRound(completedRounds.last())
+        val hasFinished =
+            completedRounds.isNotEmpty() && isFinishRound(completedRounds.last(), config.finishType)
         if (!hasFinished) {
             return (completedRounds.size * 3) + currentRound.size
         } else {

diff --git a/src/main/kotlin/dartzee/screen/game/x01/MatchStatisticsPanelX01.kt b/src/main/kotlin/dartzee/screen/game/x01/MatchStatisticsPanelX01.kt
@@ -1,10 +1,13 @@
 package dartzee.screen.game.x01
 
 import dartzee.core.util.minOrZero
+import dartzee.game.X01Config
 import dartzee.utils.isFinishRound
 import dartzee.utils.sumScore
 
 class MatchStatisticsPanelX01(gameParams: String) : GameStatisticsPanelX01(gameParams) {
+    private val config = X01Config.fromJson(gameParams)
+
     override fun addRowsToTable() {
         super.addRowsToTable()
 
@@ -17,7 +20,7 @@ class MatchStatisticsPanelX01(gameParams: String) : GameStatisticsPanelX01(gameP
     private fun getHighestFinishRow() =
         prepareRow("Best Finish") { playerName ->
             val rounds = hmPlayerToDarts[playerName].orEmpty()
-            val finishRounds = rounds.filter { r -> isFinishRound(r) }
+            val finishRounds = rounds.filter { r -> isFinishRound(r, config.finishType) }
             finishRounds.maxOfOrNull { r -> sumScore(r) }
         }
 

diff --git a/src/main/kotlin/dartzee/utils/X01Util.kt b/src/main/kotlin/dartzee/utils/X01Util.kt
@@ -74,9 +74,9 @@ fun getCheckoutScores(): MutableList<Int> {
 
 fun getCheckoutSingles(): List<Int> = getCheckoutScores().map { it / 2 }
 
-fun isFinishRound(round: List<Dart>): Boolean {
+fun isFinishRound(round: List<Dart>, finishType: FinishType): Boolean {
     val drt = round.last()
-    return drt.isDouble() && drt.getTotal() == drt.startingScore
+    return drt.getTotal() == drt.startingScore && !isBust(drt, finishType)
 }
 
 /** Refactored out of GameWrapper for use in game stats panel */

diff --git a/src/test/kotlin/dartzee/e2e/GameHelpers.kt b/src/test/kotlin/dartzee/e2e/GameHelpers.kt
@@ -9,7 +9,10 @@ import dartzee.achievements.runConversionsWithProgressBar
 import dartzee.ai.AI_DARTBOARD
 import dartzee.ai.DartsAiModel
 import dartzee.ai.getPointForScore
+import dartzee.bean.GameSetupPlayerSelector
 import dartzee.bean.ParticipantAvatar
+import dartzee.clickButton
+import dartzee.core.bean.ScrollTable
 import dartzee.core.util.DateStatics
 import dartzee.core.util.getSortedValues
 import dartzee.db.DartEntity
@@ -28,7 +31,6 @@ import dartzee.helper.retrieveParticipant
 import dartzee.helper.wipeTable
 import dartzee.listener.DartboardListener
 import dartzee.`object`.Dart
-import dartzee.`object`.DartboardSegment
 import dartzee.`object`.SegmentType
 import dartzee.screen.GameplayDartboard
 import dartzee.screen.ScreenCache
@@ -102,8 +104,13 @@ fun DartsGamePanel<*, *>.startGame(players: List<PlayerEntity>): List<IWrappedPa
     return participants
 }
 
-fun DartsGamePanel<*, *>.throwHumanRound(darts: List<DartboardSegment>) {
-    darts.forEach { throwHumanDart(it.score, it.type) }
+fun GameSetupPlayerSelector.selectTopPlayer() {
+    getChild<ScrollTable>("TableUnselected").selectRow(0)
+    clickButton("Select")
+}
+
+fun DartsGamePanel<*, *>.throwHumanRound(vararg darts: Dart) {
+    darts.forEach { throwHumanDart(it.score, it.segmentType) }
 
     confirmRound()
 }

diff --git a/src/test/kotlin/dartzee/e2e/TestPartyModeE2E.kt b/src/test/kotlin/dartzee/e2e/TestPartyModeE2E.kt
@@ -5,17 +5,37 @@ import com.github.alyssaburlton.swingtest.findWindow
 import com.github.alyssaburlton.swingtest.getChild
 import com.github.alyssaburlton.swingtest.shouldBeVisible
 import dartzee.bean.GameSetupPlayerSelector
+import dartzee.bean.ScrollTableDartsGame
 import dartzee.clickButton
-import dartzee.core.bean.ScrollTable
+import dartzee.db.PlayerEntity.Companion.ICON_HUMAN
+import dartzee.drtDoubleTwenty
+import dartzee.drtInnerFourteen
+import dartzee.drtInnerOne
+import dartzee.drtInnerSeven
+import dartzee.drtMissTwelve
+import dartzee.drtOuterFive
+import dartzee.drtOuterFourteen
+import dartzee.drtOuterNineteen
+import dartzee.drtOuterOne
+import dartzee.drtOuterSeven
+import dartzee.drtOuterSixteen
+import dartzee.drtOuterTwelve
+import dartzee.drtOuterTwenty
+import dartzee.drtTrebleFive
+import dartzee.drtTrebleNineteen
+import dartzee.drtTrebleSeven
+import dartzee.drtTrebleTwenty
+import dartzee.getRows
 import dartzee.helper.AbstractTest
 import dartzee.helper.preparePlayers
-import dartzee.`object`.SegmentType
 import dartzee.screen.DartsApp
 import dartzee.screen.ScreenCache
 import dartzee.screen.game.DartsGamePanel
 import dartzee.screen.game.DartsGameScreen
 import dartzee.waitForAssertionWithReturn
+import io.kotest.matchers.collections.shouldContainExactly
 import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
 import javax.swing.JButton
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
@@ -32,82 +52,47 @@ class TestPartyModeE2E : AbstractTest() {
         app.clickButton(text = "New Game")
 
         val selector = app.getChild<GameSetupPlayerSelector>()
-        selector.getChild<ScrollTable>("TableUnselected").selectRow(0)
-        selector.clickButton("Select")
-        selector.getChild<ScrollTable>("TableUnselected").selectRow(0)
-        selector.clickButton("Select")
+        selector.selectTopPlayer()
+        selector.selectTopPlayer()
         app.clickButton(text = "Launch Game >")
 
         val gameWindow = waitForAssertionWithReturn {
-            val window = findWindow<DartsGameScreen>()
-            window.shouldNotBeNull()
-            window.shouldBeVisible()
-            window
+            findWindow<DartsGameScreen>().run {
+                shouldNotBeNull()
+                shouldBeVisible()
+                this
+            }
         }
 
         val gamePanel = gameWindow.getChild<DartsGamePanel<*, *>>()
+        gamePanel.throwHumanRound(drtOuterTwenty(), drtTrebleTwenty(), drtOuterTwenty()) // 201
+        gamePanel.throwHumanRound(drtOuterNineteen(), drtOuterNineteen(), drtInnerSeven()) // 256
+        gamePanel.throwHumanRound(drtOuterTwenty(), drtTrebleTwenty(), drtTrebleFive()) // 106
+        gamePanel.throwHumanRound(drtTrebleNineteen(), drtTrebleNineteen(), drtTrebleSeven()) // 121
+        gamePanel.throwHumanRound(drtOuterTwenty(), drtOuterFive(), drtOuterOne()) // 80
+        gamePanel.throwHumanRound(drtTrebleNineteen(), drtInnerFourteen(), drtOuterFourteen()) // 36
+        gamePanel.throwHumanRound(drtOuterTwenty(), drtDoubleTwenty(), drtOuterTwenty()) // 0
 
-        // Alice - 201
-        gamePanel.throwHumanDart(20, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(20, SegmentType.TREBLE)
-        gamePanel.throwHumanDart(20, SegmentType.OUTER_SINGLE)
-        gamePanel.confirmRound()
-
-        // Bob - 256
-        gamePanel.throwHumanDart(19, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(19, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(7, SegmentType.INNER_SINGLE)
-        gamePanel.confirmRound()
-
-        // Alice - 106
-        gamePanel.throwHumanDart(20, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(20, SegmentType.TREBLE)
-        gamePanel.throwHumanDart(5, SegmentType.TREBLE)
-        gamePanel.confirmRound()
-
-        // Bob - 121
-        gamePanel.throwHumanDart(19, SegmentType.TREBLE)
-        gamePanel.throwHumanDart(19, SegmentType.TREBLE)
-        gamePanel.throwHumanDart(7, SegmentType.TREBLE)
-        gamePanel.confirmRound()
-
-        // Alice - 80
-        gamePanel.throwHumanDart(20, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(5, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(1, SegmentType.OUTER_SINGLE)
-        gamePanel.confirmRound()
-
-        // Bob - 36
-        gamePanel.throwHumanDart(19, SegmentType.TREBLE)
-        gamePanel.throwHumanDart(14, SegmentType.INNER_SINGLE)
-        gamePanel.throwHumanDart(14, SegmentType.OUTER_SINGLE)
-        gamePanel.confirmRound()
-
-        // Alice - 0 - 12 darts.
-        gamePanel.throwHumanDart(20, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(20, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(20, SegmentType.DOUBLE)
-        gamePanel.confirmRound()
-
-        // Bob - resume - 12
         gamePanel.clickChild<JButton> { it.isVisible && it.toolTipText == "Resume throwing" }
-        gamePanel.throwHumanDart(16, SegmentType.OUTER_SINGLE)
-        gamePanel.throwHumanDart(1, SegmentType.INNER_SINGLE)
-        gamePanel.throwHumanDart(7, SegmentType.OUTER_SINGLE)
-        gamePanel.confirmRound()
-
-        // Bob - 0 - 14 darts
-        gamePanel.throwHumanDart(12, SegmentType.MISS)
-        gamePanel.throwHumanDart(12, SegmentType.OUTER_SINGLE)
-        gamePanel.confirmRound()
-
-        // Assert some boring stuff etc
+        gamePanel.throwHumanRound(drtOuterSixteen(), drtInnerOne(), drtOuterSeven()) // 12
+        gamePanel.throwHumanRound(drtMissTwelve(), drtOuterTwelve()) // 0
 
+        // Check game outcome
+        gameWindow.getScorer("Alice").lblResult.text shouldBe "12 Darts"
+        gameWindow.getScorer("Bob").lblResult.text shouldBe "14 Darts"
         gameWindow.dispose()
 
         // Check leaderboard
         app.clickChild<JButton>(text = " < Back")
         app.clickChild<JButton>(text = "Leaderboards")
+
+        val leaderboardTable = app.getChild<ScrollTableDartsGame>()
+        leaderboardTable
+            .getRows()
+            .shouldContainExactly(
+                arrayOf(1, ICON_HUMAN, "Alice", 1L, 12),
+                arrayOf(2, ICON_HUMAN, "Bob", 1L, 14)
+            )
     }
 
     private fun launchApp(): DartsApp {

diff --git a/src/test/kotlin/dartzee/e2e/TestX01E2E.kt b/src/test/kotlin/dartzee/e2e/TestX01E2E.kt
@@ -121,7 +121,7 @@ class TestX01E2E : AbstractRegistryTest() {
             listOf(
                 listOf(makeDart(20, 3), makeDart(20, 1), makeDart(20, 1)), // 1
                 listOf(makeDart(20, 1)), // 1 (bust)
-                listOf(makeDart(1, 0), makeDart(1, 0), makeDart(1, 1)), // 0
+                listOf(makeDart(1, 0), makeDart(1, 1)), // 0
             )
 
         val p2Rounds =
@@ -141,7 +141,7 @@ class TestX01E2E : AbstractRegistryTest() {
         awaitGameFinish(game)
         waitForAssertion { pt2.participant.finalScore shouldBeGreaterThan -1 }
 
-        pt1.participant.finalScore shouldBe 9
+        pt1.participant.finalScore shouldBe 8
         pt1.participant.finishingPosition shouldBe 1
         pt2.participant.finalScore shouldBe 9
         pt2.participant.finishingPosition shouldBe 2
@@ -150,7 +150,7 @@ class TestX01E2E : AbstractRegistryTest() {
             .shouldContainExactlyInAnyOrder(
                 AchievementSummary(AchievementType.X01_BEST_THREE_DART_SCORE, 100, game.rowId),
                 AchievementSummary(AchievementType.X01_HIGHEST_BUST, 1, game.rowId),
-                AchievementSummary(AchievementType.X01_GAMES_WON, -1, game.rowId, "9"),
+                AchievementSummary(AchievementType.X01_GAMES_WON, -1, game.rowId, "8"),
             )
 
         retrieveAchievementsForPlayer(p2.rowId)

diff --git a/src/test/kotlin/dartzee/game/state/TestX01PlayerState.kt b/src/test/kotlin/dartzee/game/state/TestX01PlayerState.kt
@@ -49,6 +49,20 @@ class TestX01PlayerState : AbstractTest() {
         state.getScoreSoFar() shouldBe 8
     }
 
+    @Test
+    fun `Should not count the finishing round as 3 darts in relaxed mode`() {
+        val roundOne = listOf(Dart(20, 1), Dart(20, 1), Dart(20, 1))
+        val roundTwo = listOf(Dart(20, 3))
+        val roundThree = listOf(Dart(20, 2), makeDart(20, 1, startingScore = 20))
+
+        val state =
+            makeX01PlayerStateWithRounds(
+                completedRounds = listOf(roundOne, roundTwo, roundThree),
+                finishType = FinishType.Any
+            )
+        state.getScoreSoFar() shouldBe 8
+    }
+
     @Test
     fun `should add on darts from the in progress round`() {
         val roundOne = listOf(Dart(20, 1), Dart(20, 1), Dart(20, 1))

diff --git a/src/test/kotlin/dartzee/helper/TestFactory.kt b/src/test/kotlin/dartzee/helper/TestFactory.kt
@@ -175,11 +175,12 @@ fun makeX01PlayerStateWithRounds(
     player: PlayerEntity = insertPlayer(),
     participant: ParticipantEntity = insertParticipant(playerId = player.rowId),
     completedRounds: List<List<Dart>> = emptyList(),
-    isActive: Boolean = false
+    isActive: Boolean = false,
+    finishType: FinishType = FinishType.Doubles
 ): X01PlayerState {
     completedRounds.flatten().forEach { it.participantId = participant.rowId }
     return X01PlayerState(
-        X01Config(startingScore, FinishType.Doubles),
+        X01Config(startingScore, finishType),
         SingleParticipant(participant),
         completedRounds.toMutableList(),
         mutableListOf(),

diff --git a/src/test/kotlin/dartzee/utils/TestX01Util.kt b/src/test/kotlin/dartzee/utils/TestX01Util.kt
@@ -87,9 +87,16 @@ class TestX01Util : AbstractTest() {
 
     @Test
     fun testIsFinishRound() {
-        isFinishRound(listOf(Dart(2, 1), makeDart(20, 1, startingScore = 20))).shouldBeFalse()
-        isFinishRound(listOf(Dart(2, 1), makeDart(20, 2, startingScore = 20))).shouldBeFalse()
-        isFinishRound(listOf(Dart(2, 1), makeDart(10, 2, startingScore = 20))).shouldBeTrue()
+        isFinishRound(listOf(Dart(2, 1), makeDart(20, 1, startingScore = 20)), FinishType.Doubles)
+            .shouldBeFalse()
+        isFinishRound(listOf(Dart(2, 1), makeDart(20, 2, startingScore = 20)), FinishType.Doubles)
+            .shouldBeFalse()
+        isFinishRound(listOf(Dart(2, 1), makeDart(10, 2, startingScore = 20)), FinishType.Doubles)
+            .shouldBeTrue()
+
+        isFinishRound(listOf(Dart(2, 1), makeDart(20, 1, startingScore = 20)), FinishType.Any)
+            .shouldBeTrue()
+        isFinishRound(listOf(makeDart(20, 1, startingScore = 19)), FinishType.Any).shouldBeFalse()
     }
 
     @Test