webext-schema 7.0.0 → 7.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (32) hide show
  1. package/.github/workflows/node.js.yml +2 -2
  2. package/.prettierignore +8 -0
  3. package/README.md +37 -6
  4. package/SECURITY.md +30 -0
  5. package/eslint.config.mjs +27 -19
  6. package/index.js +9 -3
  7. package/modules/browser.js +81 -25
  8. package/modules/commander.js +8 -5
  9. package/modules/common.js +1 -1
  10. package/modules/file-util.js +23 -10
  11. package/modules/schema.js +21 -14
  12. package/modules/update.js +34 -23
  13. package/package.json +25 -24
  14. package/prettier.config.mjs +14 -0
  15. package/schemas/beta/webext.json +902 -204
  16. package/schemas/central/webext.json +902 -204
  17. package/schemas/mail/mailext.json +552 -17
  18. package/test/browser.test.js +1045 -495
  19. package/test/commander.test.js +7 -21
  20. package/test/common.test.js +7 -1
  21. package/test/file-util.test.js +65 -35
  22. package/test/index.test.js +55 -1
  23. package/test/schema.test.js +839 -430
  24. package/test/update.test.js +872 -511
  25. package/types/index.d.ts +8 -1
  26. package/types/modules/browser.d.ts +61 -61
  27. package/types/modules/commander.d.ts +3 -3
  28. package/types/modules/common.d.ts +7 -7
  29. package/types/modules/constant.d.ts +3 -3
  30. package/types/modules/file-util.d.ts +16 -16
  31. package/types/modules/schema.d.ts +6 -6
  32. package/types/modules/update.d.ts +10 -10
package/test/browser.test.js CHANGED
@@ -9,7 +9,6 @@ import sinon from 'sinon';
9
9
  import { browser } from './mocha/setup.js';
10
10
 
11
11
  /* test */
12
- // eslint-disable-next-line import-x/order
13
12
  import * as mjs from '../modules/browser.js';
14
13
 
15
14
  describe('browser', () => {
@@ -214,10 +213,16 @@ describe('browser', () => {
214
213
  browser.bookmarks.getTree.resolves([{}]);
215
214
  const res = await func();
216
215
  assert.strictEqual(browser.bookmarks.get.callCount, i, 'not called get');
217
- assert.strictEqual(browser.bookmarks.getSubTree.callCount, j,
218
- 'not called get sub tree');
219
- assert.strictEqual(browser.bookmarks.getTree.callCount, k + 1,
220
- 'called get tree');
216
+ assert.strictEqual(
217
+ browser.bookmarks.getSubTree.callCount,
218
+ j,
219
+ 'not called get sub tree'
220
+ );
221
+ assert.strictEqual(
222
+ browser.bookmarks.getTree.callCount,
223
+ k + 1,
224
+ 'called get tree'
225
+ );
221
226
  assert.deepEqual(res, [{}], 'result');
222
227
  });
223
228
 
@@ -235,10 +240,16 @@ describe('browser', () => {
235
240
  browser.bookmarks.getSubTree.withArgs('foo').resolves([{}]);
236
241
  const res = await func('foo');
237
242
  assert.strictEqual(browser.bookmarks.get.callCount, i, 'not called get');
238
- assert.strictEqual(browser.bookmarks.getSubTree.callCount, j + 1,
239
- 'called get sub tree');
240
- assert.strictEqual(browser.bookmarks.getTree.callCount, k,
241
- 'not called get tree');
243
+ assert.strictEqual(
244
+ browser.bookmarks.getSubTree.callCount,
245
+ j + 1,
246
+ 'called get sub tree'
247
+ );
248
+ assert.strictEqual(
249
+ browser.bookmarks.getTree.callCount,
250
+ k,
251
+ 'not called get tree'
252
+ );
242
253
  assert.deepEqual(res, [{}], 'result');
243
254
  });
244
255
 
@@ -249,10 +260,16 @@ describe('browser', () => {
249
260
  browser.bookmarks.get.withArgs(['foo', 'bar']).resolves([{}, {}]);
250
261
  const res = await func(['foo', 'bar']);
251
262
  assert.strictEqual(browser.bookmarks.get.callCount, i + 1, 'called get');
252
- assert.strictEqual(browser.bookmarks.getSubTree.callCount, j,
253
- 'not called get sub tree');
254
- assert.strictEqual(browser.bookmarks.getTree.callCount, k,
255
- 'not called get tree');
263
+ assert.strictEqual(
264
+ browser.bookmarks.getSubTree.callCount,
265
+ j,
266
+ 'not called get sub tree'
267
+ );
268
+ assert.strictEqual(
269
+ browser.bookmarks.getTree.callCount,
270
+ k,
271
+ 'not called get tree'
272
+ );
256
273
  assert.deepEqual(res, [{}, {}], 'result');
257
274
  });
258
275
  });
