better comparisons in tests

This commit is contained in:
Jonathan Lamothe 2020-05-01 00:16:11 -04:00 committed by Jonathan Lamothe
parent f869209ec6
commit 174b636499
2 changed files with 243 additions and 217 deletions

View File

@ -22,13 +22,11 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
module Actions.NewGame.GoalieInputSpec (spec) where module Actions.NewGame.GoalieInputSpec (spec) where
import qualified Data.Map as M import qualified Data.Map as M
import Data.Maybe (fromJust)
import Lens.Micro ((^.), (&), (.~), (?~), (%~)) import Lens.Micro ((^.), (&), (.~), (?~), (%~))
import Test.Hspec (Spec, context, describe, it, shouldBe) import Test.Hspec (Spec, context, describe, it, shouldBe)
import Mtlstats.Actions.NewGame.GoalieInput import Mtlstats.Actions.NewGame.GoalieInput
import Mtlstats.Types import Mtlstats.Types
import Mtlstats.Util
import qualified TypesSpec as TS import qualified TypesSpec as TS
@ -79,134 +77,59 @@ finishGoalieEntrySpec = describe "finishGoalieEntry" $ mapM_
bobStats = (1, newGoalieStats) bobStats = (1, newGoalieStats)
recordGoalieStatsSpec :: Spec recordGoalieStatsSpec :: Spec
recordGoalieStatsSpec = describe "recordGoalieStats" $ let recordGoalieStatsSpec = describe "recordGoalieStats" $ mapM_
goalieStats games mins goals = newGoalieStats ( \(label, input, expected) ->
& gsGames .~ games context label $ do
& gsMinsPlayed .~ mins let ps = recordGoalieStats input
& gsGoalsAllowed .~ goals ps `TS.compareTest` expected
joe = newGoalie 2 "Joe"
& gYtd .~ goalieStats 10 11 12
& gLifetime .~ goalieStats 20 21 22
bob = newGoalie 3 "Bob"
& gYtd .~ goalieStats 30 31 32
& gLifetime .~ goalieStats 40 41 42
gameState n mins goals = newGameState
& gameGoalieStats .~ M.fromList [(1, goalieStats 1 2 3)]
& gameSelectedGoalie .~ n
& gameGoalieMinsPlayed .~ mins
& gameGoalsAllowed .~ goals
progState n mins goals = newProgState
& database.dbGoalies .~ [joe, bob]
& progMode.gameStateL .~ gameState n mins goals
in mapM_
(\(setName, setGid, mins, goals, joeData, bobData, reset) -> let
s = recordGoalieStats $ progState setGid mins goals
in context setName $ do
mapM_
(\( chkName
, chkGid
, ( gGames
, gMins
, gGoals
, ytdGames
, ytdMins
, ytdGoals
, ltGames
, ltMins
, ltGoals
) )
) -> context chkName $ do
let
gs = s^.progMode.gameStateL.gameGoalieStats
game = M.findWithDefault newGoalieStats chkGid gs
goalie = fromJust $ nth chkGid $ s^.database.dbGoalies
ytd = goalie^.gYtd
lt = goalie^.gLifetime
context "game" $ [ ( "No goalie"
game `TS.compareTest` goalieStats gGames gMins gGoals , noGoalie
, noGoalie
context "year-to-date" $
ytd `TS.compareTest` goalieStats ytdGames ytdMins ytdGoals
context "lifetime" $
lt `TS.compareTest` goalieStats ltGames ltMins ltGoals)
[ ( "checking Joe", 0, joeData )
, ( "checking Bob", 1, bobData )
]
context "selected goalie" $ let
expected = if reset then Nothing else setGid
in it ("should be " ++ show expected) $
(s^.progMode.gameStateL.gameSelectedGoalie) `shouldBe` expected
context "minutes played" $ let
expected = if reset then Nothing else mins
in it ("should be " ++ show expected) $
(s^.progMode.gameStateL.gameGoalieMinsPlayed) `shouldBe` expected
context "goals allowed" $ let
expected = if reset then Nothing else goals
in it ("should be " ++ show expected) $
(s^.progMode.gameStateL.gameGoalsAllowed) `shouldBe` expected)
[ ( "updating Joe"
, Just 0
, Just 1
, Just 2
, (1, 1, 2, 11, 12, 14, 21, 22, 24)
, (1, 2, 3, 30, 31, 32, 40, 41, 42)
, True
) )
, ( "updating Bob"
, Just 1 , ( "Missing goalie"
, Just 1 , missingGoalie
, Just 2 , missingGoalie
, (0, 0, 0, 10, 11, 12, 20, 21, 22)
, (1, 3, 5, 30, 32, 34, 40, 42, 44)
, True
)
, ( "goalie out of bounds"
, Just 2
, Just 1
, Just 2
, (0, 0, 0, 10, 11, 12, 20, 21, 22)
, (1, 2, 3, 30, 31, 32, 40, 41, 42)
, False
)
, ( "missing goalie"
, Nothing
, Just 1
, Just 2
, (0, 0, 0, 10, 11, 12, 20, 21, 22)
, (1, 2, 3, 30, 31, 32, 40, 41, 42)
, False
)
, ( "missing minutes"
, Just 0
, Nothing
, Just 1
, (0, 0, 0, 10, 11, 12, 20, 21, 22)
, (1, 2, 3, 30, 31, 32, 40, 41, 42)
, False
)
, ( "missing goals"
, Just 0
, Just 1
, Nothing
, (0, 0, 0, 10, 11, 12, 20, 21, 22)
, (1, 2, 3, 30, 31, 32, 40, 41, 42)
, False
) )
] ]
where
noGoalie = defProgState
missingGoalie = defProgState
& progMode.gameStateL.gameSelectedGoalie ?~ 99
defProgState = newProgState
& progMode.gameStateL
%~ ( gameType ?~ HomeGame )
. ( homeScore ?~ 2 )
. ( awayScore ?~ 1 )
& database.dbGoalies .~ [jim, bob, steve]
jim = mkGoalie 2 "Jim" 1
bob = mkGoalie 3 "Bob" 2
steve = mkGoalie 5 "Steve" 3
mkGoalie num name n = newGoalie num name
& gYtd
%~ ( gsGames .~ n )
. ( gsMinsPlayed .~ n + 1 )
. ( gsGoalsAllowed .~ n + 2 )
. ( gsShutouts .~ n + 3 )
. ( gsWins .~ n + 4 )
. ( gsLosses .~ n + 5 )
. ( gsTies .~ n + 6 )
& gLifetime
%~ ( gsGames .~ n + 7 )
. ( gsMinsPlayed .~ n + 8 )
. ( gsGoalsAllowed .~ n + 9 )
. ( gsShutouts .~ n + 10 )
. ( gsWins .~ n + 11 )
. ( gsLosses .~ n + 12 )
. ( gsTies .~ n + 13 )
setGameGoalieSpec :: Spec setGameGoalieSpec :: Spec
setGameGoalieSpec = describe "setGameGoalie" $ mapM_ setGameGoalieSpec = describe "setGameGoalie" $ mapM_

