{- mtlstats Copyright (C) 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 . -} {-# LANGUAGE LambdaCase #-} module ActionsSpec (spec) where import Control.Monad (replicateM) import Lens.Micro ((^.), (&), (.~), (?~), (%~)) import Test.Hspec ( Spec , context , describe , it , shouldBe , shouldNotBe , shouldSatisfy ) import Mtlstats.Actions import Mtlstats.Types import qualified Actions.NewGameSpec as NewGame import qualified Actions.EditStandingsSpec as EditStandings import qualified TypesSpec as TS spec :: Spec spec = describe "Mtlstats.Actions" $ do startNewSeasonSpec startNewGameSpec resetYtdSpec clearRookiesSpec resetStandingsSpec addCharSpec removeCharSpec createPlayerSpec createGoalieSpec editSpec editPlayerSpec editSelectedPlayerSpec editGoalieSpec editSelectedGoalieSpec addPlayerSpec addGoalieSpec resetCreatePlayerStateSpec resetCreateGoalieStateSpec backHomeSpec NewGame.spec EditStandings.spec startNewSeasonSpec :: Spec startNewSeasonSpec = describe "startNewSeason" $ do let s = newProgState & database . dbGames .~ 1 & startNewSeason it "should set the progState to NewSeason" $ show (s^.progMode) `shouldBe` "NewSeason" it "should set the number of games to 0" $ s ^. database . dbGames `shouldBe` 0 startNewGameSpec :: Spec startNewGameSpec = describe "startNewGame" $ do let s = startNewGame newProgState it "should increment the number of games" $ s ^. database . dbGames `shouldBe` 1 it "should set the mode to NewGame" $ show (s^.progMode) `shouldBe` "NewGame" resetYtdSpec :: Spec resetYtdSpec = describe "resetYtd" $ it "should reset the year-to-date stats for all players" $ do ps <- replicateM 2 TS.makePlayer gs <- replicateM 2 TS.makeGoalie let s = newProgState & database . dbPlayers .~ ps & database . dbGoalies .~ gs & resetYtd mapM_ (\p -> do let ytd = p ^. pYtd lt = p ^. pLifetime ytd ^. psGoals `shouldBe` 0 ytd ^. psAssists `shouldBe` 0 ytd ^. psPMin `shouldBe` 0 lt ^. psGoals `shouldNotBe` 0 lt ^. psAssists `shouldNotBe` 0 lt ^. psPMin `shouldNotBe` 0) $ s ^. database . dbPlayers mapM_ (\g -> do let ytd = g ^. gYtd lt = g ^. gLifetime ytd ^. gsGames `shouldBe` 0 ytd ^. gsMinsPlayed `shouldBe` 0 ytd ^. gsGoalsAllowed `shouldBe` 0 ytd ^. gsWins `shouldBe` 0 ytd ^. gsLosses `shouldBe` 0 ytd ^. gsTies `shouldBe` 0 lt ^. gsGames `shouldNotBe` 0 lt ^. gsMinsPlayed `shouldNotBe` 0 lt ^. gsGoalsAllowed `shouldNotBe` 0 lt ^. gsWins `shouldNotBe` 0 lt ^. gsLosses `shouldNotBe` 0 lt ^. gsTies `shouldNotBe` 0) $ s ^. database . dbGoalies clearRookiesSpec :: Spec clearRookiesSpec = describe "clearRookies" $ do let players = [ newPlayer 1 "Joe" "centre" & pRookie .~ True , newPlayer 2 "Bob" "centre" & pRookie .~ False ] goalies = [ newGoalie 3 "Bill" & gRookie .~ True , newGoalie 4 "Doug" & gRookie .~ False ] ps = newProgState & database %~ (dbPlayers .~ players) . (dbGoalies .~ goalies) ps' = clearRookies ps context "Players" $ mapM_ (\p -> let name = p^.pName rFlag = p^.pRookie in context name $ it "should not be a rookie" $ rFlag `shouldBe` False) (ps'^.database.dbPlayers) context "Goalies" $ mapM_ (\g -> let name = g^.gName rFlag = g^.gRookie in context name $ it "should not be a rookie" $ rFlag `shouldBe` False) (ps'^.database.dbGoalies) resetStandingsSpec :: Spec resetStandingsSpec = describe "resetStandings" $ do let home = GameStats { _gmsWins = 1 , _gmsLosses = 2 , _gmsOvertime = 3 , _gmsGoalsFor = 4 , _gmsGoalsAgainst = 5 } away = GameStats { _gmsWins = 6 , _gmsLosses = 7 , _gmsOvertime = 8 , _gmsGoalsFor = 9 , _gmsGoalsAgainst = 10 } db = newDatabase & dbHomeGameStats .~ home & dbAwayGameStats .~ away ps = newProgState & database .~ db & resetStandings context "home standings" $ it "should be reset" $ ps^.database.dbHomeGameStats `shouldBe` newGameStats context "away standings" $ it "should be reset" $ ps^.database.dbAwayGameStats `shouldBe` newGameStats addCharSpec :: Spec addCharSpec = describe "addChar" $ it "should add the character to the input buffer" $ let s = newProgState & inputBuffer .~ "foo" & addChar 'd' in s ^. inputBuffer `shouldBe` "food" removeCharSpec :: Spec removeCharSpec = describe "removeChar" $ do context "empty" $ it "should remove the character from the input buffer" $ let s = removeChar newProgState in s ^. inputBuffer `shouldBe` "" context "not empty" $ it "should remove the character from the input buffer" $ let s = newProgState & inputBuffer .~ "foo" & removeChar in s ^. inputBuffer `shouldBe` "fo" createPlayerSpec :: Spec createPlayerSpec = describe "createPlayer" $ it "should change the mode appropriately" $ let s = createPlayer newProgState in show (s^.progMode) `shouldBe` "CreatePlayer" createGoalieSpec :: Spec createGoalieSpec = describe "createGoalie" $ it "should change the mode appropriately" $ let s = createGoalie newProgState in show (s^.progMode) `shouldBe` "CreateGoalie" editSpec :: Spec editSpec = describe "edit" $ it "should change the mode to EditMenu" $ let ps = edit newProgState in show (ps^.progMode) `shouldBe` "EditMenu" editPlayerSpec :: Spec editPlayerSpec = describe "editPlayer" $ it "should change the mode appropriately" $ let s = editPlayer newProgState in show (s^.progMode) `shouldBe` "EditPlayer" editSelectedPlayerSpec :: Spec editSelectedPlayerSpec = describe "editSelectedPlayer" $ mapM_ (\(label, pState, expected) -> context label $ it "should edit the players appropriately" $ let pState' = editSelectedPlayer (pName .~ "foo") pState players' = pState'^.database.dbPlayers in players' `shouldBe` expected) -- label, initial state, expected [ ( "wrong mode", baseState, players ) , ( "not selected", changePlayer Nothing, players ) , ( "player 0", changePlayer $ Just 0, changed0 ) , ( "player 1", changePlayer $ Just 1, changed1 ) , ( "out of bounds", changePlayer $ Just 2, players ) ] where baseState = newProgState & database.dbPlayers .~ players changePlayer n = baseState & (progMode.editPlayerStateL.epsSelectedPlayer .~ n) players = [ player 0, player 1 ] changed0 = [ player' 0, player 1 ] changed1 = [ player 0, player' 1 ] player n = newPlayer n ("Player " ++ show n) "pos" player' n = newPlayer n "foo" "pos" editGoalieSpec :: Spec editGoalieSpec = describe "editGoalie" $ it "should change the mode appropriately" $ let s = editGoalie newProgState in show (s^.progMode) `shouldBe` "EditGoalie" editSelectedGoalieSpec :: Spec editSelectedGoalieSpec = describe "editSelectedGoalie" $ mapM_ (\(label, pState, expected) -> context label $ it "should edit the goalies appropriately" $ let pState' = editSelectedGoalie (gName .~ "foo") pState goalies' = pState'^.database.dbGoalies in goalies' `shouldBe` expected) -- label, initial state, expected [ ( "wrong mode", baseState, goalies ) , ( "not selected", changeGoalie Nothing, goalies ) , ( "goalie 0", changeGoalie $ Just 0, changed0 ) , ( "goalie 1", changeGoalie $ Just 1, changed1 ) , ( "out of bounds", changeGoalie $ Just 2, goalies ) ] where baseState = newProgState & database.dbGoalies .~ goalies changeGoalie n = baseState & (progMode.editGoalieStateL.egsSelectedGoalie .~ n) goalies = [ goalie 0, goalie 1 ] changed0 = [ goalie' 0, goalie 1 ] changed1 = [ goalie 0, goalie' 1 ] goalie n = newGoalie n ("Player " ++ show n) goalie' n = newGoalie n "foo" addPlayerSpec :: Spec addPlayerSpec = describe "addPlayer" $ mapM_ (\(label, expectation, pm, players) -> context label $ it expectation $ let ps = newProgState & progMode .~ pm & database.dbPlayers .~ [joe] ps' = addPlayer ps in ps'^.database.dbPlayers `shouldBe` players) -- label, expectation, progMode, players [ ( "wrong mode", failure, MainMenu, [joe] ) , ( "missing number", failure, noNum, [joe] ) , ( "missing rookie flag", failure, noRookie, [joe] ) , ( "missing active flag", failure, noActive, [joe] ) , ( "rookie", success, mkRookie, [joe, rookie] ) , ( "retired", success, mkRetired, [joe, retired] ) , ( "normal player", success, mkNormal, [joe, normal] ) ] where failure = "should not create the player" success = "should create the player" noNum = mkpm Nothing (Just False) (Just True) noRookie = mkpm (Just 3) Nothing (Just True) noActive = mkpm (Just 3) (Just False) Nothing mkRookie = mkpm (Just 3) (Just True) (Just True) mkRetired = mkpm (Just 3) (Just False) (Just False) mkNormal = mkpm (Just 3) (Just False) (Just True) joe = newPlayer 2 "Joe" "centre" rookie = player True True retired = player False False normal = player False True player r a = newPlayer 3 "Bob" "defense" & pRookie .~ r & pActive .~ a mkpm n r a = CreatePlayer $ newCreatePlayerState & cpsNumber .~ n & cpsName .~ "Bob" & cpsPosition .~ "defense" & cpsRookieFlag .~ r & cpsActiveFlag .~ a addGoalieSpec :: Spec addGoalieSpec = describe "addGoalie" $ mapM_ (\(label, expectation, pm, goalies) -> context label $ it expectation $ let ps = newProgState & progMode .~ pm & database.dbGoalies .~ [joe] ps' = addGoalie ps in ps'^.database.dbGoalies `shouldBe` goalies) -- label, expectation, progMode, expected goalies [ ( "wrong mode", failure, MainMenu, [joe] ) , ( "no number", failure, noNum, [joe] ) , ( "no rookie flag", failure, noRookie, [joe] ) , ( "no active flag", failure, noActive, [joe] ) , ( "rookie", success, mkRookie, [joe, rookie] ) , ( "retired", success, mkRetired, [joe, retired] ) , ( "normal goalie", success, mkNormal, [joe, normal] ) ] where failure = "should not create the goalie" success = "should create the goalie" noNum = cgs Nothing (Just False) (Just True) noRookie = cgs (Just 3) Nothing (Just True) noActive = cgs (Just 3) (Just False) Nothing mkRookie = cgs (Just 3) (Just True) (Just True) mkRetired = cgs (Just 3) (Just False) (Just False) mkNormal = cgs (Just 3) (Just False) (Just True) joe = newGoalie 2 "Joe" rookie = goalie True True retired = goalie False False normal = goalie False True goalie r a = newGoalie 3 "Bob" & gRookie .~ r & gActive .~ a cgs n r a = CreateGoalie $ newCreateGoalieState & cgsNumber .~ n & cgsName .~ "Bob" & cgsRookieFlag .~ r & cgsActiveFlag .~ a resetCreatePlayerStateSpec :: Spec resetCreatePlayerStateSpec = describe "resetCreatePlayerState" $ let cps = newCreatePlayerState & cpsNumber ?~ 1 & cpsName .~ "Joe" & cpsPosition .~ "centre" ps = resetCreatePlayerState $ newProgState & progMode.createPlayerStateL .~ cps in TS.compareTest (ps^.progMode.createPlayerStateL) newCreatePlayerState resetCreateGoalieStateSpec :: Spec resetCreateGoalieStateSpec = describe "resetCreateGoalieState" $ let cgs = newCreateGoalieState & cgsNumber ?~ 1 & cgsName .~ "Joe" ps = resetCreateGoalieState $ newProgState & progMode.createGoalieStateL .~ cgs in TS.compareTest (ps^.progMode.createGoalieStateL) newCreateGoalieState backHomeSpec :: Spec backHomeSpec = describe "backHome" $ do let input = newProgState & progMode.gameStateL .~ newGameState & inputBuffer .~ "foo" result = backHome input it "should set the program mode back to MainMenu" $ result^.progMode `shouldSatisfy` \case MainMenu -> True _ -> False it "should clear the input buffer" $ result^.inputBuffer `shouldBe` ""