@@ -265,7 +282,8 @@ describe('browser', () => {
265
282
  const i = browser.browserSettings.closeTabsByDoubleClick.get.callCount;
266
283
  const res = await func({ foo: 'bar' });
267
284
  assert.strictEqual(
268
- browser.browserSettings.closeTabsByDoubleClick.get.callCount, i,
285
+ browser.browserSettings.closeTabsByDoubleClick.get.callCount,
286
+ i,
269
287
  'not called'
270
288
  );
271
289
  assert.deepEqual(res, null, 'result');
@@ -277,7 +295,8 @@ describe('browser', () => {
277
295
  });
278
296
 
279
297
  it('should get object', async () => {
280
- browser.browserSettings.closeTabsByDoubleClick.get.withArgs({})
298
+ browser.browserSettings.closeTabsByDoubleClick.get
299
+ .withArgs({})
281
300
  .resolves({});
282
301
  const res = await func();
283
302
  assert.deepEqual(res, {}, 'result');
@@ -292,7 +311,8 @@ describe('browser', () => {
292
311
  const i = browser.browserSettings.contextMenuShowEvent.get.callCount;
293
312
  const res = await func();
294
313
  assert.strictEqual(
295
- browser.browserSettings.contextMenuShowEvent.get.callCount, i,
314
+ browser.browserSettings.contextMenuShowEvent.get.callCount,
315
+ i,
296
316
  'not called'
297
317
  );
298
318
  assert.strictEqual(res, false, 'result');
@@ -306,11 +326,13 @@ describe('browser', () => {
306
326
  });
307
327
  const res = await func();
308
328
  assert.strictEqual(
309
- browser.browserSettings.contextMenuShowEvent.get.callCount, i + 1,
329
+ browser.browserSettings.contextMenuShowEvent.get.callCount,
330
+ i + 1,
310
331
  'called'
311
332
  );
312
333
  assert.strictEqual(
313
- browser.browserSettings.contextMenuShowEvent.set.callCount, j,
334
+ browser.browserSettings.contextMenuShowEvent.set.callCount,
335
+ j,
314
336
  'not called'
315
337
  );
316
338
  assert.strictEqual(res, true, 'result');
@@ -326,11 +348,13 @@ describe('browser', () => {
326
348
  browser.browserSettings.contextMenuShowEvent.set.resolves(true);
327
349
  const res = await func();
328
350
  assert.strictEqual(
329
- browser.browserSettings.contextMenuShowEvent.get.callCount, i + 1,
351
+ browser.browserSettings.contextMenuShowEvent.get.callCount,
352
+ i + 1,
330
353
  'called'
331
354
  );
332
355
  assert.strictEqual(
333
- browser.browserSettings.contextMenuShowEvent.set.callCount, j + 1,
356
+ browser.browserSettings.contextMenuShowEvent.set.callCount,
357
+ j + 1,
334
358
  'called'
335
359
  );
336
360
  assert.strictEqual(res, true, 'result');
@@ -346,11 +370,13 @@ describe('browser', () => {
346
370
  browser.browserSettings.contextMenuShowEvent.set.resolves(false);
347
371
  const res = await func();
348
372
  assert.strictEqual(
349
- browser.browserSettings.contextMenuShowEvent.get.callCount, i + 1,
373
+ browser.browserSettings.contextMenuShowEvent.get.callCount,
374
+ i + 1,
350
375
  'called'
351
376
  );
352
377
  assert.strictEqual(
353
- browser.browserSettings.contextMenuShowEvent.set.callCount, j + 1,
378
+ browser.browserSettings.contextMenuShowEvent.set.callCount,
379
+ j + 1,
354
380
  'called'
355
381
  );
356
382
  assert.strictEqual(res, false, 'result');
@@ -365,11 +391,13 @@ describe('browser', () => {
365
391
  });
366
392
  const res = await func();
367
393
  assert.strictEqual(
368
- browser.browserSettings.contextMenuShowEvent.get.callCount, i + 1,
394
+ browser.browserSettings.contextMenuShowEvent.get.callCount,
395
+ i + 1,
369
396
  'called'
370
397
  );
371
398
  assert.strictEqual(
372
- browser.browserSettings.contextMenuShowEvent.set.callCount, j,
399
+ browser.browserSettings.contextMenuShowEvent.set.callCount,
400
+ j,
373
401
  'not called'
374
402
  );
375
403
  assert.strictEqual(res, false, 'result');
@@ -384,7 +412,8 @@ describe('browser', () => {
384
412
  const i = browser.browserSettings.contextMenuShowEvent.clear.callCount;
385
413
  const res = await func();
386
414
  assert.strictEqual(
387
- browser.browserSettings.contextMenuShowEvent.clear.callCount, i,
415
+ browser.browserSettings.contextMenuShowEvent.clear.callCount,
416
+ i,
388
417
  'not called'
389
418
  );
390
419
  assert.strictEqual(res, false, 'result');
@@ -395,7 +424,8 @@ describe('browser', () => {
395
424
  browser.browserSettings.contextMenuShowEvent.clear.resolves(true);
396
425
  const res = await func();
397
426
  assert.strictEqual(
398
- browser.browserSettings.contextMenuShowEvent.clear.callCount, i + 1,
427
+ browser.browserSettings.contextMenuShowEvent.clear.callCount,
428
+ i + 1,
399
429
  'called'
400
430
  );
401
431
  assert.strictEqual(res, true, 'result');
@@ -406,7 +436,8 @@ describe('browser', () => {
406
436
  browser.browserSettings.contextMenuShowEvent.clear.resolves(false);
407
437
  const res = await func();
408
438
  assert.strictEqual(
409
- browser.browserSettings.contextMenuShowEvent.clear.callCount, i + 1,
439
+ browser.browserSettings.contextMenuShowEvent.clear.callCount,
440
+ i + 1,
410
441
  'called'
411
442
  );
412
443
  assert.strictEqual(res, false, 'result');
@@ -421,7 +452,9 @@ describe('browser', () => {
421
452
  const i = browser.browserSettings.newTabPosition.get.callCount;
422
453
  const res = await func();
423
454
  assert.strictEqual(
424
- browser.browserSettings.newTabPosition.get.callCount, i, 'not called'
455
+ browser.browserSettings.newTabPosition.get.callCount,
456
+ i,
457
+ 'not called'
425
458
  );
426
459
  assert.deepEqual(res, null, 'result');
427
460
  });
@@ -431,7 +464,9 @@ describe('browser', () => {
431
464
  browser.browserSettings.newTabPosition.get.resolves('foo');
432
465
  const res = await func();
433
466
  assert.strictEqual(
434
- browser.browserSettings.newTabPosition.get.callCount, i + 1, 'called'
467
+ browser.browserSettings.newTabPosition.get.callCount,
468
+ i + 1,
469
+ 'called'
435
470
  );
436
471
  assert.strictEqual(res, 'foo', 'result');
437
472
  });
@@ -476,19 +511,31 @@ describe('browser', () => {
476
511
  it('should get null', async () => {
477
512
  browser.permissions.contains.resolves(false);
478
513
  const res = await func('foo', '');
479
- assert.strictEqual(browser.commands.reset.calledOnce, false,
480
- 'not called');
481
- assert.strictEqual(browser.commands.update.calledOnce, false,
482
- 'not called');
514
+ assert.strictEqual(
515
+ browser.commands.reset.calledOnce,
516
+ false,
517
+ 'not called'
518
+ );
519
+ assert.strictEqual(
520
+ browser.commands.update.calledOnce,
521
+ false,
522
+ 'not called'
523
+ );
483
524
  assert.deepEqual(res, null, 'result');
484
525
  });
485
526
 
486
527
  it('should get null', async () => {
487
528
  const res = await func('foo', 'a');
488
- assert.strictEqual(browser.commands.reset.calledOnce, false,
489
- 'not called');
490
- assert.strictEqual(browser.commands.update.calledOnce, false,
491
- 'not called');
529
+ assert.strictEqual(
530
+ browser.commands.reset.calledOnce,
531
+ false,
532
+ 'not called'
533
+ );
534
+ assert.strictEqual(
535
+ browser.commands.update.calledOnce,
536
+ false,
537
+ 'not called'
538
+ );
492
539
  assert.deepEqual(res, null, 'result');
493
540
  });
494
541
 
@@ -497,8 +544,11 @@ describe('browser', () => {
497
544
  browser.commands.update.rejects();
498
545
  const res = await func('foo', '');
499
546
  assert.strictEqual(browser.commands.reset.calledOnce, true, 'called');
500
- assert.strictEqual(browser.commands.update.calledOnce, false,
501
- 'not called');
547
+ assert.strictEqual(
548
+ browser.commands.update.calledOnce,
549
+ false,
550
+ 'not called'
551
+ );
502
552
  assert.strictEqual(res, undefined, 'result');
503
553
  });
504
554
 
@@ -506,56 +556,135 @@ describe('browser', () => {
506
556
  browser.commands.reset.rejects();
507
557
  browser.commands.update.resolves(undefined);
508
558
  const items = [
509
- 'Alt+1', 'Command+1', 'Ctrl+1', 'MacCtrl+1',
510
- 'Alt+Shift+1', 'Command+Shift+1', 'Ctrl+Shift+1', 'MacCtrl+Shift+1',
511
- 'Alt+Command+1', 'Alt+Ctrl+1', 'Alt+MacCtrl+1',
512
- 'Command+Alt+1', 'Command+MacCtrl+1',
513
- 'Ctrl+Alt+1', 'Ctrl+MacCtrl+1',
514
- 'MacCtrl+Alt+1', 'MacCtrl+Command+1', 'MacCtrl+Ctrl+1',
515
- 'Alt+a', 'Command+a', 'Ctrl+a', 'MacCtrl+a',
516
- 'Alt+Shift+a', 'Command+Shift+a', 'Ctrl+Shift+a', 'MacCtrl+Shift+a',
517
- 'Alt+Command+a', 'Alt+Ctrl+a', 'Alt+MacCtrl+a',
518
- 'Command+Alt+a', 'Command+MacCtrl+a',
519
- 'Ctrl+Alt+a', 'Ctrl+MacCtrl+a',
520
- 'MacCtrl+Alt+a', 'MacCtrl+Command+a', 'MacCtrl+Ctrl+a',
521
- 'Alt+F1', 'Command+F1', 'Ctrl+F1', 'MacCtrl+F1',
522
- 'Alt+Shift+F1', 'Command+Shift+F1', 'Ctrl+Shift+F1', 'MacCtrl+Shift+F1',
523
- 'Alt+Command+F1', 'Alt+Ctrl+F1', 'Alt+MacCtrl+F1',
524
- 'Command+Alt+F1', 'Command+MacCtrl+F1',
525
- 'Ctrl+Alt+F1', 'Ctrl+MacCtrl+F1',
526
- 'MacCtrl+Alt+F1', 'MacCtrl+Command+F1', 'MacCtrl+Ctrl+F1',
527
- 'Alt+PageDown', 'Command+PageDown', 'Ctrl+PageDown', 'MacCtrl+PageDown',
528
- 'Alt+Shift+PageDown', 'Command+Shift+PageDown', 'Ctrl+Shift+PageDown',
559
+ 'Alt+1',
560
+ 'Command+1',
561
+ 'Ctrl+1',
562
+ 'MacCtrl+1',
563
+ 'Alt+Shift+1',
564
+ 'Command+Shift+1',
565
+ 'Ctrl+Shift+1',
566
+ 'MacCtrl+Shift+1',
567
+ 'Alt+Command+1',
568
+ 'Alt+Ctrl+1',
569
+ 'Alt+MacCtrl+1',
570
+ 'Command+Alt+1',
571
+ 'Command+MacCtrl+1',
572
+ 'Ctrl+Alt+1',
573
+ 'Ctrl+MacCtrl+1',
574
+ 'MacCtrl+Alt+1',
575
+ 'MacCtrl+Command+1',
576
+ 'MacCtrl+Ctrl+1',
577
+ 'Alt+a',
578
+ 'Command+a',
579
+ 'Ctrl+a',
580
+ 'MacCtrl+a',
581
+ 'Alt+Shift+a',
582
+ 'Command+Shift+a',
583
+ 'Ctrl+Shift+a',
584
+ 'MacCtrl+Shift+a',
585
+ 'Alt+Command+a',
586
+ 'Alt+Ctrl+a',
587
+ 'Alt+MacCtrl+a',
588
+ 'Command+Alt+a',
589
+ 'Command+MacCtrl+a',
590
+ 'Ctrl+Alt+a',
591
+ 'Ctrl+MacCtrl+a',
592
+ 'MacCtrl+Alt+a',
593
+ 'MacCtrl+Command+a',
594
+ 'MacCtrl+Ctrl+a',
595
+ 'Alt+F1',
596
+ 'Command+F1',
597
+ 'Ctrl+F1',
598
+ 'MacCtrl+F1',
599
+ 'Alt+Shift+F1',
600
+ 'Command+Shift+F1',
601
+ 'Ctrl+Shift+F1',
602
+ 'MacCtrl+Shift+F1',
603
+ 'Alt+Command+F1',
604
+ 'Alt+Ctrl+F1',
605
+ 'Alt+MacCtrl+F1',
606
+ 'Command+Alt+F1',
607
+ 'Command+MacCtrl+F1',
608
+ 'Ctrl+Alt+F1',
609
+ 'Ctrl+MacCtrl+F1',
610
+ 'MacCtrl+Alt+F1',
611
+ 'MacCtrl+Command+F1',
612
+ 'MacCtrl+Ctrl+F1',
613
+ 'Alt+PageDown',
614
+ 'Command+PageDown',
615
+ 'Ctrl+PageDown',
616
+ 'MacCtrl+PageDown',
617
+ 'Alt+Shift+PageDown',
618
+ 'Command+Shift+PageDown',
619
+ 'Ctrl+Shift+PageDown',
529
620
  'MacCtrl+Shift+PageDown',
530
- 'Alt+Command+PageDown', 'Alt+Ctrl+PageDown', 'Alt+MacCtrl+PageDown',
531
- 'Command+Alt+PageDown', 'Command+MacCtrl+PageDown',
532
- 'Ctrl+Alt+PageDown', 'Ctrl+MacCtrl+PageDown',
533
- 'MacCtrl+Alt+PageDown', 'MacCtrl+Command+PageDown',
621
+ 'Alt+Command+PageDown',
622
+ 'Alt+Ctrl+PageDown',
623
+ 'Alt+MacCtrl+PageDown',
624
+ 'Command+Alt+PageDown',
625
+ 'Command+MacCtrl+PageDown',
626
+ 'Ctrl+Alt+PageDown',
627
+ 'Ctrl+MacCtrl+PageDown',
628
+ 'MacCtrl+Alt+PageDown',
629
+ 'MacCtrl+Command+PageDown',
534
630
  'MacCtrl+Ctrl+PageDown',
535
- 'Alt+Up', 'Command+Up', 'Ctrl+Up', 'MacCtrl+Up',
536
- 'Alt+Shift+Up', 'Command+Shift+Up', 'Ctrl+Shift+Up', 'MacCtrl+Shift+Up',
537
- 'Alt+Command+Up', 'Alt+Ctrl+Up', 'Alt+MacCtrl+Up',
538
- 'Command+Alt+Up', 'Command+MacCtrl+Up',
539
- 'Ctrl+Alt+Up', 'Ctrl+MacCtrl+Up',
540
- 'MacCtrl+Alt+Up', 'MacCtrl+Command+Up', 'MacCtrl+Ctrl+Up',
541
- 'Alt+Left', 'Command+Left', 'Ctrl+Left', 'MacCtrl+Left',
542
- 'Alt+Shift+Left', 'Command+Shift+Left', 'Ctrl+Shift+Left',
631
+ 'Alt+Up',
632
+ 'Command+Up',
633
+ 'Ctrl+Up',
634
+ 'MacCtrl+Up',
635
+ 'Alt+Shift+Up',
636
+ 'Command+Shift+Up',
637
+ 'Ctrl+Shift+Up',
638
+ 'MacCtrl+Shift+Up',
639
+ 'Alt+Command+Up',
640
+ 'Alt+Ctrl+Up',
641
+ 'Alt+MacCtrl+Up',
642
+ 'Command+Alt+Up',
643
+ 'Command+MacCtrl+Up',
644
+ 'Ctrl+Alt+Up',
645
+ 'Ctrl+MacCtrl+Up',
646
+ 'MacCtrl+Alt+Up',
647
+ 'MacCtrl+Command+Up',
648
+ 'MacCtrl+Ctrl+Up',
649
+ 'Alt+Left',
650
+ 'Command+Left',
651
+ 'Ctrl+Left',
652
+ 'MacCtrl+Left',
653
+ 'Alt+Shift+Left',
654
+ 'Command+Shift+Left',
655
+ 'Ctrl+Shift+Left',
543
656
  'MacCtrl+Shift+Left',
544
- 'Alt+Command+Left', 'Alt+Ctrl+Left', 'Alt+MacCtrl+Left',
545
- 'Command+Alt+Left', 'Command+MacCtrl+Left',
546
- 'Ctrl+Alt+Left', 'Ctrl+MacCtrl+Left',
547
- 'MacCtrl+Alt+Left', 'MacCtrl+Command+Left', 'MacCtrl+Ctrl+Left',
548
- 'F1', 'F12',
549
- 'MediaNextTrack', 'MediaPrevTrack', 'MediaPlayPause', 'MediaStop'
657
+ 'Alt+Command+Left',
658
+ 'Alt+Ctrl+Left',
659
+ 'Alt+MacCtrl+Left',
660
+ 'Command+Alt+Left',
661
+ 'Command+MacCtrl+Left',
662
+ 'Ctrl+Alt+Left',
663
+ 'Ctrl+MacCtrl+Left',
664
+ 'MacCtrl+Alt+Left',
665
+ 'MacCtrl+Command+Left',
666
+ 'MacCtrl+Ctrl+Left',
667
+ 'F1',
668
+ 'F12',
669
+ 'MediaNextTrack',
670
+ 'MediaPrevTrack',
671
+ 'MediaPlayPause',
672
+ 'MediaStop'
550
673
  ];
551
674
  for (const item of items) {
552
675
  const i = browser.commands.update.callCount;
553
676
  // eslint-disable-next-line no-await-in-loop
554
677
  const res = await func('foo', item);
555
- assert.strictEqual(browser.commands.update.callCount, i + 1,
556
- `called ${item}`);
557
- assert.strictEqual(browser.commands.reset.calledOnce, false,
558
- 'not called');
678
+ assert.strictEqual(
679
+ browser.commands.update.callCount,
680
+ i + 1,
681
+ `called ${item}`
682
+ );
683
+ assert.strictEqual(
684
+ browser.commands.reset.calledOnce,
685
+ false,
686
+ 'not called'
687
+ );
559
688
  assert.strictEqual(res, undefined, 'result');
560
689
  }
561
690
  });
@@ -565,8 +694,11 @@ describe('browser', () => {
565
694
  browser.commands.update.resolves(undefined);
566
695
  const res = await func('foo', ' Ctrl+a ');
567
696
  assert.strictEqual(browser.commands.update.calledOnce, true, 'called');
568
- assert.strictEqual(browser.commands.reset.calledOnce, false,
569
- 'not called');
697
+ assert.strictEqual(
698
+ browser.commands.reset.calledOnce,
699
+ false,
700
+ 'not called'
701
+ );
570
702
  assert.strictEqual(res, undefined, 'result');
571
703
  });
572
704
  });
@@ -578,8 +710,11 @@ describe('browser', () => {
578
710
  browser.permissions.contains.resolves(false);
579
711
  const i = browser.contextualIdentities.query.callCount;
580
712
  const res = await func();
581
- assert.strictEqual(browser.contextualIdentities.query.callCount, i,
582
- 'not called');
713
+ assert.strictEqual(
714
+ browser.contextualIdentities.query.callCount,
715
+ i,
716
+ 'not called'
717
+ );
583
718
  assert.deepEqual(res, null, 'result');
584
719
  });
585
720
 
@@ -610,15 +745,19 @@ describe('browser', () => {
610
745
 
611
746
  it('should throw if no argument given', async () => {
612
747
  await func().catch(e => {
613
- assert.deepStrictEqual(e,
614
- new TypeError('Expected String but got Undefined.'));
748
+ assert.deepStrictEqual(
749
+ e,
750
+ new TypeError('Expected String but got Undefined.')
751
+ );
615
752
  });
616
753
  });
617
754
 
618
755
  it('should throw if given argument is not string', async () => {
619
756
  await func(1).catch(e => {
620
- assert.deepStrictEqual(e,
621
- new TypeError('Expected String but got Number.'));
757
+ assert.deepStrictEqual(
758
+ e,
759
+ new TypeError('Expected String but got Number.')
760
+ );
622
761
  });
623
762
  });
624
763
 
@@ -626,13 +765,17 @@ describe('browser', () => {
626
765
  browser.permissions.contains.resolves(false);
627
766
  const i = browser.contextualIdentities.get.callCount;
628
767
  const res = await func('foo');
629
- assert.strictEqual(browser.contextualIdentities.get.callCount, i,
630
- 'not called');
768
+ assert.strictEqual(
769
+ browser.contextualIdentities.get.callCount,
770
+ i,
771
+ 'not called'
772
+ );
631
773
  assert.deepEqual(res, null, 'result');
632
774
  });
633
775
 
634
776
  it('should throw', async () => {
635
- browser.contextualIdentities.get.withArgs('foo')
777
+ browser.contextualIdentities.get
778
+ .withArgs('foo')
636
779
  .rejects(new Error('error'));
637
780
  await func('foo').catch(e => {
638
781
  assert.deepStrictEqual(e, new Error('error'));
@@ -699,12 +842,16 @@ describe('browser', () => {
699
842
  const { called } = stub;
700
843
  stub.restore();
701
844
  assert.strictEqual(called, false, 'not logged');
702
- assert.deepEqual(res, [
703
- {
704
- enabled: true,
705
- type: 'theme'
706
- }
707
- ], 'result');
845
+ assert.deepEqual(
846
+ res,
847
+ [
848
+ {
849
+ enabled: true,
850
+ type: 'theme'
851
+ }
852
+ ],
853
+ 'result'
854
+ );
708
855
  });
709
856
  });
710
857
 
@@ -713,15 +860,19 @@ describe('browser', () => {
713
860
 
714
861
  it('should throw if no argument given', async () => {
715
862
  await func().catch(e => {
716
- assert.deepStrictEqual(e,
717
- new TypeError('Expected String but got Undefined.'));
863
+ assert.deepStrictEqual(
864
+ e,
865
+ new TypeError('Expected String but got Undefined.')
866
+ );
718
867
  });
719
868
  });
720
869
 
721
870
  it('should throw if given argument is not string', async () => {
722
871
  await func(1).catch(e => {
723
- assert.deepStrictEqual(e,
724
- new TypeError('Expected String but got Number.'));
872
+ assert.deepStrictEqual(
873
+ e,
874
+ new TypeError('Expected String but got Number.')
875
+ );
725
876
  });
726
877
  });
727
878
 
@@ -792,14 +943,18 @@ describe('browser', () => {
792
943
  }
793
944
  ]);
794
945
  const res = await func();
795
- assert.deepEqual(res, [
796
- {
797
- type: 'extension'
798
- },
799
- {
800
- type: 'extension'
801
- }
802
- ], 'result');
946
+ assert.deepEqual(
947
+ res,
948
+ [
949
+ {
950
+ type: 'extension'
951
+ },
952
+ {
953
+ type: 'extension'
954
+ }
955
+ ],
956
+ 'result'
957
+ );
803
958
  });
804
959
  });
805
960
 
@@ -808,15 +963,19 @@ describe('browser', () => {
808
963
 
809
964
  it('should throw if no argument given', async () => {
810
965
  await func().catch(e => {
811
- assert.deepStrictEqual(e,
812
- new TypeError('Expected String but got Undefined.'));
966
+ assert.deepStrictEqual(
967
+ e,
968
+ new TypeError('Expected String but got Undefined.')
969
+ );
813
970
  });
814
971
  });
815
972
 
816
973
  it('should throw if given argument is not string', async () => {
817
974
  await func(1).catch(e => {
818
- assert.deepStrictEqual(e,
819
- new TypeError('Expected String but got Number.'));
975
+ assert.deepStrictEqual(
976
+ e,
977
+ new TypeError('Expected String but got Number.')
978
+ );
820
979
  });
821
980
  });
822
981
 
@@ -824,8 +983,11 @@ describe('browser', () => {
824
983
  browser.permissions.contains.resolves(false);
825
984
  const i = browser.notifications.clear.callCount;
826
985
  const res = await func('foo');
827
- assert.strictEqual(browser.notifications.clear.callCount, i,
828
- 'not called');
986
+ assert.strictEqual(
987
+ browser.notifications.clear.callCount,
988
+ i,
989
+ 'not called'
990
+ );
829
991
  assert.deepEqual(res, null, 'result');
830
992
  });
831
993
 
@@ -841,15 +1003,19 @@ describe('browser', () => {
841
1003
 
842
1004
  it('should throw if no argument given', async () => {
843
1005
  await func().catch(e => {
844
- assert.deepStrictEqual(e,
845
- new TypeError('Expected String but got Undefined.'));
1006
+ assert.deepStrictEqual(
1007
+ e,
1008
+ new TypeError('Expected String but got Undefined.')
1009
+ );
846
1010
  });
847
1011
  });
848
1012
 
849
1013
  it('should throw if first argument is not string', async () => {
850
1014
  await func(1).catch(e => {
851
- assert.deepStrictEqual(e,
852
- new TypeError('Expected String but got Number.'));
1015
+ assert.deepStrictEqual(
1016
+ e,
1017
+ new TypeError('Expected String but got Number.')
1018
+ );
853
1019
  });
854
1020
  });
855
1021
 
@@ -857,8 +1023,11 @@ describe('browser', () => {
857
1023
  browser.permissions.contains.resolves(false);
858
1024
  const i = browser.notifications.create.callCount;
859
1025
  const res = await func('foo');
860
- assert.strictEqual(browser.notifications.create.callCount, i,
861
- 'not called');
1026
+ assert.strictEqual(
1027
+ browser.notifications.create.callCount,
1028
+ i,
1029
+ 'not called'
1030
+ );
862
1031
  assert.deepEqual(res, null, 'result');
863
1032
  });
864
1033
 
@@ -873,8 +1042,11 @@ describe('browser', () => {
873
1042
  browser.notifications.create.withArgs('foo', {}).resolves('bar');
874
1043
  const i = browser.notifications.onClosed.addListener.callCount;
875
1044
  const res = await func('foo', {});
876
- assert.strictEqual(browser.notifications.onClosed.addListener.callCount,
877
- i + 1, 'called');
1045
+ assert.strictEqual(
1046
+ browser.notifications.onClosed.addListener.callCount,
1047
+ i + 1,
1048
+ 'called'
1049
+ );
878
1050
  assert.strictEqual(res, 'bar', 'result');
879
1051
  });
880
1052
 
@@ -883,8 +1055,11 @@ describe('browser', () => {
883
1055
  browser.notifications.create.withArgs('foo', {}).resolves('bar');
884
1056
  const i = browser.notifications.onClosed.addListener.callCount;
885
1057
  const res = await func('foo', {});
886
- assert.strictEqual(browser.notifications.onClosed.addListener.callCount,
887
- i, 'not called');
1058
+ assert.strictEqual(
1059
+ browser.notifications.onClosed.addListener.callCount,
1060
+ i,
1061
+ 'not called'
1062
+ );
888
1063
  assert.strictEqual(res, 'bar', 'result');
889
1064
  });
890
1065
  });
@@ -894,34 +1069,41 @@ describe('browser', () => {
894
1069
 
895
1070
  it('should throw if no argument given', async () => {
896
1071
  await func().catch(e => {
897
- assert.deepStrictEqual(e,
898
- new TypeError('Expected String or Array but got Undefined.'));
1072
+ assert.deepStrictEqual(
1073
+ e,
1074
+ new TypeError('Expected String or Array but got Undefined.')
1075
+ );
899
1076
  });
900
1077
  });
901
1078
 
902
1079
  it('should throw if given argument is not string or array', async () => {
903
1080
  await func(1).catch(e => {
904
- assert.deepStrictEqual(e,
905
- new TypeError('Expected String or Array but got Number.'));
1081
+ assert.deepStrictEqual(
1082
+ e,
1083
+ new TypeError('Expected String or Array but got Number.')
1084
+ );
906
1085
  });
907
1086
  });
908
1087
 
909
1088
  it('should get result', async () => {
910
- browser.permissions.remove.withArgs({ permissions: ['foo'] })
1089
+ browser.permissions.remove
1090
+ .withArgs({ permissions: ['foo'] })
911
1091
  .resolves(true);
912
1092
  const res = await func('foo');
913
1093
  assert.strictEqual(res, true, 'result');
914
1094
  });
915
1095
 
916
1096
  it('should get result', async () => {
917
- browser.permissions.remove.withArgs({ permissions: ['foo'] })
1097
+ browser.permissions.remove
1098
+ .withArgs({ permissions: ['foo'] })
918
1099
  .resolves(false);
919
1100
  const res = await func('foo');
920
1101
  assert.strictEqual(res, false, 'result');
921
1102
  });
922
1103
 
923
1104
  it('should get result', async () => {
924
- browser.permissions.remove.withArgs({ permissions: ['foo'] })
1105
+ browser.permissions.remove
1106
+ .withArgs({ permissions: ['foo'] })
925
1107
  .resolves(true);
926
1108
  const res = await func(['foo']);
927
1109
  assert.strictEqual(res, true, 'result');
@@ -933,34 +1115,41 @@ describe('browser', () => {
933
1115
 
934
1116
  it('should throw if no argument given', async () => {
935
1117
  await func().catch(e => {
936
- assert.deepStrictEqual(e,
937
- new TypeError('Expected String or Array but got Undefined.'));
1118
+ assert.deepStrictEqual(
1119
+ e,
1120
+ new TypeError('Expected String or Array but got Undefined.')
1121
+ );
938
1122
  });
939
1123
  });
940
1124
 
941
1125
  it('should throw if given argument is not string or array', async () => {
942
1126
  await func(1).catch(e => {
943
- assert.deepStrictEqual(e,
944
- new TypeError('Expected String or Array but got Number.'));
1127
+ assert.deepStrictEqual(
1128
+ e,
1129
+ new TypeError('Expected String or Array but got Number.')
1130
+ );
945
1131
  });
946
1132
  });
947
1133
 
948
1134
  it('should get result', async () => {
949
- browser.permissions.request.withArgs({ permissions: ['foo'] })
1135
+ browser.permissions.request
1136
+ .withArgs({ permissions: ['foo'] })
950
1137
  .resolves(true);
951
1138
  const res = await func('foo');
952
1139
  assert.strictEqual(res, true, 'result');
953
1140
  });
954
1141
 
955
1142
  it('should get result', async () => {
956
- browser.permissions.request.withArgs({ permissions: ['foo'] })
1143
+ browser.permissions.request
1144
+ .withArgs({ permissions: ['foo'] })
957
1145
  .resolves(false);
958
1146
  const res = await func('foo');
959
1147
  assert.strictEqual(res, false, 'result');
960
1148
  });
961
1149
 
962
1150
  it('should get result', async () => {
963
- browser.permissions.request.withArgs({ permissions: ['foo'] })
1151
+ browser.permissions.request
1152
+ .withArgs({ permissions: ['foo'] })
964
1153
  .resolves(true);
965
1154
  const res = await func(['foo']);
966
1155
  assert.strictEqual(res, true, 'result');
@@ -1031,7 +1220,8 @@ describe('browser', () => {
1031
1220
  });
1032
1221
 
1033
1222
  it('should get object', async () => {
1034
- browser.runtime.connect.withArgs('foo', { foo: 'bar' })
1223
+ browser.runtime.connect
1224
+ .withArgs('foo', { foo: 'bar' })
1035
1225
  .resolves({ bar: 'baz' });
1036
1226
  const res = await func('foo', { foo: 'bar' });
1037
1227
  assert.deepEqual(res, { bar: 'baz' }, 'result');
@@ -1070,8 +1260,11 @@ describe('browser', () => {
1070
1260
  const j = browser.runtime.sendMessage.callCount;
1071
1261
  const res = await func();
1072
1262
  assert.strictEqual(browser.tabs.sendMessage.callCount, i, 'not called');
1073
- assert.strictEqual(browser.runtime.sendMessage.callCount, j,
1074
- 'not called');
1263
+ assert.strictEqual(
1264
+ browser.runtime.sendMessage.callCount,
1265
+ j,
1266
+ 'not called'
1267
+ );
1075
1268
  assert.deepEqual(res, null, 'result');
1076
1269
  });
1077
1270
 
@@ -1079,18 +1272,23 @@ describe('browser', () => {
1079
1272
  browser.runtime.sendMessage.withArgs('foo', null).resolves({});
1080
1273
  const i = browser.runtime.sendMessage.callCount;
1081
1274
  const res = await func(null, 'foo');
1082
- assert.strictEqual(browser.runtime.sendMessage.callCount, i + 1,
1083
- 'called');
1275
+ assert.strictEqual(
1276
+ browser.runtime.sendMessage.callCount,
1277
+ i + 1,
1278
+ 'called'
1279
+ );
1084
1280
  assert.deepEqual(res, {}, 'result');
1085
1281
  });
1086
1282
 
1087
1283
  it('should call function', async () => {
1088
- browser.runtime.sendMessage.withArgs('foo', { bar: 'baz' })
1089
- .resolves({});
1284
+ browser.runtime.sendMessage.withArgs('foo', { bar: 'baz' }).resolves({});
1090
1285
  const i = browser.runtime.sendMessage.callCount;
1091
1286
  const res = await func(null, 'foo', { bar: 'baz' });
1092
- assert.strictEqual(browser.runtime.sendMessage.callCount, i + 1,
1093
- 'called');
1287
+ assert.strictEqual(
1288
+ browser.runtime.sendMessage.callCount,
1289
+ i + 1,
1290
+ 'called'
1291
+ );
1094
1292
  assert.deepEqual(res, {}, 'result');
1095
1293
  });
1096
1294
 
@@ -1098,8 +1296,11 @@ describe('browser', () => {
1098
1296
  browser.runtime.sendMessage.withArgs('foo', 'bar', null).resolves({});
1099
1297
  const i = browser.runtime.sendMessage.callCount;
1100
1298
  const res = await func('foo', 'bar');
1101
- assert.strictEqual(browser.runtime.sendMessage.callCount, i + 1,
1102
- 'called');
1299
+ assert.strictEqual(
1300
+ browser.runtime.sendMessage.callCount,
1301
+ i + 1,
1302
+ 'called'
1303
+ );
1103
1304
  assert.deepEqual(res, {}, 'result');
1104
1305
  });
1105
1306
 
@@ -1116,8 +1317,11 @@ describe('browser', () => {
1116
1317
  const j = browser.runtime.sendMessage.callCount;
1117
1318
  const res = await func(browser.tabs.TAB_ID_NONE, 'foo');
1118
1319
  assert.strictEqual(browser.tabs.sendMessage.callCount, i, 'not called');
1119
- assert.strictEqual(browser.runtime.sendMessage.callCount, j,
1120
- 'not called');
1320
+ assert.strictEqual(
1321
+ browser.runtime.sendMessage.callCount,
1322
+ j,
1323
+ 'not called'
1324
+ );
1121
1325
  assert.deepEqual(res, null, 'result');
1122
1326
  });
1123
1327
  });
@@ -1145,8 +1349,11 @@ describe('browser', () => {
1145
1349
  browser.scripting.executeScript.resolves([{}]);
1146
1350
  const i = browser.scripting.executeScript.callCount;
1147
1351
  const res = await func();
1148
- assert.strictEqual(browser.scripting.executeScript.callCount, i,
1149
- 'not called');
1352
+ assert.strictEqual(
1353
+ browser.scripting.executeScript.callCount,
1354
+ i,
1355
+ 'not called'
1356
+ );
1150
1357
  assert.deepEqual(res, null, 'result');
1151
1358
  });
1152
1359
 
@@ -1156,8 +1363,11 @@ describe('browser', () => {
1156
1363
  const res = await func({
1157
1364
  target: {}
1158
1365
  });
1159
- assert.strictEqual(browser.scripting.executeScript.callCount, i,
1160
- 'not called');
1366
+ assert.strictEqual(
1367
+ browser.scripting.executeScript.callCount,
1368
+ i,
1369
+ 'not called'
1370
+ );
1161
1371
  assert.deepEqual(res, null, 'result');
1162
1372
  });
1163
1373
 
@@ -1169,8 +1379,11 @@ describe('browser', () => {
1169
1379
  tabId: 1
1170
1380
  }
1171
1381
  });
1172
- assert.strictEqual(browser.scripting.executeScript.callCount, i,
1173
- 'not called');
1382
+ assert.strictEqual(
1383
+ browser.scripting.executeScript.callCount,
1384
+ i,
1385
+ 'not called'
1386
+ );
1174
1387
  assert.deepEqual(res, null, 'result');
1175
1388
  });
1176
1389
 
@@ -1183,8 +1396,11 @@ describe('browser', () => {
1183
1396
  tabId: 1
1184
1397
  }
1185
1398
  });
1186
- assert.strictEqual(browser.scripting.executeScript.callCount, i,
1187
- 'not called');
1399
+ assert.strictEqual(
1400
+ browser.scripting.executeScript.callCount,
1401
+ i,
1402
+ 'not called'
1403
+ );
1188
1404
  assert.deepEqual(res, null, 'result');
1189
1405
  });
1190
1406
 
@@ -1211,8 +1427,11 @@ describe('browser', () => {
1211
1427
  tabId: 1
1212
1428
  }
1213
1429
  });
1214
- assert.strictEqual(browser.scripting.executeScript.callCount, i + 1,
1215
- 'called');
1430
+ assert.strictEqual(
1431
+ browser.scripting.executeScript.callCount,
1432
+ i + 1,
1433
+ 'called'
1434
+ );
1216
1435
  assert.deepEqual(res, [{}], 'result');
1217
1436
  });
1218
1437
 
@@ -1225,8 +1444,11 @@ describe('browser', () => {
1225
1444
  tabId: 1
1226
1445
  }
1227
1446
  });
1228
- assert.strictEqual(browser.scripting.executeScript.callCount, i,
1229
- 'not called');
1447
+ assert.strictEqual(
1448
+ browser.scripting.executeScript.callCount,
1449
+ i,
1450
+ 'not called'
1451
+ );
1230
1452
  assert.deepEqual(res, null, 'result');
1231
1453
  });
1232
1454
 
@@ -1239,8 +1461,11 @@ describe('browser', () => {
1239
1461
  tabId: 1
1240
1462
  }
1241
1463
  });
1242
- assert.strictEqual(browser.scripting.executeScript.callCount, i + 1,
1243
- 'called');
1464
+ assert.strictEqual(
1465
+ browser.scripting.executeScript.callCount,
1466
+ i + 1,
1467
+ 'called'
1468
+ );
1244
1469
  assert.deepEqual(res, [{}], 'result');
1245
1470
  });
1246
1471
 
@@ -1254,8 +1479,11 @@ describe('browser', () => {
1254
1479
  tabId: 1
1255
1480
  }
1256
1481
  });
1257
- assert.strictEqual(browser.scripting.executeScript.callCount, i + 1,
1258
- 'called');
1482
+ assert.strictEqual(
1483
+ browser.scripting.executeScript.callCount,
1484
+ i + 1,
1485
+ 'called'
1486
+ );
1259
1487
  assert.deepEqual(res, [{}], 'result');
1260
1488
  });
1261
1489
  });
@@ -1265,15 +1493,13 @@ describe('browser', () => {
1265
1493
 
1266
1494
  it('should throw if no argument given', async () => {
1267
1495
  await func().catch(e => {
1268
- assert.strictEqual(e.message,
1269
- 'Expected String but got Undefined.');
1496
+ assert.strictEqual(e.message, 'Expected String but got Undefined.');
1270
1497
  });
1271
1498
  });
1272
1499
 
1273
1500
  it('should throw if 1st argument is not string', async () => {
1274
1501
  await func(1).catch(e => {
1275
- assert.strictEqual(e.message,
1276
- 'Expected String but got Number.');
1502
+ assert.strictEqual(e.message, 'Expected String but got Number.');
1277
1503
  });
1278
1504
  });
1279
1505
 
@@ -1297,22 +1523,32 @@ describe('browser', () => {
1297
1523
  tabId: 1
1298
1524
  }).callCount;
1299
1525
  const res = await func('foo');
1300
- assert.strictEqual(browser.search.query.withArgs({
1301
- text: 'foo',
1302
- tabId: 1
1303
- }).callCount, i + 1, 'called');
1304
- assert.deepEqual(res, {
1305
- id: 1
1306
- }, 'result');
1526
+ assert.strictEqual(
1527
+ browser.search.query.withArgs({
1528
+ text: 'foo',
1529
+ tabId: 1
1530
+ }).callCount,
1531
+ i + 1,
1532
+ 'called'
1533
+ );
1534
+ assert.deepEqual(
1535
+ res,
1536
+ {
1537
+ id: 1
1538
+ },
1539
+ 'result'
1540
+ );
1307
1541
  });
1308
1542
 
1309
1543
  it('should call function', async () => {
1310
- browser.tabs.create.withArgs({
1311
- index: 2
1312
- }).resolves({
1313
- id: 1,
1314
- index: 2
1315
- });
1544
+ browser.tabs.create
1545
+ .withArgs({
1546
+ index: 2
1547
+ })
1548
+ .resolves({
1549
+ id: 1,
1550
+ index: 2
1551
+ });
1316
1552
  browser.tabs.get.withArgs(1).resolves({
1317
1553
  id: 1,
1318
1554
  index: 2
@@ -1324,14 +1560,22 @@ describe('browser', () => {
1324
1560
  const res = await func('foo', {
1325
1561
  index: 2
1326
1562
  });
1327
- assert.strictEqual(browser.search.query.withArgs({
1328
- text: 'foo',
1329
- tabId: 1
1330
- }).callCount, i + 1, 'called');
1331
- assert.deepEqual(res, {
1332
- id: 1,
1333
- index: 2
1334
- }, 'result');
1563
+ assert.strictEqual(
1564
+ browser.search.query.withArgs({
1565
+ text: 'foo',
1566
+ tabId: 1
1567
+ }).callCount,
1568
+ i + 1,
1569
+ 'called'
1570
+ );
1571
+ assert.deepEqual(
1572
+ res,
1573
+ {
1574
+ id: 1,
1575
+ index: 2
1576
+ },
1577
+ 'result'
1578
+ );
1335
1579
  });
1336
1580
  });
1337
1581
 
@@ -1340,15 +1584,19 @@ describe('browser', () => {
1340
1584
 
1341
1585
  it('should throw if no argument given', async () => {
1342
1586
  await func().catch(e => {
1343
- assert.deepStrictEqual(e,
1344
- new TypeError('Expected String but got Undefined.'));
1587
+ assert.deepStrictEqual(
1588
+ e,
1589
+ new TypeError('Expected String but got Undefined.')
1590
+ );
1345
1591
  });
1346
1592
  });
1347
1593
 
1348
1594
  it('should throw if 1st argument is not string', async () => {
1349
1595
  await func(1).catch(e => {
1350
- assert.deepStrictEqual(e,
1351
- new TypeError('Expected String but got Number.'));
1596
+ assert.deepStrictEqual(
1597
+ e,
1598
+ new TypeError('Expected String but got Number.')
1599
+ );
1352
1600
  });
1353
1601
  });
1354
1602
 
@@ -1364,9 +1612,13 @@ describe('browser', () => {
1364
1612
  query: 'foo'
1365
1613
  }).callCount;
1366
1614
  await func('foo');
1367
- assert.strictEqual(browser.search.search.withArgs({
1368
- query: 'foo'
1369
- }).callCount, i + 1, 'called');
1615
+ assert.strictEqual(
1616
+ browser.search.search.withArgs({
1617
+ query: 'foo'
1618
+ }).callCount,
1619
+ i + 1,
1620
+ 'called'
1621
+ );
1370
1622
  });
1371
1623
 
1372
1624
  it('should call function', async () => {
@@ -1379,11 +1631,15 @@ describe('browser', () => {
1379
1631
  engine: 'bar',
1380
1632
  tabId: 1
1381
1633
  });
1382
- assert.strictEqual(browser.search.search.withArgs({
1383
- engine: 'bar',
1384
- query: 'foo',
1385
- tabId: 1
1386
- }).callCount, i + 1, 'called');
1634
+ assert.strictEqual(
1635
+ browser.search.search.withArgs({
1636
+ engine: 'bar',
1637
+ query: 'foo',
1638
+ tabId: 1
1639
+ }).callCount,
1640
+ i + 1,
1641
+ 'called'
1642
+ );
1387
1643
  });
1388
1644
  });
1389
1645
 
@@ -1394,8 +1650,11 @@ describe('browser', () => {
1394
1650
  browser.permissions.contains.resolves(false);
1395
1651
  const i = browser.sessions.getRecentlyClosed.callCount;
1396
1652
  const res = await func();
1397
- assert.strictEqual(browser.sessions.getRecentlyClosed.callCount, i,
1398
- 'not called');
1653
+ assert.strictEqual(
1654
+ browser.sessions.getRecentlyClosed.callCount,
1655
+ i,
1656
+ 'not called'
1657
+ );
1399
1658
  assert.deepEqual(res, null, 'result');
1400
1659
  });
1401
1660
 
@@ -1446,15 +1705,19 @@ describe('browser', () => {
1446
1705
 
1447
1706
  it('should throw if no argument given', async () => {
1448
1707
  await func().catch(e => {
1449
- assert.deepStrictEqual(e,
1450
- new TypeError('Expected String but got Undefined.'));
1708
+ assert.deepStrictEqual(
1709
+ e,
1710
+ new TypeError('Expected String but got Undefined.')
1711
+ );
1451
1712
  });
1452
1713
  });
1453
1714
 
1454
1715
  it('should throw if given argument is not string', async () => {
1455
1716
  await func(1).catch(e => {
1456
- assert.deepStrictEqual(e,
1457
- new TypeError('Expected String but got Number.'));
1717
+ assert.deepStrictEqual(
1718
+ e,
1719
+ new TypeError('Expected String but got Number.')
1720
+ );
1458
1721
  });
1459
1722
  });
1460
1723
 
@@ -1462,8 +1725,11 @@ describe('browser', () => {
1462
1725
  browser.permissions.contains.resolves(false);
1463
1726
  const i = browser.sessions.getWindowValue.callCount;
1464
1727
  const res = await func('foo', 1);
1465
- assert.strictEqual(browser.sessions.getWindowValue.callCount, i,
1466
- 'not called');
1728
+ assert.strictEqual(
1729
+ browser.sessions.getWindowValue.callCount,
1730
+ i,
1731
+ 'not called'
1732
+ );
1467
1733
  assert.deepEqual(res, null, 'result');
1468
1734
  });
1469
1735
 
@@ -1475,7 +1741,8 @@ describe('browser', () => {
1475
1741
 
1476
1742
  it('should get object', async () => {
1477
1743
  browser.sessions.getWindowValue
1478
- .withArgs(browser.windows.WINDOW_ID_CURRENT, 'foo').resolves('bar');
1744
+ .withArgs(browser.windows.WINDOW_ID_CURRENT, 'foo')
1745
+ .resolves('bar');
1479
1746
  const res = await func('foo');
1480
1747
  assert.strictEqual(res, 'bar', 'result');
1481
1748
  });
@@ -1486,15 +1753,19 @@ describe('browser', () => {
1486
1753
 
1487
1754
  it('should throw if no argument given', async () => {
1488
1755
  await func().catch(e => {
1489
- assert.deepStrictEqual(e,
1490
- new TypeError('Expected String but got Undefined.'));
1756
+ assert.deepStrictEqual(
1757
+ e,
1758
+ new TypeError('Expected String but got Undefined.')
1759
+ );
1491
1760
  });
1492
1761
  });
1493
1762
 
1494
1763
  it('should throw if given argument is not string', async () => {
1495
1764
  await func(1).catch(e => {
1496
- assert.deepStrictEqual(e,
1497
- new TypeError('Expected String but got Number.'));
1765
+ assert.deepStrictEqual(
1766
+ e,
1767
+ new TypeError('Expected String but got Number.')
1768
+ );
1498
1769
  });
1499
1770
  });
1500
1771
 
@@ -1502,8 +1773,11 @@ describe('browser', () => {
1502
1773
  browser.permissions.contains.resolves(false);
1503
1774
  const i = browser.sessions.getWindowValue.callCount;
1504
1775
  const res = await func('foo');
1505
- assert.strictEqual(browser.sessions.getWindowValue.callCount, i,
1506
- 'not called');
1776
+ assert.strictEqual(
1777
+ browser.sessions.getWindowValue.callCount,
1778
+ i,
1779
+ 'not called'
1780
+ );
1507
1781
  assert.deepEqual(res, null, 'result');
1508
1782
  });
1509
1783
 
@@ -1519,15 +1793,19 @@ describe('browser', () => {
1519
1793
 
1520
1794
  it('should throw if no argument given', async () => {
1521
1795
  await func().catch(e => {
1522
- assert.deepStrictEqual(e,
1523
- new TypeError('Expected String but got Undefined.'));
1796
+ assert.deepStrictEqual(
1797
+ e,
1798
+ new TypeError('Expected String but got Undefined.')
1799
+ );
1524
1800
  });
1525
1801
  });
1526
1802
 
1527
1803
  it('should throw if given argument is not string', async () => {
1528
1804
  await func(1).catch(e => {
1529
- assert.deepStrictEqual(e,
1530
- new TypeError('Expected String but got Number.'));
1805
+ assert.deepStrictEqual(
1806
+ e,
1807
+ new TypeError('Expected String but got Number.')
1808
+ );
1531
1809
  });
1532
1810
  });
1533
1811
 
@@ -1535,22 +1813,31 @@ describe('browser', () => {
1535
1813
  browser.permissions.contains.resolves(false);
1536
1814
  const i = browser.sessions.setWindowValue.callCount;
1537
1815
  await func('foo');
1538
- assert.strictEqual(browser.sessions.setWindowValue.callCount, i,
1539
- 'not called');
1816
+ assert.strictEqual(
1817
+ browser.sessions.setWindowValue.callCount,
1818
+ i,
1819
+ 'not called'
1820
+ );
1540
1821
  });
1541
1822
 
1542
1823
  it('should call function', async () => {
1543
1824
  const i = browser.sessions.setWindowValue.callCount;
1544
1825
  await func('foo', 'bar', 1);
1545
- assert.strictEqual(browser.sessions.setWindowValue.callCount, i + 1,
1546
- 'called');
1826
+ assert.strictEqual(
1827
+ browser.sessions.setWindowValue.callCount,
1828
+ i + 1,
1829
+ 'called'
1830
+ );
1547
1831
  });
1548
1832
 
1549
1833
  it('should call function', async () => {
1550
1834
  const i = browser.sessions.setWindowValue.callCount;
1551
1835
  await func('foo', 'bar');
1552
- assert.strictEqual(browser.sessions.setWindowValue.callCount, i + 1,
1553
- 'called');
1836
+ assert.strictEqual(
1837
+ browser.sessions.setWindowValue.callCount,
1838
+ i + 1,
1839
+ 'called'
1840
+ );
1554
1841
  });
1555
1842
  });
1556
1843
 
@@ -1564,10 +1851,16 @@ describe('browser', () => {
1564
1851
  // const k = browser.storage.session.clear.callCount;
1565
1852
  const l = browser.storage.sync.clear.callCount;
1566
1853
  await func();
1567
- assert.strictEqual(browser.storage.local.clear.callCount, i,
1568
- 'not called');
1569
- assert.strictEqual(browser.storage.managed.clear.callCount, j,
1570
- 'not called');
1854
+ assert.strictEqual(
1855
+ browser.storage.local.clear.callCount,
1856
+ i,
1857
+ 'not called'
1858
+ );
1859
+ assert.strictEqual(
1860
+ browser.storage.managed.clear.callCount,
1861
+ j,
1862
+ 'not called'
1863
+ );
1571
1864
  /*
1572
1865
  assert.strictEqual(browser.storage.session.clear.callCount, k,
1573
1866
  'not called');
@@ -1581,10 +1874,16 @@ describe('browser', () => {
1581
1874
  // const k = browser.storage.session.clear.callCount;
1582
1875
  const l = browser.storage.sync.clear.callCount;
1583
1876
  await func('foo');
1584
- assert.strictEqual(browser.storage.local.clear.callCount, i,
1585
- 'not called');
1586
- assert.strictEqual(browser.storage.managed.clear.callCount, j,
1587
- 'not called');
1877
+ assert.strictEqual(
1878
+ browser.storage.local.clear.callCount,
1879
+ i,
1880
+ 'not called'
1881
+ );
1882
+ assert.strictEqual(
1883
+ browser.storage.managed.clear.callCount,
1884
+ j,
1885
+ 'not called'
1886
+ );
1588
1887
  /*
1589
1888
  assert.strictEqual(browser.storage.session.clear.callCount, k,
1590
1889
  'not called');
@@ -1595,22 +1894,31 @@ describe('browser', () => {
1595
1894
  it('should call function', async () => {
1596
1895
  const i = browser.storage.local.clear.callCount;
1597
1896
  await func();
1598
- assert.strictEqual(browser.storage.local.clear.callCount, i + 1,
1599
- 'called');
1897
+ assert.strictEqual(
1898
+ browser.storage.local.clear.callCount,
1899
+ i + 1,
1900
+ 'called'
1901
+ );
1600
1902
  });
1601
1903
 
1602
1904
  it('should call function', async () => {
1603
1905
  const i = browser.storage.local.clear.callCount;
1604
1906
  await func('local');
1605
- assert.strictEqual(browser.storage.local.clear.callCount, i + 1,
1606
- 'called');
1907
+ assert.strictEqual(
1908
+ browser.storage.local.clear.callCount,
1909
+ i + 1,
1910
+ 'called'
1911
+ );
1607
1912
  });
1608
1913
 
1609
1914
  it('should not call function', async () => {
1610
1915
  const i = browser.storage.managed.clear.callCount;
1611
1916
  await func('managed');
1612
- assert.strictEqual(browser.storage.managed.clear.callCount, i,
1613
- 'not called');
1917
+ assert.strictEqual(
1918
+ browser.storage.managed.clear.callCount,
1919
+ i,
1920
+ 'not called'
1921
+ );
1614
1922
  });
1615
1923
 
1616
1924
  /*
@@ -1639,10 +1947,12 @@ describe('browser', () => {
1639
1947
  // const k = browser.storage.session.get.callCount;
1640
1948
  const l = browser.storage.sync.get.callCount;
1641
1949
  const res = await func();
1642
- assert.strictEqual(browser.storage.local.get.callCount, i,
1643
- 'not called');
1644
- assert.strictEqual(browser.storage.managed.get.callCount, j,
1645
- 'not called');
1950
+ assert.strictEqual(browser.storage.local.get.callCount, i, 'not called');
1951
+ assert.strictEqual(
1952
+ browser.storage.managed.get.callCount,
1953
+ j,
1954
+ 'not called'
1955
+ );
1646
1956
  /*
1647
1957
  assert.strictEqual(browser.storage.session.get.callCount, k,
1648
1958
  'not called');
@@ -1658,8 +1968,11 @@ describe('browser', () => {
1658
1968
  const l = browser.storage.sync.get.callCount;
1659
1969
  const res = await func('foo');
1660
1970
  assert.strictEqual(browser.storage.local.get.callCount, i, 'not called');
1661
- assert.strictEqual(browser.storage.managed.get.callCount, j,
1662
- 'not called');
1971
+ assert.strictEqual(
1972
+ browser.storage.managed.get.callCount,
1973
+ j,
1974
+ 'not called'
1975
+ );
1663
1976
  /*
1664
1977
  assert.strictEqual(browser.storage.session.get.callCount, k,
1665
1978
  'not called');
@@ -1688,8 +2001,11 @@ describe('browser', () => {
1688
2001
  browser.storage.managed.get.resolves({ foo: 'bar' });
1689
2002
  const i = browser.storage.managed.get.callCount;
1690
2003
  const res = await func('managed');
1691
- assert.strictEqual(browser.storage.managed.get.callCount, i + 1,
1692
- 'called');
2004
+ assert.strictEqual(
2005
+ browser.storage.managed.get.callCount,
2006
+ i + 1,
2007
+ 'called'
2008
+ );
1693
2009
  assert.deepEqual(res, { foo: 'bar' }, 'result');
1694
2010
  });
1695
2011
 
@@ -1724,8 +2040,11 @@ describe('browser', () => {
1724
2040
  const l = browser.storage.sync.get.callCount;
1725
2041
  const res = await func('foo');
1726
2042
  assert.strictEqual(browser.storage.local.get.callCount, i, 'not called');
1727
- assert.strictEqual(browser.storage.managed.get.callCount, j,
1728
- 'not called');
2043
+ assert.strictEqual(
2044
+ browser.storage.managed.get.callCount,
2045
+ j,
2046
+ 'not called'
2047
+ );
1729
2048
  /*
1730
2049
  assert.strictEqual(browser.storage.session.get.callCount, k,
1731
2050
  'not called');
@@ -1741,8 +2060,11 @@ describe('browser', () => {
1741
2060
  const l = browser.storage.sync.get.callCount;
1742
2061
  const res = await func('foo', 'bar');
1743
2062
  assert.strictEqual(browser.storage.local.get.callCount, i, 'not called');
1744
- assert.strictEqual(browser.storage.managed.get.callCount, j,
1745
- 'not called');
2063
+ assert.strictEqual(
2064
+ browser.storage.managed.get.callCount,
2065
+ j,
2066
+ 'not called'
2067
+ );
1746
2068
  /*
1747
2069
  assert.strictEqual(browser.storage.session.get.callCount, k,
1748
2070
  'not called');
@@ -1771,8 +2093,11 @@ describe('browser', () => {
1771
2093
  browser.storage.managed.get.withArgs('foo').resolves({ foo: 'bar' });
1772
2094
  const i = browser.storage.managed.get.callCount;
1773
2095
  const res = await func('foo', 'managed');
1774
- assert.strictEqual(browser.storage.managed.get.callCount, i + 1,
1775
- 'called');
2096
+ assert.strictEqual(
2097
+ browser.storage.managed.get.callCount,
2098
+ i + 1,
2099
+ 'called'
2100
+ );
1776
2101
  assert.deepEqual(res, { foo: 'bar' }, 'result');
1777
2102
  });
1778
2103
 
@@ -1806,16 +2131,25 @@ describe('browser', () => {
1806
2131
  // const k = browser.storage.session.remove.callCount;
1807
2132
  const l = browser.storage.sync.remove.callCount;
1808
2133
  await func('foo');
1809
- assert.strictEqual(browser.storage.local.remove.callCount, i,
1810
- 'not called');
1811
- assert.strictEqual(browser.storage.managed.remove.callCount, j,
1812
- 'not called');
2134
+ assert.strictEqual(
2135
+ browser.storage.local.remove.callCount,
2136
+ i,
2137
+ 'not called'
2138
+ );
2139
+ assert.strictEqual(
2140
+ browser.storage.managed.remove.callCount,
2141
+ j,
2142
+ 'not called'
2143
+ );
1813
2144
  /*
1814
2145
  assert.strictEqual(browser.storage.session.remove.callCount, k,
1815
2146
  'not called');
1816
2147
  */
1817
- assert.strictEqual(browser.storage.sync.remove.callCount, l,
1818
- 'not called');
2148
+ assert.strictEqual(
2149
+ browser.storage.sync.remove.callCount,
2150
+ l,
2151
+ 'not called'
2152
+ );
1819
2153
  });
1820
2154
 
1821
2155
  it('should not call function', async () => {
@@ -1824,37 +2158,55 @@ describe('browser', () => {
1824
2158
  // const k = browser.storage.session.remove.callCount;
1825
2159
  const l = browser.storage.sync.remove.callCount;
1826
2160
  await func('foo', 'bar');
1827
- assert.strictEqual(browser.storage.local.remove.callCount, i,
1828
- 'not called');
1829
- assert.strictEqual(browser.storage.managed.remove.callCount, j,
1830
- 'not called');
2161
+ assert.strictEqual(
2162
+ browser.storage.local.remove.callCount,
2163
+ i,
2164
+ 'not called'
2165
+ );
2166
+ assert.strictEqual(
2167
+ browser.storage.managed.remove.callCount,
2168
+ j,
2169
+ 'not called'
2170
+ );
1831
2171
  /*
1832
2172
  assert.strictEqual(browser.storage.session.remove.callCount, k,
1833
2173
  'not called');
1834
2174
  */
1835
- assert.strictEqual(browser.storage.sync.remove.callCount, l,
1836
- 'not called');
2175
+ assert.strictEqual(
2176
+ browser.storage.sync.remove.callCount,
2177
+ l,
2178
+ 'not called'
2179
+ );
1837
2180
  });
1838
2181
 
1839
2182
  it('should call function', async () => {
1840
2183
  const i = browser.storage.local.remove.callCount;
1841
2184
  await func('foo');
1842
- assert.strictEqual(browser.storage.local.remove.callCount, i + 1,
1843
- 'called');
2185
+ assert.strictEqual(
2186
+ browser.storage.local.remove.callCount,
2187
+ i + 1,
2188
+ 'called'
2189
+ );
1844
2190
  });
1845
2191
 
1846
2192
  it('should call function', async () => {
1847
2193
  const i = browser.storage.local.remove.callCount;
1848
2194
  await func('foo', 'local');
1849
- assert.strictEqual(browser.storage.local.remove.callCount, i + 1,
1850
- 'called');
2195
+ assert.strictEqual(
2196
+ browser.storage.local.remove.callCount,
2197
+ i + 1,
2198
+ 'called'
2199
+ );
1851
2200
  });
1852
2201
 
1853
2202
  it('should not call function', async () => {
1854
2203
  const i = browser.storage.managed.remove.callCount;
1855
2204
  await func('foo', 'managed');
1856
- assert.strictEqual(browser.storage.managed.remove.callCount, i,
1857
- 'not called');
2205
+ assert.strictEqual(
2206
+ browser.storage.managed.remove.callCount,
2207
+ i,
2208
+ 'not called'
2209
+ );
1858
2210
  });
1859
2211
 
1860
2212
  /*
@@ -1869,8 +2221,11 @@ describe('browser', () => {
1869
2221
  it('should call function', async () => {
1870
2222
  const i = browser.storage.sync.remove.callCount;
1871
2223
  await func('foo', 'sync');
1872
- assert.strictEqual(browser.storage.sync.remove.callCount, i + 1,
1873
- 'called');
2224
+ assert.strictEqual(
2225
+ browser.storage.sync.remove.callCount,
2226
+ i + 1,
2227
+ 'called'
2228
+ );
1874
2229
  });
1875
2230
  });
1876
2231
 
@@ -1884,10 +2239,12 @@ describe('browser', () => {
1884
2239
  // const k = browser.storage.session.set.callCount;
1885
2240
  const l = browser.storage.sync.set.callCount;
1886
2241
  await func('foo');
1887
- assert.strictEqual(browser.storage.local.set.callCount, i,
1888
- 'not called');
1889
- assert.strictEqual(browser.storage.managed.set.callCount, j,
1890
- 'not called');
2242
+ assert.strictEqual(browser.storage.local.set.callCount, i, 'not called');
2243
+ assert.strictEqual(
2244
+ browser.storage.managed.set.callCount,
2245
+ j,
2246
+ 'not called'
2247
+ );
1891
2248
  /*
1892
2249
  assert.strictEqual(browser.storage.session.set.callCount, k,
1893
2250
  'not called');
@@ -1916,8 +2273,11 @@ describe('browser', () => {
1916
2273
  it('should not call function', async () => {
1917
2274
  const i = browser.storage.managed.set.callCount;
1918
2275
  await func('foo', 'managed');
1919
- assert.strictEqual(browser.storage.managed.set.callCount, i,
1920
- 'not called');
2276
+ assert.strictEqual(
2277
+ browser.storage.managed.set.callCount,
2278
+ i,
2279
+ 'not called'
2280
+ );
1921
2281
  });
1922
2282
 
1923
2283
  /*
@@ -1966,8 +2326,10 @@ describe('browser', () => {
1966
2326
 
1967
2327
  it('should throw', async () => {
1968
2328
  await func().catch(e => {
1969
- assert.deepStrictEqual(e,
1970
- new TypeError('Expected Number but got Undefined.'));
2329
+ assert.deepStrictEqual(
2330
+ e,
2331
+ new TypeError('Expected Number but got Undefined.')
2332
+ );
1971
2333
  });
1972
2334
  });
1973
2335
 
@@ -1995,8 +2357,11 @@ describe('browser', () => {
1995
2357
  browser.tabs.query.resolves([{}]);
1996
2358
  browser.tabs.query.withArgs({}).resolves([{}, {}]);
1997
2359
  const res = await func({});
1998
- assert.strictEqual(browser.tabs.query.withArgs({}).callCount, i + 1,
1999
- 'called');
2360
+ assert.strictEqual(
2361
+ browser.tabs.query.withArgs({}).callCount,
2362
+ i + 1,
2363
+ 'called'
2364
+ );
2000
2365
  assert.deepEqual(res, [{}, {}], 'result');
2001
2366
  });
2002
2367
  });
@@ -2015,15 +2380,21 @@ describe('browser', () => {
2015
2380
  const i = browser.tabs.executeScript.withArgs(1, {
2016
2381
  file
2017
2382
  }).callCount;
2018
- browser.tabs.executeScript.withArgs(1, {
2019
- file
2020
- }).resolves([{}]);
2383
+ browser.tabs.executeScript
2384
+ .withArgs(1, {
2385
+ file
2386
+ })
2387
+ .resolves([{}]);
2021
2388
  const res = await func(1, { file });
2022
2389
  const { calledOnce: errCalled } = stubErr;
2023
2390
  stubErr.restore();
2024
- assert.strictEqual(browser.tabs.executeScript.withArgs(1, {
2025
- file
2026
- }).callCount, i + 1, 'called');
2391
+ assert.strictEqual(
2392
+ browser.tabs.executeScript.withArgs(1, {
2393
+ file
2394
+ }).callCount,
2395
+ i + 1,
2396
+ 'called'
2397
+ );
2027
2398
  assert.strictEqual(errCalled, false, 'error not called');
2028
2399
  assert.deepEqual(res, [{}], 'result');
2029
2400
  });
@@ -2034,15 +2405,21 @@ describe('browser', () => {
2034
2405
  const i = browser.tabs.executeScript.withArgs(1, {
2035
2406
  file
2036
2407
  }).callCount;
2037
- browser.tabs.executeScript.withArgs(1, {
2038
- file
2039
- }).rejects(new Error('error'));
2408
+ browser.tabs.executeScript
2409
+ .withArgs(1, {
2410
+ file
2411
+ })
2412
+ .rejects(new Error('error'));
2040
2413
  const res = await func(1, { file });
2041
2414
  const { calledOnce: errCalled } = stubErr;
2042
2415
  stubErr.restore();
2043
- assert.strictEqual(browser.tabs.executeScript.withArgs(1, {
2044
- file
2045
- }).callCount, i + 1, 'called');
2416
+ assert.strictEqual(
2417
+ browser.tabs.executeScript.withArgs(1, {
2418
+ file
2419
+ }).callCount,
2420
+ i + 1,
2421
+ 'called'
2422
+ );
2046
2423
  assert.strictEqual(errCalled, true, 'error called');
2047
2424
  assert.strictEqual(res, false, 'result');
2048
2425
  });
@@ -2053,15 +2430,21 @@ describe('browser', () => {
2053
2430
  const i = browser.tabs.executeScript.withArgs({
2054
2431
  file
2055
2432
  }).callCount;
2056
- browser.tabs.executeScript.withArgs({
2057
- file
2058
- }).resolves([{}]);
2433
+ browser.tabs.executeScript
2434
+ .withArgs({
2435
+ file
2436
+ })
2437
+ .resolves([{}]);
2059
2438
  const res = await func({ file });
2060
2439
  const { calledOnce: errCalled } = stubErr;
2061
2440
  stubErr.restore();
2062
- assert.strictEqual(browser.tabs.executeScript.withArgs({
2063
- file
2064
- }).callCount, i + 1, 'called');
2441
+ assert.strictEqual(
2442
+ browser.tabs.executeScript.withArgs({
2443
+ file
2444
+ }).callCount,
2445
+ i + 1,
2446
+ 'called'
2447
+ );
2065
2448
  assert.strictEqual(errCalled, false, 'error not called');
2066
2449
  assert.deepEqual(res, [{}], 'result');
2067
2450
  });
@@ -2072,15 +2455,21 @@ describe('browser', () => {
2072
2455
  const i = browser.tabs.executeScript.withArgs({
2073
2456
  file
2074
2457
  }).callCount;
2075
- browser.tabs.executeScript.withArgs({
2076
- file
2077
- }).rejects(new Error('error'));
2458
+ browser.tabs.executeScript
2459
+ .withArgs({
2460
+ file
2461
+ })
2462
+ .rejects(new Error('error'));
2078
2463
  const res = await func({ file });
2079
2464
  const { calledOnce: errCalled } = stubErr;
2080
2465
  stubErr.restore();
2081
- assert.strictEqual(browser.tabs.executeScript.withArgs({
2082
- file
2083
- }).callCount, i + 1, 'called');
2466
+ assert.strictEqual(
2467
+ browser.tabs.executeScript.withArgs({
2468
+ file
2469
+ }).callCount,
2470
+ i + 1,
2471
+ 'called'
2472
+ );
2084
2473
  assert.strictEqual(errCalled, true, 'error called');
2085
2474
  assert.strictEqual(res, false, 'result');
2086
2475
  });
@@ -2091,15 +2480,21 @@ describe('browser', () => {
2091
2480
  const i = browser.tabs.executeScript.withArgs({
2092
2481
  file
2093
2482
  }).callCount;
2094
- browser.tabs.executeScript.withArgs({
2095
- file
2096
- }).resolves([{}]);
2483
+ browser.tabs.executeScript
2484
+ .withArgs({
2485
+ file
2486
+ })
2487
+ .resolves([{}]);
2097
2488
  const res = await func(null, { file });
2098
2489
  const { calledOnce: errCalled } = stubErr;
2099
2490
  stubErr.restore();
2100
- assert.strictEqual(browser.tabs.executeScript.withArgs({
2101
- file
2102
- }).callCount, i + 1, 'called');
2491
+ assert.strictEqual(
2492
+ browser.tabs.executeScript.withArgs({
2493
+ file
2494
+ }).callCount,
2495
+ i + 1,
2496
+ 'called'
2497
+ );
2103
2498
  assert.strictEqual(errCalled, false, 'error not called');
2104
2499
  assert.deepEqual(res, [{}], 'result');
2105
2500
  });
@@ -2110,15 +2505,21 @@ describe('browser', () => {
2110
2505
  const i = browser.tabs.executeScript.withArgs({
2111
2506
  file
2112
2507
  }).callCount;
2113
- browser.tabs.executeScript.withArgs({
2114
- file
2115
- }).rejects(new Error('error'));
2508
+ browser.tabs.executeScript
2509
+ .withArgs({
2510
+ file
2511
+ })
2512
+ .rejects(new Error('error'));
2116
2513
  const res = await func(null, { file });
2117
2514
  const { calledOnce: errCalled } = stubErr;
2118
2515
  stubErr.restore();
2119
- assert.strictEqual(browser.tabs.executeScript.withArgs({
2120
- file
2121
- }).callCount, i + 1, 'called');
2516
+ assert.strictEqual(
2517
+ browser.tabs.executeScript.withArgs({
2518
+ file
2519
+ }).callCount,
2520
+ i + 1,
2521
+ 'called'
2522
+ );
2122
2523
  assert.strictEqual(errCalled, true, 'error called');
2123
2524
  assert.strictEqual(res, false, 'result');
2124
2525
  });
@@ -2150,10 +2551,16 @@ describe('browser', () => {
2150
2551
  const res = await func();
2151
2552
  const { calledOnce: errCalled } = stubErr;
2152
2553
  stubErr.restore();
2153
- assert.strictEqual(browser.tabs.executeScript.withArgs(1, {}).callCount,
2154
- i + 1, 'called');
2155
- assert.strictEqual(browser.tabs.executeScript.withArgs(2, {}).callCount,
2156
- j + 1, 'called');
2554
+ assert.strictEqual(
2555
+ browser.tabs.executeScript.withArgs(1, {}).callCount,
2556
+ i + 1,
2557
+ 'called'
2558
+ );
2559
+ assert.strictEqual(
2560
+ browser.tabs.executeScript.withArgs(2, {}).callCount,
2561
+ j + 1,
2562
+ 'called'
2563
+ );
2157
2564
  assert.strictEqual(errCalled, true, 'error called');
2158
2565
  assert.deepEqual(res, [[{}], false], 'result');
2159
2566
  });
@@ -2183,28 +2590,40 @@ describe('browser', () => {
2183
2590
  url: 'about:blank'
2184
2591
  }
2185
2592
  ]);
2186
- browser.tabs.executeScript.withArgs(1, {
2187
- file,
2188
- allFrames: true
2189
- }).resolves([{}, {}]);
2190
- browser.tabs.executeScript.withArgs(2, {
2191
- file,
2192
- allFrames: true
2193
- }).rejects(new Error('error'));
2593
+ browser.tabs.executeScript
2594
+ .withArgs(1, {
2595
+ file,
2596
+ allFrames: true
2597
+ })
2598
+ .resolves([{}, {}]);
2599
+ browser.tabs.executeScript
2600
+ .withArgs(2, {
2601
+ file,
2602
+ allFrames: true
2603
+ })
2604
+ .rejects(new Error('error'));
2194
2605
  const res = await func({
2195
2606
  file,
2196
2607
  allFrames: true
2197
2608
  });
2198
2609
  const { calledOnce: errCalled } = stubErr;
2199
2610
  stubErr.restore();
2200
- assert.strictEqual(browser.tabs.executeScript.withArgs(1, {
2201
- file,
2202
- allFrames: true
2203
- }).callCount, i + 1, 'called');
2204
- assert.strictEqual(browser.tabs.executeScript.withArgs(2, {
2205
- file,
2206
- allFrames: true
2207
- }).callCount, j + 1, 'called');
2611
+ assert.strictEqual(
2612
+ browser.tabs.executeScript.withArgs(1, {
2613
+ file,
2614
+ allFrames: true
2615
+ }).callCount,
2616
+ i + 1,
2617
+ 'called'
2618
+ );
2619
+ assert.strictEqual(
2620
+ browser.tabs.executeScript.withArgs(2, {
2621
+ file,
2622
+ allFrames: true
2623
+ }).callCount,
2624
+ j + 1,
2625
+ 'called'
2626
+ );
2208
2627
  assert.strictEqual(errCalled, true, 'error called');
2209
2628
  assert.deepEqual(res, [[{}, {}], false], 'result');
2210
2629
  });
@@ -2262,10 +2681,16 @@ describe('browser', () => {
2262
2681
  const res = await func(1, opts);
2263
2682
  const { calledOnce: errCalled } = stubErr;
2264
2683
  stubErr.restore();
2265
- assert.strictEqual(browser.tabs.executeScript.withArgs(1, opt).callCount,
2266
- i + 1, 'called');
2267
- assert.strictEqual(browser.tabs.executeScript.withArgs(1, opt2).callCount,
2268
- j + 1, 'called');
2684
+ assert.strictEqual(
2685
+ browser.tabs.executeScript.withArgs(1, opt).callCount,
2686
+ i + 1,
2687
+ 'called'
2688
+ );
2689
+ assert.strictEqual(
2690
+ browser.tabs.executeScript.withArgs(1, opt2).callCount,
2691
+ j + 1,
2692
+ 'called'
2693
+ );
2269
2694
  assert.strictEqual(errCalled, true, 'error called');
2270
2695
  assert.deepEqual(res, [{}], 'result');
2271
2696
  });
@@ -2286,10 +2711,16 @@ describe('browser', () => {
2286
2711
  const res = await func(opts);
2287
2712
  const { calledOnce: errCalled } = stubErr;
2288
2713
  stubErr.restore();
2289
- assert.strictEqual(browser.tabs.executeScript.withArgs(opt).callCount,
2290
- i + 1, 'called');
2291
- assert.strictEqual(browser.tabs.executeScript.withArgs(opt2).callCount,
2292
- j + 1, 'called');
2714
+ assert.strictEqual(
2715
+ browser.tabs.executeScript.withArgs(opt).callCount,
2716
+ i + 1,
2717
+ 'called'
2718
+ );
2719
+ assert.strictEqual(
2720
+ browser.tabs.executeScript.withArgs(opt2).callCount,
2721
+ j + 1,
2722
+ 'called'
2723
+ );
2293
2724
  assert.strictEqual(errCalled, true, 'error called');
2294
2725
  assert.deepEqual(res, [{}], 'result');
2295
2726
  });
@@ -2310,10 +2741,16 @@ describe('browser', () => {
2310
2741
  const res = await func(null, opts);
2311
2742
  const { calledOnce: errCalled } = stubErr;
2312
2743
  stubErr.restore();
2313
- assert.strictEqual(browser.tabs.executeScript.withArgs(opt).callCount,
2314
- i + 1, 'called');
2315
- assert.strictEqual(browser.tabs.executeScript.withArgs(opt2).callCount,
2316
- j + 1, 'called');
2744
+ assert.strictEqual(
2745
+ browser.tabs.executeScript.withArgs(opt).callCount,
2746
+ i + 1,
2747
+ 'called'
2748
+ );
2749
+ assert.strictEqual(
2750
+ browser.tabs.executeScript.withArgs(opt2).callCount,
2751
+ j + 1,
2752
+ 'called'
2753
+ );
2317
2754
  assert.strictEqual(errCalled, true, 'error called');
2318
2755
  assert.deepEqual(res, [{}], 'result');
2319
2756
  });
@@ -2412,15 +2849,19 @@ describe('browser', () => {
2412
2849
 
2413
2850
  it('should throw if no argument given', async () => {
2414
2851
  await func().catch(e => {
2415
- assert.deepStrictEqual(e,
2416
- new TypeError('Expected Number but got Undefined.'));
2852
+ assert.deepStrictEqual(
2853
+ e,
2854
+ new TypeError('Expected Number but got Undefined.')
2855
+ );
2417
2856
  });
2418
2857
  });
2419
2858
 
2420
2859
  it('should throw if argument is not number', async () => {
2421
2860
  await func('').catch(e => {
2422
- assert.deepStrictEqual(e,
2423
- new TypeError('Expected Number but got String.'));
2861
+ assert.deepStrictEqual(
2862
+ e,
2863
+ new TypeError('Expected Number but got String.')
2864
+ );
2424
2865
  });
2425
2866
  });
2426
2867
 
@@ -2436,15 +2877,19 @@ describe('browser', () => {
2436
2877
 
2437
2878
  it('should throw if no argument given', async () => {
2438
2879
  await func().catch(e => {
2439
- assert.deepStrictEqual(e,
2440
- new TypeError('Expected Number or Array but got Undefined.'));
2880
+ assert.deepStrictEqual(
2881
+ e,
2882
+ new TypeError('Expected Number or Array but got Undefined.')
2883
+ );
2441
2884
  });
2442
2885
  });
2443
2886
 
2444
2887
  it('should throw if argument is not number', async () => {
2445
2888
  await func('').catch(e => {
2446
- assert.deepStrictEqual(e,
2447
- new TypeError('Expected Number or Array but got String.'));
2889
+ assert.deepStrictEqual(
2890
+ e,
2891
+ new TypeError('Expected Number or Array but got String.')
2892
+ );
2448
2893
  });
2449
2894
  });
2450
2895
 
@@ -2466,15 +2911,19 @@ describe('browser', () => {
2466
2911
 
2467
2912
  it('should throw if no argument given', async () => {
2468
2913
  await func().catch(e => {
2469
- assert.deepStrictEqual(e,
2470
- new TypeError('Expected Number or Array but got Undefined.'));
2914
+ assert.deepStrictEqual(
2915
+ e,
2916
+ new TypeError('Expected Number or Array but got Undefined.')
2917
+ );
2471
2918
  });
2472
2919
  });
2473
2920
 
2474
2921
  it('should throw if argument is not number', async () => {
2475
2922
  await func('').catch(e => {
2476
- assert.deepStrictEqual(e,
2477
- new TypeError('Expected Number or Array but got String.'));
2923
+ assert.deepStrictEqual(
2924
+ e,
2925
+ new TypeError('Expected Number or Array but got String.')
2926
+ );
2478
2927
  });
2479
2928
  });
2480
2929
 
@@ -2513,23 +2962,30 @@ describe('browser', () => {
2513
2962
 
2514
2963
  it('should throw if no argument given', async () => {
2515
2964
  await func().catch(e => {
2516
- assert.deepStrictEqual(e,
2517
- new TypeError('Expected Number but got Undefined.'));
2965
+ assert.deepStrictEqual(
2966
+ e,
2967
+ new TypeError('Expected Number but got Undefined.')
2968
+ );
2518
2969
  });
2519
2970
  });
2520
2971
 
2521
2972
  it('should throw if argument is not number', async () => {
2522
2973
  await func('').catch(e => {
2523
- assert.deepStrictEqual(e,
2524
- new TypeError('Expected Number but got String.'));
2974
+ assert.deepStrictEqual(
2975
+ e,
2976
+ new TypeError('Expected Number but got String.')
2977
+ );
2525
2978
  });
2526
2979
  });
2527
2980
 
2528
2981
  it('should call function', async () => {
2529
2982
  const i = browser.tabs.reload.withArgs(1, null).callCount;
2530
2983
  await func(1);
2531
- assert.strictEqual(browser.tabs.reload.withArgs(1, null).callCount, i + 1,
2532
- 'res');
2984
+ assert.strictEqual(
2985
+ browser.tabs.reload.withArgs(1, null).callCount,
2986
+ i + 1,
2987
+ 'res'
2988
+ );
2533
2989
  });
2534
2990
 
2535
2991
  it('should call function', async () => {
@@ -2537,7 +2993,8 @@ describe('browser', () => {
2537
2993
  await func(1, { foo: 'bar' });
2538
2994
  assert.strictEqual(
2539
2995
  browser.tabs.reload.withArgs(1, { foo: 'bar' }).callCount,
2540
- i + 1, 'res'
2996
+ i + 1,
2997
+ 'res'
2541
2998
  );
2542
2999
  });
2543
3000
  });
@@ -2547,15 +3004,19 @@ describe('browser', () => {
2547
3004
 
2548
3005
  it('should throw if no argument given', async () => {
2549
3006
  await func().catch(e => {
2550
- assert.deepStrictEqual(e,
2551
- new TypeError('Expected Array but got Undefined.'));
3007
+ assert.deepStrictEqual(
3008
+ e,
3009
+ new TypeError('Expected Array but got Undefined.')
3010
+ );
2552
3011
  });
2553
3012
  });
2554
3013
 
2555
3014
  it('should throw if argument is not number or array', async () => {
2556
3015
  await func('').catch(e => {
2557
- assert.deepStrictEqual(e,
2558
- new TypeError('Expected Array but got String.'));
3016
+ assert.deepStrictEqual(
3017
+ e,
3018
+ new TypeError('Expected Array but got String.')
3019
+ );
2559
3020
  });
2560
3021
  });
2561
3022
 
@@ -2577,15 +3038,19 @@ describe('browser', () => {
2577
3038
 
2578
3039
  it('should throw if no argument given', async () => {
2579
3040
  await func().catch(e => {
2580
- assert.deepStrictEqual(e,
2581
- new TypeError('Expected Number but got Undefined.'));
3041
+ assert.deepStrictEqual(
3042
+ e,
3043
+ new TypeError('Expected Number but got Undefined.')
3044
+ );
2582
3045
  });
2583
3046
  });
2584
3047
 
2585
3048
  it('should throw if argument is not number', async () => {
2586
3049
  await func('').catch(e => {
2587
- assert.deepStrictEqual(e,
2588
- new TypeError('Expected Number but got String.'));
3050
+ assert.deepStrictEqual(
3051
+ e,
3052
+ new TypeError('Expected Number but got String.')
3053
+ );
2589
3054
  });
2590
3055
  });
2591
3056
 
@@ -2600,8 +3065,11 @@ describe('browser', () => {
2600
3065
  browser.tabs.update.withArgs(1).resolves({});
2601
3066
  const i = browser.tabs.update.withArgs(1).callCount;
2602
3067
  const res = await func(1);
2603
- assert.strictEqual(browser.tabs.update.withArgs(1).callCount, i + 1,
2604
- 'called');
3068
+ assert.strictEqual(
3069
+ browser.tabs.update.withArgs(1).callCount,
3070
+ i + 1,
3071
+ 'called'
3072
+ );
2605
3073
  assert.strictEqual(typeof res, 'object', 'res');
2606
3074
  });
2607
3075
 
@@ -2623,15 +3091,19 @@ describe('browser', () => {
2623
3091
 
2624
3092
  it('should throw if no argument given', async () => {
2625
3093
  await func().catch(e => {
2626
- assert.deepStrictEqual(e,
2627
- new TypeError('Expected Number but got Undefined.'));
3094
+ assert.deepStrictEqual(
3095
+ e,
3096
+ new TypeError('Expected Number but got Undefined.')
3097
+ );
2628
3098
  });
2629
3099
  });
2630
3100
 
2631
3101
  it('should throw if argument is not number', async () => {
2632
3102
  await func('').catch(e => {
2633
- assert.deepStrictEqual(e,
2634
- new TypeError('Expected Number but got String.'));
3103
+ assert.deepStrictEqual(
3104
+ e,
3105
+ new TypeError('Expected Number but got String.')
3106
+ );
2635
3107
  });
2636
3108
  });
2637
3109
 
@@ -2649,166 +3121,233 @@ describe('browser', () => {
2649
3121
 
2650
3122
  it('should not call function if permission is not granted', async () => {
2651
3123
  browser.runtime.getBrowserInfo.resolves({
2652
- vender: 'Mozilla',
3124
+ vendor: 'Mozilla',
2653
3125
  version: '125.0.1'
2654
3126
  });
2655
- browser.permissions.contains.withArgs({
2656
- origins: ['<all_urls>']
2657
- }).resolves(false);
3127
+ browser.permissions.contains
3128
+ .withArgs({
3129
+ origins: ['<all_urls>']
3130
+ })
3131
+ .resolves(false);
2658
3132
  const i = browser.tabs.captureVisibleTab.callCount;
2659
3133
  const res = await func();
2660
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i,
2661
- 'not called');
3134
+ assert.strictEqual(
3135
+ browser.tabs.captureVisibleTab.callCount,
3136
+ i,
3137
+ 'not called'
3138
+ );
2662
3139
  assert.deepEqual(res, null, 'result');
2663
3140
  });
2664
3141
 
2665
3142
  it('should call function', async () => {
2666
3143
  browser.runtime.getBrowserInfo.resolves({
2667
- vender: 'Mozilla',
3144
+ vendor: 'Mozilla',
2668
3145
  version: '125.0.1'
2669
3146
  });
2670
- browser.permissions.contains.withArgs({
2671
- origins: ['<all_urls>']
2672
- }).resolves(true);
3147
+ browser.permissions.contains
3148
+ .withArgs({
3149
+ origins: ['<all_urls>']
3150
+ })
3151
+ .resolves(true);
2673
3152
  const i = browser.tabs.captureVisibleTab.callCount;
2674
3153
  const windowId = browser.windows.WINDOW_ID_CURRENT;
2675
- const url = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
2676
- browser.tabs.captureVisibleTab.withArgs(windowId, {
2677
- format: 'png'
2678
- }).resolves(url);
3154
+ const url =
3155
+ 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
3156
+ browser.tabs.captureVisibleTab
3157
+ .withArgs(windowId, {
3158
+ format: 'png'
3159
+ })
3160
+ .resolves(url);
2679
3161
  const res = await func();
2680
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i + 1,
2681
- 'called');
3162
+ assert.strictEqual(
3163
+ browser.tabs.captureVisibleTab.callCount,
3164
+ i + 1,
3165
+ 'called'
3166
+ );
2682
3167
  assert.strictEqual(res, url, 'result');
2683
3168
  });
2684
3169
 
2685
3170
  it('should not call function if permission is not granted', async () => {
2686
3171
  browser.runtime.getBrowserInfo.resolves({
2687
- vender: 'Mozilla',
3172
+ vendor: 'Mozilla',
2688
3173
  version: '126.0.a1'
2689
3174
  });
2690
- browser.permissions.contains.withArgs({
2691
- permissions: ['activeTab']
2692
- }).resolves(false);
2693
- browser.permissions.contains.withArgs({
2694
- origins: ['<all_urls>']
2695
- }).resolves(false);
3175
+ browser.permissions.contains
3176
+ .withArgs({
3177
+ permissions: ['activeTab']
3178
+ })
3179
+ .resolves(false);
3180
+ browser.permissions.contains
3181
+ .withArgs({
3182
+ origins: ['<all_urls>']
3183
+ })
3184
+ .resolves(false);
2696
3185
  const i = browser.tabs.captureVisibleTab.callCount;
2697
3186
  const res = await func();
2698
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i,
2699
- 'not called');
3187
+ assert.strictEqual(
3188
+ browser.tabs.captureVisibleTab.callCount,
3189
+ i,
3190
+ 'not called'
3191
+ );
2700
3192
  assert.deepEqual(res, null, 'result');
2701
3193
  });
2702
3194
 
2703
3195
  it('should call function', async () => {
2704
3196
  browser.runtime.getBrowserInfo.resolves({
2705
- vender: 'Mozilla',
3197
+ vendor: 'Mozilla',
2706
3198
  version: '126.0a1'
2707
3199
  });
2708
- browser.permissions.contains.withArgs({
2709
- permissions: ['activeTab']
2710
- }).resolves(false);
2711
- browser.permissions.contains.withArgs({
2712
- origins: ['<all_urls>']
2713
- }).resolves(true);
3200
+ browser.permissions.contains
3201
+ .withArgs({
3202
+ permissions: ['activeTab']
3203
+ })
3204
+ .resolves(false);
3205
+ browser.permissions.contains
3206
+ .withArgs({
3207
+ origins: ['<all_urls>']
3208
+ })
3209
+ .resolves(true);
2714
3210
  const i = browser.tabs.captureVisibleTab.callCount;
2715
3211
  const windowId = browser.windows.WINDOW_ID_CURRENT;
2716
- const url = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
2717
- browser.tabs.captureVisibleTab.withArgs(windowId, {
2718
- format: 'png'
2719
- }).resolves(url);
3212
+ const url =
3213
+ 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
3214
+ browser.tabs.captureVisibleTab
3215
+ .withArgs(windowId, {
3216
+ format: 'png'
3217
+ })
3218
+ .resolves(url);
2720
3219
  const res = await func();
2721
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i + 1,
2722
- 'called');
3220
+ assert.strictEqual(
3221
+ browser.tabs.captureVisibleTab.callCount,
3222
+ i + 1,
3223
+ 'called'
3224
+ );
2723
3225
  assert.strictEqual(res, url, 'result');
2724
3226
  });
2725
3227
 
2726
3228
  it('should call function', async () => {
2727
3229
  browser.runtime.getBrowserInfo.resolves({
2728
- vender: 'Mozilla',
3230
+ vendor: 'Mozilla',
2729
3231
  version: '126.0a1'
2730
3232
  });
2731
- browser.permissions.contains.withArgs({
2732
- permissions: ['activeTab']
2733
- }).resolves(true);
2734
- browser.permissions.contains.withArgs({
2735
- origins: ['<all_urls>']
2736
- }).resolves(false);
3233
+ browser.permissions.contains
3234
+ .withArgs({
3235
+ permissions: ['activeTab']
3236
+ })
3237
+ .resolves(true);
3238
+ browser.permissions.contains
3239
+ .withArgs({
3240
+ origins: ['<all_urls>']
3241
+ })
3242
+ .resolves(false);
2737
3243
  const i = browser.tabs.captureVisibleTab.callCount;
2738
3244
  const windowId = browser.windows.WINDOW_ID_CURRENT;
2739
- const url = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
2740
- browser.tabs.captureVisibleTab.withArgs(windowId, {
2741
- format: 'png'
2742
- }).resolves(url);
3245
+ const url =
3246
+ 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
3247
+ browser.tabs.captureVisibleTab
3248
+ .withArgs(windowId, {
3249
+ format: 'png'
3250
+ })
3251
+ .resolves(url);
2743
3252
  const res = await func();
2744
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i + 1,
2745
- 'called');
3253
+ assert.strictEqual(
3254
+ browser.tabs.captureVisibleTab.callCount,
3255
+ i + 1,
3256
+ 'called'
3257
+ );
2746
3258
  assert.strictEqual(res, url, 'result');
2747
3259
  });
2748
3260
 
2749
3261
  it('should not call function if permission is not granted', async () => {
2750
3262
  browser.runtime.getBrowserInfo.resolves({
2751
- vender: 'Foo',
3263
+ vendor: 'Foo',
2752
3264
  version: '126.0.1'
2753
3265
  });
2754
- browser.permissions.contains.withArgs({
2755
- permissions: ['activeTab']
2756
- }).resolves(false);
2757
- browser.permissions.contains.withArgs({
2758
- origins: ['<all_urls>']
2759
- }).resolves(false);
3266
+ browser.permissions.contains
3267
+ .withArgs({
3268
+ permissions: ['activeTab']
3269
+ })
3270
+ .resolves(false);
3271
+ browser.permissions.contains
3272
+ .withArgs({
3273
+ origins: ['<all_urls>']
3274
+ })
3275
+ .resolves(false);
2760
3276
  const i = browser.tabs.captureVisibleTab.callCount;
2761
3277
  const res = await func();
2762
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i,
2763
- 'not called');
3278
+ assert.strictEqual(
3279
+ browser.tabs.captureVisibleTab.callCount,
3280
+ i,
3281
+ 'not called'
3282
+ );
2764
3283
  assert.deepEqual(res, null, 'result');
2765
3284
  });
2766
3285
 
2767
3286
  it('should call function', async () => {
2768
3287
  browser.runtime.getBrowserInfo.resolves({
2769
- vender: 'Foo',
3288
+ vendor: 'Foo',
2770
3289
  version: '126.0.1'
2771
3290
  });
2772
- browser.permissions.contains.withArgs({
2773
- permissions: ['activeTab']
2774
- }).resolves(true);
2775
- browser.permissions.contains.withArgs({
2776
- origins: ['<all_urls>']
2777
- }).resolves(false);
3291
+ browser.permissions.contains
3292
+ .withArgs({
3293
+ permissions: ['activeTab']
3294
+ })
3295
+ .resolves(true);
3296
+ browser.permissions.contains
3297
+ .withArgs({
3298
+ origins: ['<all_urls>']
3299
+ })
3300
+ .resolves(false);
2778
3301
  const i = browser.tabs.captureVisibleTab.callCount;
2779
3302
  const windowId = browser.windows.WINDOW_ID_CURRENT;
2780
- const url = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
2781
- browser.tabs.captureVisibleTab.withArgs(windowId, {
2782
- format: 'png'
2783
- }).resolves(url);
3303
+ const url =
3304
+ 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
3305
+ browser.tabs.captureVisibleTab
3306
+ .withArgs(windowId, {
3307
+ format: 'png'
3308
+ })
3309
+ .resolves(url);
2784
3310
  const res = await func();
2785
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i + 1,
2786
- 'called');
3311
+ assert.strictEqual(
3312
+ browser.tabs.captureVisibleTab.callCount,
3313
+ i + 1,
3314
+ 'called'
3315
+ );
2787
3316
  assert.strictEqual(res, url, 'result');
2788
3317
  });
2789
3318
 
2790
3319
  it('should call function', async () => {
2791
3320
  browser.runtime.getBrowserInfo.resolves({
2792
- vender: 'Foo',
3321
+ vendor: 'Foo',
2793
3322
  version: '126.0.1'
2794
3323
  });
2795
- browser.permissions.contains.withArgs({
2796
- permissions: ['activeTab']
2797
- }).resolves(false);
2798
- browser.permissions.contains.withArgs({
2799
- origins: ['<all_urls>']
2800
- }).resolves(true);
3324
+ browser.permissions.contains
3325
+ .withArgs({
3326
+ permissions: ['activeTab']
3327
+ })
3328
+ .resolves(false);
3329
+ browser.permissions.contains
3330
+ .withArgs({
3331
+ origins: ['<all_urls>']
3332
+ })
3333
+ .resolves(true);
2801
3334
  const i = browser.tabs.captureVisibleTab.callCount;
2802
3335
  const windowId = browser.windows.WINDOW_ID_CURRENT;
2803
- const url = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
2804
- browser.tabs.captureVisibleTab.withArgs(windowId, {
2805
- format: 'png'
2806
- }).resolves(url);
3336
+ const url =
3337
+ 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==';
3338
+ browser.tabs.captureVisibleTab
3339
+ .withArgs(windowId, {
3340
+ format: 'png'
3341
+ })
3342
+ .resolves(url);
2807
3343
  const res = await func(windowId, {
2808
3344
  format: 'png'
2809
3345
  });
2810
- assert.strictEqual(browser.tabs.captureVisibleTab.callCount, i + 1,
2811
- 'called');
3346
+ assert.strictEqual(
3347
+ browser.tabs.captureVisibleTab.callCount,
3348
+ i + 1,
3349
+ 'called'
3350
+ );
2812
3351
  assert.strictEqual(res, url, 'result');
2813
3352
  });
2814
3353
  });
@@ -2818,15 +3357,19 @@ describe('browser', () => {
2818
3357
 
2819
3358
  it('should throw if no argument given', async () => {
2820
3359
  await func().catch(e => {
2821
- assert.deepStrictEqual(e,
2822
- new TypeError('Expected Number but got Undefined.'));
3360
+ assert.deepStrictEqual(
3361
+ e,
3362
+ new TypeError('Expected Number but got Undefined.')
3363
+ );
2823
3364
  });
2824
3365
  });
2825
3366
 
2826
3367
  it('should throw if argument is not number', async () => {
2827
3368
  await func('').catch(e => {
2828
- assert.deepStrictEqual(e,
2829
- new TypeError('Expected Number but got String.'));
3369
+ assert.deepStrictEqual(
3370
+ e,
3371
+ new TypeError('Expected Number but got String.')
3372
+ );
2830
3373
  });
2831
3374
  });
2832
3375
 
@@ -2856,8 +3399,7 @@ describe('browser', () => {
2856
3399
  browser.permissions.contains.resolves(false);
2857
3400
  const i = browser.theme.getCurrent.callCount;
2858
3401
  await func('foo');
2859
- assert.strictEqual(browser.theme.getCurrent.callCount, i,
2860
- 'not called');
3402
+ assert.strictEqual(browser.theme.getCurrent.callCount, i, 'not called');
2861
3403
  });
2862
3404
 
2863
3405
  it('should get function called and get result', async () => {
@@ -2912,10 +3454,12 @@ describe('browser', () => {
2912
3454
  const func = mjs.getAllNormalWindows;
2913
3455
 
2914
3456
  it('should get function called and get result', async () => {
2915
- browser.windows.getAll.withArgs({
2916
- populate: false,
2917
- windowTypes: ['normal']
2918
- }).resolves([]);
3457
+ browser.windows.getAll
3458
+ .withArgs({
3459
+ populate: false,
3460
+ windowTypes: ['normal']
3461
+ })
3462
+ .resolves([]);
2919
3463
  const i = browser.windows.getAll.withArgs({
2920
3464
  populate: false,
2921
3465
  windowTypes: ['normal']
@@ -2926,10 +3470,12 @@ describe('browser', () => {
2926
3470
  });
2927
3471
 
2928
3472
  it('should get function called and get result', async () => {
2929
- browser.windows.getAll.withArgs({
2930
- populate: true,
2931
- windowTypes: ['normal']
2932
- }).resolves([]);
3473
+ browser.windows.getAll
3474
+ .withArgs({
3475
+ populate: true,
3476
+ windowTypes: ['normal']
3477
+ })
3478
+ .resolves([]);
2933
3479
  const i = browser.windows.getAll.withArgs({
2934
3480
  populate: true,
2935
3481
  windowTypes: ['normal']
@@ -2976,8 +3522,10 @@ describe('browser', () => {
2976
3522
 
2977
3523
  it('should throw', async () => {
2978
3524
  await func().catch(e => {
2979
- assert.deepStrictEqual(e,
2980
- new TypeError('Expected Number but got Undefined.'));
3525
+ assert.deepStrictEqual(
3526
+ e,
3527
+ new TypeError('Expected Number but got Undefined.')
3528
+ );
2981
3529
  });
2982
3530
  });
2983
3531
 
@@ -2990,9 +3538,11 @@ describe('browser', () => {
2990
3538
  });
2991
3539
 
2992
3540
  it('should get result', async () => {
2993
- browser.windows.get.withArgs(1, {
2994
- populate: true
2995
- }).resolves({});
3541
+ browser.windows.get
3542
+ .withArgs(1, {
3543
+ populate: true
3544
+ })
3545
+ .resolves({});
2996
3546
  const i = browser.windows.get.callCount;
2997
3547
  const res = await func(1, {
2998
3548
  populate: true