View File

@ -972,119 +972,222 @@ makeBool = randomIO
makeName :: IO String makeName :: IO String
makeName = replicateM 10 $ randomRIO ('A', 'Z') makeName = replicateM 10 $ randomRIO ('A', 'Z')
instance Comparable GoalieStats where instance Comparable ProgState where
compareTest actual expected = mapM_ compareTest act expect = do
(\(name, lens) -> describe name $ compareLenses "database" database act expect
it ("should be " ++ show (expected^.lens)) $ compareLenses "progMode" progMode act expect
actual^.lens `shouldBe` expected^.lens) compareLenses "dbName" dbName act expect
-- name, lens compareLenses "inputBuffer" inputBuffer act expect
[ ( "gsGames", gsGames ) compareLenses "scrollOffset" scrollOffset act expect
, ( "gsMinsPlayed", gsMinsPlayed )
, ( "gsGoalsAllowed", gsGoalsAllowed ) instance Comparable ProgMode where
, ( "gsWins", gsWins ) compareTest TitleScreen TitleScreen = return ()
, ( "gsLosses", gsLosses ) compareTest MainMenu MainMenu = return ()
, ( "gsTies", gsTies )
] compareTest (NewSeason act) (NewSeason expect) =
context "NewSeason flag" $
act `compareTest` expect
compareTest (NewGame act) (NewGame expect) =
context "NewGame GameState" $
act `compareTest` expect
compareTest EditMenu EditMenu = return ()
compareTest (CreatePlayer act) (CreatePlayer expect) =
context "CreatePlayer CreatePlayerState" $
act `compareTest` expect
compareTest (CreateGoalie act) (CreateGoalie expect) =
context "CreateGoalie CreateGoalieState" $
act `compareTest` expect
compareTest (EditPlayer act) (EditPlayer expect) =
context "EditPlayer EditPlayerState" $
act `compareTest` expect
compareTest (EditGoalie act) (EditGoalie expect) =
context "EditGoalie EditGoalieState" $
act `compareTest` expect
compareTest (EditStandings act) (EditStandings expect) =
context "EditStandings EditStandingsMode" $
act `compareTest` expect
compareTest _ _ = fail "ProgMode mismatch"
instance Comparable GameState where instance Comparable GameState where
compareTest actual expected = compareTest act expect = do
it ("should be " ++ show expected) $ compareLenses "gameYear" gameYear act expect
actual `shouldBe` expected compareLenses "gameMonth" gameMonth act expect
compareLenses "gameDay" gameDay act expect
compareLenses "gameType" gameType act expect
compareLenses "otherTeam" otherTeam act expect
compareLenses "homeScore" homeScore act expect
compareLenses "awayScore" awayScore act expect
compareLenses "overtimeFlag" overtimeFlag act expect
compareLenses "dataVerified" dataVerified act expect
compareLenses "pointsAccounted" pointsAccounted act expect
compareLenses "goalBy" goalBy act expect
compareLenses "assistsBy" assistsBy act expect
compareLenses "gamePlayerStats" gamePlayerStats act expect
compareLenses "confirmGoalDataGlag" confirmGoalDataFlag act expect
compareLenses "gameSelectedPlayer" gameSelectedPlayer act expect
compareLenses "gamePMinsRecorded" gamePMinsRecorded act expect
compareLenses "gameGoalieStats" gameGoalieStats act expect
compareLenses "gameSelectedGoalie" gameSelectedGoalie act expect
compareLenses "gameGoalieMinsPlayed" gameGoalieMinsPlayed act expect
compareLenses "gameGoalsAllowed" gameGoalsAllowed act expect
compareLenses "gameGoaliesRecorded" gameGoaliesRecorded act expect
compareLenses "gameGoalieAssigned" gameGoalieAssigned act expect
instance Comparable CreatePlayerState where instance Comparable Database where
compareTest actual expected = do compareTest act expect = do
compareLenses "dbPlayers" dbPlayers act expect
compareLenses "dbGoalies" dbGoalies act expect
compareLenses "dbGames" dbGames act expect
compareLenses "dbHomeGameStats" dbHomeGameStats act expect
compareLenses "dbAwayGameStats" dbAwayGameStats act expect
describe "cpsNumber" $ instance Comparable Player where
it ("should be " ++ show (expected^.cpsNumber)) $ compareTest act expect = do
actual^.cpsNumber `shouldBe` expected^.cpsNumber compareLenses "pNumber" pNumber act expect
compareLenses "pName" pName act expect
compareLenses "pPosition" pPosition act expect
compareLenses "pRookie" pRookie act expect
compareLenses "pActive" pActive act expect
compareLenses "pYtd" pYtd act expect
compareLenses "pLifetime" pLifetime act expect
describe "cpsName" $ instance Comparable [Player] where
it ("should be " ++ expected^.cpsName) $ compareTest = compareLists
actual^.cpsName `shouldBe` expected^.cpsName
describe "cpsPosition" $ instance Comparable PlayerStats where
it ("should be " ++ expected^.cpsPosition) $ compareTest act expect = do
actual^.cpsPosition `shouldBe` expected^.cpsPosition compareLenses "psGoals" psGoals act expect
compareLenses "psAssists" psAssists act expect
instance Comparable EditPlayerState where compareLenses "psPMin" psPMin act expect
compareTest actual expected = do
describe "epsSelectedPlayer" $
it ("should be " ++ show (expected^.epsSelectedPlayer)) $
actual^.epsSelectedPlayer `shouldBe` expected^.epsSelectedPlayer
describe "epsMode" $
it ("should be " ++ show (expected^.epsMode)) $
actual^.epsMode `shouldBe` expected^.epsMode
instance Comparable EditGoalieState where
compareTest actual expected = do
describe "egsSelectedGoalie" $
it ("should be " ++ show (expected^.egsSelectedGoalie)) $
actual^.egsSelectedGoalie `shouldBe` expected^.egsSelectedGoalie
describe "egsMode" $
it ("should be " ++ show (expected^.egsMode)) $
actual^.egsMode `shouldBe` expected^.egsMode
instance Comparable CreateGoalieState where
compareTest actual expected = do
describe "cgsNuber" $
it("should be " ++ show (expected^.cgsNumber)) $
actual^.cgsNumber `shouldBe` expected^.cgsNumber
describe "cgsName" $
it ("should be " ++ expected^.cgsName) $
actual^.cgsName `shouldBe` expected^.cgsName
instance Comparable EditStandingsMode where
compareTest actual expected =
it ("should be " ++ show expected) $
actual `shouldBe` expected
instance Comparable Goalie where instance Comparable Goalie where
compareTest actual expected = do compareTest act expect = do
compareLenses "gNumber" gNumber act expect
compareLenses "gName" gName act expect
compareLenses "gRookie" gRookie act expect
compareLenses "gActive" gActive act expect
compareLenses "gYtd" gYtd act expect
compareLenses "gLifetime" gLifetime act expect
describe "gNumber" $ instance Comparable [Goalie] where
it ("should be " ++ show (expected^.gNumber)) $ compareTest = compareLists
actual^.gNumber `shouldBe` expected^.gNumber
describe "gName" $ instance Comparable GoalieStats where
it ("should be " ++ show (expected^.gName)) $ compareTest act expect = do
actual^.gName `shouldBe` expected^.gName compareLenses "gsGames" gsGames act expect
compareLenses "gsMisPlayed" gsMinsPlayed act expect
compareLenses "gsGoalsAllowed" gsGoalsAllowed act expect
compareLenses "gsWins" gsWins act expect
compareLenses "gsLosses" gsLosses act expect
compareLenses "gsTies" gsTies act expect
describe "gRookie" $ instance Comparable GameStats where
it ("should be " ++ show (expected^.gRookie)) $ compareTest act expect = do
actual^.gRookie `shouldBe` expected^.gRookie compareLenses "gmsWins" gmsWins act expect
compareLenses "gmsLosses" gmsLosses act expect
compareLenses "gmsOvertime" gmsOvertime act expect
compareLenses "gmsGoalsFor" gmsGoalsFor act expect
compareLenses "gmsGoalsAgainst" gmsGoalsAgainst act expect
describe "gActive" $ instance Comparable GameType where
it ("should be " ++ show (expected^.gActive)) $ compareTest = compareVals
actual^.gActive `shouldBe` expected^.gActive
describe "gYtd" $ instance Comparable CreatePlayerState where
(actual^.gYtd) `compareTest` (expected^.gYtd) compareTest act expect = do
compareLenses "cpsNumber" cpsNumber act expect
compareLenses "cpsName" cpsName act expect
compareLenses "cpsPosition" cpsPosition act expect
describe "gLifetime" $ instance Comparable EditPlayerState where
(actual^.gLifetime) `compareTest` (expected^.gLifetime) compareTest act expect = do
compareLenses "epsSelectedPlayer" epsSelectedPlayer act expect
compareLenses "epsMode" epsMode act expect
instance Comparable (M.Map Int GoalieStats) where instance Comparable EditPlayerMode where
compareTest actual expected = do compareTest = compareVals
let instance Comparable EditGoalieState where
aList = M.toList actual compareTest act expect = do
eList = M.toList expected compareLenses "egsSelectedGoalie" egsSelectedGoalie act expect
compareLenses "egsMode" egsMode act expect
it "should have the correct number of elements" $ instance Comparable EditGoalieMode where
length aList `shouldBe` length eList compareTest = compareVals
instance Comparable CreateGoalieState where
compareTest act expect = do
compareLenses "cgsNumber" cgsNumber act expect
compareLenses "cgsName" cgsName act expect
instance Comparable EditStandingsMode where
compareTest = compareVals
instance Comparable Int where
compareTest = compareVals
instance Comparable Bool where
compareTest = compareVals
instance Comparable String where
compareTest = compareVals
instance Comparable [Int] where
compareTest = compareLists
instance Comparable a => Comparable (Maybe a) where
compareTest Nothing Nothing = return ()
compareTest (Just a) (Just e) = a `compareTest` e
compareTest Nothing (Just _) = error "Unexpectedly received a value"
compareTest (Just _) Nothing = error "Received Nothing"
instance (Ord k, Show k, Comparable v) => Comparable (M.Map k v) where
compareTest actM expectM = do
context "number of elements" $
length actM `compareVals` length expectM
context "check values" $
mapM_ mapM_
(\(n, (ka, va), (ke, ve)) -> context ("element " ++ show n) $ do ( \k -> context (show k) $
M.lookup k actM `compareTest` M.lookup k expectM
) $ M.keys actM
context "key" $ compareLists :: (Comparable a) => [a] -> [a] -> Spec
it ("should be " ++ show ke) $ compareLists acts expects = do
ka `shouldBe` ke let
aLen = length acts
eLen = length expects
context "value" $ va `compareTest` ve) context "count elements" $
(zip3 ([0..] :: [Int]) aList eList) it ("should be " ++ show eLen) $
aLen `shouldBe` eLen
context "compare elements" $
mapM_
( \(n, act, expect) ->
context ("element " ++ show n) $
expect `compareTest` act
) $ zip3 ([0..] :: [Int]) acts expects
compareVals :: (Eq a, Show a) => a -> a -> Spec
compareVals expect act =
it ("should be " ++ show expect) $
act `shouldBe` expect
compareLenses
:: Comparable b
=> String
-> Lens' a b
-> a
-> a
-> Spec
compareLenses label lens act expect =
describe label $
(act^.lens) `compareTest` (expect^.lens)