From acefe43cef5a216cb2504e85799699c359b6b4d8 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Wed, 31 Dec 2014 20:52:27 +0000 Subject: Modes; incorporate three test modes. As a proof of concept, this incorporates normal mode, passkeys mode and insert mode. --- tests/dom_tests/dom_tests.coffee | 1 + tests/dom_tests/dom_tests.html | 1 + tests/unit_tests/test_chrome_stubs.coffee | 2 ++ 3 files changed, 4 insertions(+) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index 4a61877c..124fae06 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -178,6 +178,7 @@ context "Input focus", focusInput 1 assert.equal "first", document.activeElement.id # deactivate the tabbing mode and its overlays + currentCompletionKeys = "" handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") focusInput 100 diff --git a/tests/dom_tests/dom_tests.html b/tests/dom_tests/dom_tests.html index a764b42d..33ccc95c 100644 --- a/tests/dom_tests/dom_tests.html +++ b/tests/dom_tests/dom_tests.html @@ -39,6 +39,7 @@ + diff --git a/tests/unit_tests/test_chrome_stubs.coffee b/tests/unit_tests/test_chrome_stubs.coffee index 3258bcd6..7f666068 100644 --- a/tests/unit_tests/test_chrome_stubs.coffee +++ b/tests/unit_tests/test_chrome_stubs.coffee @@ -41,6 +41,8 @@ exports.chrome = addListener: () -> true getAll: () -> true + browserAction: + setBadgeBackgroundColor: -> storage: # chrome.storage.local local: -- cgit v1.2.3 From aed5e2b5e1015a2e581edadbc5dd2d1b5a2719f4 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Thu, 1 Jan 2015 09:57:06 +0000 Subject: Modes; minor changes. --- tests/dom_tests/dom_tests.coffee | 1 - 1 file changed, 1 deletion(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index 124fae06..4a61877c 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -178,7 +178,6 @@ context "Input focus", focusInput 1 assert.equal "first", document.activeElement.id # deactivate the tabbing mode and its overlays - currentCompletionKeys = "" handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") focusInput 100 -- cgit v1.2.3 From daf589f2805d1c6325fab20e4232549a4ffea632 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Tue, 6 Jan 2015 05:53:21 +0000 Subject: Modes; fix tests --- tests/dom_tests/dom_tests.html | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.html b/tests/dom_tests/dom_tests.html index 33ccc95c..33759abd 100644 --- a/tests/dom_tests/dom_tests.html +++ b/tests/dom_tests/dom_tests.html @@ -40,6 +40,10 @@ + + + + -- cgit v1.2.3 From d65075a3b66fae93a10b849162fa907d0eb99846 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Sun, 11 Jan 2015 07:15:06 +0000 Subject: Modes; add DOM tests. --- tests/dom_tests/dom_tests.coffee | 111 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 108 insertions(+), 3 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index 4a61877c..ce54190a 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -8,10 +8,15 @@ mockKeyboardEvent = (keyChar) -> event.charCode = (if keyCodes[keyChar] isnt undefined then keyCodes[keyChar] else keyChar.charCodeAt(0)) event.keyIdentifier = "U+00" + event.charCode.toString(16) event.keyCode = event.charCode - event.stopImmediatePropagation = -> - event.preventDefault = -> + event.stopImmediatePropagation = (event) -> @suppressed = true + event.preventDefault = (event) -> @suppressed = true event +# Some of these tests have side effects on the handler stack. Therefore, we take backups of the stack, and +# restore them later. +backupHandlerStack = -> handlerStack.backup = handlerStack.stack +restoreHandlerStack = -> handlerStack.stack = handlerStack.backup + # # Retrieve the hint markers as an array object. # @@ -170,9 +175,11 @@ context "Input focus", testContent = " " document.getElementById("test-div").innerHTML = testContent + backupHandlerStack() tearDown -> document.getElementById("test-div").innerHTML = "" + restoreHandlerStack() should "focus the right element", -> focusInput 1 @@ -243,9 +250,107 @@ context "Find prev / next links", goNext() assert.equal '#first', window.location.hash - createLinks = (n) -> for i in [0...n] by 1 link = document.createElement("a") link.textContent = "test" document.getElementById("test-div").appendChild link + +context "Normal mode", + setup -> + backupHandlerStack() + refreshCompletionKeys + completionKeys: "o" + validFirstKeys: "o" + + tearDown -> + restoreHandlerStack() + + should "suppress mapped keys", -> + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "o" + handlerStack.bubbleEvent event, key + assert.isTrue key.suppressed + + should "not suppress unmapped keys", -> + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "a" + handlerStack.bubbleEvent event, key + assert.isFalse key.suppressed + +context "Passkeys mode", + setup -> + backupHandlerStack() + refreshCompletionKeys + completionKeys: "oj" + validFirstKeys: "oj" + + handlerStack.bubbleEvent "registerStateChange", + enabled: true + passKeys: "j" + + tearDown -> + restoreHandlerStack() + handlerStack.bubbleEvent "registerStateChange", + enabled: true + passKeys: "" + + should "not suppress passKeys", -> + # First check normal-mode key (just to verify the framework). + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "o" + handlerStack.bubbleEvent event, key + assert.isTrue key.suppressed + + # Then check passKey. + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "j" + handlerStack.bubbleEvent event, key + assert.isFalse key.suppressed + +context "Insert mode", + setup -> + backupHandlerStack() + refreshCompletionKeys + completionKeys: "o" + validFirstKeys: "o" + + tearDown -> + backupHandlerStack() + + should "not suppress mapped keys in insert mode", -> + # First check normal-mode key (just to verify the framework). + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "o" + handlerStack.bubbleEvent event, key + assert.isTrue key.suppressed + + # Install insert mode. + insertMode = new InsertMode() + + # Then verify insert mode. + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "o" + handlerStack.bubbleEvent event, key + assert.isFalse key.suppressed + + insertMode.exit() + + # Then check insert mode has been successfully removed. + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "o" + handlerStack.bubbleEvent event, key + assert.isTrue key.suppressed + +context "Insert mode trigger", + setup -> + backupHandlerStack() + refreshCompletionKeys + completionKeys: "o" + validFirstKeys: "o" + + tearDown -> + backupHandlerStack() + + should "trigger insert mode on input-focus events", -> + -- cgit v1.2.3 From e8f10007f1528808f72be6fac829cc55309527f2 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Sun, 11 Jan 2015 07:15:20 +0000 Subject: Modes; add DOM tests. --- tests/dom_tests/dom_tests.coffee | 309 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 292 insertions(+), 17 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index ce54190a..c9fab56b 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -12,10 +12,16 @@ mockKeyboardEvent = (keyChar) -> event.preventDefault = (event) -> @suppressed = true event -# Some of these tests have side effects on the handler stack. Therefore, we take backups of the stack, and -# restore them later. -backupHandlerStack = -> handlerStack.backup = handlerStack.stack -restoreHandlerStack = -> handlerStack.stack = handlerStack.backup +# Some of these tests have side effects on the handler stack and mode. Therefore, we take backups and restore +# them later. +backupStackState = -> + Mode.backup = Mode.modes[..] + handlerStack.backup = handlerStack.stack[..] +restoreStackState = -> + for mode in Mode.modes + mode.exit() unless mode in Mode.backup + Mode.modes = Mode.backup + handlerStack.stack = handlerStack.backup # # Retrieve the hint markers as an array object. @@ -175,11 +181,11 @@ context "Input focus", testContent = " " document.getElementById("test-div").innerHTML = testContent - backupHandlerStack() + backupStackState() tearDown -> document.getElementById("test-div").innerHTML = "" - restoreHandlerStack() + restoreStackState() should "focus the right element", -> focusInput 1 @@ -258,13 +264,13 @@ createLinks = (n) -> context "Normal mode", setup -> - backupHandlerStack() + backupStackState() refreshCompletionKeys completionKeys: "o" validFirstKeys: "o" tearDown -> - restoreHandlerStack() + restoreStackState() should "suppress mapped keys", -> for event in [ "keydown", "keypress", "keyup" ] @@ -280,7 +286,7 @@ context "Normal mode", context "Passkeys mode", setup -> - backupHandlerStack() + backupStackState() refreshCompletionKeys completionKeys: "oj" validFirstKeys: "oj" @@ -290,7 +296,7 @@ context "Passkeys mode", passKeys: "j" tearDown -> - restoreHandlerStack() + restoreStackState() handlerStack.bubbleEvent "registerStateChange", enabled: true passKeys: "" @@ -310,13 +316,13 @@ context "Passkeys mode", context "Insert mode", setup -> - backupHandlerStack() + backupStackState() refreshCompletionKeys completionKeys: "o" validFirstKeys: "o" tearDown -> - backupHandlerStack() + backupStackState() should "not suppress mapped keys in insert mode", -> # First check normal-mode key (just to verify the framework). @@ -336,21 +342,290 @@ context "Insert mode", insertMode.exit() - # Then check insert mode has been successfully removed. + # Then verify that insert mode has been successfully removed. for event in [ "keydown", "keypress", "keyup" ] key = mockKeyboardEvent "o" handlerStack.bubbleEvent event, key assert.isTrue key.suppressed -context "Insert mode trigger", +context "Insert-mode trigger", setup -> - backupHandlerStack() + backupStackState() refreshCompletionKeys completionKeys: "o" validFirstKeys: "o" + testContent = " + + " + document.getElementById("test-div").innerHTML = testContent + + tearDown -> + restoreStackState() + document.getElementById("test-div").innerHTML = "" + + should "trigger insert mode on focus of contentEditable elements", -> + handlerStack.bubbleEvent "focus", + target: + isContentEditable: true + + assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + + should "trigger insert mode on focus of text input", -> + document.getElementById("first").focus() + handlerStack.bubbleEvent "focus", { target: document.activeElement } + + assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + + should "trigger insert mode on focus of password input", -> + document.getElementById("third").focus() + handlerStack.bubbleEvent "focus", { target: document.activeElement } + + assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + + should "not trigger insert mode on focus of contentEditable elements", -> + new InsertModeBlocker() + handlerStack.bubbleEvent "focus", + target: + isContentEditable: true + + assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + + should "not trigger insert mode on focus of text input", -> + new InsertModeBlocker() + document.getElementById("first").focus() + handlerStack.bubbleEvent "focus", { target: document.activeElement } + + assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + + should "not trigger insert mode on focus of password input", -> + new InsertModeBlocker() + document.getElementById("third").focus() + handlerStack.bubbleEvent "focus", { target: document.activeElement } + + assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + +context "Mode utilities", + setup -> + backupStackState() + refreshCompletionKeys + completionKeys: "o" + validFirstKeys: "o" + + testContent = " + + " + document.getElementById("test-div").innerHTML = testContent + tearDown -> - backupHandlerStack() + restoreStackState() + document.getElementById("test-div").innerHTML = "" + + should "not have duplicate singletons", -> + count = 0 + + class Test extends Mode + constructor: -> + count += 1 + super + singleton: Test + + exit: -> + count -= 1 + super() + + assert.isTrue count == 0 + new Test() + assert.isTrue count == 1 + new Test() + assert.isTrue count == 1 + + should "exit on escape", -> + escape = + keyCode: 27 + + new Mode + exitOnEscape: true + name: "test" + + assert.isTrue Mode.modes[Mode.modes.length-1].name == "test" + handlerStack.bubbleEvent "keydown", escape + assert.isTrue Mode.modes[Mode.modes.length-1].name != "test" + + should "exit on blur", -> + element = document.getElementById("first") + + new Mode + exitOnBlur: element + name: "test" + + assert.isTrue Mode.modes[Mode.modes.length-1].name == "test" + handlerStack.bubbleEvent "blur", { srcElement: element } + assert.isTrue Mode.modes[Mode.modes.length-1].name != "test" + + should "register state change", -> + enabled = null + passKeys = null + + class Test extends Mode + constructor: -> + super + trackState: true + + registerStateChange: -> + enabled = @enabled + passKeys = @passKeys + + new Test() + handlerStack.bubbleEvent "registerStateChange", + enabled: "enabled" + passKeys: "passKeys" + assert.isTrue enabled == "enabled" + assert.isTrue passKeys == "passKeys" + + should "suppress printable keys", -> + element = document.getElementById("first") + + # Verify key is always passed through. + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent event, key + assert.isFalse key.suppressed + + new Mode + suppressPrintableEvents: element + + # Verify key is now suppressed for keypress. + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent "keypress", + extend key, + srcElement: element + assert.isTrue key.suppressed + + # Verify key is not suppressed with Control key. + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent "keypress", + extend key, + srcElement: element + ctrlKey: true + assert.isFalse key.suppressed + + # Verify key is not suppressed with Meta key. + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent "keypress", + extend key, + srcElement: element + metaKey: true + assert.isFalse key.suppressed + + # Verify other keyboard events are not suppressed. + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent "keydown", + extend key, + srcElement: element + assert.isFalse key.suppressed + +context "PostFindMode", + setup -> + backupStackState() + refreshCompletionKeys + completionKeys: "o" + validFirstKeys: "o" + + testContent = " + + " + document.getElementById("test-div").innerHTML = testContent + + tearDown -> + restoreStackState() + document.getElementById("test-div").innerHTML = "" + + should "be a singleton", -> + element = document.getElementById("first") + element.focus() + count = 0 + + class Test extends PostFindMode + constructor: (element) -> + count += 1 + super element + + exit: -> + count -= 1 + super() + + assert.isTrue count == 0 + new Test element + assert.isTrue count == 1 + new Test element + assert.isTrue count == 1 + + should "suppress unmapped printable keypress events", -> + element = document.getElementById("first") + element.focus() + + # Verify key is passed through. + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent event, key + assert.isFalse key.suppressed - should "trigger insert mode on input-focus events", -> + new PostFindMode element + + # Verify key is now suppressed for keypress. + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent "keypress", + extend key, + srcElement: element + assert.isTrue key.suppressed + + # Verify other keyboard events are not suppressed. + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent "keydown", + extend key, + srcElement: element + assert.isFalse key.suppressed + + # Verify keyboard events on other elements are not suppressed. + key = mockKeyboardEvent "A" + handlerStack.bubbleEvent "keypress", + extend key, + srcElement: document.body + assert.isFalse key.suppressed + + should "be clickable to focus", -> + element = document.getElementById("first") + element.focus() + + new PostFindMode element + + assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + handlerStack.bubbleEvent "click", { target: document.activeElement } + assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + + should "enter insert mode on immediate escape", -> + escape = + keyCode: 27 + element = document.getElementById("first") + element.focus() + + new PostFindMode element + assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + handlerStack.bubbleEvent "keydown", escape + assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + + should "enter not insert mode on subsequent escape", -> + escape = + keyCode: 27 + keyIdentifier: "" + stopImmediatePropagation: -> + element = document.getElementById("first") + element.focus() + + new PostFindMode element + assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" + handlerStack.bubbleEvent "keydown", mockKeyboardEvent "A" + handlerStack.bubbleEvent "keydown", escape + assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" -- cgit v1.2.3 From a8096d235eae39d309c0ffd74e0d2493ff12dd22 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Sun, 11 Jan 2015 11:42:02 +0000 Subject: Modes; tweek tests. --- tests/dom_tests/dom_tests.coffee | 130 +++++++++++++++++++-------------------- 1 file changed, 64 insertions(+), 66 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index c9fab56b..c84d513d 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -262,25 +262,26 @@ createLinks = (n) -> link.textContent = "test" document.getElementById("test-div").appendChild link +# For these tests, we use "m" as a mapped key, "p" ass a pass key, and "u" as an unmapped key. context "Normal mode", setup -> backupStackState() refreshCompletionKeys - completionKeys: "o" - validFirstKeys: "o" + completionKeys: [ "m" ] + validFirstKeys: {} tearDown -> restoreStackState() should "suppress mapped keys", -> for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "o" + key = mockKeyboardEvent "m" handlerStack.bubbleEvent event, key assert.isTrue key.suppressed should "not suppress unmapped keys", -> for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "a" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent event, key assert.isFalse key.suppressed @@ -288,12 +289,11 @@ context "Passkeys mode", setup -> backupStackState() refreshCompletionKeys - completionKeys: "oj" - validFirstKeys: "oj" + completionKeys: "mp" handlerStack.bubbleEvent "registerStateChange", enabled: true - passKeys: "j" + passKeys: "" tearDown -> restoreStackState() @@ -303,31 +303,42 @@ context "Passkeys mode", should "not suppress passKeys", -> # First check normal-mode key (just to verify the framework). + for k in [ "m", "p" ] + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "p" + handlerStack.bubbleEvent event, key + assert.isTrue key.suppressed + + # Install passKey. + handlerStack.bubbleEvent "registerStateChange", + enabled: true + passKeys: "p" + + # Then verify passKey. for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "o" + key = mockKeyboardEvent "p" handlerStack.bubbleEvent event, key - assert.isTrue key.suppressed + assert.isFalse key.suppressed - # Then check passKey. + # And re-verify mapped key. for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "j" + key = mockKeyboardEvent "m" handlerStack.bubbleEvent event, key - assert.isFalse key.suppressed + assert.isTrue key.suppressed context "Insert mode", setup -> backupStackState() refreshCompletionKeys - completionKeys: "o" - validFirstKeys: "o" + completionKeys: "m" tearDown -> backupStackState() should "not suppress mapped keys in insert mode", -> - # First check normal-mode key (just to verify the framework). + # First verify normal-mode key (just to verify the framework). for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "o" + key = mockKeyboardEvent "m" handlerStack.bubbleEvent event, key assert.isTrue key.suppressed @@ -336,7 +347,7 @@ context "Insert mode", # Then verify insert mode. for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "o" + key = mockKeyboardEvent "m" handlerStack.bubbleEvent event, key assert.isFalse key.suppressed @@ -344,7 +355,7 @@ context "Insert mode", # Then verify that insert mode has been successfully removed. for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "o" + key = mockKeyboardEvent "m" handlerStack.bubbleEvent event, key assert.isTrue key.suppressed @@ -352,8 +363,7 @@ context "Insert-mode trigger", setup -> backupStackState() refreshCompletionKeys - completionKeys: "o" - validFirstKeys: "o" + completionKeys: "m" testContent = " @@ -409,8 +419,7 @@ context "Mode utilities", setup -> backupStackState() refreshCompletionKeys - completionKeys: "o" - validFirstKeys: "o" + completionKeys: "m" testContent = " @@ -486,24 +495,24 @@ context "Mode utilities", should "suppress printable keys", -> element = document.getElementById("first") - # Verify key is always passed through. + # Verify that a key is not suppressed. for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent event, key assert.isFalse key.suppressed new Mode suppressPrintableEvents: element - # Verify key is now suppressed for keypress. - key = mockKeyboardEvent "A" + # Verify that the key is now suppressed for keypress. + key = mockKeyboardEvent "u" handlerStack.bubbleEvent "keypress", extend key, srcElement: element assert.isTrue key.suppressed # Verify key is not suppressed with Control key. - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent "keypress", extend key, srcElement: element @@ -511,7 +520,7 @@ context "Mode utilities", assert.isFalse key.suppressed # Verify key is not suppressed with Meta key. - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent "keypress", extend key, srcElement: element @@ -519,7 +528,7 @@ context "Mode utilities", assert.isFalse key.suppressed # Verify other keyboard events are not suppressed. - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent "keydown", extend key, srcElement: element @@ -529,21 +538,27 @@ context "PostFindMode", setup -> backupStackState() refreshCompletionKeys - completionKeys: "o" - validFirstKeys: "o" + completionKeys: "m" testContent = " " document.getElementById("test-div").innerHTML = testContent + @escape = + keyCode: 27 + keyIdentifier: "" + stopImmediatePropagation: -> + preventDefault: -> + + @element = document.getElementById("first") + @element.focus() + tearDown -> restoreStackState() document.getElementById("test-div").innerHTML = "" should "be a singleton", -> - element = document.getElementById("first") - element.focus() count = 0 class Test extends PostFindMode @@ -556,76 +571,59 @@ context "PostFindMode", super() assert.isTrue count == 0 - new Test element + new Test @element assert.isTrue count == 1 - new Test element + new Test @element assert.isTrue count == 1 should "suppress unmapped printable keypress events", -> - element = document.getElementById("first") - element.focus() - # Verify key is passed through. for event in [ "keydown", "keypress", "keyup" ] - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent event, key assert.isFalse key.suppressed - new PostFindMode element + new PostFindMode @element # Verify key is now suppressed for keypress. - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent "keypress", extend key, - srcElement: element + srcElement: @element assert.isTrue key.suppressed # Verify other keyboard events are not suppressed. - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent "keydown", extend key, - srcElement: element + srcElement: @element assert.isFalse key.suppressed # Verify keyboard events on other elements are not suppressed. - key = mockKeyboardEvent "A" + key = mockKeyboardEvent "u" handlerStack.bubbleEvent "keypress", extend key, srcElement: document.body assert.isFalse key.suppressed should "be clickable to focus", -> - element = document.getElementById("first") - element.focus() - - new PostFindMode element + new PostFindMode @element assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" handlerStack.bubbleEvent "click", { target: document.activeElement } assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" should "enter insert mode on immediate escape", -> - escape = - keyCode: 27 - element = document.getElementById("first") - element.focus() - new PostFindMode element + new PostFindMode @element assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" - handlerStack.bubbleEvent "keydown", escape + handlerStack.bubbleEvent "keydown", @escape assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" - should "enter not insert mode on subsequent escape", -> - escape = - keyCode: 27 - keyIdentifier: "" - stopImmediatePropagation: -> - element = document.getElementById("first") - element.focus() - - new PostFindMode element + should "not enter insert mode on subsequent escape", -> + new PostFindMode @element assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" - handlerStack.bubbleEvent "keydown", mockKeyboardEvent "A" - handlerStack.bubbleEvent "keydown", escape + handlerStack.bubbleEvent "keydown", mockKeyboardEvent "u" + handlerStack.bubbleEvent "keydown", @escape assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" -- cgit v1.2.3 From f76c15c6ae6565c0c08569a127974dfd3383ed88 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Sun, 11 Jan 2015 12:19:19 +0000 Subject: Modes; tweaks, including more tests. --- tests/dom_tests/dom_tests.coffee | 28 +++++++++++++++++++++------- tests/unit_tests/handler_stack_test.coffee | 23 +++++++++++++++++++++++ 2 files changed, 44 insertions(+), 7 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index c84d513d..d9e7775f 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -8,12 +8,12 @@ mockKeyboardEvent = (keyChar) -> event.charCode = (if keyCodes[keyChar] isnt undefined then keyCodes[keyChar] else keyChar.charCodeAt(0)) event.keyIdentifier = "U+00" + event.charCode.toString(16) event.keyCode = event.charCode - event.stopImmediatePropagation = (event) -> @suppressed = true - event.preventDefault = (event) -> @suppressed = true + event.stopImmediatePropagation = -> @suppressed = true + event.preventDefault = -> @suppressed = true event # Some of these tests have side effects on the handler stack and mode. Therefore, we take backups and restore -# them later. +# them on tear down. backupStackState = -> Mode.backup = Mode.modes[..] handlerStack.backup = handlerStack.stack[..] @@ -197,6 +197,21 @@ context "Input focus", assert.equal "third", document.activeElement.id handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") + # This is the same as above, but also verifies that focusInput activates insert mode. + should "focus the right element, and activate insert mode", -> + focusInput 1 + assert.equal "first", document.activeElement.id + # deactivate the tabbing mode and its overlays + assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") + assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + + focusInput 100 + assert.equal "third", document.activeElement.id + assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") + assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + # TODO: these find prev/next link tests could be refactored into unit tests which invoke a function which has # a tighter contract than goNext(), since they test minor aspects of goNext()'s link matching behavior, and we # don't need to construct external state many times over just to test that. @@ -262,13 +277,12 @@ createLinks = (n) -> link.textContent = "test" document.getElementById("test-div").appendChild link -# For these tests, we use "m" as a mapped key, "p" ass a pass key, and "u" as an unmapped key. +# For these tests, we use "m" as a mapped key, "p" as a pass key, and "u" as an unmapped key. context "Normal mode", setup -> backupStackState() refreshCompletionKeys - completionKeys: [ "m" ] - validFirstKeys: {} + completionKeys: "m" tearDown -> restoreStackState() @@ -616,7 +630,7 @@ context "PostFindMode", should "enter insert mode on immediate escape", -> new PostFindMode @element - assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" handlerStack.bubbleEvent "keydown", @escape assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" diff --git a/tests/unit_tests/handler_stack_test.coffee b/tests/unit_tests/handler_stack_test.coffee index 0ed8f4c0..0ed85e63 100644 --- a/tests/unit_tests/handler_stack_test.coffee +++ b/tests/unit_tests/handler_stack_test.coffee @@ -23,6 +23,29 @@ context "handlerStack", assert.isTrue @handler2Called assert.isFalse @handler1Called + should "terminate bubbling on stopBubblingAndTrue, and be true", -> + @handlerStack.push { keydown: => @handler1Called = true } + @handlerStack.push { keydown: => @handler2Called = true; @handlerStack.stopBubblingAndTrue } + assert.isTrue @handlerStack.bubbleEvent 'keydown', {} + assert.isTrue @handler2Called + assert.isFalse @handler1Called + + should "terminate bubbling on stopBubblingAndTrue, and be false", -> + @handlerStack.push { keydown: => @handler1Called = true } + @handlerStack.push { keydown: => @handler2Called = true; @handlerStack.stopBubblingAndFalse } + assert.isFalse @handlerStack.bubbleEvent 'keydown', {} + assert.isTrue @handler2Called + assert.isFalse @handler1Called + + should "restart bubbling on restartBubbling", -> + @handler1Called = 0 + @handler2Called = 0 + id = @handlerStack.push { keydown: => @handler1Called++; @handlerStack.remove(id); @handlerStack.restartBubbling } + @handlerStack.push { keydown: => @handler2Called++; true } + assert.isTrue @handlerStack.bubbleEvent 'keydown', {} + assert.isTrue @handler1Called == 1 + assert.isTrue @handler2Called == 2 + should "remove handlers correctly", -> @handlerStack.push { keydown: => @handler1Called = true } handlerId = @handlerStack.push { keydown: => @handler2Called = true } -- cgit v1.2.3 From 8066a3838ef44b010f6dfb46cea8b47c6bdfc087 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Sun, 11 Jan 2015 15:01:12 +0000 Subject: Modes; yet more tweaks, yet more tests. --- tests/dom_tests/dom_tests.coffee | 128 +++++++++++++++++++++++++++++++-------- 1 file changed, 102 insertions(+), 26 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index d9e7775f..eacd0aed 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -12,8 +12,8 @@ mockKeyboardEvent = (keyChar) -> event.preventDefault = -> @suppressed = true event -# Some of these tests have side effects on the handler stack and mode. Therefore, we take backups and restore -# them on tear down. +# Some of these tests have side effects on the handler stack and active mode. Therefore, we take backups and +# restore them on tear down. backupStackState = -> Mode.backup = Mode.modes[..] handlerStack.backup = handlerStack.stack[..] @@ -202,15 +202,15 @@ context "Input focus", focusInput 1 assert.equal "first", document.activeElement.id # deactivate the tabbing mode and its overlays - assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + assert.isTrue Mode.top() != "insert" handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") - assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + assert.isTrue Mode.top() == "insert" focusInput 100 assert.equal "third", document.activeElement.id - assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + assert.isTrue Mode.top() != "insert" handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") - assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + assert.isTrue Mode.top() == "insert" # TODO: these find prev/next link tests could be refactored into unit tests which invoke a function which has # a tighter contract than goNext(), since they test minor aspects of goNext()'s link matching behavior, and we @@ -393,19 +393,19 @@ context "Insert-mode trigger", target: isContentEditable: true - assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + assert.isTrue Mode.top() == "insert" should "trigger insert mode on focus of text input", -> document.getElementById("first").focus() handlerStack.bubbleEvent "focus", { target: document.activeElement } - assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + assert.isTrue Mode.top() == "insert" should "trigger insert mode on focus of password input", -> document.getElementById("third").focus() handlerStack.bubbleEvent "focus", { target: document.activeElement } - assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + assert.isTrue Mode.top() == "insert" should "not trigger insert mode on focus of contentEditable elements", -> new InsertModeBlocker() @@ -413,21 +413,21 @@ context "Insert-mode trigger", target: isContentEditable: true - assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + assert.isTrue Mode.top() != "insert" should "not trigger insert mode on focus of text input", -> new InsertModeBlocker() document.getElementById("first").focus() handlerStack.bubbleEvent "focus", { target: document.activeElement } - assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + assert.isTrue Mode.top() != "insert" should "not trigger insert mode on focus of password input", -> new InsertModeBlocker() document.getElementById("third").focus() handlerStack.bubbleEvent "focus", { target: document.activeElement } - assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + assert.isTrue Mode.top() != "insert" context "Mode utilities", setup -> @@ -458,10 +458,11 @@ context "Mode utilities", super() assert.isTrue count == 0 - new Test() - assert.isTrue count == 1 - new Test() - assert.isTrue count == 1 + for [1..10] + mode = new Test(); assert.isTrue count == 1 + + mode.exit() + assert.isTrue count == 0 should "exit on escape", -> escape = @@ -471,20 +472,47 @@ context "Mode utilities", exitOnEscape: true name: "test" - assert.isTrue Mode.modes[Mode.modes.length-1].name == "test" + assert.isTrue Mode.top() == "test" + handlerStack.bubbleEvent "keydown", escape + assert.isTrue Mode.top() != "test" + + should "not exit on escape if not enabled", -> + escape = + keyCode: 27 + keyIdentifier: "" + stopImmediatePropagation: -> + + new Mode + exitOnEscape: false + name: "test" + + assert.isTrue Mode.top() == "test" handlerStack.bubbleEvent "keydown", escape - assert.isTrue Mode.modes[Mode.modes.length-1].name != "test" + assert.isTrue Mode.top() == "test" should "exit on blur", -> element = document.getElementById("first") + element.focus() new Mode exitOnBlur: element name: "test" - assert.isTrue Mode.modes[Mode.modes.length-1].name == "test" + assert.isTrue Mode.top() == "test" handlerStack.bubbleEvent "blur", { srcElement: element } - assert.isTrue Mode.modes[Mode.modes.length-1].name != "test" + assert.isTrue Mode.top() != "test" + + should "not exit on blur if not enabled", -> + element = document.getElementById("first") + element.focus() + + new Mode + exitOnBlur: null + name: "test" + + assert.isTrue Mode.top() == "test" + handlerStack.bubbleEvent "blur", { srcElement: element } + assert.isTrue Mode.top() == "test" should "register state change", -> enabled = null @@ -623,21 +651,69 @@ context "PostFindMode", should "be clickable to focus", -> new PostFindMode @element - assert.isTrue Mode.modes[Mode.modes.length-1].name != "insert" + assert.isTrue Mode.top() != "insert" handlerStack.bubbleEvent "click", { target: document.activeElement } - assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + assert.isTrue Mode.top() == "insert" should "enter insert mode on immediate escape", -> new PostFindMode @element - assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" + assert.isTrue Mode.top() == "post-find" handlerStack.bubbleEvent "keydown", @escape - assert.isTrue Mode.modes[Mode.modes.length-1].name == "insert" + assert.isTrue Mode.top() == "insert" should "not enter insert mode on subsequent escape", -> new PostFindMode @element - assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" + assert.isTrue Mode.top() == "post-find" handlerStack.bubbleEvent "keydown", mockKeyboardEvent "u" handlerStack.bubbleEvent "keydown", @escape - assert.isTrue Mode.modes[Mode.modes.length-1].name == "post-find" + assert.isTrue Mode.top() == "post-find" + +context "Mode badges", + setup -> + backupStackState() + + tearDown -> + restoreStackState() + + should "have an N badge without passKeys", -> + handlerStack.bubbleEvent "registerStateChange", + enabled: true + passKeys: "" + + handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } + assert.isTrue badge.badge == "N" + + should "have an P badge with passKeys", -> + handlerStack.bubbleEvent "registerStateChange", + enabled: true + passKeys: "p" + + handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } + assert.isTrue badge.badge == "P" + + should "have an I badge in insert mode", -> + handlerStack.bubbleEvent "registerStateChange", + enabled: true + passKeys: "" + + handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } + assert.isTrue badge.badge == "N" + + insertMode = new InsertMode() + handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } + assert.isTrue badge.badge == "I" + + insertMode.exit() + handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } + assert.isTrue badge.badge == "N" + + should "have no badge when disabled", -> + handlerStack.bubbleEvent "registerStateChange", + enabled: false + passKeys: "" + + new InsertMode() + handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } + assert.isTrue badge.badge == "" -- cgit v1.2.3 From ab56d8bcd6686991483694d7153c4d0c9b5e513a Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Wed, 14 Jan 2015 13:33:29 +0000 Subject: Modes; fix tests. --- tests/dom_tests/dom_tests.coffee | 164 ++++++++++++++------------------------- 1 file changed, 57 insertions(+), 107 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index eacd0aed..9918b12d 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -16,11 +16,13 @@ mockKeyboardEvent = (keyChar) -> # restore them on tear down. backupStackState = -> Mode.backup = Mode.modes[..] + InsertMode.permanentInstance.exit() handlerStack.backup = handlerStack.stack[..] restoreStackState = -> for mode in Mode.modes mode.exit() unless mode in Mode.backup Mode.modes = Mode.backup + InsertMode.permanentInstance.exit() handlerStack.stack = handlerStack.backup # @@ -198,19 +200,14 @@ context "Input focus", handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") # This is the same as above, but also verifies that focusInput activates insert mode. - should "focus the right element, and activate insert mode", -> + should "activate insert mode", -> focusInput 1 - assert.equal "first", document.activeElement.id - # deactivate the tabbing mode and its overlays - assert.isTrue Mode.top() != "insert" - handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") - assert.isTrue Mode.top() == "insert" + handlerStack.bubbleEvent 'focus', { target: document. activeElement } + assert.isTrue InsertMode.permanentInstance.isActive() focusInput 100 - assert.equal "third", document.activeElement.id - assert.isTrue Mode.top() != "insert" - handlerStack.bubbleEvent 'keydown', mockKeyboardEvent("A") - assert.isTrue Mode.top() == "insert" + handlerStack.bubbleEvent 'focus', { target: document. activeElement } + assert.isTrue InsertMode.permanentInstance.isActive() # TODO: these find prev/next link tests could be refactored into unit tests which invoke a function which has # a tighter contract than goNext(), since they test minor aspects of goNext()'s link matching behavior, and we @@ -280,6 +277,7 @@ createLinks = (n) -> # For these tests, we use "m" as a mapped key, "p" as a pass key, and "u" as an unmapped key. context "Normal mode", setup -> + document.activeElement?.blur() backupStackState() refreshCompletionKeys completionKeys: "m" @@ -342,6 +340,7 @@ context "Passkeys mode", context "Insert mode", setup -> + document.activeElement?.blur() backupStackState() refreshCompletionKeys completionKeys: "m" @@ -357,7 +356,8 @@ context "Insert mode", assert.isTrue key.suppressed # Install insert mode. - insertMode = new InsertMode() + insertMode = new InsertMode + targetElement: document.body # Then verify insert mode. for event in [ "keydown", "keypress", "keyup" ] @@ -373,8 +373,9 @@ context "Insert mode", handlerStack.bubbleEvent event, key assert.isTrue key.suppressed -context "Insert-mode trigger", +context "Triggering insert mode", setup -> + document.activeElement?.blur() backupStackState() refreshCompletionKeys completionKeys: "m" @@ -393,41 +394,32 @@ context "Insert-mode trigger", target: isContentEditable: true - assert.isTrue Mode.top() == "insert" + assert.isTrue Mode.top().name == "insert" and Mode.top().isActive() should "trigger insert mode on focus of text input", -> document.getElementById("first").focus() handlerStack.bubbleEvent "focus", { target: document.activeElement } - assert.isTrue Mode.top() == "insert" + assert.isTrue Mode.top().name == "insert" and Mode.top().isActive() should "trigger insert mode on focus of password input", -> document.getElementById("third").focus() handlerStack.bubbleEvent "focus", { target: document.activeElement } - assert.isTrue Mode.top() == "insert" - - should "not trigger insert mode on focus of contentEditable elements", -> - new InsertModeBlocker() - handlerStack.bubbleEvent "focus", - target: - isContentEditable: true - - assert.isTrue Mode.top() != "insert" + assert.isTrue Mode.top().name == "insert" and Mode.top().isActive() - should "not trigger insert mode on focus of text input", -> - new InsertModeBlocker() + should "not handle suppressed events", -> document.getElementById("first").focus() handlerStack.bubbleEvent "focus", { target: document.activeElement } + assert.isTrue Mode.top().name == "insert" and Mode.top().isActive() - assert.isTrue Mode.top() != "insert" - - should "not trigger insert mode on focus of password input", -> - new InsertModeBlocker() - document.getElementById("third").focus() - handlerStack.bubbleEvent "focus", { target: document.activeElement } + for event in [ "keydown", "keypress", "keyup" ] + # Because "m" is mapped, we expect insert mode to ignore it, and normal mode to suppress it. + key = mockKeyboardEvent "m" + InsertMode.suppressEvent key + handlerStack.bubbleEvent event, key + assert.isTrue key.suppressed - assert.isTrue Mode.top() != "insert" context "Mode utilities", setup -> @@ -472,9 +464,9 @@ context "Mode utilities", exitOnEscape: true name: "test" - assert.isTrue Mode.top() == "test" + assert.isTrue Mode.top().name == "test" handlerStack.bubbleEvent "keydown", escape - assert.isTrue Mode.top() != "test" + assert.isTrue Mode.top().name != "test" should "not exit on escape if not enabled", -> escape = @@ -486,9 +478,9 @@ context "Mode utilities", exitOnEscape: false name: "test" - assert.isTrue Mode.top() == "test" + assert.isTrue Mode.top().name == "test" handlerStack.bubbleEvent "keydown", escape - assert.isTrue Mode.top() == "test" + assert.isTrue Mode.top().name == "test" should "exit on blur", -> element = document.getElementById("first") @@ -498,21 +490,21 @@ context "Mode utilities", exitOnBlur: element name: "test" - assert.isTrue Mode.top() == "test" - handlerStack.bubbleEvent "blur", { srcElement: element } - assert.isTrue Mode.top() != "test" + assert.isTrue Mode.top().name == "test" + handlerStack.bubbleEvent "blur", { target: element } + assert.isTrue Mode.top().name != "test" - should "not exit on blur if not enabled", -> - element = document.getElementById("first") - element.focus() + should "not exit on blur if not enabled", -> + element = document.getElementById("first") + element.focus() - new Mode - exitOnBlur: null - name: "test" + new Mode + exitOnBlur: null + name: "test" - assert.isTrue Mode.top() == "test" - handlerStack.bubbleEvent "blur", { srcElement: element } - assert.isTrue Mode.top() == "test" + assert.isTrue Mode.top().name == "test" + handlerStack.bubbleEvent "blur", { target: element } + assert.isTrue Mode.top().name == "test" should "register state change", -> enabled = null @@ -536,6 +528,8 @@ context "Mode utilities", should "suppress printable keys", -> element = document.getElementById("first") + element.focus() + handlerStack.bubbleEvent "focus", { target: document.activeElement } # Verify that a key is not suppressed. for event in [ "keydown", "keypress", "keyup" ] @@ -543,8 +537,7 @@ context "Mode utilities", handlerStack.bubbleEvent event, key assert.isFalse key.suppressed - new Mode - suppressPrintableEvents: element + new PostFindMode {} # Verify that the key is now suppressed for keypress. key = mockKeyboardEvent "u" @@ -569,13 +562,6 @@ context "Mode utilities", metaKey: true assert.isFalse key.suppressed - # Verify other keyboard events are not suppressed. - key = mockKeyboardEvent "u" - handlerStack.bubbleEvent "keydown", - extend key, - srcElement: element - assert.isFalse key.suppressed - context "PostFindMode", setup -> backupStackState() @@ -595,6 +581,7 @@ context "PostFindMode", @element = document.getElementById("first") @element.focus() + handlerStack.bubbleEvent "focus", { target: document.activeElement } tearDown -> restoreStackState() @@ -603,20 +590,13 @@ context "PostFindMode", should "be a singleton", -> count = 0 - class Test extends PostFindMode - constructor: (element) -> - count += 1 - super element - - exit: -> - count -= 1 - super() - - assert.isTrue count == 0 - new Test @element - assert.isTrue count == 1 - new Test @element - assert.isTrue count == 1 + assert.isTrue Mode.top().name == "insert" + new PostFindMode @element + assert.isTrue Mode.top().name == "post-find" + new PostFindMode @element + assert.isTrue Mode.top().name == "post-find" + Mode.top().exit() + assert.isTrue Mode.top().name == "insert" should "suppress unmapped printable keypress events", -> # Verify key is passed through. @@ -634,40 +614,26 @@ context "PostFindMode", srcElement: @element assert.isTrue key.suppressed - # Verify other keyboard events are not suppressed. - key = mockKeyboardEvent "u" - handlerStack.bubbleEvent "keydown", - extend key, - srcElement: @element - assert.isFalse key.suppressed - - # Verify keyboard events on other elements are not suppressed. - key = mockKeyboardEvent "u" - handlerStack.bubbleEvent "keypress", - extend key, - srcElement: document.body - assert.isFalse key.suppressed - should "be clickable to focus", -> new PostFindMode @element - assert.isTrue Mode.top() != "insert" + assert.isTrue Mode.top().name != "insert" handlerStack.bubbleEvent "click", { target: document.activeElement } - assert.isTrue Mode.top() == "insert" + assert.isTrue Mode.top().name == "insert" should "enter insert mode on immediate escape", -> new PostFindMode @element - assert.isTrue Mode.top() == "post-find" + assert.isTrue Mode.top().name == "post-find" handlerStack.bubbleEvent "keydown", @escape - assert.isTrue Mode.top() == "insert" + assert.isTrue Mode.top().name == "insert" should "not enter insert mode on subsequent escape", -> new PostFindMode @element - assert.isTrue Mode.top() == "post-find" + assert.isTrue Mode.top().name == "post-find" handlerStack.bubbleEvent "keydown", mockKeyboardEvent "u" handlerStack.bubbleEvent "keydown", @escape - assert.isTrue Mode.top() == "post-find" + assert.isTrue Mode.top().name == "post-find" context "Mode badges", setup -> @@ -692,22 +658,6 @@ context "Mode badges", handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } assert.isTrue badge.badge == "P" - should "have an I badge in insert mode", -> - handlerStack.bubbleEvent "registerStateChange", - enabled: true - passKeys: "" - - handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } - assert.isTrue badge.badge == "N" - - insertMode = new InsertMode() - handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } - assert.isTrue badge.badge == "I" - - insertMode.exit() - handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } - assert.isTrue badge.badge == "N" - should "have no badge when disabled", -> handlerStack.bubbleEvent "registerStateChange", enabled: false -- cgit v1.2.3 From 455ee7fcdea7baf1aeaed67603ec87004c1c8cce Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Thu, 15 Jan 2015 11:35:09 +0000 Subject: Modes; yet more teaks and fiddles. --- tests/dom_tests/dom_tests.coffee | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index 9918b12d..0b09df27 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -307,12 +307,18 @@ context "Passkeys mode", enabled: true passKeys: "" + handlerStack.bubbleEvent "registerKeyQueue", + keyQueue: "" + tearDown -> restoreStackState() handlerStack.bubbleEvent "registerStateChange", enabled: true passKeys: "" + handlerStack.bubbleEvent "registerKeyQueue", + keyQueue: "" + should "not suppress passKeys", -> # First check normal-mode key (just to verify the framework). for k in [ "m", "p" ] @@ -332,12 +338,33 @@ context "Passkeys mode", handlerStack.bubbleEvent event, key assert.isFalse key.suppressed - # And re-verify mapped key. + # And re-verify a mapped key. for event in [ "keydown", "keypress", "keyup" ] key = mockKeyboardEvent "m" handlerStack.bubbleEvent event, key assert.isTrue key.suppressed + should "suppress passKeys with a non-empty keyQueue", -> + # Install passKey. + handlerStack.bubbleEvent "registerStateChange", + enabled: true + passKeys: "p" + + # First check the key is indeed not suppressed. + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "p" + handlerStack.bubbleEvent event, key + assert.isFalse key.suppressed + + handlerStack.bubbleEvent "registerKeyQueue", + keyQueue: "1" + + # Now verify that the key is suppressed. + for event in [ "keydown", "keypress", "keyup" ] + key = mockKeyboardEvent "p" + handlerStack.bubbleEvent event, key + assert.isTrue key.suppressed + context "Insert mode", setup -> document.activeElement?.blur() -- cgit v1.2.3 From 46d4cb903494be6df2b2e570e11f3854ec99c3aa Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Thu, 15 Jan 2015 15:39:39 +0000 Subject: Modes; match test to reality. --- tests/dom_tests/dom_tests.coffee | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index 0b09df27..9e65d954 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -675,7 +675,7 @@ context "Mode badges", passKeys: "" handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } - assert.isTrue badge.badge == "N" + assert.isTrue badge.badge == "" should "have an P badge with passKeys", -> handlerStack.bubbleEvent "registerStateChange", -- cgit v1.2.3 From bbc7257842293fbd58dd2f84a58c86691ceae3e1 Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Fri, 16 Jan 2015 07:31:24 +0000 Subject: Modes; tweaks. --- tests/dom_tests/dom_tests.coffee | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index 9e65d954..dae69dd8 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -202,7 +202,7 @@ context "Input focus", # This is the same as above, but also verifies that focusInput activates insert mode. should "activate insert mode", -> focusInput 1 - handlerStack.bubbleEvent 'focus', { target: document. activeElement } + handlerStack.bubbleEvent 'focus', { target: document.activeElement } assert.isTrue InsertMode.permanentInstance.isActive() focusInput 100 @@ -384,7 +384,7 @@ context "Insert mode", # Install insert mode. insertMode = new InsertMode - targetElement: document.body + global: true # Then verify insert mode. for event in [ "keydown", "keypress", "keyup" ] -- cgit v1.2.3 From 9cb0f2853a155e39270282e6ed224966afffc61e Mon Sep 17 00:00:00 2001 From: Stephen Blott Date: Sat, 17 Jan 2015 05:51:52 +0000 Subject: Modes; yet more tweaks... - Mainly comments. - Rename chooseBadge to updateBadge (for consistency). - No badge for passkeys; also fix tests. --- tests/dom_tests/dom_tests.coffee | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'tests') diff --git a/tests/dom_tests/dom_tests.coffee b/tests/dom_tests/dom_tests.coffee index dae69dd8..c73e0885 100644 --- a/tests/dom_tests/dom_tests.coffee +++ b/tests/dom_tests/dom_tests.coffee @@ -669,7 +669,7 @@ context "Mode badges", tearDown -> restoreStackState() - should "have an N badge without passKeys", -> + should "have no badge without passKeys", -> handlerStack.bubbleEvent "registerStateChange", enabled: true passKeys: "" @@ -677,13 +677,13 @@ context "Mode badges", handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } assert.isTrue badge.badge == "" - should "have an P badge with passKeys", -> + should "have no badge with passKeys", -> handlerStack.bubbleEvent "registerStateChange", enabled: true passKeys: "p" handlerStack.bubbleEvent "updateBadge", badge = { badge: "" } - assert.isTrue badge.badge == "P" + assert.isTrue badge.badge == "" should "have no badge when disabled", -> handlerStack.bubbleEvent "registerStateChange", -- cgit v1.2.3