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,133 +77,58 @@ 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" [ ( "No goalie"
& gYtd .~ goalieStats 10 11 12 , noGoalie
& gLifetime .~ goalieStats 20 21 22 , noGoalie
)
bob = newGoalie 3 "Bob" , ( "Missing goalie"
& gYtd .~ goalieStats 30 31 32 , missingGoalie
& gLifetime .~ goalieStats 40 41 42 , missingGoalie
)
]
gameState n mins goals = newGameState where
& gameGoalieStats .~ M.fromList [(1, goalieStats 1 2 3)] noGoalie = defProgState
& gameSelectedGoalie .~ n
& gameGoalieMinsPlayed .~ mins
& gameGoalsAllowed .~ goals
progState n mins goals = newProgState missingGoalie = defProgState
& database.dbGoalies .~ [joe, bob] & progMode.gameStateL.gameSelectedGoalie ?~ 99
& progMode.gameStateL .~ gameState n mins goals
in mapM_ defProgState = newProgState
(\(setName, setGid, mins, goals, joeData, bobData, reset) -> let & progMode.gameStateL
s = recordGoalieStats $ progState setGid mins goals %~ ( gameType ?~ HomeGame )
in context setName $ do . ( homeScore ?~ 2 )
. ( awayScore ?~ 1 )
& database.dbGoalies .~ [jim, bob, steve]
mapM_ jim = mkGoalie 2 "Jim" 1
(\( chkName bob = mkGoalie 3 "Bob" 2
, chkGid steve = mkGoalie 5 "Steve" 3
, ( 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" $ mkGoalie num name n = newGoalie num name
game `TS.compareTest` goalieStats gGames gMins gGoals & gYtd
%~ ( gsGames .~ n )
context "year-to-date" $ . ( gsMinsPlayed .~ n + 1 )
ytd `TS.compareTest` goalieStats ytdGames ytdMins ytdGoals . ( gsGoalsAllowed .~ n + 2 )
. ( gsShutouts .~ n + 3 )
context "lifetime" $ . ( gsWins .~ n + 4 )
lt `TS.compareTest` goalieStats ltGames ltMins ltGoals) . ( gsLosses .~ n + 5 )
. ( gsTies .~ n + 6 )
[ ( "checking Joe", 0, joeData ) & gLifetime
, ( "checking Bob", 1, bobData ) %~ ( gsGames .~ n + 7 )
] . ( gsMinsPlayed .~ n + 8 )
. ( gsGoalsAllowed .~ n + 9 )
context "selected goalie" $ let . ( gsShutouts .~ n + 10 )
expected = if reset then Nothing else setGid . ( gsWins .~ n + 11 )
in it ("should be " ++ show expected) $ . ( gsLosses .~ n + 12 )
(s^.progMode.gameStateL.gameSelectedGoalie) `shouldBe` expected . ( gsTies .~ n + 13 )
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
, Just 1
, Just 2
, (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
)
]
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
instance Comparable EditGoalieState where
compareTest act expect = do
compareLenses "egsSelectedGoalie" egsSelectedGoalie act expect
compareLenses "egsMode" egsMode act expect
instance Comparable EditGoalieMode where
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_
( \k -> context (show k) $
M.lookup k actM `compareTest` M.lookup k expectM
) $ M.keys actM
compareLists :: (Comparable a) => [a] -> [a] -> Spec
compareLists acts expects = do
let let
aList = M.toList actual aLen = length acts
eList = M.toList expected eLen = length expects
it "should have the correct number of elements" $ context "count elements" $
length aList `shouldBe` length eList it ("should be " ++ show eLen) $
aLen `shouldBe` eLen
mapM_ context "compare elements" $
(\(n, (ka, va), (ke, ve)) -> context ("element " ++ show n) $ do mapM_
( \(n, act, expect) ->
context ("element " ++ show n) $
expect `compareTest` act
) $ zip3 ([0..] :: [Int]) acts expects
context "key" $ compareVals :: (Eq a, Show a) => a -> a -> Spec
it ("should be " ++ show ke) $ compareVals expect act =
ka `shouldBe` ke it ("should be " ++ show expect) $
act `shouldBe` expect
context "value" $ va `compareTest` ve) compareLenses
(zip3 ([0..] :: [Int]) aList eList) :: Comparable b
=> String
-> Lens' a b
-> a
-> a
-> Spec
compareLenses label lens act expect =
describe label $
(act^.lens) `compareTest` (expect^.lens)