1 files changed, 131 insertions, 101 deletions
diff --git a/specs/Specs/AppStateUpdateSpec.hs b/specs/Specs/AppStateSpec.hs
index 861264d..eb5ab1b 100644
--- a/specs/Specs/AppStateUpdateSpec.hs
+++ b/specs/Specs/AppStateSpec.hs
@@ -1,6 +1,6 @@
-module Specs.AppStateUpdateSpec where
+module Specs.AppStateSpec where
 
-import Chelleport (initialState, update)
+import Chelleport.AppState (initialState, update)
 import Chelleport.Types
 import Chelleport.Utils (uniq)
 import Control.Monad (join)
@@ -30,69 +30,6 @@ test = do
   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
 
@@ -129,6 +66,59 @@ test = 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}
@@ -152,27 +142,38 @@ test = do
           ((_, action), _) <- runWithMocks $ update currentState MouseDragToggle
           action `shouldBe` Just MouseDragStart
 
-    context "with action MouseDragStart" $ do
-      let currentState = defaultState
+    context "with action HandleKeyInput" $ do
+      context "when mode is ModeSearch" $ do
+        it "todo: implement" $ do
+          1 `shouldBe` 1
 
-      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]
+      context "when mode is ModeHints" $ do
+        context "when there are no matches" $ do
+          let currentState = defaultState {stateKeySequence = "D", stateMode = defaultHintsMode}
 
-      it "does not continue or update state" $ do
-        (result, _) <- runWithMocks $ update currentState MouseDragStart
-        result `shouldBe` (currentState, Nothing)
+          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 "with action MouseDragEnd" $ do
-      let currentState = defaultState
+          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"}
 
-      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]
+        context "when there is a matches" $ do
+          let currentState = defaultState {stateKeySequence = "DE", stateMode = defaultHintsMode}
 
-      it "does not continue or update state" $ do
-        (result, _) <- runWithMocks $ update currentState MouseDragStart
-        result `shouldBe` (currentState, Nothing)
+          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
@@ -193,30 +194,24 @@ test = do
         action `shouldBe` Nothing
         nextState `shouldBe` currentState {stateKeySequence = [], stateIsMatched = False, stateRepetition = 1}
 
-    context "with action IncrementMouseCursor" $ do
+    context "with action SetMode" $ 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 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 repetition is 0" $ do
-        let currentState = defaultState {stateRepetition = 0}
+      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 "increments just once" $ do
-          ((_, action), _) <- runWithMocks $ update currentState $ IncrementMouseCursor (10, -5)
-          action `shouldBe` Just (MoveMousePosition (52, 37))
+        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
@@ -229,6 +224,41 @@ test = 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