{- mtlstats Copyright (C) 2019 Rhéal Lamothe This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . -} module Actions.NewGameSpec (spec) where import Control.Monad (replicateM) import qualified Data.Map as M import Data.Maybe (fromJust) import Lens.Micro ((^.), (&), (.~), (?~), (%~)) import Test.Hspec (Spec, context, describe, it, runIO, shouldBe) import Mtlstats.Actions.NewGame import Mtlstats.Types import Mtlstats.Util import qualified Actions.NewGame.GoalieInputSpec as GoalieInput import qualified TypesSpec as TS spec :: Spec spec = describe "NewGame" $ do overtimeCheckSpec updateGameStatsSpec validateGameDateSpec recordGoalAssistsSpec awardGoalSpec awardAssistSpec resetGoalDataSpec assignPMinsSpec awardShutoutsSpec GoalieInput.spec overtimeCheckSpec :: Spec overtimeCheckSpec = describe "overtimeCheck" $ do context "tie game" $ do let s = newProgState & progMode.gameStateL %~ (gameType ?~ HomeGame) . (homeScore ?~ 1) . (awayScore ?~ 1) & overtimeCheck it "should clear the home score" $ s^.progMode.gameStateL.homeScore `shouldBe` Nothing it "should clear the away score" $ s^.progMode.gameStateL.awayScore `shouldBe` Nothing it "should leave the overtimeFlag blank" $ s^.progMode.gameStateL.overtimeFlag `shouldBe` Nothing context "game won" $ do let s = newProgState & progMode.gameStateL %~ (gameType ?~ HomeGame) . (homeScore ?~ 2) . (awayScore ?~ 1) & overtimeCheck it "should not change the home score" $ s^.progMode.gameStateL.homeScore `shouldBe` Just 2 it "should not change the away score" $ s^.progMode.gameStateL.awayScore `shouldBe` Just 1 it "should set the overtimeCheck flag to False" $ s^.progMode.gameStateL.overtimeFlag `shouldBe` Just False context "game lost" $ do let s = newProgState & progMode.gameStateL %~ (gameType ?~ HomeGame) . (homeScore ?~ 1) . (awayScore ?~ 2) & overtimeCheck it "should not change the home score" $ s^.progMode.gameStateL.homeScore `shouldBe` Just 1 it "should not change the away score" $ s^.progMode.gameStateL.awayScore `shouldBe` Just 2 it "should leave the overtimeCheck flag blank" $ s^.progMode.gameStateL.overtimeFlag `shouldBe` Nothing updateGameStatsSpec :: Spec updateGameStatsSpec = describe "updateGameStats" $ do let baseStats = newGameStats & gmsWins .~ 1 & gmsLosses .~ 1 & gmsOvertime .~ 1 & gmsGoalsFor .~ 1 & gmsGoalsAgainst .~ 1 s t h a o = newProgState & progMode.gameStateL %~ (gameType .~ t) . (homeScore .~ h) . (awayScore .~ a) . (overtimeFlag .~ o) & database %~ (dbHomeGameStats .~ baseStats) . (dbAwayGameStats .~ baseStats) db hw hl ho hf ha aw al ao af aa = newDatabase & dbHomeGameStats %~ (gmsWins .~ hw) . (gmsLosses .~ hl) . (gmsOvertime .~ ho) . (gmsGoalsFor .~ hf) . (gmsGoalsAgainst .~ ha) & dbAwayGameStats %~ (gmsWins .~ aw) . (gmsLosses .~ al) . (gmsOvertime .~ ao) . (gmsGoalsFor .~ af) . (gmsGoalsAgainst .~ aa) context "home win" $ it "should record a home win" $ let s' = s (Just HomeGame) (Just 2) (Just 1) (Just False) db' = updateGameStats s' ^. database in db' `shouldBe` db 2 1 1 3 2 1 1 1 1 1 context "home loss" $ it "should record a home loss" $ let s' = s (Just HomeGame) (Just 1) (Just 2) (Just False) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 2 1 2 3 1 1 1 1 1 context "home overtime loss" $ it "should record a home overtime" $ let s' = s (Just HomeGame) (Just 1) (Just 2) (Just True) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 2 2 3 1 1 1 1 1 context "away win" $ it "should record an away win" $ let s' = s (Just AwayGame) (Just 1) (Just 2) (Just False) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 1 1 1 2 1 1 3 2 context "away loss" $ it "should record an away loss" $ let s' = s (Just AwayGame) (Just 2) (Just 1) (Just False) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 1 1 1 1 2 1 2 3 context "away overtime loss" $ it "should record an away overtime" $ let s' = s (Just AwayGame) (Just 2) (Just 1) (Just True) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 1 1 1 1 1 2 2 3 context "missing game type" $ it "should not change anything" $ let s' = s Nothing (Just 1) (Just 2) (Just True) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1 context "missing home score" $ it "should not change anything" $ let s' = s (Just HomeGame) Nothing (Just 1) (Just True) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1 context "missing away score" $ it "should not change anything" $ let s' = s (Just HomeGame) (Just 1) Nothing (Just True) db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1 context "missing overtime flag" $ it "should not change anything" $ let s' = s (Just HomeGame) (Just 1) (Just 2) Nothing db' = updateGameStats s' ^. database in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1 validateGameDateSpec :: Spec validateGameDateSpec = describe "validateGameDate" $ do context "valid date" $ it "should leave the date unchanged" $ do let s = newProgState & progMode.gameStateL %~ (gameYear ?~ 2019) . (gameMonth ?~ 6) . (gameDay ?~ 25) & validateGameDate s^.progMode.gameStateL.gameYear `shouldBe` Just 2019 s^.progMode.gameStateL.gameMonth `shouldBe` Just 6 s^.progMode.gameStateL.gameDay `shouldBe` Just 25 context "invalid date" $ it "should clear the date" $ do let s = newProgState & progMode.gameStateL %~ (gameYear ?~ 2019) . (gameMonth ?~ 2) . (gameDay ?~ 30) & validateGameDate s^.progMode.gameStateL.gameYear `shouldBe` Nothing s^.progMode.gameStateL.gameMonth `shouldBe` Nothing s^.progMode.gameStateL.gameDay `shouldBe` Nothing context "missing day" $ it "should not change anything" $ do let gs = newGameState & gameYear ?~ 2019 & gameMonth ?~ 6 s = newProgState & progMode.gameStateL .~ gs & validateGameDate s^.progMode.gameStateL.gameYear `shouldBe` Just 2019 s^.progMode.gameStateL.gameMonth `shouldBe` Just 6 s^.progMode.gameStateL.gameDay `shouldBe` Nothing recordGoalAssistsSpec :: Spec recordGoalAssistsSpec = describe "recordGoalAssists" $ do let joe = newPlayer 1 "Joe" "centre" bob = newPlayer 2 "Bob" "defense" steve = newPlayer 3 "Steve" "forward" dave = newPlayer 4 "Dave" "somewhere" frank = newPlayer 5 "Frank" "elsewhere" ps = newProgState & database.dbPlayers .~ [joe, bob, steve, dave, frank] & progMode.gameStateL %~ (goalBy ?~ 0) . (assistsBy .~ [1, 2]) . (confirmGoalDataFlag .~ True) & recordGoalAssists mapM_ (\(name, n, goals, assists) -> context name $ do let player = (ps^.database.dbPlayers) !! n stats = M.findWithDefault newPlayerStats n $ ps^.progMode.gameStateL.gamePlayerStats it ("should set the year-to-date goals to " ++ show goals) $ player^.pYtd.psGoals `shouldBe` goals it ("should set the lifetime goals to " ++ show goals) $ player^.pLifetime.psGoals `shouldBe` goals it ("should set the game goals to " ++ show goals) $ stats^.psAssists `shouldBe` assists it ("should set the year-to-date assists to " ++ show assists) $ player^.pYtd.psAssists `shouldBe` assists it ("should set the lifetime assists to " ++ show assists) $ player^.pLifetime.psAssists `shouldBe` assists it ("should set the game assists to " ++ show assists) $ stats^.psAssists `shouldBe` assists) -- name, index, goals, assists [ ( "Joe", 0, 1, 0 ) , ( "Bob", 1, 0, 1 ) , ( "Steve", 2, 0, 1 ) , ( "Dave", 3, 0, 0 ) ] it "should clear the goalBy value" $ ps^.progMode.gameStateL.goalBy `shouldBe` Nothing it "should clear the assistsBy list" $ ps^.progMode.gameStateL.assistsBy `shouldBe` [] it "should increment the pointsAccounted counter" $ ps^.progMode.gameStateL.pointsAccounted `shouldBe` 1 it "should clear the confirmGoalDataFlag" $ ps^.progMode.gameStateL.confirmGoalDataFlag `shouldBe` False awardGoalSpec :: Spec awardGoalSpec = describe "awardGoal" $ do let joe = newPlayer 2 "Joe" "centre" & pYtd.psGoals .~ 1 & pLifetime.psGoals .~ 2 bob = newPlayer 3 "Bob" "defense" & pYtd.psGoals .~ 3 & pLifetime.psGoals .~ 4 db = newDatabase & dbPlayers .~ [joe, bob] joeStats = newPlayerStats & psGoals .~ 1 ps = newProgState & progMode.gameStateL.gamePlayerStats .~ M.singleton 0 joeStats & database .~ db mapM_ (\(name, pid, ytd, lt, game) -> context name $ do let ps' = awardGoal pid ps player = (ps'^.database.dbPlayers) !! pid gStats = (ps'^.progMode.gameStateL.gamePlayerStats) M.! pid it ("should increment " ++ name ++ "'s year-to-date goals") $ player^.pYtd.psGoals `shouldBe` ytd it ("should increment " ++ name ++ "'s lifetime goals") $ player^.pLifetime.psGoals `shouldBe` lt it ("should increment " ++ name ++ "'s game goals") $ gStats^.psGoals `shouldBe` game) -- player name, player id, ytd goals, lifetime goals, game goals [ ( "Joe", 0, 2, 3, 2 ) , ( "Bob", 1, 4, 5, 1 ) ] context "invalid index" $ let ps' = awardGoal 2 ps in it "should not change the database" $ ps'^.database `shouldBe` db context "negative index" $ let ps' = awardGoal (-1) ps in it "should not change the database" $ ps'^.database `shouldBe` db awardAssistSpec :: Spec awardAssistSpec = describe "awardAssist" $ do let joe = newPlayer 1 "Joe" "centre" & pYtd.psAssists .~ 1 & pLifetime.psAssists .~ 2 bob = newPlayer 2 "Bob" "defense" & pYtd.psAssists .~ 3 & pLifetime.psAssists .~ 4 joeStats = newPlayerStats & psAssists .~ 1 ps = newProgState & progMode.gameStateL.gamePlayerStats .~ M.singleton 0 joeStats & database.dbPlayers .~ [joe, bob] mapM_ (\(name, pid, ytd, lt, game) -> context name $ do let ps' = awardAssist pid ps player = (ps'^.database.dbPlayers) !! pid gStats = (ps'^.progMode.gameStateL.gamePlayerStats) M.! pid it ("should increment " ++ name ++ "'s year-to-date assists") $ player^.pYtd.psAssists `shouldBe` ytd it ("should increment " ++ name ++ "'s lifetime assists") $ player^.pLifetime.psAssists `shouldBe` lt it ("should increment " ++ name ++ "'s game assists") $ gStats^.psAssists `shouldBe` game) -- player name, player id, ytd assists, lifetime assists, game assists [ ( "Joe", 0, 2, 3, 2 ) , ( "Bob", 1, 4, 5, 1 ) ] context "invalid index" $ let ps' = awardAssist (-1) ps in it "should not change anything" $ ps'^.database.dbPlayers `shouldBe` ps^.database.dbPlayers resetGoalDataSpec :: Spec resetGoalDataSpec = describe "resetGoalData" $ do players <- runIO $ replicateM 5 TS.makePlayer let gs = newGameState & goalBy ?~ 1 & assistsBy .~ [2, 3] & confirmGoalDataFlag .~ True ps = newProgState & database.dbPlayers .~ players & progMode.gameStateL .~ gs & resetGoalData it "should clear the goalBy value" $ ps^.progMode.gameStateL.goalBy `shouldBe` Nothing it "should clear the assists by list" $ ps^.progMode.gameStateL.assistsBy `shouldBe` [] it "should clear confirmGoalDataFlag" $ ps^.progMode.gameStateL.confirmGoalDataFlag `shouldBe` False assignPMinsSpec :: Spec assignPMinsSpec = describe "assignPMins" $ let bob = newPlayer 2 "Bob" "centre" & pYtd.psPMin .~ 3 & pLifetime.psPMin .~ 4 joe = newPlayer 3 "Joe" "defense" & pYtd.psPMin .~ 5 & pLifetime.psPMin .~ 6 ps pid = newProgState & database.dbPlayers .~ [bob, joe] & progMode.gameStateL %~ (gamePlayerStats .~ M.fromList [(0, newPlayerStats & psPMin .~ 2)]) . (gameSelectedPlayer .~ pid) in mapM_ (\(pid, bobLt, bobYtd, bobGame, joeLt, joeYtd, joeGame) -> context ("selectedPlayer = " ++ show pid) $ do let ps' = assignPMins 2 $ ps pid mapM_ (\(name, pid', lt, ytd, game) -> context name $ do let player = fromJust $ nth pid' $ ps'^.database.dbPlayers gStats = ps'^.progMode.gameStateL.gamePlayerStats pStats = M.findWithDefault newPlayerStats pid' gStats context "lifetime penalty minutes" $ it ("should be " ++ show lt) $ player^.pLifetime.psPMin `shouldBe` lt context "year-to-date penalty minutes" $ it ("should be " ++ show ytd) $ player^.pYtd.psPMin `shouldBe` ytd context "game penalty minutes" $ it ("should be " ++ show game) $ pStats^.psPMin `shouldBe` game) -- name, index, lifetime, ytd, game [ ( "Bob", 0, bobLt, bobYtd, bobGame ) , ( "Joe", 1, joeLt, joeYtd, joeGame ) ] it "should set selectedPlayer to Nothing" $ ps'^.progMode.gameStateL.gameSelectedPlayer `shouldBe` Nothing) -- index, bob lt, bob ytd, bob game, joe lt, joe ytd, joe game [ ( Just 0, 6, 5, 4, 6, 5, 0 ) , ( Just 1, 4, 3, 2, 8, 7, 2 ) , ( Just 2, 4, 3, 2, 6, 5, 0 ) , ( Nothing, 4, 3, 2, 6, 5, 0 ) ] awardShutoutsSpec :: Spec awardShutoutsSpec = describe "awardShutouts" $ let joe = newGoalie 2 "Joe" & gYtd.gsShutouts .~ 1 & gLifetime.gsShutouts .~ 2 bob = newGoalie 3 "Bob" & gYtd.gsShutouts .~ 3 & gLifetime.gsShutouts .~ 4 steve = newGoalie 5 "Steve" & gYtd.gsShutouts .~ 5 & gLifetime.gsShutouts .~ 6 ps = newProgState & database.dbGoalies .~ [joe, bob, steve] & progMode.gameStateL.gameGoalieStats .~ M.fromList [ ( 0, newGoalieStats & gsGoalsAllowed .~ 1 ) , ( 1, newGoalieStats ) ] & awardShutouts in mapM_ (\(name, gid, expectedGame, expectedYtd, expectedLt) -> context name $ let game = M.findWithDefault newGoalieStats gid $ ps^.progMode.gameStateL.gameGoalieStats goalie = (ps^.database.dbGoalies) !! gid in mapM_ (\(label, actual, expected) -> context label $ it ("should be " ++ show actual) $ actual `shouldBe` expected) -- label, actual, expected [ ( "Game", game^.gsShutouts, expectedGame ) , ( "YTD", goalie^.gYtd.gsShutouts, expectedYtd ) , ( "lifetime", goalie^.gLifetime.gsShutouts, expectedLt ) ]) -- goalie, goalie ID, Game, YTD, lifetime [ ( "Joe", 0, 0, 1, 2 ) , ( "Bob", 1, 1, 4, 5 ) , ( "Steve", 2, 0, 5, 6 ) ]