/* eslint-disable @typescript-eslint/no-empty-function */ // Copyright (c) Jupyter Development Team. // Distributed under the terms of the Modified BSD License. /*----------------------------------------------------------------------------- | Copyright (c) 2014-2017, PhosphorJS Contributors | | Distributed under the terms of the BSD 3-Clause License. | | The full license is in the file LICENSE, distributed with this software. |----------------------------------------------------------------------------*/ import { expect } from 'chai'; import { CommandRegistry } from '@lumino/commands'; import { Platform } from '@lumino/domutils'; import { MessageLoop } from '@lumino/messaging'; import { h, VirtualDOM } from '@lumino/virtualdom'; import { CommandPalette, Widget } from '@lumino/widgets'; class LogPalette extends CommandPalette { events: string[] = []; handleEvent(event: Event): void { super.handleEvent(event); this.events.push(event.type); } } const bubbles = true; const defaultOptions: CommandPalette.IItemOptions = { command: 'test', category: 'Test Category', args: { foo: 'bar' }, rank: 42 }; describe('@lumino/widgets', () => { let commands: CommandRegistry; let palette: CommandPalette; beforeEach(() => { commands = new CommandRegistry(); palette = new CommandPalette({ commands }); Widget.attach(palette, document.body); }); afterEach(() => { palette.dispose(); }); describe('CommandPalette', () => { describe('#constructor()', () => { it('should accept command palette instantiation options', () => { expect(palette).to.be.an.instanceof(CommandPalette); expect(palette.node.classList.contains('lm-CommandPalette')).to.equal( true ); }); }); describe('#dispose()', () => { it('should dispose of the resources held by the command palette', () => { palette.addItem(defaultOptions); palette.dispose(); expect(palette.items.length).to.equal(0); expect(palette.isDisposed).to.equal(true); }); }); describe('#commands', () => { it('should get the command registry for the command palette', () => { expect(palette.commands).to.equal(commands); }); }); describe('#renderer', () => { it('should default to the default renderer', () => { expect(palette.renderer).to.equal(CommandPalette.defaultRenderer); }); }); describe('#searchNode', () => { it('should return the search node of a command palette', () => { expect( palette.searchNode.classList.contains('lm-CommandPalette-search') ).to.equal(true); }); }); describe('#inputNode', () => { it('should return the input node of a command palette', () => { expect( palette.inputNode.classList.contains('lm-CommandPalette-input') ).to.equal(true); }); }); describe('#contentNode', () => { it('should return the content node of a command palette', () => { expect( palette.contentNode.classList.contains('lm-CommandPalette-content') ).to.equal(true); }); }); describe('#items', () => { it('should be a read-only array of the palette items', () => { expect(palette.items.length).to.equal(0); palette.addItem(defaultOptions); expect(palette.items.length).to.equal(1); expect(palette.items[0].command).to.equal('test'); }); }); describe('#addItems()', () => { it('should add items to a command palette using options', () => { const item = { command: 'test2', category: 'Test Category', args: { foo: 'bar' }, rank: 100 }; expect(palette.items.length).to.equal(0); palette.addItems([defaultOptions, item]); expect(palette.items.length).to.equal(2); expect(palette.items[0].command).to.equal('test'); expect(palette.items[1].command).to.equal('test2'); }); }); describe('#addItem()', () => { it('should add an item to a command palette using options', () => { expect(palette.items.length).to.equal(0); palette.addItem(defaultOptions); expect(palette.items.length).to.equal(1); expect(palette.items[0].command).to.equal('test'); }); context('CommandPalette.IItem', () => { describe('#command', () => { it('should return the command name of a command item', () => { let item = palette.addItem(defaultOptions); expect(item.command).to.equal('test'); }); }); describe('#args', () => { it('should return the args of a command item', () => { let item = palette.addItem(defaultOptions); expect(item.args).to.deep.equal(defaultOptions.args); }); it('should default to an empty object', () => { let item = palette.addItem({ command: 'test', category: 'test' }); expect(item.args).to.deep.equal({}); }); }); describe('#category', () => { it('should return the category of a command item', () => { let item = palette.addItem(defaultOptions); expect(item.category).to.equal(defaultOptions.category); }); }); describe('#rank', () => { it('should return the rank of a command item', () => { let item = palette.addItem(defaultOptions); expect(item.rank).to.deep.equal(defaultOptions.rank); }); it('should default to `Infinity`', () => { let item = palette.addItem({ command: 'test', category: 'test' }); expect(item.rank).to.equal(Infinity); }); }); describe('#label', () => { it('should return the label of a command item', () => { let label = 'test label'; commands.addCommand('test', { execute: () => {}, label }); let item = palette.addItem(defaultOptions); expect(item.label).to.equal(label); }); }); describe('#caption', () => { it('should return the caption of a command item', () => { let caption = 'test caption'; commands.addCommand('test', { execute: () => {}, caption }); let item = palette.addItem(defaultOptions); expect(item.caption).to.equal(caption); }); }); describe('#className', () => { it('should return the class name of a command item', () => { let className = 'testClass'; commands.addCommand('test', { execute: () => {}, className }); let item = palette.addItem(defaultOptions); expect(item.className).to.equal(className); }); }); describe('#isEnabled', () => { it('should return whether a command item is enabled', () => { let called = false; commands.addCommand('test', { execute: () => {}, isEnabled: () => { called = true; return false; } }); let item = palette.addItem(defaultOptions); expect(called).to.equal(false); expect(item.isEnabled).to.equal(false); expect(called).to.equal(true); }); }); describe('#isToggled', () => { it('should return whether a command item is toggled', () => { let called = false; commands.addCommand('test', { execute: () => {}, isToggled: () => { called = true; return true; } }); let item = palette.addItem(defaultOptions); expect(called).to.equal(false); expect(item.isToggled).to.equal(true); expect(called).to.equal(true); }); }); describe('#isVisible', () => { it('should return whether a command item is visible', () => { let called = false; commands.addCommand('test', { execute: () => {}, isVisible: () => { called = true; return false; } }); let item = palette.addItem(defaultOptions); expect(called).to.equal(false); expect(item.isVisible).to.equal(false); expect(called).to.equal(true); }); }); describe('#keyBinding', () => { it('should return the key binding of a command item', () => { commands.addKeyBinding({ keys: ['Ctrl A'], selector: 'body', command: 'test', args: defaultOptions.args }); let item = palette.addItem(defaultOptions); expect(item.keyBinding!.keys).to.deep.equal(['Ctrl A']); }); }); }); }); describe('#removeItem()', () => { it('should remove an item from a command palette by item', () => { expect(palette.items.length).to.equal(0); let item = palette.addItem(defaultOptions); expect(palette.items.length).to.equal(1); palette.removeItem(item); expect(palette.items.length).to.equal(0); }); }); describe('#removeItemAt()', () => { it('should remove an item from a command palette by index', () => { expect(palette.items.length).to.equal(0); palette.addItem(defaultOptions); expect(palette.items.length).to.equal(1); palette.removeItemAt(0); expect(palette.items.length).to.equal(0); }); }); describe('#clearItems()', () => { it('should remove all items from a command palette', () => { expect(palette.items.length).to.equal(0); palette.addItem({ command: 'test', category: 'one' }); palette.addItem({ command: 'test', category: 'two' }); expect(palette.items.length).to.equal(2); palette.clearItems(); expect(palette.items.length).to.equal(0); }); }); describe('#refresh()', () => { it('should schedule a refresh of the search items', () => { commands.addCommand('test', { execute: () => {}, label: 'test' }); palette.addItem(defaultOptions); MessageLoop.flush(); let content = palette.contentNode; let itemClass = '.lm-CommandPalette-item'; let items = () => content.querySelectorAll(itemClass); expect(items()).to.have.length(1); palette.inputNode.value = 'x'; palette.refresh(); MessageLoop.flush(); expect(items()).to.have.length(0); }); it('should search a list of commands', () => { // Add several commands to the command registry and the palette commands.addCommand('example:cut', { label: 'Cut', mnemonic: 1, iconClass: 'fa fa-cut', execute: () => { console.log('Cut'); } }); commands.addCommand('example:copy', { label: 'Copy File', mnemonic: 0, iconClass: 'fa fa-copy', execute: () => { console.log('Copy'); } }); commands.addCommand('example:paste', { label: 'Paste', mnemonic: 0, iconClass: 'fa fa-paste', execute: () => { console.log('Paste'); } }); commands.addCommand('example:new-tab', { label: 'New Tab', mnemonic: 0, caption: 'Open a new tab', execute: () => { console.log('New Tab'); } }); commands.addCommand('example:close-tab', { label: 'Close Tab', mnemonic: 2, caption: 'Close the current tab', execute: () => { console.log('Close Tab'); } }); commands.addCommand('example:save-on-exit', { label: 'Save on Exit', mnemonic: 0, caption: 'Toggle the save on exit flag', execute: () => { console.log('Save on Exit'); } }); commands.addCommand('example:open-task-manager', { label: 'Task Manager', mnemonic: 5, isEnabled: () => false, execute: () => {} }); commands.addCommand('example:close', { label: 'Close', mnemonic: 0, iconClass: 'fa fa-close', execute: () => { console.log('Close'); } }); commands.addCommand('example:one', { label: 'One', execute: () => { console.log('One'); } }); commands.addCommand('example:two', { label: 'Two', execute: () => { console.log('Two'); } }); commands.addCommand('example:three', { label: 'Three', execute: () => { console.log('Three'); } }); commands.addCommand('example:four', { label: 'Four', execute: () => { console.log('Four'); } }); commands.addCommand('example:black', { label: 'Black', execute: () => { console.log('Black'); } }); commands.addCommand('example:clear-cell', { label: 'Clear Cell', execute: () => { console.log('Clear Cell'); } }); commands.addCommand('example:cut-cells', { label: 'Cut Cell(s)', execute: () => { console.log('Cut Cell(s)'); } }); commands.addCommand('example:run-cell', { label: 'Run Cell', execute: () => { console.log('Run Cell'); } }); commands.addCommand('example:cell-test', { label: 'Cell Test', execute: () => { console.log('Cell Test'); } }); commands.addCommand('notebook:new', { label: 'New Notebook', execute: () => { console.log('New Notebook'); } }); commands.addKeyBinding({ keys: ['Accel X'], selector: 'body', command: 'example:cut' }); commands.addKeyBinding({ keys: ['Accel C'], selector: 'body', command: 'example:copy' }); commands.addKeyBinding({ keys: ['Accel V'], selector: 'body', command: 'example:paste' }); commands.addKeyBinding({ keys: ['Accel J', 'Accel J'], selector: 'body', command: 'example:new-tab' }); commands.addKeyBinding({ keys: ['Accel M'], selector: 'body', command: 'example:open-task-manager' }); let palette = new CommandPalette({ commands }); Widget.attach(palette, document.body); try { palette.addItem({ command: 'example:cut', category: 'Edit' }); palette.addItem({ command: 'example:copy', category: 'Edit' }); palette.addItem({ command: 'example:paste', category: 'Edit' }); palette.addItem({ command: 'example:one', category: 'Number' }); palette.addItem({ command: 'example:two', category: 'Number' }); palette.addItem({ command: 'example:three', category: 'Number' }); palette.addItem({ command: 'example:four', category: 'Number' }); palette.addItem({ command: 'example:black', category: 'Number' }); palette.addItem({ command: 'example:new-tab', category: 'File' }); palette.addItem({ command: 'example:close-tab', category: 'File' }); palette.addItem({ command: 'example:save-on-exit', category: 'File' }); palette.addItem({ command: 'example:open-task-manager', category: 'File' }); palette.addItem({ command: 'example:close', category: 'File' }); palette.addItem({ command: 'example:clear-cell', category: 'Notebook Cell Operations' }); palette.addItem({ command: 'example:cut-cells', category: 'Notebook Cell Operations' }); palette.addItem({ command: 'example:run-cell', category: 'Notebook Cell Operations' }); palette.addItem({ command: 'example:cell-test', category: 'Console' }); palette.addItem({ command: 'notebook:new', category: 'Notebook' }); palette.id = 'palette'; // Search the command palette: update the inputNode, then force a refresh palette.inputNode.value = 'clea'; palette.refresh(); MessageLoop.flush(); // Expect that headers and items appear in descending score order, // even if the same header occurs multiple times. const children = palette.contentNode.children; expect(children.length).to.equal(7); expect(children[0].textContent).to.equal('Notebook Cell Operations'); expect(children[1].getAttribute('data-command')).to.equal( 'example:clear-cell' ); // The next match should be from a different category expect(children[2].textContent).to.equal('File'); expect(children[3].getAttribute('data-command')).to.equal( 'example:close-tab' ); // The next match should be the same as in a previous category expect(children[4].textContent).to.equal('Notebook Cell Operations'); expect(children[5].getAttribute('data-command')).to.equal( 'example:cut-cells' ); // The next match has the same category as the previous one did, so the header is not repeated expect(children[6].getAttribute('data-command')).to.equal( 'example:run-cell' ); } finally { palette.dispose(); } }); it('should clear the widget content if hidden', () => { commands.addCommand('test', { execute: () => {}, label: 'test' }); palette.addItem({ command: 'test', category: 'test' }); const content = palette.contentNode; const itemClass = '.lm-CommandPalette-item'; const items = () => content.querySelectorAll(itemClass); palette.refresh(); MessageLoop.flush(); expect(items()).to.have.length(1); palette.hide(); palette.refresh(); MessageLoop.flush(); expect(items()).to.have.length(0); }); it('should clear the widget content if container is hidden', () => { const parent = new Widget(); Widget.attach(parent, document.body); try { palette.parent = parent; commands.addCommand('test', { execute: () => {}, label: 'test' }); palette.addItem({ command: 'test', category: 'test' }); const content = palette.contentNode; const itemClass = '.lm-CommandPalette-item'; const items = () => content.querySelectorAll(itemClass); palette.refresh(); MessageLoop.flush(); expect(items()).to.have.length(1); parent.hide(); palette.refresh(); MessageLoop.flush(); expect(items()).to.have.length(0); } finally { parent.dispose(); } }); }); describe('#handleEvent()', () => { it('should handle click, keydown, and input events', () => { let palette = new LogPalette({ commands }); Widget.attach(palette, document.body); try { ['click', 'keydown', 'input'].forEach(type => { palette.node.dispatchEvent(new Event(type, { bubbles })); expect(palette.events).to.contain(type); }); } finally { palette.dispose(); } }); context('click', () => { it('should trigger a command when its item is clicked', () => { let called = false; commands.addCommand('test', { execute: () => (called = true) }); palette.addItem(defaultOptions); MessageLoop.flush(); let node = palette.contentNode.querySelector( '.lm-CommandPalette-item' )!; node.dispatchEvent(new MouseEvent('click', { bubbles })); expect(called).to.equal(true); }); it('should ignore the event if it is not a left click', () => { let called = false; commands.addCommand('test', { execute: () => (called = true) }); palette.addItem(defaultOptions); MessageLoop.flush(); let node = palette.contentNode.querySelector( '.lm-CommandPalette-item' )!; node.dispatchEvent(new MouseEvent('click', { bubbles, button: 1 })); expect(called).to.equal(false); }); }); context('keydown', () => { it('should navigate down if down arrow is pressed', () => { commands.addCommand('test', { execute: () => {} }); let content = palette.contentNode; palette.addItem(defaultOptions); MessageLoop.flush(); let node = content.querySelector('.lm-mod-active'); expect(node).to.equal(null); palette.node.dispatchEvent( new KeyboardEvent('keydown', { bubbles, keyCode: 40 // Down arrow }) ); MessageLoop.flush(); node = content.querySelector('.lm-CommandPalette-item.lm-mod-active'); expect(node).to.not.equal(null); }); it('should navigate up if up arrow is pressed', () => { commands.addCommand('test', { execute: () => {} }); let content = palette.contentNode; palette.addItem(defaultOptions); MessageLoop.flush(); let node = content.querySelector('.lm-mod-active'); expect(node).to.equal(null); palette.node.dispatchEvent( new KeyboardEvent('keydown', { bubbles, keyCode: 38 // Up arrow }) ); MessageLoop.flush(); node = content.querySelector('.lm-CommandPalette-item.lm-mod-active'); expect(node).to.not.equal(null); }); it('should ignore if modifier keys are pressed', () => { let called = false; commands.addCommand('test', { execute: () => (called = true) }); let content = palette.contentNode; palette.addItem(defaultOptions); MessageLoop.flush(); let node = content.querySelector('.lm-mod-active'); expect(node).to.equal(null); ['altKey', 'ctrlKey', 'shiftKey', 'metaKey'].forEach(key => { palette.node.dispatchEvent( new KeyboardEvent('keydown', { bubbles, [key]: true, keyCode: 38 // Up arrow }) ); node = content.querySelector( '.lm-CommandPalette-item.lm-mod-active' ); expect(node).to.equal(null); }); expect(called).to.be.false; }); it('should trigger active item if enter is pressed', () => { let called = false; commands.addCommand('test', { execute: () => (called = true) }); let content = palette.contentNode; palette.addItem(defaultOptions); MessageLoop.flush(); expect(content.querySelector('.lm-mod-active')).to.equal(null); palette.node.dispatchEvent( new KeyboardEvent('keydown', { bubbles, keyCode: 40 // Down arrow }) ); palette.node.dispatchEvent( new KeyboardEvent('keydown', { bubbles, keyCode: 13 // Enter }) ); expect(called).to.equal(true); }); }); context('input', () => { it('should filter the list of visible items', () => { ['A', 'B', 'C', 'D', 'E'].forEach(name => { commands.addCommand(name, { execute: () => {}, label: name }); palette.addItem({ command: name, category: 'test' }); }); MessageLoop.flush(); let content = palette.contentNode; let itemClass = '.lm-CommandPalette-item'; let items = () => content.querySelectorAll(itemClass); expect(items()).to.have.length(5); palette.inputNode.value = 'A'; palette.refresh(); MessageLoop.flush(); expect(items()).to.have.length(1); }); it('should filter by both text and category', () => { let categories = ['Z', 'Y']; let names = [ ['A1', 'B2', 'C3', 'D4', 'E5'], ['F1', 'G2', 'H3', 'I4', 'J5'] ]; names.forEach((values, index) => { values.forEach(command => { palette.addItem({ command, category: categories[index] }); commands.addCommand(command, { execute: () => {}, label: command }); }); }); MessageLoop.flush(); let headers = () => palette.node.querySelectorAll('.lm-CommandPalette-header'); let items = () => palette.node.querySelectorAll('.lm-CommandPalette-item'); let input = (value: string) => { palette.inputNode.value = value; palette.refresh(); MessageLoop.flush(); }; expect(items()).to.have.length(10); input(`${categories[1]}`); // Category match expect(items()).to.have.length(5); input(`${names[1][0]}`); // Label match expect(items()).to.have.length(1); input(`${categories[1]} B`); // No match expect(items()).to.have.length(0); input(`${categories[1]} I`); // Category and text match expect(items()).to.have.length(1); input('1'); // Multi-category match expect(headers()).to.have.length(2); expect(items()).to.have.length(2); }); }); }); describe('.Renderer', () => { let renderer = new CommandPalette.Renderer(); let item: CommandPalette.IItem = null!; let enabledFlag = true; let toggledFlag = false; beforeEach(() => { enabledFlag = true; toggledFlag = false; commands.addCommand('test', { label: 'Test Command', caption: 'A simple test command', className: 'testClass', isEnabled: () => enabledFlag, isToggled: () => toggledFlag, execute: () => {} }); commands.addKeyBinding({ command: 'test', keys: ['Ctrl A'], selector: 'body' }); item = palette.addItem({ command: 'test', category: 'Test Category' }); }); describe('#renderHeader()', () => { it('should render a header node for the palette', () => { let vNode = renderer.renderHeader({ category: 'Test Category', indices: null }); let node = VirtualDOM.realize(vNode); expect(node.classList.contains('lm-CommandPalette-header')).to.equal( true ); expect(node.innerHTML).to.equal('Test Category'); }); it('should mark the matching indices', () => { let vNode = renderer.renderHeader({ category: 'Test Category', indices: [1, 2, 6, 7, 8] }); let node = VirtualDOM.realize(vNode); expect(node.classList.contains('lm-CommandPalette-header')).to.equal( true ); expect(node.innerHTML).to.equal( 'Test Category' ); }); }); describe('#renderItem()', () => { it('should render an item node for the palette', () => { let vNode = renderer.renderItem({ item, indices: null, active: false }); let node = VirtualDOM.realize(vNode); expect(node.classList.contains('lm-CommandPalette-item')).to.equal( true ); expect(node.classList.contains('lm-mod-disabled')).to.equal(false); expect(node.classList.contains('lm-mod-toggled')).to.equal(false); expect(node.classList.contains('lm-mod-active')).to.equal(false); expect(node.classList.contains('testClass')).to.equal(true); expect(node.getAttribute('data-command')).to.equal('test'); expect( node.querySelector('.lm-CommandPalette-itemShortcut') ).to.not.equal(null); expect( node.querySelector('.lm-CommandPalette-itemLabel') ).to.not.equal(null); expect( node.querySelector('.lm-CommandPalette-itemCaption') ).to.not.equal(null); }); it('should handle the disabled item state', () => { enabledFlag = false; let vNode = renderer.renderItem({ item, indices: null, active: false }); let node = VirtualDOM.realize(vNode); expect(node.classList.contains('lm-mod-disabled')).to.equal(true); }); it('should handle the toggled item state', () => { toggledFlag = true; let vNode = renderer.renderItem({ item, indices: null, active: false }); let node = VirtualDOM.realize(vNode); expect(node.classList.contains('lm-mod-toggled')).to.equal(true); }); it('should handle the active state', () => { let vNode = renderer.renderItem({ item, indices: null, active: true }); let node = VirtualDOM.realize(vNode); expect(node.classList.contains('lm-mod-active')).to.equal(true); }); }); describe('#renderEmptyMessage()', () => { it('should render an empty message node for the palette', () => { let vNode = renderer.renderEmptyMessage({ query: 'foo' }); let node = VirtualDOM.realize(vNode); expect( node.classList.contains('lm-CommandPalette-emptyMessage') ).to.equal(true); expect(node.innerHTML).to.equal("No commands found that match 'foo'"); }); }); describe('#renderItemShortcut()', () => { it('should render an item shortcut node', () => { let vNode = renderer.renderItemShortcut({ item, indices: null, active: false }); let node = VirtualDOM.realize(vNode); expect( node.classList.contains('lm-CommandPalette-itemShortcut') ).to.equal(true); if (Platform.IS_MAC) { expect(node.innerHTML).to.equal('\u2303 A'); } else { expect(node.innerHTML).to.equal('Ctrl+A'); } }); }); describe('#renderItemLabel()', () => { it('should render an item label node', () => { let vNode = renderer.renderItemLabel({ item, indices: [1, 2, 3], active: false }); let node = VirtualDOM.realize(vNode); expect( node.classList.contains('lm-CommandPalette-itemLabel') ).to.equal(true); expect(node.innerHTML).to.equal('Test Command'); }); }); describe('#renderItemCaption()', () => { it('should render an item caption node', () => { let vNode = renderer.renderItemCaption({ item, indices: null, active: false }); let node = VirtualDOM.realize(vNode); expect( node.classList.contains('lm-CommandPalette-itemCaption') ).to.equal(true); expect(node.innerHTML).to.equal('A simple test command'); }); }); describe('#createItemClass()', () => { it('should create the full class name for the item node', () => { let name = renderer.createItemClass({ item, indices: null, active: false }); let expected = 'lm-CommandPalette-item testClass'; expect(name).to.equal(expected); }); it('should handle the boolean states', () => { enabledFlag = false; toggledFlag = true; let name = renderer.createItemClass({ item, indices: null, active: true }); let expected = 'lm-CommandPalette-item lm-mod-disabled lm-mod-toggled lm-mod-active testClass'; expect(name).to.equal(expected); }); }); describe('#createItemDataset()', () => { it('should create the item dataset', () => { let dataset = renderer.createItemDataset({ item, indices: null, active: false }); expect(dataset).to.deep.equal({ command: 'test' }); }); }); describe('#formatHeader()', () => { it('should format unmatched header content', () => { let child1 = renderer.formatHeader({ category: 'Test Category', indices: null }); let child2 = renderer.formatHeader({ category: 'Test Category', indices: [] }); expect(child1).to.equal('Test Category'); expect(child2).to.equal('Test Category'); }); it('should format matched header content', () => { let child = renderer.formatHeader({ category: 'Test Category', indices: [1, 2, 6, 7, 8] }); let node = VirtualDOM.realize(h.div(child)); expect(node.innerHTML).to.equal( 'Test Category' ); }); }); describe('#formatEmptyMessage()', () => { it('should format the empty message text', () => { let child = renderer.formatEmptyMessage({ query: 'foo' }); expect(child).to.equal("No commands found that match 'foo'"); }); }); describe('#formatItemShortcut()', () => { it('should format the item shortcut text', () => { let child = renderer.formatItemShortcut({ item, indices: null, active: false }); if (Platform.IS_MAC) { expect(child).to.equal('\u2303 A'); } else { expect(child).to.equal('Ctrl+A'); } }); }); describe('#formatItemLabel()', () => { it('should format unmatched label content', () => { let child1 = renderer.formatItemLabel({ item, indices: null, active: false }); let child2 = renderer.formatItemLabel({ item, indices: [], active: false }); expect(child1).to.equal('Test Command'); expect(child2).to.equal('Test Command'); }); it('should format matched label content', () => { let child = renderer.formatItemLabel({ item, indices: [1, 2, 3], active: false }); let node = VirtualDOM.realize(h.div(child)); expect(node.innerHTML).to.equal('Test Command'); }); }); describe('#formatItemCaption()', () => { it('should format the item caption text', () => { let child = renderer.formatItemCaption({ item, indices: null, active: false }); expect(child).to.equal('A simple test command'); }); }); }); }); });