tests/test.keyboard.js

   1 var assert = chai.assert;
   2 var expect = chai.expect;
   3
   4 import sinon from '../vendor/sinon.js';
   5
   6 import Keyboard from '../core/input/keyboard.js';
   7
   8 function isIE() {
   9     return navigator && !!(/trident/i).exec(navigator.userAgent);
  10 }
  11 function isEdge() {
  12     return navigator && !!(/edge/i).exec(navigator.userAgent);
  13 }
  14
  15 describe('Key Event Handling', function() {
  16     "use strict";
  17
  18     // The real KeyboardEvent constructor might not work everywhere we
  19     // want to run these tests
  20     function keyevent(typeArg, KeyboardEventInit) {
  21         var e = { type: typeArg };
  22         for (var key in KeyboardEventInit) {
  23             e[key] = KeyboardEventInit[key];
  24         }
  25         e.stopPropagation = sinon.spy();
  26         e.preventDefault = sinon.spy();
  27         return e;
  28     };
  29
  30     describe('Decode Keyboard Events', function() {
  31         it('should decode keydown events', function(done) {
  32             if (isIE() || isEdge()) this.skip();
  33             var kbd = new Keyboard(document);
  34             kbd.onkeyevent = function(keysym, code, down) {
  35                 expect(keysym).to.be.equal(0x61);
  36                 expect(code).to.be.equal('KeyA');
  37                 expect(down).to.be.equal(true);
  38                 done();
  39             };
  40             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
  41         });
  42         it('should decode keyup events', function(done) {
  43             if (isIE() || isEdge()) this.skip();
  44             var calls = 0;
  45             var kbd = new Keyboard(document);
  46             kbd.onkeyevent = function(keysym, code, down) {
  47                 expect(keysym).to.be.equal(0x61);
  48                 expect(code).to.be.equal('KeyA');
  49                 if (calls++ === 1) {
  50                     expect(down).to.be.equal(false);
  51                     done();
  52                 }
  53             };
  54             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
  55             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
  56         });
  57
  58         describe('Legacy keypress Events', function() {
  59             it('should wait for keypress when needed', function() {
  60                 var kbd = new Keyboard(document);
  61                 kbd.onkeyevent = sinon.spy();
  62                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  63                 expect(kbd.onkeyevent).to.not.have.been.called;
  64             });
  65             it('should decode keypress events', function(done) {
  66                 var kbd = new Keyboard(document);
  67                 kbd.onkeyevent = function(keysym, code, down) {
  68                     expect(keysym).to.be.equal(0x61);
  69                     expect(code).to.be.equal('KeyA');
  70                     expect(down).to.be.equal(true);
  71                     done();
  72                 };
  73                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  74                 kbd._handleKeyPress(keyevent('keypress', {code: 'KeyA', charCode: 0x61}));
  75             });
  76             it('should ignore keypress with different code', function() {
  77                 var kbd = new Keyboard(document);
  78                 kbd.onkeyevent = sinon.spy();
  79                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  80                 kbd._handleKeyPress(keyevent('keypress', {code: 'KeyB', charCode: 0x61}));
  81                 expect(kbd.onkeyevent).to.not.have.been.called;
  82             });
  83             it('should handle keypress with missing code', function(done) {
  84                 var kbd = new Keyboard(document);
  85                 kbd.onkeyevent = function(keysym, code, down) {
  86                     expect(keysym).to.be.equal(0x61);
  87                     expect(code).to.be.equal('KeyA');
  88                     expect(down).to.be.equal(true);
  89                     done();
  90                 };
  91                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  92                 kbd._handleKeyPress(keyevent('keypress', {charCode: 0x61}));
  93             });
  94             it('should guess key if no keypress and numeric key', function(done) {
  95                 var kbd = new Keyboard(document);
  96                 kbd.onkeyevent = function(keysym, code, down) {
  97                     expect(keysym).to.be.equal(0x32);
  98                     expect(code).to.be.equal('Digit2');
  99                     expect(down).to.be.equal(true);
 100                     done();
 101                 };
 102                 kbd._handleKeyDown(keyevent('keydown', {code: 'Digit2', keyCode: 0x32}));
 103             });
 104             it('should guess key if no keypress and alpha key', function(done) {
 105                 var kbd = new Keyboard(document);
 106                 kbd.onkeyevent = function(keysym, code, down) {
 107                     expect(keysym).to.be.equal(0x61);
 108                     expect(code).to.be.equal('KeyA');
 109                     expect(down).to.be.equal(true);
 110                     done();
 111                 };
 112                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41, shiftKey: false}));
 113             });
 114             it('should guess key if no keypress and alpha key (with shift)', function(done) {
 115                 var kbd = new Keyboard(document);
 116                 kbd.onkeyevent = function(keysym, code, down) {
 117                     expect(keysym).to.be.equal(0x41);
 118                     expect(code).to.be.equal('KeyA');
 119                     expect(down).to.be.equal(true);
 120                     done();
 121                 };
 122                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41, shiftKey: true}));
 123             });
 124             it('should not guess key if no keypress and unknown key', function(done) {
 125                 var kbd = new Keyboard(document);
 126                 kbd.onkeyevent = function(keysym, code, down) {
 127                     expect(keysym).to.be.equal(0);
 128                     expect(code).to.be.equal('KeyA');
 129                     expect(down).to.be.equal(true);
 130                     done();
 131                 };
 132                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x09}));
 133             });
 134         });
 135
 136         describe('suppress the right events at the right time', function() {
 137             beforeEach(function () {
 138                 if (isIE() || isEdge()) this.skip();
 139             });
 140             it('should suppress anything with a valid key', function() {
 141                 var kbd = new Keyboard(document, {});
 142                 var evt = keyevent('keydown', {code: 'KeyA', key: 'a'});
 143                 kbd._handleKeyDown(evt);
 144                 expect(evt.preventDefault).to.have.been.called;
 145                 evt = keyevent('keyup', {code: 'KeyA', key: 'a'});
 146                 kbd._handleKeyUp(evt);
 147                 expect(evt.preventDefault).to.have.been.called;
 148             });
 149             it('should not suppress keys without key', function() {
 150                 var kbd = new Keyboard(document, {});
 151                 var evt = keyevent('keydown', {code: 'KeyA', keyCode: 0x41});
 152                 kbd._handleKeyDown(evt);
 153                 expect(evt.preventDefault).to.not.have.been.called;
 154             });
 155             it('should suppress the following keypress event', function() {
 156                 var kbd = new Keyboard(document, {});
 157                 var evt = keyevent('keydown', {code: 'KeyA', keyCode: 0x41});
 158                 kbd._handleKeyDown(evt);
 159                 var evt = keyevent('keypress', {code: 'KeyA', charCode: 0x41});
 160                 kbd._handleKeyPress(evt);
 161                 expect(evt.preventDefault).to.have.been.called;
 162             });
 163         });
 164     });
 165
 166     describe('Fake keyup', function() {
 167         it('should fake keyup events for virtual keyboards', function(done) {
 168             if (isIE() || isEdge()) this.skip();
 169             var count = 0;
 170             var kbd = new Keyboard(document);
 171             kbd.onkeyevent = function(keysym, code, down) {
 172                 switch (count++) {
 173                     case 0:
 174                         expect(keysym).to.be.equal(0x61);
 175                         expect(code).to.be.equal('Unidentified');
 176                         expect(down).to.be.equal(true);
 177                         break;
 178                     case 1:
 179                         expect(keysym).to.be.equal(0x61);
 180                         expect(code).to.be.equal('Unidentified');
 181                         expect(down).to.be.equal(false);
 182                         done();
 183                 }
 184             };
 185             kbd._handleKeyDown(keyevent('keydown', {code: 'Unidentified', key: 'a'}));
 186         });
 187
 188         describe('iOS', function() {
 189             var origNavigator;
 190             beforeEach(function () {
 191                 // window.navigator is a protected read-only property in many
 192                 // environments, so we need to redefine it whilst running these
 193                 // tests.
 194                 origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
 195                 if (origNavigator === undefined) {
 196                     // Object.getOwnPropertyDescriptor() doesn't work
 197                     // properly in any version of IE
 198                     this.skip();
 199                 }
 200
 201                 Object.defineProperty(window, "navigator", {value: {}});
 202                 if (window.navigator.platform !== undefined) {
 203                     // Object.defineProperty() doesn't work properly in old
 204                     // versions of Chrome
 205                     this.skip();
 206                 }
 207
 208                 window.navigator.platform = "iPhone 9.0";
 209             });
 210             afterEach(function () {
 211                 Object.defineProperty(window, "navigator", origNavigator);
 212             });
 213
 214             it('should fake keyup events on iOS', function(done) {
 215                 if (isIE() || isEdge()) this.skip();
 216                 var count = 0;
 217                 var kbd = new Keyboard(document);
 218                 kbd.onkeyevent = function(keysym, code, down) {
 219                     switch (count++) {
 220                         case 0:
 221                             expect(keysym).to.be.equal(0x61);
 222                             expect(code).to.be.equal('KeyA');
 223                             expect(down).to.be.equal(true);
 224                             break;
 225                         case 1:
 226                             expect(keysym).to.be.equal(0x61);
 227                             expect(code).to.be.equal('KeyA');
 228                             expect(down).to.be.equal(false);
 229                             done();
 230                     }
 231                 };
 232                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 233             });
 234         });
 235     });
 236
 237     describe('Track Key State', function() {
 238         beforeEach(function () {
 239             if (isIE() || isEdge()) this.skip();
 240         });
 241         it('should send release using the same keysym as the press', function(done) {
 242             var kbd = new Keyboard(document);
 243             kbd.onkeyevent = function(keysym, code, down) {
 244                 expect(keysym).to.be.equal(0x61);
 245                 expect(code).to.be.equal('KeyA');
 246                 if (!down) {
 247                     done();
 248                 }
 249             };
 250             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 251             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'b'}));
 252         });
 253         it('should send the same keysym for multiple presses', function() {
 254             var count = 0;
 255             var kbd = new Keyboard(document);
 256             kbd.onkeyevent = function(keysym, code, down) {
 257                 expect(keysym).to.be.equal(0x61);
 258                 expect(code).to.be.equal('KeyA');
 259                 expect(down).to.be.equal(true);
 260                 count++;
 261             };
 262             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 263             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'b'}));
 264             expect(count).to.be.equal(2);
 265         });
 266         it('should do nothing on keyup events if no keys are down', function() {
 267             var kbd = new Keyboard(document);
 268             kbd.onkeyevent = sinon.spy();
 269             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
 270             expect(kbd.onkeyevent).to.not.have.been.called;
 271         });
 272
 273         describe('Legacy Events', function() {
 274             it('should track keys using keyCode if no code', function(done) {
 275                 var kbd = new Keyboard(document);
 276                 kbd.onkeyevent = function(keysym, code, down) {
 277                     expect(keysym).to.be.equal(0x61);
 278                     expect(code).to.be.equal('Platform65');
 279                     if (!down) {
 280                         done();
 281                     }
 282                 };
 283                 kbd._handleKeyDown(keyevent('keydown', {keyCode: 65, key: 'a'}));
 284                 kbd._handleKeyUp(keyevent('keyup', {keyCode: 65, key: 'b'}));
 285             });
 286             it('should ignore compositing code', function() {
 287                 var kbd = new Keyboard(document);
 288                 kbd.onkeyevent = function(keysym, code, down) {
 289                     expect(keysym).to.be.equal(0x61);
 290                     expect(code).to.be.equal('Unidentified');
 291                 };
 292                 kbd._handleKeyDown(keyevent('keydown', {keyCode: 229, key: 'a'}));
 293             });
 294             it('should track keys using keyIdentifier if no code', function(done) {
 295                 var kbd = new Keyboard(document);
 296                 kbd.onkeyevent = function(keysym, code, down) {
 297                     expect(keysym).to.be.equal(0x61);
 298                     expect(code).to.be.equal('Platform65');
 299                     if (!down) {
 300                         done();
 301                     }
 302                 };
 303                 kbd._handleKeyDown(keyevent('keydown', {keyIdentifier: 'U+0041', key: 'a'}));
 304                 kbd._handleKeyUp(keyevent('keyup', {keyIdentifier: 'U+0041', key: 'b'}));
 305             });
 306         });
 307     });
 308
 309     describe('Shuffle modifiers on macOS', function() {
 310         var origNavigator;
 311         beforeEach(function () {
 312             // window.navigator is a protected read-only property in many
 313             // environments, so we need to redefine it whilst running these
 314             // tests.
 315             origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
 316             if (origNavigator === undefined) {
 317                 // Object.getOwnPropertyDescriptor() doesn't work
 318                 // properly in any version of IE
 319                 this.skip();
 320             }
 321
 322             Object.defineProperty(window, "navigator", {value: {}});
 323             if (window.navigator.platform !== undefined) {
 324                 // Object.defineProperty() doesn't work properly in old
 325                 // versions of Chrome
 326                 this.skip();
 327             }
 328
 329             window.navigator.platform = "Mac x86_64";
 330         });
 331         afterEach(function () {
 332             Object.defineProperty(window, "navigator", origNavigator);
 333         });
 334
 335         it('should change Alt to AltGraph', function() {
 336             var count = 0;
 337             var kbd = new Keyboard(document);
 338             kbd.onkeyevent = function(keysym, code, down) {
 339                 switch (count++) {
 340                     case 0:
 341                         expect(keysym).to.be.equal(0xFF7E);
 342                         expect(code).to.be.equal('AltLeft');
 343                         break;
 344                     case 1:
 345                         expect(keysym).to.be.equal(0xFE03);
 346                         expect(code).to.be.equal('AltRight');
 347                         break;
 348                 }
 349             };
 350             kbd._handleKeyDown(keyevent('keydown', {code: 'AltLeft', key: 'Alt', location: 1}));
 351             kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'Alt', location: 2}));
 352             expect(count).to.be.equal(2);
 353         });
 354         it('should change left Super to Alt', function(done) {
 355             var kbd = new Keyboard(document);
 356             kbd.onkeyevent = function(keysym, code, down) {
 357                 expect(keysym).to.be.equal(0xFFE9);
 358                 expect(code).to.be.equal('MetaLeft');
 359                 done();
 360             };
 361             kbd._handleKeyDown(keyevent('keydown', {code: 'MetaLeft', key: 'Meta', location: 1}));
 362         });
 363         it('should change right Super to left Super', function(done) {
 364             var kbd = new Keyboard(document);
 365             kbd.onkeyevent = function(keysym, code, down) {
 366                 expect(keysym).to.be.equal(0xFFEB);
 367                 expect(code).to.be.equal('MetaRight');
 368                 done();
 369             };
 370             kbd._handleKeyDown(keyevent('keydown', {code: 'MetaRight', key: 'Meta', location: 2}));
 371         });
 372     });
 373
 374     describe('Escape AltGraph on Windows', function() {
 375         var origNavigator;
 376         beforeEach(function () {
 377             // window.navigator is a protected read-only property in many
 378             // environments, so we need to redefine it whilst running these
 379             // tests.
 380             origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
 381             if (origNavigator === undefined) {
 382                 // Object.getOwnPropertyDescriptor() doesn't work
 383                 // properly in any version of IE
 384                 this.skip();
 385             }
 386
 387             Object.defineProperty(window, "navigator", {value: {}});
 388             if (window.navigator.platform !== undefined) {
 389                 // Object.defineProperty() doesn't work properly in old
 390                 // versions of Chrome
 391                 this.skip();
 392             }
 393
 394             window.navigator.platform = "Windows x86_64";
 395         });
 396         afterEach(function () {
 397             Object.defineProperty(window, "navigator", origNavigator);
 398         });
 399
 400         it('should generate fake undo/redo events on press when AltGraph is down', function() {
 401             var times_called = 0;
 402             var kbd = new Keyboard(document);
 403             kbd.onkeyevent = function(keysym, code, down) {
 404                 switch(times_called++) {
 405                 case 0:
 406                     expect(keysym).to.be.equal(0xFFE3);
 407                     expect(code).to.be.equal('ControlLeft');
 408                     expect(down).to.be.equal(true);
 409                     break;
 410                 case 1:
 411                     expect(keysym).to.be.equal(0xFFEA);
 412                     expect(code).to.be.equal('AltRight');
 413                     expect(down).to.be.equal(true);
 414                     break;
 415                 case 2:
 416                     expect(keysym).to.be.equal(0xFFEA);
 417                     expect(code).to.be.equal('AltRight');
 418                     expect(down).to.be.equal(false);
 419                     break;
 420                 case 3:
 421                     expect(keysym).to.be.equal(0xFFE3);
 422                     expect(code).to.be.equal('ControlLeft');
 423                     expect(down).to.be.equal(false);
 424                     break;
 425                 case 4:
 426                     expect(keysym).to.be.equal(0x61);
 427                     expect(code).to.be.equal('KeyA');
 428                     expect(down).to.be.equal(true);
 429                     break;
 430                 case 5:
 431                     expect(keysym).to.be.equal(0xFFE3);
 432                     expect(code).to.be.equal('ControlLeft');
 433                     expect(down).to.be.equal(true);
 434                     break;
 435                 case 6:
 436                     expect(keysym).to.be.equal(0xFFEA);
 437                     expect(code).to.be.equal('AltRight');
 438                     expect(down).to.be.equal(true);
 439                     break;
 440                 }
 441             };
 442             // First the modifier combo
 443             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
 444             kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'Alt', location: 2}));
 445             // Next a normal character
 446             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 447             expect(times_called).to.be.equal(7);
 448         });
 449         it('should no do anything on key release', function() {
 450             var times_called = 0;
 451             var kbd = new Keyboard(document);
 452             kbd.onkeyevent = function(keysym, code, down) {
 453                 switch(times_called++) {
 454                 case 7:
 455                     expect(keysym).to.be.equal(0x61);
 456                     expect(code).to.be.equal('KeyA');
 457                     expect(down).to.be.equal(false);
 458                     break;
 459                 }
 460             };
 461             // First the modifier combo
 462             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
 463             kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'Alt', location: 2}));
 464             // Next a normal character
 465             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 466             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
 467             expect(times_called).to.be.equal(8);
 468         });
 469         it('should not consider a char modifier to be down on the modifier key itself', function() {
 470             var times_called = 0;
 471             var kbd = new Keyboard(document);
 472             kbd.onkeyevent = function(keysym, code, down) {
 473                 switch(times_called++) {
 474                 case 0:
 475                     expect(keysym).to.be.equal(0xFFE3);
 476                     expect(code).to.be.equal('ControlLeft');
 477                     expect(down).to.be.equal(true);
 478                     break;
 479                 case 1:
 480                     expect(keysym).to.be.equal(0xFFE9);
 481                     expect(code).to.be.equal('AltLeft');
 482                     expect(down).to.be.equal(true);
 483                     break;
 484                 case 2:
 485                     expect(keysym).to.be.equal(0xFFE3);
 486                     expect(code).to.be.equal('ControlLeft');
 487                     expect(down).to.be.equal(true);
 488                     break;
 489                 }
 490             };
 491             // First the modifier combo
 492             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
 493             kbd._handleKeyDown(keyevent('keydown', {code: 'AltLeft', key: 'Alt', location: 1}));
 494             // Then one of the keys again
 495             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
 496             expect(times_called).to.be.equal(3);
 497         });
 498     });
 499 });