]>
git.proxmox.com Git - mirror_novnc.git/blob - tests/test.keyboard.js
1ebbbd4a3479c9a225f67fbb48780279e3e73911
1 var assert
= chai
.assert
;
2 var expect
= chai
.expect
;
4 import { Keyboard
} from '../core/input/devices.js';
5 import keysyms
from '../core/input/keysymdef.js';
6 import * as KeyboardUtil
from '../core/input/util.js';
8 /* jshint newcap: false, expr: true */
9 describe('Key Event Handling', function() {
12 // The real KeyboardEvent constructor might not work everywhere we
13 // want to run these tests
14 function keyevent(typeArg
, KeyboardEventInit
) {
15 var e
= { type
: typeArg
};
16 for (var key
in KeyboardEventInit
) {
17 e
[key
] = KeyboardEventInit
[key
];
19 e
.stopPropagation
= sinon
.spy();
20 e
.preventDefault
= sinon
.spy();
24 describe('Decode Keyboard Events', function() {
25 it('should decode keydown events', function(done
) {
26 var kbd
= new Keyboard({
27 onKeyEvent: function(keysym
, code
, down
) {
28 expect(keysym
).to
.be
.equal(0x61);
29 expect(code
).to
.be
.equal('KeyA');
30 expect(down
).to
.be
.equal(true);
33 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', key
: 'a'}));
35 it('should decode keyup events', function(done
) {
37 var kbd
= new Keyboard({
38 onKeyEvent: function(keysym
, code
, down
) {
39 expect(keysym
).to
.be
.equal(0x61);
40 expect(code
).to
.be
.equal('KeyA');
42 expect(down
).to
.be
.equal(false);
46 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', key
: 'a'}));
47 kbd
._handleKeyUp(keyevent('keyup', {code
: 'KeyA', key
: 'a'}));
50 describe('Legacy keypress Events', function() {
51 it('should wait for keypress when needed', function() {
52 var callback
= sinon
.spy();
53 var kbd
= new Keyboard({onKeyEvent
: callback
});
54 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', keyCode
: 0x41}));
55 expect(callback
).to
.not
.have
.been
.called
;
57 it('should decode keypress events', function(done
) {
58 var kbd
= new Keyboard({
59 onKeyEvent: function(keysym
, code
, down
) {
60 expect(keysym
).to
.be
.equal(0x61);
61 expect(code
).to
.be
.equal('KeyA');
62 expect(down
).to
.be
.equal(true);
65 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', keyCode
: 0x41}));
66 kbd
._handleKeyPress(keyevent('keypress', {code
: 'KeyA', charCode
: 0x61}));
68 it('should ignore keypress with different code', function() {
69 var callback
= sinon
.spy();
70 var kbd
= new Keyboard({onKeyEvent
: callback
});
71 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', keyCode
: 0x41}));
72 kbd
._handleKeyPress(keyevent('keypress', {code
: 'KeyB', charCode
: 0x61}));
73 expect(callback
).to
.not
.have
.been
.called
;
75 it('should handle keypress with missing code', function(done
) {
76 var kbd
= new Keyboard({
77 onKeyEvent: function(keysym
, code
, down
) {
78 expect(keysym
).to
.be
.equal(0x61);
79 expect(code
).to
.be
.equal('KeyA');
80 expect(down
).to
.be
.equal(true);
83 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', keyCode
: 0x41}));
84 kbd
._handleKeyPress(keyevent('keypress', {charCode
: 0x61}));
88 describe('suppress the right events at the right time', function() {
89 it('should suppress anything with a valid key', function() {
90 var kbd
= new Keyboard({});
91 var evt
= keyevent('keydown', {code
: 'KeyA', key
: 'a'});
92 kbd
._handleKeyDown(evt
);
93 expect(evt
.preventDefault
).to
.have
.been
.called
;
94 evt
= keyevent('keyup', {code
: 'KeyA', key
: 'a'});
95 kbd
._handleKeyUp(evt
);
96 expect(evt
.preventDefault
).to
.have
.been
.called
;
98 it('should not suppress keys without key', function() {
99 var kbd
= new Keyboard({});
100 var evt
= keyevent('keydown', {code
: 'KeyA', keyCode
: 0x41});
101 kbd
._handleKeyDown(evt
);
102 expect(evt
.preventDefault
).to
.not
.have
.been
.called
;
104 it('should suppress the following keypress event', function() {
105 var kbd
= new Keyboard({});
106 var evt
= keyevent('keydown', {code
: 'KeyA', keyCode
: 0x41});
107 kbd
._handleKeyDown(evt
);
108 var evt
= keyevent('keypress', {code
: 'KeyA', charCode
: 0x41});
109 kbd
._handleKeyPress(evt
);
110 expect(evt
.preventDefault
).to
.have
.been
.called
;
115 describe('Track Key State', function() {
116 it('should send release using the same keysym as the press', function(done
) {
117 var kbd
= new Keyboard({
118 onKeyEvent: function(keysym
, code
, down
) {
119 expect(keysym
).to
.be
.equal(0x61);
120 expect(code
).to
.be
.equal('KeyA');
125 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', key
: 'a'}));
126 kbd
._handleKeyUp(keyevent('keyup', {code
: 'KeyA', key
: 'b'}));
128 it('should send the same keysym for multiple presses', function() {
130 var kbd
= new Keyboard({
131 onKeyEvent: function(keysym
, code
, down
) {
132 expect(keysym
).to
.be
.equal(0x61);
133 expect(code
).to
.be
.equal('KeyA');
134 expect(down
).to
.be
.equal(true);
137 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', key
: 'a'}));
138 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', key
: 'b'}));
139 expect(count
).to
.be
.equal(2);
141 it('should do nothing on keyup events if no keys are down', function() {
142 var callback
= sinon
.spy();
143 var kbd
= new Keyboard({onKeyEvent
: callback
});
144 kbd
._handleKeyUp(keyevent('keyup', {code
: 'KeyA', key
: 'a'}));
145 expect(callback
).to
.not
.have
.been
.called
;
149 describe('Shuffle modifiers on macOS', function() {
151 beforeEach(function () {
152 // window.navigator is a protected read-only property in many
153 // environments, so we need to redefine it whilst running these
155 origNavigator
= Object
.getOwnPropertyDescriptor(window
, "navigator");
156 if (origNavigator
=== undefined) {
157 // Object.getOwnPropertyDescriptor() doesn't work
158 // properly in any version of IE
162 Object
.defineProperty(window
, "navigator", {value
: {}});
163 if (window
.navigator
.platform
!== undefined) {
164 // Object.defineProperty() doesn't work properly in old
165 // versions of Chrome
169 window
.navigator
.platform
= "Mac x86_64";
171 afterEach(function () {
172 Object
.defineProperty(window
, "navigator", origNavigator
);
175 it('should change Alt to AltGraph', function() {
177 var kbd
= new Keyboard({
178 onKeyEvent: function(keysym
, code
, down
) {
181 expect(keysym
).to
.be
.equal(0xFF7E);
182 expect(code
).to
.be
.equal('AltLeft');
185 expect(keysym
).to
.be
.equal(0xFE03);
186 expect(code
).to
.be
.equal('AltRight');
190 kbd
._handleKeyDown(keyevent('keydown', {code
: 'AltLeft', key
: 'Alt'}));
191 kbd
._handleKeyDown(keyevent('keydown', {code
: 'AltRight', key
: 'Alt'}));
192 expect(count
).to
.be
.equal(2);
194 it('should change left Super to Alt', function(done
) {
195 var kbd
= new Keyboard({
196 onKeyEvent: function(keysym
, code
, down
) {
197 expect(keysym
).to
.be
.equal(0xFFE9);
198 expect(code
).to
.be
.equal('MetaLeft');
201 kbd
._handleKeyDown(keyevent('keydown', {code
: 'MetaLeft', key
: 'Meta'}));
203 it('should change right Super to left Super', function(done
) {
204 var kbd
= new Keyboard({
205 onKeyEvent: function(keysym
, code
, down
) {
206 expect(keysym
).to
.be
.equal(0xFFEB);
207 expect(code
).to
.be
.equal('MetaRight');
210 kbd
._handleKeyDown(keyevent('keydown', {code
: 'MetaRight', key
: 'Meta'}));
214 describe('Escape AltGraph on Windows', function() {
216 beforeEach(function () {
217 // window.navigator is a protected read-only property in many
218 // environments, so we need to redefine it whilst running these
220 origNavigator
= Object
.getOwnPropertyDescriptor(window
, "navigator");
221 if (origNavigator
=== undefined) {
222 // Object.getOwnPropertyDescriptor() doesn't work
223 // properly in any version of IE
227 Object
.defineProperty(window
, "navigator", {value
: {}});
228 if (window
.navigator
.platform
!== undefined) {
229 // Object.defineProperty() doesn't work properly in old
230 // versions of Chrome
234 window
.navigator
.platform
= "Windows x86_64";
236 afterEach(function () {
237 Object
.defineProperty(window
, "navigator", origNavigator
);
240 it('should generate fake undo/redo events on press when AltGraph is down', function() {
241 var times_called
= 0;
242 var kbd
= new Keyboard({
243 onKeyEvent: function(keysym
, code
, down
) {
244 switch(times_called
++) {
246 expect(keysym
).to
.be
.equal(0xFFE3);
247 expect(code
).to
.be
.equal('ControlLeft');
248 expect(down
).to
.be
.equal(true);
251 expect(keysym
).to
.be
.equal(0xFFEA);
252 expect(code
).to
.be
.equal('AltRight');
253 expect(down
).to
.be
.equal(true);
256 expect(keysym
).to
.be
.equal(0xFFEA);
257 expect(code
).to
.be
.equal('AltRight');
258 expect(down
).to
.be
.equal(false);
261 expect(keysym
).to
.be
.equal(0xFFE3);
262 expect(code
).to
.be
.equal('ControlLeft');
263 expect(down
).to
.be
.equal(false);
266 expect(keysym
).to
.be
.equal(0x61);
267 expect(code
).to
.be
.equal('KeyA');
268 expect(down
).to
.be
.equal(true);
271 expect(keysym
).to
.be
.equal(0xFFE3);
272 expect(code
).to
.be
.equal('ControlLeft');
273 expect(down
).to
.be
.equal(true);
276 expect(keysym
).to
.be
.equal(0xFFEA);
277 expect(code
).to
.be
.equal('AltRight');
278 expect(down
).to
.be
.equal(true);
282 // First the modifier combo
283 kbd
._handleKeyDown(keyevent('keydown', {code
: 'ControlLeft', key
: 'Control'}));
284 kbd
._handleKeyDown(keyevent('keydown', {code
: 'AltRight', key
: 'Alt'}));
285 // Next a normal character
286 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', key
: 'a'}));
287 expect(times_called
).to
.be
.equal(7);
289 it('should no do anything on key release', function() {
290 var times_called
= 0;
291 var kbd
= new Keyboard({
292 onKeyEvent: function(keysym
, code
, down
) {
293 switch(times_called
++) {
295 expect(keysym
).to
.be
.equal(0x61);
296 expect(code
).to
.be
.equal('KeyA');
297 expect(down
).to
.be
.equal(false);
301 // First the modifier combo
302 kbd
._handleKeyDown(keyevent('keydown', {code
: 'ControlLeft', key
: 'Control'}));
303 kbd
._handleKeyDown(keyevent('keydown', {code
: 'AltRight', key
: 'Alt'}));
304 // Next a normal character
305 kbd
._handleKeyDown(keyevent('keydown', {code
: 'KeyA', key
: 'a'}));
306 kbd
._handleKeyUp(keyevent('keyup', {code
: 'KeyA', key
: 'a'}));
307 expect(times_called
).to
.be
.equal(8);
309 it('should not consider a char modifier to be down on the modifier key itself', function() {
310 var times_called
= 0;
311 var kbd
= new Keyboard({
312 onKeyEvent: function(keysym
, code
, down
) {
313 switch(times_called
++) {
315 expect(keysym
).to
.be
.equal(0xFFE3);
316 expect(code
).to
.be
.equal('ControlLeft');
317 expect(down
).to
.be
.equal(true);
320 expect(keysym
).to
.be
.equal(0xFFE9);
321 expect(code
).to
.be
.equal('AltLeft');
322 expect(down
).to
.be
.equal(true);
325 expect(keysym
).to
.be
.equal(0xFFE3);
326 expect(code
).to
.be
.equal('ControlLeft');
327 expect(down
).to
.be
.equal(true);
331 // First the modifier combo
332 kbd
._handleKeyDown(keyevent('keydown', {code
: 'ControlLeft', key
: 'Control'}));
333 kbd
._handleKeyDown(keyevent('keydown', {code
: 'AltLeft', key
: 'Alt'}));
334 // Then one of the keys again
335 kbd
._handleKeyDown(keyevent('keydown', {code
: 'ControlLeft', key
: 'Control'}));
336 expect(times_called
).to
.be
.equal(3);