extension/test/test-api.coffee

   1 ###
   2 # Copyright Simon Lydell 2015, 2016.
   3 #
   4 # This file is part of VimFx.
   5 #
   6 # VimFx is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # VimFx is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with VimFx.  If not, see <http://www.gnu.org/licenses/>.
  18 ###
  19
  20 testUtils = require('./utils')
  21 createConfigAPI = require('../lib/api')
  22 defaults = require('../lib/defaults')
  23 prefs = require('../lib/prefs')
  24 utils = require('../lib/utils')
  25
  26 {throws} = testUtils
  27
  28 exports['test exports'] = (assert, $vimfx) ->
  29   vimfx = createConfigAPI($vimfx)
  30
  31   assert.equal(typeof vimfx.get, 'function', 'get')
  32   assert.equal(typeof vimfx.getDefault, 'function', 'getDefault')
  33   assert.equal(typeof vimfx.set, 'function', 'set')
  34   assert.equal(typeof vimfx.addCommand, 'function', 'addCommand')
  35   assert.equal(typeof vimfx.addOptionOverrides, 'function',
  36                'addOptionOverrides')
  37   assert.equal(typeof vimfx.addKeyOverrides, 'function', 'addKeyOverrides')
  38   assert.equal(typeof vimfx.send, 'function', 'send')
  39   assert.equal(typeof vimfx.on, 'function', 'on')
  40   assert.equal(typeof vimfx.off, 'function', 'off')
  41   assert.equal(vimfx.modes, $vimfx.modes, 'modes')
  42
  43 exports['test vimfx.get and vimfx.set'] = (assert, $vimfx, teardown) ->
  44   vimfx = createConfigAPI($vimfx)
  45
  46   resetHintChars = prefs.tmp('hint_chars', 'abcd')
  47   resetBlacklist = prefs.tmp('blacklist', null)
  48   originalOptions = Object.assign({}, $vimfx.options)
  49   teardown(->
  50     resetHintChars?()
  51     resetBlacklist?()
  52     $vimfx.options = originalOptions
  53   )
  54
  55   assert.equal(vimfx.get('hint_chars'), 'abcd')
  56   assert.ok(not prefs.has('blacklist'))
  57
  58   vimfx.set('hint_chars', 'xyz')
  59   assert.equal(vimfx.get('hint_chars'), 'xyz')
  60
  61   vimfx.set('blacklist', 'test')
  62   assert.equal(vimfx.get('blacklist'), 'test')
  63
  64   vimfx.set('translations', {KeyQ: ['ö', 'Ö']})
  65   assert.deepEqual(vimfx.get('translations'), {KeyQ: ['ö', 'Ö']})
  66
  67   $vimfx.emit('shutdown')
  68   assert.equal(vimfx.get('hint_chars'), 'abcd')
  69   assert.ok(not prefs.has('blacklist'))
  70   assert.deepEqual(vimfx.get('translations'), {})
  71
  72 exports['test vimfx.getDefault'] = (assert, $vimfx, teardown) ->
  73   vimfx = createConfigAPI($vimfx)
  74
  75   reset = prefs.tmp('hint_chars', 'abcd')
  76   teardown(->
  77     reset?()
  78   )
  79
  80   assert.equal(vimfx.getDefault('hint_chars'), defaults.options.hint_chars)
  81
  82 exports['test customization'] = (assert, $vimfx, teardown) ->
  83   vimfx = createConfigAPI($vimfx)
  84
  85   originalOptions = Object.assign({}, $vimfx.options)
  86   originalCategories = Object.assign({}, $vimfx.options.categories)
  87   $vimfx.options.keyValidator = null
  88   $vimfx.options.ignore_keyboard_layout = true
  89   vimfx.set('translations', {KeyQ: ['ö', 'Ö']})
  90   teardown(->
  91     $vimfx.options = originalOptions
  92     $vimfx.options.categories = originalCategories
  93     delete $vimfx.modes.normal.commands.test_command
  94     delete $vimfx.modes.ignore.commands.test_command
  95   )
  96
  97   nonce = {}
  98   event = {code: 'KeyQ'}
  99
 100   # Add a simple test command.
 101   vimfx.addCommand({
 102     name: 'test_command'
 103     description: 'Test command'
 104   }, -> nonce)
 105   vimfx.set('custom.mode.normal.test_command', 'ö')
 106
 107   # Add a slightly more complex command.
 108   vimfx.get('categories')['new_category'] = {
 109     name: 'New category'
 110     order: -100
 111   }
 112   vimfx.addCommand({
 113     name: 'test_command'
 114     description: 'Test ignore mode command'
 115     mode: 'ignore'
 116     category: 'new_category'
 117   }, -> nonce)
 118   vimfx.set('custom.mode.ignore.test_command', 'ö  <ö>  <c-c-invalid>')
 119
 120   $vimfx.createKeyTrees()
 121
 122   # Test that the new simple command can be run.
 123   $vimfx.reset('normal')
 124   match = $vimfx.consumeKeyEvent(event, {mode: 'normal', focusType: 'none'})
 125   assert.equal(match.type, 'full')
 126   assert.equal(match.command.run(), nonce)
 127
 128   # Test that the new complex command can be run.
 129   $vimfx.reset('ignore')
 130   match = $vimfx.consumeKeyEvent(event, {mode: 'ignore', focusType: 'none'})
 131   assert.equal(match.type, 'full')
 132   assert.equal(match.command.run(), nonce)
 133
 134   modes = $vimfx.getGroupedCommands({enabledOnly: true})
 135
 136   # Test that the new simple command can show up in the help dialog.
 137   mode_normal = modes.find((mode) -> mode._name == 'normal')
 138   category_misc = mode_normal.categories.find(
 139     (category) -> category._name == 'misc'
 140   )
 141   [..., {command: test_command}] = category_misc.commands
 142   assert.equal(test_command.description, 'Test command')
 143
 144   # Test that the new complex command can show up in the help dialog.
 145   mode_ignore = modes.find((mode) -> mode._name == 'ignore')
 146   [category_new] = mode_ignore.categories
 147   assert.equal(category_new.name, 'New category')
 148   [test_command] = category_new.commands
 149   assert.equal(test_command.command.description, 'Test ignore mode command')
 150   assert.deepEqual(test_command.enabledSequences, ['ö'])
 151
 152   # Remove the added commands.
 153   delete vimfx.modes.normal.commands.test_command
 154   delete vimfx.modes.ignore.commands.test_command
 155   $vimfx.createKeyTrees()
 156
 157   # Test that the new simple command cannot be run.
 158   $vimfx.reset('normal')
 159   match = $vimfx.consumeKeyEvent(event, {mode: 'normal', focusType: 'none'})
 160   if match.type == 'full'
 161     value = try match.command.run() catch then null
 162     assert.notEqual(value, nonce)
 163
 164   # Test that the new complex command cannot be run.
 165   $vimfx.reset('ignore')
 166   match = $vimfx.consumeKeyEvent(event, {mode: 'ignore', focusType: 'none'})
 167   if match.type == 'full'
 168     value = try match.command.run() catch then null
 169     assert.notEqual(value, nonce)
 170
 171   modes = $vimfx.getGroupedCommands({enabledOnly: true})
 172
 173   # Test that the new simple command cannot show up in the help dialog.
 174   mode_normal = modes.find((mode) -> mode._name == 'normal')
 175   category_misc = mode_normal.categories.find(
 176     (category) -> category._name == 'misc'
 177   )
 178   [..., {command: last_command}] = category_misc.commands
 179   assert.notEqual(last_command.description, 'Test command')
 180
 181   # Test that the new complex command cannot show up in the help dialog.
 182   mode_ignore = modes.find((mode) -> mode._name == 'ignore')
 183   [first_category] = mode_ignore.categories
 184   assert.notEqual(first_category.name, 'New category')
 185
 186 exports['test vimfx.addCommand order'] = (assert, $vimfx, teardown) ->
 187   vimfx = createConfigAPI($vimfx)
 188
 189   teardown(->
 190     delete vimfx.modes.normal.commands.test_command
 191   )
 192
 193   vimfx.addCommand({
 194     name: 'test_command'
 195     description: 'Test command'
 196     order: 0
 197   }, Function.prototype)
 198   vimfx.set('custom.mode.normal.test_command', 'ö')
 199
 200   modes = $vimfx.getGroupedCommands()
 201   mode_normal = modes.find((mode) -> mode._name == 'normal')
 202   category_misc = mode_normal.categories.find(
 203     (category) -> category._name == 'misc'
 204   )
 205   [{command: first_command}] = category_misc.commands
 206   assert.equal(first_command.description, 'Test command')
 207
 208   assert.ok('test_command' of vimfx.modes.normal.commands)
 209   $vimfx.emit('shutdown')
 210   assert.ok('test_command' not of vimfx.modes.normal.commands)
 211
 212 exports['test vimfx.addOptionOverrides'] = (assert, $vimfx, teardown) ->
 213   vimfx = createConfigAPI($vimfx)
 214
 215   originalOptions = Object.assign({}, $vimfx.options)
 216   originalOptionOverrides = Object.assign({}, $vimfx.optionOverrides)
 217   $vimfx.optionOverrides = null
 218   $vimfx.options.prevent_autofocus = true
 219   teardown(->
 220     reset?() # Defined below.
 221     $vimfx.options = originalOptions
 222     $vimfx.optionOverrides = originalOptionOverrides
 223   )
 224
 225   vimfx.addOptionOverrides(
 226     [
 227       (location) -> location.hostname == 'example.com'
 228       {prevent_autofocus: false}
 229     ]
 230   )
 231
 232   assert.equal($vimfx.options.prevent_autofocus, true)
 233
 234   reset = testUtils.stub(utils, 'getCurrentLocation', -> {
 235     hostname: 'example.com'
 236   })
 237
 238   assert.equal($vimfx.options.prevent_autofocus, false)
 239
 240   $vimfx.emit('shutdown')
 241   assert.equal($vimfx.options.prevent_autofocus, true)
 242
 243 exports['test vimfx.addKeyOverrides'] = (assert, $vimfx, teardown) ->
 244   vimfx = createConfigAPI($vimfx)
 245
 246   originalOptions = Object.assign({}, $vimfx.options)
 247   originalKeyOverrides = Object.assign({}, $vimfx.keyOverrides)
 248   $vimfx.options.keyValidator = null
 249   $vimfx.options.ignore_keyboard_layout = false
 250   $vimfx.options.translations = {}
 251   teardown(->
 252     resetScrollToBottom?() # Defined below.
 253     resetGetCurrentLocation?() # Defined below.
 254     $vimfx.options = originalOptions
 255     $vimfx.keyOverrides = originalKeyOverrides
 256   )
 257
 258   vimfx.addKeyOverrides(
 259     [
 260       (location, mode) -> mode == 'normal' and location.hostname == 'example.co'
 261       ['j', '<c-foobar>']
 262     ],
 263     [
 264       (location, mode) -> mode == 'ignore' and location.href == 'about:blank'
 265       ['<escape>']
 266     ]
 267   )
 268
 269   resetScrollToBottom = prefs.tmp('mode.normal.scroll_to_bottom', '<foobar>j')
 270   $vimfx.createKeyTrees()
 271   $vimfx.reset('normal')
 272
 273   match = $vimfx.consumeKeyEvent({key: 'j'},
 274                                  {mode: 'ignore', focusType: 'none'})
 275   assert.ok(match)
 276
 277   resetGetCurrentLocation = testUtils.stub(utils, 'getCurrentLocation', -> {
 278     hostname: 'example.co'
 279     href: 'about:blank'
 280   })
 281
 282   match = $vimfx.consumeKeyEvent({key: '1'},
 283                                  {mode: 'normal', focusType: 'none'})
 284   assert.equal(match.type, 'count')
 285   assert.equal(match.count, 1)
 286
 287   match = $vimfx.consumeKeyEvent({key: 'j'},
 288                                  {mode: 'normal', focusType: 'none'})
 289   assert.ok(not match)
 290
 291   match = $vimfx.consumeKeyEvent({key: 'foobar', ctrlKey: true},
 292                                  {mode: 'normal', focusType: 'none'})
 293   assert.ok(not match)
 294
 295   match = $vimfx.consumeKeyEvent({key: 'foobar'},
 296                                  {mode: 'normal', focusType: 'none'})
 297   assert.equal(match.type, 'partial')
 298   match = $vimfx.consumeKeyEvent({key: 'j'},
 299                                  {mode: 'normal', focusType: 'none'})
 300   assert.equal(match.type, 'full')
 301   assert.strictEqual(match.count, undefined)
 302
 303   $vimfx.reset('ignore')
 304
 305   match = $vimfx.consumeKeyEvent({key: 'j'},
 306                                  {mode: 'ignore', focusType: 'none'})
 307   assert.ok(match)
 308
 309   match = $vimfx.consumeKeyEvent({key: 'escape'},
 310                                  {mode: 'ignore', focusType: 'none'})
 311   assert.ok(not match)
 312
 313   $vimfx.emit('shutdown')
 314
 315   $vimfx.reset('normal')
 316   match = $vimfx.consumeKeyEvent({key: 'j'},
 317                                  {mode: 'normal', focusType: 'none'})
 318   assert.ok(match)
 319
 320   $vimfx.reset('ignore')
 321   match = $vimfx.consumeKeyEvent({key: 'escape'},
 322                                  {mode: 'ignore', focusType: 'none'})
 323   assert.ok(match)
 324
 325 exports['test vimfx.send'] = (assert, $vimfx) ->
 326   vimfx = createConfigAPI($vimfx)
 327
 328   messageManager = new testUtils.MockMessageManager()
 329   vim = new testUtils.MockVim(messageManager)
 330
 331   vimfx.send(vim, 'message', {example: 5})
 332   assert.equal(messageManager.sendAsyncMessageCalls, 1)
 333   assert.equal(messageManager.addMessageListenerCalls, 0)
 334   assert.equal(messageManager.removeMessageListenerCalls, 0)
 335
 336   vimfx.send(vim, 'message2', null, ->)
 337   assert.equal(messageManager.sendAsyncMessageCalls, 2)
 338   assert.equal(messageManager.addMessageListenerCalls, 1)
 339   assert.equal(messageManager.removeMessageListenerCalls, 0)
 340
 341   $vimfx.emit('shutdown')
 342   assert.equal(messageManager.sendAsyncMessageCalls, 2)
 343   assert.equal(messageManager.addMessageListenerCalls, 1)
 344   assert.equal(messageManager.removeMessageListenerCalls, 0)
 345
 346 exports['test vimfx.on and vimfx.off'] = (assert, $vimfx) ->
 347   vimfx = createConfigAPI($vimfx)
 348
 349   callCount = 0
 350   count = -> callCount += 1
 351   vimfx.on('foo', count)
 352   vimfx.on('bar', count)
 353
 354   $vimfx.emit('foo')
 355   assert.equal(callCount, 1)
 356
 357   $vimfx.emit('bar')
 358   assert.equal(callCount, 2)
 359
 360   vimfx.off('bar', count)
 361   $vimfx.emit('bar')
 362   assert.equal(callCount, 2)
 363
 364   $vimfx.emit('shutdown')
 365
 366   $vimfx.emit('foo')
 367   assert.equal(callCount, 2)
 368
 369 exports['test vimfx.[gs]et(Default)? errors'] = (assert, $vimfx) ->
 370   vimfx = createConfigAPI($vimfx)
 371
 372   throws(assert, /unknown pref/i, 'undefined', ->
 373     vimfx.get()
 374   )
 375
 376   throws(assert, /unknown pref/i, 'undefined', ->
 377     vimfx.getDefault()
 378   )
 379
 380   throws(assert, /unknown pref/i, 'undefined', ->
 381     vimfx.set()
 382   )
 383
 384   throws(assert, /unknown pref/i, 'unknown_pref', ->
 385     vimfx.get('unknown_pref')
 386   )
 387
 388   throws(assert, /unknown pref/i, 'unknown_pref', ->
 389     vimfx.getDefault('unknown_pref')
 390   )
 391
 392   throws(assert, /no default/i, 'custom.mode.normal.foo', ->
 393     vimfx.getDefault('custom.mode.normal.foo')
 394   )
 395
 396   throws(assert, /no default/i, 'translations', ->
 397     vimfx.getDefault('translations')
 398   )
 399
 400   throws(assert, /unknown pref/i, 'unknown_pref', ->
 401     vimfx.set('unknown_pref', 'foo')
 402   )
 403
 404   throws(assert, /boolean, number, string or null/i, 'undefined', ->
 405     vimfx.set('hint_chars')
 406   )
 407
 408   throws(assert, /boolean, number, string or null/i, 'object', ->
 409     vimfx.set('hint_chars', ['a', 'b', 'c'])
 410   )
 411
 412 exports['test vimfx.addCommand errors'] = (assert, $vimfx) ->
 413   vimfx = createConfigAPI($vimfx)
 414
 415   throws(assert, /name.+string.+required/i, 'undefined', ->
 416     vimfx.addCommand()
 417   )
 418
 419   throws(assert, /name.+a-z.+underscore/i, 'Command', ->
 420     vimfx.addCommand({name: 'Command'})
 421   )
 422
 423   throws(assert, /name.+a-z.+underscore/i, 'command-name', ->
 424     vimfx.addCommand({name: 'command-name'})
 425   )
 426
 427   throws(assert, /name.+a-z.+underscore/i, 'ö', ->
 428     vimfx.addCommand({name: 'ö'})
 429   )
 430
 431   throws(assert, /non-empty description/i, 'undefined', ->
 432     vimfx.addCommand({name: 'test'})
 433   )
 434
 435   throws(assert, /non-empty description/i, '', ->
 436     vimfx.addCommand({name: 'test', description: ''})
 437   )
 438
 439   throws(assert, /unknown mode.+available.+normal/i, 'toString', ->
 440     vimfx.addCommand({name: 'test', description: 'Test', mode: 'toString'})
 441   )
 442
 443   throws(assert, /unknown category.+available.+location/i, 'toString', ->
 444     vimfx.addCommand({name: 'test', description: 'Test', category: 'toString'})
 445   )
 446
 447   throws(assert, /order.+number/i, 'false', ->
 448     vimfx.addCommand({name: 'test', description: 'Test', order: false})
 449   )
 450
 451   throws(assert, /function/i, 'undefined', ->
 452     vimfx.addCommand({name: 'test', description: 'Test'})
 453   )
 454
 455   throws(assert, /function/i, 'false', ->
 456     vimfx.addCommand({name: 'test_command', description: 'Test command'}, false)
 457   )
 458
 459 exports['test vimfx.send errors'] = (assert, $vimfx) ->
 460   vimfx = createConfigAPI($vimfx)
 461
 462   vim = new testUtils.MockVim()
 463
 464   throws(assert, /vim object/i, 'undefined', ->
 465     vimfx.send()
 466   )
 467
 468   throws(assert, /vim object/i, '[object Object]', ->
 469     vimfx.send({mode: 'normal'})
 470   )
 471
 472   throws(assert, /message string/i, 'undefined', ->
 473     vimfx.send(vim)
 474   )
 475
 476   throws(assert, /message string/i, 'false', ->
 477     vimfx.send(vim, false)
 478   )
 479
 480   throws(assert, /not.+function/i, 'function () {}', ->
 481     vimfx.send(vim, 'message', ->)
 482   )
 483
 484   throws(assert, /if provided.+function/i, '5', ->
 485     vimfx.send(vim, 'message', null, 5)
 486   )