647 lines
26 KiB
JavaScript
647 lines
26 KiB
JavaScript
/**
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; under version 2
|
|
* of the License (non-upgradable).
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* Copyright (c) 2015 (original work) Open Assessment Technologies SA ;
|
|
*/
|
|
/**
|
|
* @author Jean-Sébastien Conan <jean-sebastien.conan@vesperiagroup.com>
|
|
*/
|
|
define([
|
|
|
|
'jquery',
|
|
'lodash',
|
|
'taoQtiTest/testRunner/actionBar/button'
|
|
], function($, _, button) {
|
|
'use strict';
|
|
|
|
var buttons = [{
|
|
title: 'full button',
|
|
id: 'full',
|
|
testContext: {},
|
|
testRunner: {},
|
|
config: {
|
|
label: 'My button',
|
|
title: 'A test button',
|
|
icon: 'test',
|
|
order: 1
|
|
}
|
|
}, {
|
|
title: 'button with a single label',
|
|
id: 'btn',
|
|
testContext: {},
|
|
testRunner: {},
|
|
config: {
|
|
label: 'A button'
|
|
}
|
|
}, {
|
|
title: 'empty button',
|
|
id: 'empty',
|
|
testContext: {},
|
|
testRunner: {},
|
|
config: {}
|
|
}, {
|
|
title: 'button with menu (inferred type)',
|
|
id: 'menu',
|
|
testContext: {},
|
|
testRunner: {},
|
|
config: {
|
|
label: 'My menu',
|
|
title: 'A test menu',
|
|
icon: 'menu',
|
|
order: 2,
|
|
items: [{
|
|
id: 'entry-1',
|
|
label: 'Item 1',
|
|
title: 'Menu entry #1',
|
|
icon: 'style'
|
|
}, {
|
|
id: 'entry-2',
|
|
label: 'Item 2',
|
|
title: 'Menu entry #2',
|
|
icon: 'add'
|
|
}, {
|
|
id: 'entry-3',
|
|
label: 'Item 3',
|
|
title: 'Menu entry #3',
|
|
icon: 'remove'
|
|
}]
|
|
}
|
|
}, {
|
|
title: 'full button (specified type)',
|
|
id: 'full',
|
|
testContext: {},
|
|
testRunner: {},
|
|
config: {
|
|
type: 'button',
|
|
label: 'My button',
|
|
title: 'A test button',
|
|
icon: 'test',
|
|
order: 1
|
|
}
|
|
}, {
|
|
title: 'button with menu (specified type)',
|
|
id: 'menu',
|
|
testContext: {},
|
|
testRunner: {},
|
|
config: {
|
|
type: 'menu',
|
|
label: 'My menu',
|
|
title: 'A test menu',
|
|
icon: 'menu',
|
|
order: 2,
|
|
items: [{
|
|
id: 'entry-1',
|
|
label: 'Item 1',
|
|
title: 'Menu entry #1',
|
|
icon: 'style'
|
|
}, {
|
|
id: 'entry-2',
|
|
label: 'Item 2',
|
|
title: 'Menu entry #2',
|
|
icon: 'add'
|
|
}, {
|
|
id: 'entry-3',
|
|
label: 'Item 3',
|
|
title: 'Menu entry #3',
|
|
icon: 'remove'
|
|
}]
|
|
}
|
|
}, {
|
|
title: 'group of buttons',
|
|
id: 'group',
|
|
testContext: {},
|
|
testRunner: {},
|
|
config: {
|
|
type: 'group',
|
|
label: 'Unused label',
|
|
title: 'Unused title',
|
|
icon: 'unused icon',
|
|
order: 2,
|
|
items: [{
|
|
id: 'entry-1',
|
|
label: 'Item 1',
|
|
title: 'Menu entry #1',
|
|
icon: 'style'
|
|
}, {
|
|
id: 'entry-2',
|
|
label: 'Item 2',
|
|
title: 'Menu entry #2',
|
|
icon: 'add'
|
|
}, {
|
|
id: 'entry-3',
|
|
label: 'Item 3',
|
|
title: 'Menu entry #3',
|
|
icon: 'remove'
|
|
}]
|
|
}
|
|
}];
|
|
|
|
QUnit.module('button');
|
|
|
|
QUnit.test('module', function(assert) {
|
|
assert.equal(typeof button, 'function', 'The button module exposes a function');
|
|
assert.equal(typeof button(), 'object', 'The button factory produces an object');
|
|
assert.notStrictEqual(button(), button(), 'The button factory provides a different object on each call');
|
|
assert.strictEqual(button().init, button().init, 'The button factory provides a different object on each call, but the same methods');
|
|
|
|
var customInit = function() {};
|
|
var customFn = function() {};
|
|
var btn = button({
|
|
init: customInit,
|
|
myCustomFn: customFn
|
|
});
|
|
assert.notStrictEqual(btn.init, button().init, 'The button factory enable to overwrite methods and properties');
|
|
assert.strictEqual(btn.init, customInit, 'The button factory enable to overwrite methods and properties');
|
|
assert.strictEqual(btn.myCustomFn, customFn, 'The button factory enable to set custom methods and properties');
|
|
});
|
|
|
|
var buttonApi = [
|
|
{name: 'init', title: 'init'},
|
|
{name: 'clear', title: 'clear'},
|
|
{name: 'render', title: 'render'},
|
|
{name: 'bindTo', title: 'bindTo'},
|
|
{name: 'bindEvents', title: 'bindEvents'},
|
|
{name: 'unbindEvents', title: 'unbindEvents'},
|
|
{name: 'is', title: 'is'},
|
|
{name: 'getId', title: 'getId'},
|
|
{name: 'getLabel', title: 'getLabel'},
|
|
{name: 'isVisible', title: 'isVisible'},
|
|
{name: 'hasMenu', title: 'hasMenu'},
|
|
{name: 'isMenuOpen', title: 'isMenuOpen'},
|
|
{name: 'closeMenu', title: 'closeMenu'},
|
|
{name: 'openMenu', title: 'openMenu'},
|
|
{name: 'toggleMenu', title: 'toggleMenu'},
|
|
{name: 'setActive', title: 'setActive'},
|
|
{name: 'trigger', title: 'trigger'},
|
|
{name: 'on', title: 'on'},
|
|
{name: 'off', title: 'off'},
|
|
{name: 'setup', title: 'setup'},
|
|
{name: 'action', title: 'action'},
|
|
{name: 'menuAction', title: 'menuAction'},
|
|
{name: 'enable', title: 'enable'},
|
|
{name: 'disable', title: 'disable'},
|
|
{name: 'show', title: 'show'},
|
|
{name: 'hide', title: 'hide'}
|
|
];
|
|
|
|
QUnit
|
|
.cases.init(buttonApi)
|
|
.test('instance API ', function(data, assert) {
|
|
var instance = button();
|
|
assert.equal(typeof instance[data.name], 'function', 'The button instance exposes a "' + data.title + '" function');
|
|
});
|
|
|
|
QUnit
|
|
.cases.init(buttons)
|
|
.test('install', function(data, assert) {
|
|
var instance = button();
|
|
var $button;
|
|
var ret;
|
|
|
|
assert.equal(typeof instance, 'object', 'A button is an object');
|
|
|
|
ret = instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
assert.strictEqual(ret, instance, 'The init method must return the instance');
|
|
|
|
$button = instance.render();
|
|
|
|
assert.equal(typeof $button, 'object', 'The rendered content is an object');
|
|
assert.ok(!!$button.jquery, 'The rendered content is a jQuery selection');
|
|
assert.equal($button.length, 1, 'The rendered content is one DOM element');
|
|
|
|
if (instance.is('button')) {
|
|
assert.equal($button.data('control'), data.id, 'The button must have the right identifier');
|
|
assert.ok($button.hasClass('action-button'), 'The button must be a class of action-button');
|
|
}
|
|
|
|
if (data.config.label !== undefined) {
|
|
if (instance.is('button')) {
|
|
assert.equal($button.find('>a .label').text(), data.config.label, 'The label must be displayed');
|
|
|
|
if (!data.config.title) {
|
|
assert.equal($button.attr('title'), data.config.label, 'The title must be equal to the label');
|
|
}
|
|
} else {
|
|
assert.notEqual($button.find('.label').first().text(), data.config.label, 'No label must be displayed');
|
|
}
|
|
|
|
}
|
|
|
|
if (data.config.title !== undefined) {
|
|
if (instance.is('button')) {
|
|
assert.equal($button.attr('title'), data.config.title, 'The title must be set with the correct value');
|
|
} else {
|
|
assert.equal($button.attr('title'), undefined, 'The title must not be set');
|
|
}
|
|
}
|
|
|
|
if (data.config.order !== undefined) {
|
|
assert.equal($button.data('order'), data.config.order, 'The order data must be set with the correct value');
|
|
}
|
|
|
|
if (data.config.icon !== undefined && !instance.is('group')) {
|
|
assert.ok($button.find('>a .icon').hasClass('icon-' + data.config.icon), 'The icon must be set with the correct class');
|
|
}
|
|
|
|
if (data.config.items !== undefined) {
|
|
if (instance.is('menu')) {
|
|
assert.equal($button.find('.menu').length, 1, 'The button must contain a menu');
|
|
assert.equal($button.find('.menu-item').length, data.config.items.length, 'The button menu must contain the exact number of entries');
|
|
|
|
data.config.items.forEach(function(item) {
|
|
var $item = $button.find('[data-control="' + item.id + '"]');
|
|
assert.equal($item.length, 1, "The button menu must contain the entry " + item.id);
|
|
|
|
if (item.label !== undefined) {
|
|
assert.equal($item.find('>a .label').text(), item.label, 'The menu item label must be displayed');
|
|
|
|
if (!item.title) {
|
|
assert.equal($item.attr('title'), item.label, 'The menu item title must be equal to the label');
|
|
}
|
|
}
|
|
|
|
if (item.title !== undefined) {
|
|
assert.equal($item.attr('title'), item.title, 'The menu item title must be set with the correct value');
|
|
}
|
|
|
|
if (item.icon !== undefined) {
|
|
assert.ok($item.find('>a .icon').hasClass('icon-' + item.icon), 'The menu item icon must be set with the correct class');
|
|
}
|
|
});
|
|
}
|
|
|
|
if (instance.is('group')) {
|
|
assert.equal($button.find('.action-button').length, data.config.items.length, 'The buttons group must contain the exact number of entries');
|
|
|
|
data.config.items.forEach(function(btn) {
|
|
var $btn = $button.find('[data-control="' + btn.id + '"]');
|
|
assert.equal($btn.length, 1, "The group button must contain the entry " + btn.id);
|
|
|
|
if (btn.label !== undefined) {
|
|
assert.equal($btn.find('.label').text(), btn.label, 'The group button label must be displayed');
|
|
|
|
if (!btn.title) {
|
|
assert.equal($btn.attr('title'), btn.label, 'The group button title must be equal to the label');
|
|
}
|
|
}
|
|
|
|
if (btn.title !== undefined) {
|
|
assert.equal($btn.attr('title'), btn.title, 'The group button title must be set with the correct value');
|
|
}
|
|
|
|
if (btn.icon !== undefined) {
|
|
assert.ok($btn.find('.icon').hasClass('icon-' + btn.icon), 'The group button icon must be set with the correct class');
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
assert.equal($button.find('.menu').length, 0, 'The button must nost contain a menu');
|
|
assert.equal($button.find('.menu-item').length, 0, 'There is not button menu entries');
|
|
}
|
|
|
|
instance.clear();
|
|
});
|
|
|
|
QUnit.test('events [button]', function(assert) {
|
|
var ready1 = assert.async();
|
|
var ready = assert.async();
|
|
var instance = button();
|
|
var data = buttons[0];
|
|
var $container = $('#button-1');
|
|
var $button;
|
|
|
|
instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
$button = instance.render();
|
|
$container.append($button);
|
|
|
|
instance.action = function(id, $btn) {
|
|
assert.ok(true, 'The action method has been called');
|
|
assert.equal(id, data.id, 'The action method provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action method provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action method provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action method provide the right button element');
|
|
assert.equal($btn.data('control'), data.id, 'The action method provide the right button element');
|
|
ready();
|
|
};
|
|
|
|
instance.on('action', function(e, id, $btn, btn) {
|
|
assert.ok(true, 'The action event has been triggered');
|
|
assert.equal(id, data.id, 'The action event provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action event provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action event provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action event provide the right button element');
|
|
assert.equal($btn.data('control'), data.id, 'The action event provide the right button element');
|
|
assert.strictEqual(btn, instance, 'The action event provide the right button instance');
|
|
ready1();
|
|
});
|
|
|
|
assert.expect(13);
|
|
$button.click();
|
|
});
|
|
|
|
QUnit.test('events [menu]', function(assert) {
|
|
var ready3 = assert.async();
|
|
var ready2 = assert.async(3);
|
|
var ready1 = assert.async();
|
|
var ready = assert.async(3);
|
|
var instance = button();
|
|
var data = buttons[3];
|
|
var expectedMenuOpenState = false;
|
|
var expectedMenuConfig = data.config.items[0];
|
|
var $container = $('#button-2');
|
|
var $button;
|
|
var $menu;
|
|
var $menuItem;
|
|
|
|
assert.expect(66);
|
|
|
|
instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
$button = instance.render();
|
|
$menu = $button.find('.menu');
|
|
$container.append($button);
|
|
|
|
assert.equal($menu.length, 1, 'The button must contain a menu');
|
|
|
|
instance.action = function(id, $btn) {
|
|
assert.ok(true, 'The action method has been called');
|
|
assert.equal(id, data.id, 'The action method provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action method provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action method provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action method provide the right button element');
|
|
assert.equal($btn.data('control'), data.id, 'The action method provide the right button element');
|
|
ready();
|
|
};
|
|
|
|
instance.menuAction = function(id, $item) {
|
|
assert.ok(true, 'The menuAction method has been called');
|
|
assert.equal(id, expectedMenuConfig.id, 'The menuAction method provide the right button id');
|
|
assert.equal(typeof $item, 'object', 'The menuAction method provide a button element');
|
|
assert.ok(!!$item.jquery, 'The menuAction method provide a button element as a jQuery selection');
|
|
assert.ok($item.is('.menu-item'), 'The menuAction method provide the right button element');
|
|
assert.equal($item.data('control'), expectedMenuConfig.id, 'The menuAction method provide the right button element');
|
|
|
|
ready1();
|
|
};
|
|
|
|
instance.on('action', function(e, id, $btn, btn) {
|
|
assert.ok(true, 'The action event has been triggered');
|
|
assert.equal(id, data.id, 'The action event provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action event provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action event provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action event provide the right button element');
|
|
assert.equal($btn.data('control'), data.id, 'The action event provide the right button element');
|
|
assert.strictEqual(btn, instance, 'The action event provide the right button instance');
|
|
|
|
expectedMenuOpenState = !expectedMenuOpenState;
|
|
assert.equal(instance.isMenuOpen(), expectedMenuOpenState, 'The menu must be ' + (expectedMenuOpenState ? 'open' : 'closed'));
|
|
assert.equal($menu.hasClass('hidden'), !expectedMenuOpenState, 'The menu state must be ' + (expectedMenuOpenState ? 'open' : 'closed'));
|
|
assert.equal($button.hasClass('active'), expectedMenuOpenState, 'The button state must be ' + (expectedMenuOpenState ? 'active' : 'inactive'));
|
|
|
|
ready2();
|
|
});
|
|
|
|
instance.on('menuaction', function(e, id, $item, btn) {
|
|
assert.ok(true, 'The menuaction event has been triggered');
|
|
assert.equal(id, expectedMenuConfig.id, 'The menuaction event provide the right button id');
|
|
assert.equal(typeof $item, 'object', 'The menuaction event provide a button element');
|
|
assert.ok(!!$item.jquery, 'The menuaction event provide a button element as a jQuery selection');
|
|
assert.ok($item.is('.menu-item'), 'The menuaction event provide the right button element');
|
|
assert.equal($item.data('control'), expectedMenuConfig.id, 'The menuaction event provide the right button element');
|
|
|
|
expectedMenuOpenState = !expectedMenuOpenState;
|
|
assert.equal(instance.isMenuOpen(), expectedMenuOpenState, 'The menu must be ' + (expectedMenuOpenState ? 'open' : 'closed'));
|
|
assert.equal($menu.hasClass('hidden'), !expectedMenuOpenState, 'The menu state must be ' + (expectedMenuOpenState ? 'open' : 'closed'));
|
|
assert.equal($button.hasClass('active'), expectedMenuOpenState, 'The button state must be ' + (expectedMenuOpenState ? 'active' : 'inactive'));
|
|
|
|
ready3();
|
|
});
|
|
|
|
assert.equal(instance.isMenuOpen(), expectedMenuOpenState, 'The menu must be closed');
|
|
|
|
$button.click();
|
|
$button.click();
|
|
$button.click();
|
|
$menuItem = $menu.find('.action').first();
|
|
$menuItem.click();
|
|
|
|
assert.equal(instance.getActiveMenu(), expectedMenuConfig.id, 'The selected menu must the right one');
|
|
});
|
|
|
|
QUnit.test('events [group]', function(assert) {
|
|
var ready1 = assert.async();
|
|
var ready = assert.async();
|
|
|
|
var instance = button();
|
|
var data = buttons[6];
|
|
var expectedButtonConfig = data.config.items[1];
|
|
var $container = $('#button-3');
|
|
var $button;
|
|
|
|
instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
$button = instance.render();
|
|
$container.append($button);
|
|
|
|
instance.action = function(id, $btn) {
|
|
assert.ok(true, 'The action method has been called');
|
|
assert.equal(id, expectedButtonConfig.id, 'The action method provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action method provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action method provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action method provide the right button element');
|
|
assert.equal($btn.data('control'), expectedButtonConfig.id, 'The action method provide the right button element');
|
|
ready();
|
|
};
|
|
|
|
instance.on('action', function(e, id, $btn, btn) {
|
|
assert.ok(true, 'The action event has been triggered');
|
|
assert.equal(id, expectedButtonConfig.id, 'The action event provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action event provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action event provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action event provide the right button element');
|
|
assert.equal($btn.data('control'), expectedButtonConfig.id, 'The action event provide the right button element');
|
|
assert.strictEqual(btn, instance, 'The action event provide the right button instance');
|
|
ready1();
|
|
});
|
|
|
|
assert.expect(13);
|
|
$button.children().eq(1).click();
|
|
});
|
|
|
|
QUnit.test('menu selection', function(assert) {
|
|
var instance = button();
|
|
var data = buttons[3];
|
|
var expectedMenuConfig = data.config.items[0];
|
|
var expectedMenuId = 'entry-3';
|
|
var $container = $('#button-4');
|
|
var $button;
|
|
var $menu;
|
|
var $menuItem;
|
|
|
|
instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
$button = instance.render();
|
|
$menu = $button.find('.menu');
|
|
$container.append($button);
|
|
|
|
assert.equal($menu.length, 1, 'The button must contain a menu');
|
|
|
|
$menuItem = $menu.find('.action').first();
|
|
$menuItem.click();
|
|
|
|
assert.equal(instance.getActiveMenu(), expectedMenuConfig.id, 'The selected menu must the right one');
|
|
|
|
instance.setActiveMenu(expectedMenuId);
|
|
|
|
assert.equal(instance.getActiveMenu(), expectedMenuId, 'The new selected menu must the right one');
|
|
|
|
instance.clearActiveMenu();
|
|
|
|
assert.strictEqual(instance.getActiveMenu(), null, 'The menu selection must cleared');
|
|
});
|
|
|
|
QUnit.test('group selection', function(assert) {
|
|
var instance = button();
|
|
var data = buttons[6];
|
|
var expectedMenuConfig = data.config.items[1];
|
|
var $container = $('#button-5');
|
|
var $button;
|
|
var $btn;
|
|
|
|
instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
$button = instance.render();
|
|
$container.append($button);
|
|
|
|
assert.equal($button.find('.action-button').length, data.config.items.length, 'The buttons group must contain the exact number of entries');
|
|
|
|
$btn = $button.find('.action-button').eq(1);
|
|
|
|
assert.ok(!$btn.hasClass('active'), 'The button must not be selected');
|
|
assert.equal($button.find('.active').length, 0, 'The number of active buttons must be 0');
|
|
|
|
instance.setActive(true, expectedMenuConfig.id);
|
|
|
|
assert.ok($btn.hasClass('active'), 'The button must be selected');
|
|
assert.equal($button.find('.active').length, 1, 'The number of active buttons must be 1');
|
|
|
|
instance.setActive(false, expectedMenuConfig.id);
|
|
|
|
assert.ok(!$btn.hasClass('active'), 'The button must not be selected');
|
|
assert.equal($button.find('.active').length, 0, 'The number of active buttons must be 0');
|
|
|
|
});
|
|
|
|
QUnit.test('enable/disable', function(assert) {
|
|
var ready1 = assert.async(2);
|
|
var ready = assert.async(2);
|
|
var instance = button();
|
|
var data = buttons[0];
|
|
var $container = $('#button-6');
|
|
var $button;
|
|
var actionEnabled = true;
|
|
var callCount = 0;
|
|
|
|
instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
$button = instance.render();
|
|
$container.append($button);
|
|
|
|
instance.action = function(id, $btn) {
|
|
callCount++;
|
|
|
|
assert.equal(true, actionEnabled, 'The action method has been called');
|
|
assert.equal(id, data.id, 'The action method provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action method provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action method provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action method provide the right button element');
|
|
assert.equal($btn.data('control'), data.id, 'The action method provide the right button element');
|
|
ready();
|
|
};
|
|
|
|
instance.on('action', function(e, id, $btn, btn) {
|
|
callCount++;
|
|
|
|
assert.equal(true, actionEnabled, 'The action event has been triggered');
|
|
assert.equal(id, data.id, 'The action event provide the right button id');
|
|
assert.equal(typeof $btn, 'object', 'The action event provide a button element');
|
|
assert.ok(!!$btn.jquery, 'The action event provide a button element as a jQuery selection');
|
|
assert.ok($btn.is('.action-button'), 'The action event provide the right button element');
|
|
assert.equal($btn.data('control'), data.id, 'The action event provide the right button element');
|
|
assert.strictEqual(btn, instance, 'The action event provide the right button instance');
|
|
ready1();
|
|
});
|
|
|
|
assert.expect(32);
|
|
|
|
assert.ok(!$button.hasClass('disabled'), 'This button is enabled');
|
|
|
|
$button.click();
|
|
|
|
assert.equal(callCount, 2, 'Action can be called when button is enabled');
|
|
|
|
instance.disable();
|
|
actionEnabled = false;
|
|
|
|
assert.ok($button.hasClass('disabled'), 'This button is disabled');
|
|
|
|
$button.click();
|
|
|
|
assert.equal(callCount, 2, 'No action called when button is disabled');
|
|
|
|
instance.enable();
|
|
actionEnabled = true;
|
|
|
|
assert.ok(!$button.hasClass('disabled'), 'This button is enabled');
|
|
|
|
$button.click();
|
|
|
|
assert.equal(callCount, 4, 'Action can be called when button is enabled');
|
|
});
|
|
|
|
QUnit.test('show/hide', function(assert) {
|
|
var ready = assert.async();
|
|
var instance = button();
|
|
var data = buttons[0];
|
|
var $container = $('#button-7');
|
|
var $button;
|
|
|
|
instance.init(data.id, data.config, data.testContext, data.testRunner);
|
|
|
|
$button = instance.render();
|
|
$container.append($button);
|
|
|
|
assert.equal($button.length, 1, 'the button exists');
|
|
assert.notEqual($button.css('display'), 'none', 'the button is displayed');
|
|
|
|
instance.hide();
|
|
|
|
_.defer(function() {
|
|
assert.equal($button.css('display'), 'none', 'the button is hidden');
|
|
|
|
instance.show();
|
|
|
|
_.defer(function() {
|
|
assert.notEqual($button.css('display'), 'none', 'the button is back');
|
|
|
|
ready();
|
|
});
|
|
});
|
|
});
|
|
|
|
});
|