JAVASCRIPT   107

clipboard-action.js

Guest on 31st July 2021 06:59:36 AM

  1. import ClipboardAction from '../src/clipboard-action';
  2. import Emitter from 'tiny-emitter';
  3.  
  4. describe('ClipboardAction', () => {
  5.     before(() => {
  6.         global.input = document.createElement('input');
  7.         global.input.setAttribute('id', 'input');
  8.         global.input.setAttribute('value', 'abc');
  9.         document.body.appendChild(global.input);
  10.  
  11.         global.paragraph = document.createElement('p');
  12.         global.paragraph.setAttribute('id', 'paragraph');
  13.         global.paragraph.textContent = 'abc';
  14.         document.body.appendChild(global.paragraph);
  15.     });
  16.  
  17.     after(() => {
  18.         document.body.innerHTML = '';
  19.     });
  20.  
  21.     describe('#resolveOptions', () => {
  22.         it('should set base properties', () => {
  23.             let clip = new ClipboardAction({
  24.                 emitter: new Emitter(),
  25.                 text: 'foo'
  26.             });
  27.  
  28.             assert.property(clip, 'action');
  29.             assert.property(clip, 'emitter');
  30.             assert.property(clip, 'target');
  31.             assert.property(clip, 'text');
  32.             assert.property(clip, 'trigger');
  33.             assert.property(clip, 'selectedText');
  34.         });
  35.     });
  36.  
  37.     describe('#initSelection', () => {
  38.         it('should throw an error since both "text" and "target" were passed', done => {
  39.             try {
  40.                 new ClipboardAction({
  41.                     text: 'foo',
  42.                     target: document.querySelector('#input')
  43.                 });
  44.             }
  45.             catch(e) {
  46.                 assert.equal(e.message, 'Multiple attributes declared, use either "target" or "text"');
  47.                 done();
  48.             }
  49.         });
  50.  
  51.         it('should throw an error since neither "text" nor "target" were passed', done => {
  52.             try {
  53.                 new ClipboardAction();
  54.             }
  55.             catch(e) {
  56.                 assert.equal(e.message, 'Missing required attributes, use either "target" or "text"');
  57.                 done();
  58.             }
  59.         });
  60.     });
  61.  
  62.     describe('#set action', () => {
  63.         it('should throw an error since "action" is invalid', done => {
  64.             try {
  65.                 new ClipboardAction({
  66.                     text: 'foo',
  67.                     action: 'paste'
  68.                 });
  69.             }
  70.             catch(e) {
  71.                 assert.equal(e.message, 'Invalid "action" value, use either "copy" or "cut"');
  72.                 done();
  73.             }
  74.         });
  75.     });
  76.  
  77.     describe('#set target', () => {
  78.         it('should throw an error since "target" do not match any element', done => {
  79.             try {
  80.                 new ClipboardAction({
  81.                     target: document.querySelector('#foo')
  82.                 });
  83.             }
  84.             catch(e) {
  85.                 assert.equal(e.message, 'Invalid "target" value, use a valid Element');
  86.                 done();
  87.             }
  88.         });
  89.     });
  90.  
  91.     describe('#selectText', () => {
  92.         it('should create a fake element and select its value', () => {
  93.             let clip = new ClipboardAction({
  94.                 emitter: new Emitter(),
  95.                 text: 'blah'
  96.             });
  97.  
  98.             assert.equal(clip.selectedText, clip.fakeElem.value);
  99.         });
  100.     });
  101.  
  102.     describe('#removeFake', () => {
  103.         it('should remove a temporary fake element', () => {
  104.             let clip = new ClipboardAction({
  105.                 emitter: new Emitter(),
  106.                 text: 'blah'
  107.             });
  108.  
  109.             clip.removeFake();
  110.  
  111.             assert.equal(clip.fakeElem, null);
  112.         });
  113.     });
  114.  
  115.     describe('#selectTarget', () => {
  116.         it('should select text from editable element', () => {
  117.             let clip = new ClipboardAction({
  118.                 emitter: new Emitter(),
  119.                 target: document.querySelector('#input')
  120.             });
  121.  
  122.             assert.equal(clip.selectedText, clip.target.value);
  123.         });
  124.  
  125.         it('should select text from non-editable element', () => {
  126.             let clip = new ClipboardAction({
  127.                 emitter: new Emitter(),
  128.                 target: document.querySelector('#paragraph')
  129.             });
  130.  
  131.             assert.equal(clip.selectedText, clip.target.textContent);
  132.         });
  133.     });
  134.  
  135.     describe('#copyText', () => {
  136.         before(() => {
  137.             global.stub = sinon.stub(document, 'execCommand');
  138.         });
  139.  
  140.         after(() => {
  141.             global.stub.restore();
  142.         });
  143.  
  144.         it('should fire a success event on browsers that support copy command', done => {
  145.             global.stub.returns(true);
  146.  
  147.             let emitter = new Emitter();
  148.  
  149.             emitter.on('success', () => {
  150.                 done();
  151.             });
  152.  
  153.             let clip = new ClipboardAction({
  154.                 emitter: emitter,
  155.                 target: document.querySelector('#input')
  156.             });
  157.         });
  158.  
  159.         it('should fire an error event on browsers that support copy command', done => {
  160.             global.stub.returns(false);
  161.  
  162.             let emitter = new Emitter();
  163.  
  164.             emitter.on('error', () => {
  165.                 done();
  166.             });
  167.  
  168.             let clip = new ClipboardAction({
  169.                 emitter: emitter,
  170.                 target: document.querySelector('#input')
  171.             });
  172.         });
  173.     });
  174.  
  175.     describe('#handleResult', () => {
  176.         it('should fire a success event with certain properties', done => {
  177.             let clip = new ClipboardAction({
  178.                 emitter: new Emitter(),
  179.                 target: document.querySelector('#input')
  180.             });
  181.  
  182.             clip.emitter.on('success', (e) => {
  183.                 assert.property(e, 'action');
  184.                 assert.property(e, 'text');
  185.                 assert.property(e, 'trigger');
  186.                 assert.property(e, 'clearSelection');
  187.  
  188.                 done();
  189.             });
  190.  
  191.             clip.handleResult(true);
  192.         });
  193.  
  194.         it('should fire a error event with certain properties', done => {
  195.             let clip = new ClipboardAction({
  196.                 emitter: new Emitter(),
  197.                 target: document.querySelector('#input')
  198.             });
  199.  
  200.             clip.emitter.on('error', (e) => {
  201.                 assert.property(e, 'action');
  202.                 assert.property(e, 'trigger');
  203.                 assert.property(e, 'clearSelection');
  204.  
  205.                 done();
  206.             });
  207.  
  208.             clip.handleResult(false);
  209.         });
  210.     });
  211.  
  212.     describe('#clearSelection', () => {
  213.         it('should remove focus from target and text selection', () => {
  214.             let clip = new ClipboardAction({
  215.                 emitter: new Emitter(),
  216.                 target: document.querySelector('#input')
  217.             });
  218.  
  219.             clip.clearSelection();
  220.  
  221.             let selectedElem = document.activeElement;
  222.             let selectedText = window.getSelection().toString();
  223.  
  224.             assert.equal(selectedElem, document.body);
  225.             assert.equal(selectedText, '');
  226.         });
  227.     });
  228.  
  229.     describe('#destroy', () => {
  230.         it('should destroy an existing fake element', () => {
  231.             let clip = new ClipboardAction({
  232.                 emitter: new Emitter(),
  233.                 text: 'blah'
  234.             });
  235.  
  236.             clip.selectFake();
  237.             clip.destroy();
  238.  
  239.             assert.equal(clip.fakeElem, null);
  240.         });
  241.     });
  242. });

Raw Paste


Login or Register to edit or fork this paste. It's free.