From d9b2256047669b5a5dbac4baec7140f18a5b6eff Mon Sep 17 00:00:00 2001 From: Akshay Nair Date: Wed, 25 Dec 2024 22:49:41 +0530 Subject: Refactor state update + test fixes --- specs/Main.hs | 4 +- specs/Specs/AppEventSpec.hs | 38 +++--- specs/Specs/AppStateSpec.hs | 276 ++++++++++++++++++++++++++++++++++++++ specs/Specs/AppStateUpdateSpec.hs | 246 --------------------------------- specs/Specs/ViewSpec.hs | 22 +-- specs/TestUtils.hs | 8 +- 6 files changed, 312 insertions(+), 282 deletions(-) create mode 100644 specs/Specs/AppStateSpec.hs delete mode 100644 specs/Specs/AppStateUpdateSpec.hs (limited to 'specs') diff --git a/specs/Main.hs b/specs/Main.hs index 91a9e5a..4af8694 100644 --- a/specs/Main.hs +++ b/specs/Main.hs @@ -1,7 +1,7 @@ module Main (main) where import qualified Specs.AppEventSpec -import qualified Specs.AppStateUpdateSpec +import qualified Specs.AppStateSpec import qualified Specs.KeySequenceSpec import qualified Specs.ViewSpec import Test.Hspec (hspec) @@ -9,6 +9,6 @@ import Test.Hspec (hspec) main :: IO () main = hspec $ do Specs.AppEventSpec.test - Specs.AppStateUpdateSpec.test + Specs.AppStateSpec.test Specs.KeySequenceSpec.test Specs.ViewSpec.test diff --git a/specs/Specs/AppEventSpec.hs b/specs/Specs/AppEventSpec.hs index db292a7..e643958 100644 --- a/specs/Specs/AppEventSpec.hs +++ b/specs/Specs/AppEventSpec.hs @@ -9,7 +9,7 @@ import Unsafe.Coerce (unsafeCoerce) test :: SpecWith () test = do - describe "#eventHandler" $ do + describe "#eventHandler currentState" $ do let mkEvent payload = SDL.Event {SDL.eventTimestamp = 0, SDL.eventPayload = payload} let mkKeyboardEvent key motion modifier = mkEvent $ @@ -26,78 +26,74 @@ test = do SDL.keyboardEventKeyMotion = motion } let defaultMod = fromNumber 0 + let currentState = defaultAppState context "when window quit event is triggered" $ do it "shuts down app" $ do - let action = eventHandler $ mkEvent SDL.QuitEvent + let action = eventHandler currentState $ mkEvent SDL.QuitEvent action `shouldBe` Just ShutdownApp context "when escape key is pressed" $ do it "shuts down app" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeEscape SDL.Pressed defaultMod + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeEscape SDL.Pressed defaultMod action `shouldBe` Just ShutdownApp context "when ctrl+v is pressed" $ do it "toggles dragging" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeV SDL.Pressed (defaultMod {SDL.keyModifierLeftCtrl = True}) + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeV SDL.Pressed (defaultMod {SDL.keyModifierLeftCtrl = True}) action `shouldBe` Just MouseDragToggle context "when space key is pressed" $ do it "triggers left mouse button click" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeSpace SDL.Pressed defaultMod + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeSpace SDL.Pressed defaultMod action `shouldBe` Just (TriggerMouseClick LeftClick) context "when pressed with right shift" $ do it "chains left mouse button click" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeSpace SDL.Pressed (defaultMod {SDL.keyModifierRightShift = True}) + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeSpace SDL.Pressed (defaultMod {SDL.keyModifierRightShift = True}) action `shouldBe` Just (ChainMouseClick LeftClick) context "when pressed with left shift" $ do it "chains left mouse button click" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeSpace SDL.Pressed (defaultMod {SDL.keyModifierLeftShift = True}) + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeSpace SDL.Pressed (defaultMod {SDL.keyModifierLeftShift = True}) action `shouldBe` Just (ChainMouseClick LeftClick) context "when minus key is pressed" $ do it "triggers left mouse button click" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeMinus SDL.Pressed defaultMod + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeMinus SDL.Pressed defaultMod action `shouldBe` Just (TriggerMouseClick RightClick) context "when pressed with right shift" $ do it "chains right mouse button click" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeMinus SDL.Pressed (defaultMod {SDL.keyModifierRightShift = True}) + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeMinus SDL.Pressed (defaultMod {SDL.keyModifierRightShift = True}) action `shouldBe` Just (ChainMouseClick RightClick) context "when pressed with left shift" $ do it "chains right mouse button click" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeMinus SDL.Pressed (defaultMod {SDL.keyModifierLeftShift = True}) + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeMinus SDL.Pressed (defaultMod {SDL.keyModifierLeftShift = True}) action `shouldBe` Just (ChainMouseClick RightClick) - context "when tab key is pressed" $ do - it "resets key state" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeTab SDL.Pressed defaultMod - action `shouldBe` Just ResetKeys - context "when backspace key is pressed" $ do it "resets key state" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeBackspace SDL.Pressed defaultMod + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeBackspace SDL.Pressed defaultMod action `shouldBe` Just ResetKeys context "when an alphanumeric key (excluding Q) is pressed" $ do it "calls key input handler" $ do - eventHandler (mkKeyboardEvent SDL.KeycodeA SDL.Pressed defaultMod) `shouldBe` Just (HandleKeyInput SDL.KeycodeA) - eventHandler (mkKeyboardEvent SDL.KeycodeQ SDL.Pressed defaultMod) `shouldBe` Just (HandleKeyInput SDL.KeycodeQ) + eventHandler currentState (mkKeyboardEvent SDL.KeycodeA SDL.Pressed defaultMod) `shouldBe` Just (HandleKeyInput SDL.KeycodeA) + eventHandler currentState (mkKeyboardEvent SDL.KeycodeQ SDL.Pressed defaultMod) `shouldBe` Just (HandleKeyInput SDL.KeycodeQ) context "when shift key is pressed" $ do it "enables shift" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeRShift SDL.Pressed defaultMod + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeRShift SDL.Pressed defaultMod action `shouldBe` Just (UpdateShiftState True) context "when shift key is released" $ do it "disabled shift" $ do - let action = eventHandler $ mkKeyboardEvent SDL.KeycodeRShift SDL.Released defaultMod + let action = eventHandler currentState $ mkKeyboardEvent SDL.KeycodeRShift SDL.Released defaultMod action `shouldBe` Just (UpdateShiftState False) context "when digit is pressed" $ do it "sets repetition count" $ do - let action = eventHandler $ mkKeyboardEvent SDL.Keycode9 SDL.Pressed defaultMod + let action = eventHandler currentState $ mkKeyboardEvent SDL.Keycode9 SDL.Pressed defaultMod action `shouldBe` Just (UpdateRepetition 9) diff --git a/specs/Specs/AppStateSpec.hs b/specs/Specs/AppStateSpec.hs new file mode 100644 index 0000000..eb5ab1b --- /dev/null +++ b/specs/Specs/AppStateSpec.hs @@ -0,0 +1,276 @@ +module Specs.AppStateSpec where + +import Chelleport.AppState (initialState, update) +import Chelleport.Types +import Chelleport.Utils (uniq) +import Control.Monad (join) +import qualified SDL +import Test.Hspec +import TestUtils + +test :: SpecWith () +test = do + describe "#initialState" $ do + it "returns the initial state of the app" $ do + ((initState, _), _) <- runWithMocks initialState + stateKeySequence initState `shouldBe` [] + stateIsMatched initState `shouldBe` False + stateIsShiftPressed initState `shouldBe` False + + it "returns grid with 16x9 key sequences" $ do + ((initState, _), _) <- runWithMocks initialState + length (stateGrid initState) `shouldBe` 9 + stateGrid initState `shouldSatisfy` all ((== 16) . length) + stateGrid initState `shouldSatisfy` all (all ((== 2) . length)) + + it "returns grid with all unique key sequences" $ do + ((initState, _), _) <- runWithMocks initialState + join (stateGrid initState) `shouldBe` uniq (join $ stateGrid initState) + + describe "#update" $ do + let defaultState = defaultAppState {stateGrid = [["ABC", "DEF"], ["DJK", "JKL"]]} + + context "with action ChainMouseClick" $ do + let currentState = defaultState + + it "hides window, triggers mouse click and shows the window again" $ do + (_, mock) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick + calls mock `shouldBe` [Mock_hideWindow, Mock_clickMouseButton LeftClick, Mock_showWindow] + + it "continues with action ResetKeys without updating state" $ do + ((nextState, action), _) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick + action `shouldBe` Just ResetKeys + nextState `shouldBe` currentState + + context "when repetition is more than 1" $ do + let currentState = defaultState {stateRepetition = 3} + + it "resets repetition back to 1" $ do + ((nextState, _), _) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick + nextState `shouldBe` currentState {stateRepetition = 1} + + it "clicks multiple times" $ do + (_, mock) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick + calls mock + `shouldBe` [ Mock_hideWindow, + Mock_clickMouseButton LeftClick, + Mock_clickMouseButton LeftClick, + Mock_clickMouseButton LeftClick, + Mock_showWindow + ] + + context "when repetition is 0" $ do + let currentState = defaultState {stateRepetition = 0} + + it "clicks just once" $ do + (_, mock) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick + calls mock `shouldBe` [Mock_hideWindow, Mock_clickMouseButton LeftClick, Mock_showWindow] + + context "with action IncrementHighlightIndex" $ do + let currentState = defaultState + + it "todo: implement" $ do + 1 `shouldBe` 1 + + context "with action IncrementMouseCursor" $ do + let currentState = defaultState + + it "continues with MoveMousePosition" $ do + ((_, action), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) + action `shouldBe` Just (MoveMousePosition (52, 37)) + + it "does update state" $ do + ((state, _), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) + state `shouldBe` currentState + + context "when repetition is more than 1" $ do + let currentState = defaultState {stateRepetition = 5} + + it "multiplies increment" $ do + ((_, action), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) + action `shouldBe` Just (MoveMousePosition (92, 17)) + + context "when repetition is 0" $ do + let currentState = defaultState {stateRepetition = 0} + + it "increments just once" $ do + ((_, action), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) + action `shouldBe` Just (MoveMousePosition (52, 37)) + + context "with action MouseDragEnd" $ do + let currentState = defaultState + + it "hides window, stops dragging and shows the window again" $ do + (_, mock) <- runWithMocks $ update currentState MouseDragEnd + calls mock `shouldContain` [Mock_hideWindow, Mock_releaseMouseButton, Mock_showWindow] + + it "does not continue or update state" $ do + (result, _) <- runWithMocks $ update currentState MouseDragStart + result `shouldBe` (currentState, Nothing) + + context "with action MouseDragStart" $ do + let currentState = defaultState + + it "hides window, starts dragging and shows the window again" $ do + (_, mock) <- runWithMocks $ update currentState MouseDragStart + calls mock `shouldContain` [Mock_hideWindow, Mock_pressMouseButton, Mock_showWindow] + + it "does not continue or update state" $ do + (result, _) <- runWithMocks $ update currentState MouseDragStart + result `shouldBe` (currentState, Nothing) + + context "with action MouseDragToggle" $ do + context "when is dragging is true" $ do + let currentState = defaultState {stateIsDragging = True} + + it "toggles dragging state" $ do + ((state, _), _) <- runWithMocks $ update currentState MouseDragToggle + state `shouldBe` state {stateIsDragging = False} + + it "continues with action MouseDragEnd" $ do + ((_, action), _) <- runWithMocks $ update currentState MouseDragToggle + action `shouldBe` Just MouseDragEnd + + context "when is dragging is false" $ do + let currentState = defaultState {stateIsDragging = False} + + it "toggles dragging state" $ do + ((state, _), _) <- runWithMocks $ update currentState MouseDragToggle + state `shouldBe` state {stateIsDragging = True} + + it "continues with action MouseDragStart" $ do + ((_, action), _) <- runWithMocks $ update currentState MouseDragToggle + action `shouldBe` Just MouseDragStart + + context "with action HandleKeyInput" $ do + context "when mode is ModeSearch" $ do + it "todo: implement" $ do + 1 `shouldBe` 1 + + context "when mode is ModeHints" $ do + context "when there are no matches" $ do + let currentState = defaultState {stateKeySequence = "D", stateMode = defaultHintsMode} + + context "when input key sequence has matching values in grid" $ do + it "does not update" $ do + ((nextState, action), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeZ + action `shouldBe` Nothing + nextState `shouldBe` currentState + + context "when input key sequence does not have matching values in grid" $ do + it "adds key to key sequence" $ do + ((nextState, action), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeE + action `shouldBe` Nothing + nextState `shouldBe` currentState {stateKeySequence = "DE"} + + context "when there is a matches" $ do + let currentState = defaultState {stateKeySequence = "DE", stateMode = defaultHintsMode} + + context "when input key sequence does not have matching values in grid" $ do + it "adds key to key sequence and enables isMatched" $ do + ((nextState, _), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeF + nextState `shouldBe` currentState {stateKeySequence = "DEF", stateIsMatched = True} + + it "continues with MoveMousePosition action at center of matched cell" $ do + ((_, action), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeF + action `shouldBe` Just (MoveMousePosition (1640, 370)) + + context "with action MoveMousePosition" $ do + let currentState = defaultState + + it "moves mouse pointer to the given coordinates" $ do + (_, mock) <- runWithMocks $ update currentState $ MoveMousePosition (23, 320) + mock `shouldHaveCalled` Mock_moveMousePointer 23 320 + + it "does not continue or update state" $ do + (result, _) <- runWithMocks $ update currentState $ MoveMousePosition (0, 0) + result `shouldBe` (currentState, Nothing) + + context "with action ResetKeys" $ do + let currentState = defaultState {stateRepetition = 5} + + it "resets state without any action" $ do + ((nextState, action), _) <- runWithMocks $ update currentState ResetKeys + action `shouldBe` Nothing + nextState `shouldBe` currentState {stateKeySequence = [], stateIsMatched = False, stateRepetition = 1} + + context "with action SetMode" $ do + let currentState = defaultState + + context "when mode is ModeHints" $ do + it "updates mode in state" $ do + ((nextState, action), _) <- runWithMocks $ update currentState $ SetMode defaultHintsMode + nextState `shouldBe` currentState {stateMode = defaultHintsMode} + action `shouldBe` Nothing + + context "when mode is ModeSearch" $ do + it "captures screenshot for word search" $ do + ((_, _), mock) <- runWithMocks $ update currentState $ SetMode defaultSearchMode + mock `shouldHaveCalled` Mock_captureScreenshot (mockWindowOffsetX, mockWindowOffsetY) (mockWindowWidth, mockWindowHeight) + + it "updates mode in state with ocr words" $ do + ((nextState, _), _) <- runWithMocks $ update currentState $ SetMode defaultSearchMode + let matchWord = OCRMatch {matchStartX = 40, matchStartY = 5, matchEndX = 100, matchEndY = 20, matchText = "Wow"} + nextState `shouldBe` currentState {stateMode = defaultSearchMode {searchWords = [matchWord], searchFilteredWords = [matchWord]}} + + context "with action ShutdownApp" $ do + let currentState = defaultState + + it "shuts down app" $ do + (_, mock) <- runWithMocks $ update currentState ShutdownApp + mock `shouldHaveCalled` Mock_shutdownApp + + it "does not continue or update state" $ do + (result, _) <- runWithMocks $ update currentState ShutdownApp + result `shouldBe` (currentState, Nothing) + + context "with action TriggerMouseClick" $ do + let currentState = defaultState + + it "hides window and triggers mouse click" $ do + (_, mock) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick + calls mock `shouldContain` [Mock_hideWindow, Mock_clickMouseButton LeftClick] + + it "continues with action ShutdownApp without updating state" $ do + ((nextState, action), _) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick + action `shouldBe` Just ShutdownApp + nextState `shouldBe` currentState + + context "when repetition is more than 1" $ do + let currentState = defaultState {stateRepetition = 3} + + it "resets repetition back to 1" $ do + ((nextState, _), _) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick + nextState `shouldBe` currentState {stateRepetition = 1} + + it "clicks multiple times" $ do + (_, mock) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick + calls mock + `shouldBe` [ Mock_hideWindow, + Mock_clickMouseButton LeftClick, + Mock_clickMouseButton LeftClick, + Mock_clickMouseButton LeftClick + ] + + context "when repetition is 0" $ do + let currentState = defaultState {stateRepetition = 0} + + it "clicks just once" $ do + (_, mock) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick + calls mock `shouldBe` [Mock_hideWindow, Mock_clickMouseButton LeftClick] + + context "with action UpdateRepetition" $ do + let currentState = defaultState + + it "updates shift state without any action" $ do + ((nextState, action), _) <- runWithMocks $ update currentState $ UpdateRepetition 7 + action `shouldBe` Nothing + nextState `shouldBe` currentState {stateRepetition = 7} + + context "with action UpdateShiftState" $ do + let currentState = defaultState + + it "updates shift state without any action" $ do + ((nextState, action), _) <- runWithMocks $ update currentState $ UpdateShiftState True + action `shouldBe` Nothing + nextState `shouldBe` currentState {stateIsShiftPressed = True} diff --git a/specs/Specs/AppStateUpdateSpec.hs b/specs/Specs/AppStateUpdateSpec.hs deleted file mode 100644 index 861264d..0000000 --- a/specs/Specs/AppStateUpdateSpec.hs +++ /dev/null @@ -1,246 +0,0 @@ -module Specs.AppStateUpdateSpec where - -import Chelleport (initialState, update) -import Chelleport.Types -import Chelleport.Utils (uniq) -import Control.Monad (join) -import qualified SDL -import Test.Hspec -import TestUtils - -test :: SpecWith () -test = do - describe "#initialState" $ do - it "returns the initial state of the app" $ do - ((initState, _), _) <- runWithMocks initialState - stateKeySequence initState `shouldBe` [] - stateIsMatched initState `shouldBe` False - stateIsShiftPressed initState `shouldBe` False - - it "returns grid with 16x9 key sequences" $ do - ((initState, _), _) <- runWithMocks initialState - length (stateGrid initState) `shouldBe` 9 - stateGrid initState `shouldSatisfy` all ((== 16) . length) - stateGrid initState `shouldSatisfy` all (all ((== 2) . length)) - - it "returns grid with all unique key sequences" $ do - ((initState, _), _) <- runWithMocks initialState - join (stateGrid initState) `shouldBe` uniq (join $ stateGrid initState) - - describe "#update" $ do - let defaultState = defaultAppState {stateGrid = [["ABC", "DEF"], ["DJK", "JKL"]]} - - context "with action HandleKeyInput" $ do - context "when there are no matches" $ do - let currentState = defaultState {stateKeySequence = "D"} - - context "when input key sequence has matching values in grid" $ do - it "does not update" $ do - ((nextState, action), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeZ - action `shouldBe` Nothing - nextState `shouldBe` currentState - - context "when input key sequence does not have matching values in grid" $ do - it "adds key to key sequence" $ do - ((nextState, action), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeE - action `shouldBe` Nothing - nextState `shouldBe` currentState {stateKeySequence = "DE"} - - context "when there is a matches" $ do - let currentState = defaultState {stateKeySequence = "DE"} - - context "when input key sequence does not have matching values in grid" $ do - it "adds key to key sequence and enables isMatched" $ do - ((nextState, _), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeF - nextState `shouldBe` currentState {stateKeySequence = "DEF", stateIsMatched = True} - - it "continues with MoveMousePosition action at center of matched cell" $ do - ((_, action), _) <- runWithMocks $ update currentState $ HandleKeyInput SDL.KeycodeF - action `shouldBe` Just (MoveMousePosition (1640, 370)) - - context "with action TriggerMouseClick" $ do - let currentState = defaultState - - it "hides window and triggers mouse click" $ do - (_, mock) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick - calls mock `shouldContain` [Mock_hideWindow, Mock_clickMouseButton LeftClick] - - it "continues with action ShutdownApp without updating state" $ do - ((nextState, action), _) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick - action `shouldBe` Just ShutdownApp - nextState `shouldBe` currentState - - context "when repetition is more than 1" $ do - let currentState = defaultState {stateRepetition = 3} - - it "resets repetition back to 1" $ do - ((nextState, _), _) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick - nextState `shouldBe` currentState {stateRepetition = 1} - - it "clicks multiple times" $ do - (_, mock) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick - calls mock - `shouldBe` [ Mock_hideWindow, - Mock_clickMouseButton LeftClick, - Mock_clickMouseButton LeftClick, - Mock_clickMouseButton LeftClick - ] - - context "when repetition is 0" $ do - let currentState = defaultState {stateRepetition = 0} - - it "clicks just once" $ do - (_, mock) <- runWithMocks $ update currentState $ TriggerMouseClick LeftClick - calls mock `shouldBe` [Mock_hideWindow, Mock_clickMouseButton LeftClick] - - context "with action ChainMouseClick" $ do - let currentState = defaultState - - it "hides window, triggers mouse click and shows the window again" $ do - (_, mock) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick - calls mock `shouldBe` [Mock_hideWindow, Mock_clickMouseButton LeftClick, Mock_showWindow] - - it "continues with action ResetKeys without updating state" $ do - ((nextState, action), _) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick - action `shouldBe` Just ResetKeys - nextState `shouldBe` currentState - - context "when repetition is more than 1" $ do - let currentState = defaultState {stateRepetition = 3} - - it "resets repetition back to 1" $ do - ((nextState, _), _) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick - nextState `shouldBe` currentState {stateRepetition = 1} - - it "clicks multiple times" $ do - (_, mock) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick - calls mock - `shouldBe` [ Mock_hideWindow, - Mock_clickMouseButton LeftClick, - Mock_clickMouseButton LeftClick, - Mock_clickMouseButton LeftClick, - Mock_showWindow - ] - - context "when repetition is 0" $ do - let currentState = defaultState {stateRepetition = 0} - - it "clicks just once" $ do - (_, mock) <- runWithMocks $ update currentState $ ChainMouseClick LeftClick - calls mock `shouldBe` [Mock_hideWindow, Mock_clickMouseButton LeftClick, Mock_showWindow] - - context "with action MouseDragToggle" $ do - context "when is dragging is true" $ do - let currentState = defaultState {stateIsDragging = True} - - it "toggles dragging state" $ do - ((state, _), _) <- runWithMocks $ update currentState MouseDragToggle - state `shouldBe` state {stateIsDragging = False} - - it "continues with action MouseDragEnd" $ do - ((_, action), _) <- runWithMocks $ update currentState MouseDragToggle - action `shouldBe` Just MouseDragEnd - - context "when is dragging is false" $ do - let currentState = defaultState {stateIsDragging = False} - - it "toggles dragging state" $ do - ((state, _), _) <- runWithMocks $ update currentState MouseDragToggle - state `shouldBe` state {stateIsDragging = True} - - it "continues with action MouseDragStart" $ do - ((_, action), _) <- runWithMocks $ update currentState MouseDragToggle - action `shouldBe` Just MouseDragStart - - context "with action MouseDragStart" $ do - let currentState = defaultState - - it "hides window, starts dragging and shows the window again" $ do - (_, mock) <- runWithMocks $ update currentState MouseDragStart - calls mock `shouldContain` [Mock_hideWindow, Mock_pressMouseButton, Mock_showWindow] - - it "does not continue or update state" $ do - (result, _) <- runWithMocks $ update currentState MouseDragStart - result `shouldBe` (currentState, Nothing) - - context "with action MouseDragEnd" $ do - let currentState = defaultState - - it "hides window, stops dragging and shows the window again" $ do - (_, mock) <- runWithMocks $ update currentState MouseDragEnd - calls mock `shouldContain` [Mock_hideWindow, Mock_releaseMouseButton, Mock_showWindow] - - it "does not continue or update state" $ do - (result, _) <- runWithMocks $ update currentState MouseDragStart - result `shouldBe` (currentState, Nothing) - - context "with action MoveMousePosition" $ do - let currentState = defaultState - - it "moves mouse pointer to the given coordinates" $ do - (_, mock) <- runWithMocks $ update currentState $ MoveMousePosition (23, 320) - mock `shouldHaveCalled` Mock_moveMousePointer 23 320 - - it "does not continue or update state" $ do - (result, _) <- runWithMocks $ update currentState $ MoveMousePosition (0, 0) - result `shouldBe` (currentState, Nothing) - - context "with action ResetKeys" $ do - let currentState = defaultState {stateRepetition = 5} - - it "resets state without any action" $ do - ((nextState, action), _) <- runWithMocks $ update currentState ResetKeys - action `shouldBe` Nothing - nextState `shouldBe` currentState {stateKeySequence = [], stateIsMatched = False, stateRepetition = 1} - - context "with action IncrementMouseCursor" $ do - let currentState = defaultState - - it "continues with MoveMousePosition" $ do - ((_, action), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) - action `shouldBe` Just (MoveMousePosition (52, 37)) - - it "does update state" $ do - ((state, _), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) - state `shouldBe` currentState - - context "when repetition is more than 1" $ do - let currentState = defaultState {stateRepetition = 5} - - it "multiplies increment" $ do - ((_, action), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) - action `shouldBe` Just (MoveMousePosition (92, 17)) - - context "when repetition is 0" $ do - let currentState = defaultState {stateRepetition = 0} - - it "increments just once" $ do - ((_, action), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5) - action `shouldBe` Just (MoveMousePosition (52, 37)) - - context "with action ShutdownApp" $ do - let currentState = defaultState - - it "shuts down app" $ do - (_, mock) <- runWithMocks $ update currentState ShutdownApp - mock `shouldHaveCalled` Mock_shutdownApp - - it "does not continue or update state" $ do - (result, _) <- runWithMocks $ update currentState ShutdownApp - result `shouldBe` (currentState, Nothing) - - context "with action UpdateRepetition" $ do - let currentState = defaultState - - it "updates shift state without any action" $ do - ((nextState, action), _) <- runWithMocks $ update currentState $ UpdateRepetition 7 - action `shouldBe` Nothing - nextState `shouldBe` currentState {stateRepetition = 7} - - context "with action UpdateShiftState" $ do - let currentState = defaultState - - it "updates shift state without any action" $ do - ((nextState, action), _) <- runWithMocks $ update currentState $ UpdateShiftState True - action `shouldBe` Nothing - nextState `shouldBe` currentState {stateIsShiftPressed = True} diff --git a/specs/Specs/ViewSpec.hs b/specs/Specs/ViewSpec.hs index 39e7fea..1e34811 100644 --- a/specs/Specs/ViewSpec.hs +++ b/specs/Specs/ViewSpec.hs @@ -18,10 +18,10 @@ test = do it "draws matching text labels" $ do (_, mock) <- runWithMocks $ render currentState drawTextCalls mock - `shouldBe` [ Mock_drawText (460, 10) colorWhite "ABC", - Mock_drawText (1420, 10) colorWhite "DEF", - Mock_drawText (460, 550) colorWhite "DJK", - Mock_drawText (1420, 550) colorWhite "JKL" + `shouldBe` [ Mock_drawText (460, 10) colorWhite FontLG "ABC", + Mock_drawText (1420, 10) colorWhite FontLG "DEF", + Mock_drawText (460, 550) colorWhite FontLG "DJK", + Mock_drawText (1420, 550) colorWhite FontLG "JKL" ] context "when there is a partial match" $ do @@ -30,10 +30,10 @@ test = do it "draws matching text labels" $ do (_, mock) <- runWithMocks $ render currentState drawTextCalls mock - `shouldBe` [ Mock_drawText (1420, 10) colorLightGray "D", - Mock_drawText (1430, 10) colorAccent "EF", - Mock_drawText (460, 550) colorLightGray "D", - Mock_drawText (470, 550) colorAccent "JK" + `shouldBe` [ Mock_drawText (1420, 10) colorLightGray FontLG "D", + Mock_drawText (1430, 10) colorAccent FontLG "EF", + Mock_drawText (460, 550) colorLightGray FontLG "D", + Mock_drawText (470, 550) colorAccent FontLG "JK" ] context "when key sequence is complete match" $ do @@ -41,14 +41,14 @@ test = do it "draws only the matching label" $ do (_, mock) <- runWithMocks $ render currentState - drawTextCalls mock `shouldBe` [Mock_drawText (1420, 10) colorLightGray "DEF"] + drawTextCalls mock `shouldBe` [Mock_drawText (1420, 10) colorLightGray FontLG "DEF"] describe "#renderKeySequence" $ do context "when there is a partial match" $ do it "draws the matched section and highlights the remaining characters" $ do (_, mock) <- runWithMocks $ renderKeySequence "ABC" "ABCDE" (0, 0) calls mock - `shouldBe` [Mock_drawText (0, 0) colorLightGray "ABC", Mock_drawText (3 * 10, 0) colorAccent "DE"] + `shouldBe` [Mock_drawText (0, 0) colorLightGray FontLG "ABC", Mock_drawText (3 * 10, 0) colorAccent FontLG "DE"] it "return true as the text is visible" $ do (isVisible, _) <- runWithMocks $ renderKeySequence "ABC" "ABCDE" (0, 0) @@ -57,7 +57,7 @@ test = do context "when there is no input key sequence" $ do it "draws text as a single chunk" $ do (_, mock) <- runWithMocks $ renderKeySequence "" "ABCD" (0, 0) - calls mock `shouldBe` [Mock_drawText (0, 0) colorWhite "ABCD"] + calls mock `shouldBe` [Mock_drawText (0, 0) colorWhite FontLG "ABCD"] it "return true as the text is visible" $ do (isVisible, _) <- runWithMocks $ renderKeySequence "" "ABCD" (0, 0) diff --git a/specs/TestUtils.hs b/specs/TestUtils.hs index 76a185d..59a59c7 100644 --- a/specs/TestUtils.hs +++ b/specs/TestUtils.hs @@ -4,6 +4,7 @@ import Chelleport.AppShell (MonadAppShell (..)) import Chelleport.Control (MonadControl (..)) import Chelleport.Draw (MonadDraw (..)) import Chelleport.OCR (MonadOCR (..)) +import Chelleport.Types import Control.Monad (void) import Control.Monad.IO.Class (MonadIO) import Control.Monad.State (MonadState (state), StateT (runStateT)) @@ -55,7 +56,7 @@ instance (MonadIO m) => MonadControl (TestM m) where instance (MonadIO m) => MonadDraw (TestM m) where drawLine p1 p2 = registerMockCall $ Mock_drawLine p1 p2 fillRect p size = registerMockCall $ Mock_fillRect p size - drawText p color text = (fromIntegral $ mockTextWidth * Text.length text, 0) <$ registerMockCall (Mock_drawText p color text) + drawText p color size text = (fromIntegral $ mockTextWidth * Text.length text, 0) <$ registerMockCall (Mock_drawText p color size text) drawCircle radius p = registerMockCall $ Mock_drawCircle radius p setDrawColor color = registerMockCall $ Mock_setDrawColor color windowSize = (mockWindowWidth, mockWindowHeight) <$ registerMockCall Mock_windowSize @@ -67,4 +68,7 @@ instance (MonadIO m) => MonadAppShell (TestM m) where shutdownApp = registerMockCall Mock_shutdownApp instance (MonadIO m) => MonadOCR (TestM m) where - getWordsOnScreen = [] <$ registerMockCall Mock_getWordsOnScreen + captureScreenshot p size = "" <$ registerMockCall (Mock_captureScreenshot p size) + getWordsInImage filePath = [match] <$ registerMockCall (Mock_getWordsInImage filePath) + where + match = OCRMatch {matchStartX = 40, matchStartY = 5, matchEndX = 100, matchEndY = 20, matchText = "Wow"} -- cgit v1.3.1