assert.expect(2)
var $el = $('<div/>')
var $alert = $el.bootstrapAlert()
- assert.ok($alert instanceof $, 'returns jquery collection')
+ assert.true($alert instanceof $, 'returns jquery collection')
assert.strictEqual($alert[0], $el[0], 'collection contains element')
})
$alert.find('.close').trigger('click')
- assert.strictEqual($alert.hasClass('show'), false, 'remove .show class on .close click')
+ assert.false($alert.hasClass('show'), 'remove .show class on .close click')
})
QUnit.test('should remove element when clicking .close', function (assert) {
var $el = $('<div/>')
var $alert = $el.bootstrapAlert()
- assert.ok(typeof $alert.data('bs.alert') !== 'undefined')
+ assert.notStrictEqual(typeof $alert.data('bs.alert'), 'undefined')
$alert.data('bs.alert').dispose()
- assert.ok(typeof $alert.data('bs.button') === 'undefined')
+ assert.strictEqual(typeof $alert.data('bs.button'), 'undefined')
})
QUnit.test('should return alert version', function (assert) {
assert.expect(1)
if (typeof Alert !== 'undefined') {
- assert.ok(typeof Alert.VERSION === 'string')
+ assert.strictEqual(typeof Alert.VERSION, 'string')
} else {
assert.notOk()
}
assert.expect(2)
var $el = $('<div/>')
var $button = $el.bootstrapButton()
- assert.ok($button instanceof $, 'returns jquery collection')
+ assert.true($button instanceof $, 'returns jquery collection')
assert.strictEqual($button[0], $el[0], 'collection contains element')
})
QUnit.test('should toggle active', function (assert) {
assert.expect(2)
var $btn = $('<button class="btn" data-toggle="button">mdo</button>')
- assert.ok(!$btn.hasClass('active'), 'btn does not have active class')
+ assert.false($btn.hasClass('active'), 'btn does not have active class')
$btn.bootstrapButton('toggle')
- assert.ok($btn.hasClass('active'), 'btn has class active')
+ assert.true($btn.hasClass('active'), 'btn has class active')
})
QUnit.test('should toggle active when btn children are clicked', function (assert) {
$btn
.append($inner)
.appendTo('#qunit-fixture')
- assert.ok(!$btn.hasClass('active'), 'btn does not have active class')
+ assert.false($btn.hasClass('active'), 'btn does not have active class')
$inner.trigger('click')
- assert.ok($btn.hasClass('active'), 'btn has class active')
+ assert.true($btn.hasClass('active'), 'btn has class active')
})
QUnit.test('should toggle aria-pressed', function (assert) {
$btn.appendTo('#qunit-fixture')
$(window).trigger($.Event('load'))
setTimeout(function () {
- assert.ok($btn.hasClass('active'), 'button with aria-pressed="true" has been given class active')
+ assert.true($btn.hasClass('active'), 'button with aria-pressed="true" has been given class active')
done()
}, 5)
})
$(window).trigger($.Event('load'))
setTimeout(function () {
- assert.ok($btn.hasClass('active'), 'checked checkbox button has been given class active')
+ assert.true($btn.hasClass('active'), 'checked checkbox button has been given class active')
done()
}, 5)
})
$btn.appendTo('#qunit-fixture')
$(window).trigger($.Event('load'))
setTimeout(function () {
- assert.ok(!$btn.hasClass('active'), 'button without aria-pressed="true" has had active class removed')
+ assert.false($btn.hasClass('active'), 'button without aria-pressed="true" has had active class removed')
done()
}, 5)
})
$(window).trigger($.Event('load'))
setTimeout(function () {
- assert.ok(!$btn.hasClass('active'), 'unchecked checkbox button has had active class removed')
+ assert.false($btn.hasClass('active'), 'unchecked checkbox button has had active class removed')
done()
}, 5)
})
})
setTimeout(function () {
- assert.ok(countChangeEvent === 1, 'onchange event fired only once')
+ assert.strictEqual(countChangeEvent, 1, 'onchange event fired only once')
done()
}, 5)
var $btn1 = $group.children().eq(0)
var $btn2 = $group.children().eq(1)
- assert.ok($btn1.hasClass('active'), 'btn1 has active class')
- assert.ok($btn1.find('input').prop('checked'), 'btn1 is checked')
- assert.ok(!$btn2.hasClass('active'), 'btn2 does not have active class')
- assert.ok(!$btn2.find('input').prop('checked'), 'btn2 is not checked')
+ assert.true($btn1.hasClass('active'), 'btn1 has active class')
+ assert.true($btn1.find('input').prop('checked'), 'btn1 is checked')
+ assert.false($btn2.hasClass('active'), 'btn2 does not have active class')
+ assert.false($btn2.find('input').prop('checked'), 'btn2 is not checked')
$btn2.find('input').trigger('click')
- assert.ok(!$btn1.hasClass('active'), 'btn1 does not have active class')
- assert.ok(!$btn1.find('input').prop('checked'), 'btn1 is not checked')
- assert.ok($btn2.hasClass('active'), 'btn2 has active class')
- assert.ok($btn2.find('input').prop('checked'), 'btn2 is checked')
+ assert.false($btn1.hasClass('active'), 'btn1 does not have active class')
+ assert.false($btn1.find('input').prop('checked'), 'btn1 is not checked')
+ assert.true($btn2.hasClass('active'), 'btn2 has active class')
+ assert.true($btn2.find('input').prop('checked'), 'btn2 is checked')
$btn2.find('input').trigger('click') // Clicking an already checked radio should not un-check it
- assert.ok(!$btn1.hasClass('active'), 'btn1 does not have active class')
- assert.ok(!$btn1.find('input').prop('checked'), 'btn1 is not checked')
- assert.ok($btn2.hasClass('active'), 'btn2 has active class')
- assert.ok($btn2.find('input').prop('checked'), 'btn2 is checked')
+ assert.false($btn1.hasClass('active'), 'btn1 does not have active class')
+ assert.false($btn1.find('input').prop('checked'), 'btn1 is not checked')
+ assert.true($btn2.hasClass('active'), 'btn2 has active class')
+ assert.true($btn2.find('input').prop('checked'), 'btn2 is checked')
$btn1.bootstrapButton('toggle')
- assert.ok($btn1.hasClass('active'), 'btn1 has active class')
- assert.ok($btn1.find('input').prop('checked'), 'btn1 prop is checked')
- assert.ok($btn1.find('input')[0].checked, 'btn1 is checked with jquery')
- assert.ok(!$btn2.hasClass('active'), 'btn2 does not have active class')
- assert.ok(!$btn2.find('input').prop('checked'), 'btn2 is not checked')
- assert.ok(!$btn2.find('input')[0].checked, 'btn2 is not checked')
+ assert.true($btn1.hasClass('active'), 'btn1 has active class')
+ assert.true($btn1.find('input').prop('checked'), 'btn1 prop is checked')
+ assert.true($btn1.find('input')[0].checked, 'btn1 is checked with jquery')
+ assert.false($btn2.hasClass('active'), 'btn2 does not have active class')
+ assert.false($btn2.find('input').prop('checked'), 'btn2 is not checked')
+ assert.false($btn2.find('input')[0].checked, 'btn2 is not checked')
})
QUnit.test('should fire click event on input', function (assert) {
var $btn2 = $group.children().eq(1)
$btn1.find('input').trigger('click')
- assert.ok($btn1.is(':not([aria-pressed])'), 'label for nested checkbox input has not been given an aria-pressed attribute')
+ assert.true($btn1.is(':not([aria-pressed])'), 'label for nested checkbox input has not been given an aria-pressed attribute')
$btn2.find('input').trigger('click')
- assert.ok($btn2.is(':not([aria-pressed])'), 'label for nested radio input has not been given an aria-pressed attribute')
+ assert.true($btn2.is(':not([aria-pressed])'), 'label for nested radio input has not been given an aria-pressed attribute')
})
QUnit.test('should handle disabled attribute on non-button elements', function (assert) {
var $btn = $group.children().eq(0)
var $input = $btn.children().eq(0)
- assert.ok($btn.is(':not(.active)'), 'button is initially not active')
- assert.ok(!$input.prop('checked'), 'checkbox is initially not checked')
+ assert.true($btn.is(':not(.active)'), 'button is initially not active')
+ assert.false($input.prop('checked'), 'checkbox is initially not checked')
$btn[0].click() // fire a real click on the DOM node itself, not a click() on the jQuery object that just aliases to trigger('click')
- assert.ok($btn.is(':not(.active)'), 'button did not become active')
- assert.ok(!$input.prop('checked'), 'checkbox did not get checked')
+ assert.true($btn.is(':not(.active)'), 'button did not become active')
+ assert.false($input.prop('checked'), 'checkbox did not get checked')
})
QUnit.test('should not set active class if inner hidden checkbox is disabled but author forgot to set disabled class on outer button', function (assert) {
var $btn = $group.children().eq(0)
var $input = $btn.children().eq(0)
- assert.ok($btn.is(':not(.active)'), 'button is initially not active')
- assert.ok(!$input.prop('checked'), 'checkbox is initially not checked')
+ assert.true($btn.is(':not(.active)'), 'button is initially not active')
+ assert.false($input.prop('checked'), 'checkbox is initially not checked')
$btn[0].click() // fire a real click on the DOM node itself, not a click() on the jQuery object that just aliases to trigger('click')
- assert.ok($btn.is(':not(.active)'), 'button did not become active')
- assert.ok(!$input.prop('checked'), 'checkbox did not get checked')
+ assert.true($btn.is(':not(.active)'), 'button did not become active')
+ assert.false($input.prop('checked'), 'checkbox did not get checked')
})
QUnit.test('should correctly set checked state on input and active class on label when using <label><input></label> structure', function (assert) {
var $label = $group.children().eq(0)
var $input = $label.children().eq(0)
- assert.ok($label.is(':not(.active)'), 'label is initially not active')
- assert.ok(!$input.prop('checked'), 'checkbox is initially not checked')
+ assert.true($label.is(':not(.active)'), 'label is initially not active')
+ assert.false($input.prop('checked'), 'checkbox is initially not checked')
$label[0].click() // fire a real click on the DOM node itself, not a click() on the jQuery object that just aliases to trigger('click')
- assert.ok($label.is('.active'), 'label is active after click')
- assert.ok($input.prop('checked'), 'checkbox is checked after click')
+ assert.true($label.is('.active'), 'label is active after click')
+ assert.true($input.prop('checked'), 'checkbox is checked after click')
})
QUnit.test('should correctly set checked state on input and active class on the faked button when using <div><input></div> structure', function (assert) {
var $btn = $group.children().eq(0)
var $input = $btn.children().eq(0)
- assert.
ok($btn.is(':not(.active)'), '<div> is initially not active')
- assert.ok(!$input.prop('checked'), 'checkbox is initially not checked')
+ assert.
true($btn.is(':not(.active)'), '<div> is initially not active')
+ assert.false($input.prop('checked'), 'checkbox is initially not checked')
$btn[0].click() // fire a real click on the DOM node itself, not a click() on the jQuery object that just aliases to trigger('click')
- assert.
ok($btn.is('.active'), '<div> is active after click')
- assert.ok($input.prop('checked'), 'checkbox is checked after click')
+ assert.
true($btn.is('.active'), '<div> is active after click')
+ assert.true($input.prop('checked'), 'checkbox is checked after click')
})
QUnit.test('should correctly set checked state on input and active class on the label when using button toggle', function (assert) {
var $btn = $group.children().eq(0)
var $input = $btn.children().eq(0)
- assert.ok($btn.is(':not(.active)'), '<label> is initially not active')
- assert.ok(!$input.prop('checked'), 'checkbox property is initially not checked')
- assert.ok(!$input[0].checked, 'checkbox is not checked by jquery after click')
+ assert.true($btn.is(':not(.active)'), '<label> is initially not active')
+ assert.false($input.prop('checked'), 'checkbox property is initially not checked')
+ assert.false($input[0].checked, 'checkbox is not checked by jquery after click')
$btn.bootstrapButton('toggle')
- assert.ok($btn.is('.active'), '<label> is active after click')
- assert.ok($input.prop('checked'), 'checkbox property is checked after click')
- assert.ok($input[0].checked, 'checkbox is checked by jquery after click')
+ assert.true($btn.is('.active'), '<label> is active after click')
+ assert.true($input.prop('checked'), 'checkbox property is checked after click')
+ assert.true($input[0].checked, 'checkbox is checked by jquery after click')
})
QUnit.test('should not do anything if the click was just sent to the outer container with data-toggle', function (assert) {
var $label = $group.children().eq(0)
var $input = $label.children().eq(0)
- assert.ok($label.is(':not(.active)'), 'label is initially not active')
- assert.ok(!$input.prop('checked'), 'checkbox is initially not checked')
+ assert.true($label.is(':not(.active)'), 'label is initially not active')
+ assert.false($input.prop('checked'), 'checkbox is initially not checked')
$group[0].click() // fire a real click on the DOM node itself, not a click() on the jQuery object that just aliases to trigger('click')
- assert.ok($label.is(':not(.active)'), 'label is not active after click')
- assert.ok(!$input.prop('checked'), 'checkbox is not checked after click')
+ assert.true($label.is(':not(.active)'), 'label is not active after click')
+ assert.false($input.prop('checked'), 'checkbox is not checked after click')
})
QUnit.test('should not try and set checked property on an input of type="hidden"', function (assert) {
var $label = $group.children().eq(0)
var $input = $label.children().eq(0)
- assert.ok(!$input.prop('checked'), 'hidden input initially has no checked property')
+ assert.false($input.prop('checked'), 'hidden input initially has no checked property')
$label[0].click() // fire a real click on the DOM node itself, not a click() on the jQuery object that just aliases to trigger('click')
- assert.ok(!$input.prop('checked'), 'hidden input does not have a checked property')
+ assert.false($input.prop('checked'), 'hidden input does not have a checked property')
})
QUnit.test('should not try and set checked property on an input that is not a radio button or checkbox', function (assert) {
var $label = $group.children().eq(0)
var $input = $label.children().eq(0)
- assert.ok(!$input.prop('checked'), 'text input initially has no checked property')
+ assert.false($input.prop('checked'), 'text input initially has no checked property')
$label[0].click() // fire a real click on the DOM node itself, not a click() on the jQuery object that just aliases to trigger('click')
- assert.ok(!$input.prop('checked'), 'text input does not have a checked property')
+ assert.false($input.prop('checked'), 'text input does not have a checked property')
})
QUnit.test('dispose should remove data and the element', function (assert) {
var $el = $('<div/>')
var $button = $el.bootstrapButton()
- assert.ok(typeof $button.data('bs.button') !== 'undefined')
+ assert.notStrictEqual(typeof $button.data('bs.button'), 'undefined')
$button.data('bs.button').dispose()
- assert.ok(typeof $button.data('bs.button') === 'undefined')
+ assert.strictEqual(typeof $button.data('bs.button'), 'undefined')
})
QUnit.test('should return button version', function (assert) {
assert.expect(1)
if (typeof Button !== 'undefined') {
- assert.ok(typeof Button.VERSION === 'string')
+ assert.strictEqual(typeof Button.VERSION, 'string')
} else {
assert.notOk()
}
var defaultConfig = Carousel.Default
- assert.strictEqual(defaultConfig.touch, true)
+ assert.true(defaultConfig.touch)
})
QUnit.test('should throw explicit error on undefined method', function (assert) {
assert.expect(2)
var $el = $('<div/>')
var $carousel = $el.bootstrapCarousel()
- assert.ok($carousel instanceof $, 'returns jquery collection')
+ assert.true($carousel instanceof $, 'returns jquery collection')
assert.strictEqual($carousel[0], $el[0], 'collection contains element')
})
message = error.message
}
- assert.ok(message === expectedMessage, 'correct error message')
+ assert.strictEqual(message, expectedMessage, 'correct error message')
config = {
keyboard: document.createElement('div')
message = error.message
}
- assert.ok(message === expectedMessage, 'correct error message')
+ assert.strictEqual(message, expectedMessage, 'correct error message')
})
QUnit.test('should not fire slid when slide is prevented', function (assert) {
.one('slide.bs.carousel', function (e) {
e.preventDefault()
setTimeout(function () {
- assert.ok($carousel.find('.carousel-item:nth-child(1)').is('.active'), 'first item still active')
- assert.ok($carousel.find('.carousel-indicators li:nth-child(1)').is('.active'), 'first indicator still active')
+ assert.true($carousel.find('.carousel-item:nth-child(1)').is('.active'), 'first item still active')
+ assert.true($carousel.find('.carousel-indicators li:nth-child(1)').is('.active'), 'first indicator still active')
$carousel.bootstrapCarousel('next')
}, 0)
})
.one('slid.bs.carousel', function () {
setTimeout(function () {
- assert.ok(!$carousel.find('.carousel-item:nth-child(1)').is('.active'), 'first item still active')
- assert.ok(!$carousel.find('.carousel-indicators li:nth-child(1)').is('.active'), 'first indicator still active')
- assert.ok($carousel.find('.carousel-item:nth-child(2)').is('.active'), 'second item active')
- assert.ok($carousel.find('.carousel-indicators li:nth-child(2)').is('.active'), 'second indicator active')
+ assert.false($carousel.find('.carousel-item:nth-child(1)').is('.active'), 'first item still active')
+ assert.false($carousel.find('.carousel-indicators li:nth-child(1)').is('.active'), 'first indicator still active')
+ assert.true($carousel.find('.carousel-item:nth-child(2)').is('.active'), 'second item active')
+ assert.true($carousel.find('.carousel-indicators li:nth-child(2)').is('.active'), 'second indicator active')
done()
}, 0)
})
$carousel
.one('slide.bs.carousel', function (e) {
- assert.ok(e.direction, 'direction present on next')
+ assert.notStrictEqual(e.direction, 'undefined', 'direction present on next')
assert.strictEqual(e.direction, 'left', 'direction is left on next')
$carousel
.one('slide.bs.carousel', function (e) {
- assert.ok(e.direction, 'direction present on prev')
+ assert.notStrictEqual(e.direction, 'undefined', 'direction present on prev')
assert.strictEqual(e.direction, 'right', 'direction is right on prev')
done()
})
$carousel
.one('slid.bs.carousel', function (e) {
- assert.ok(e.direction, 'direction present on next')
+ assert.notStrictEqual(e.direction, 'undefined', 'direction present on next')
assert.strictEqual(e.direction, 'left', 'direction is left on next')
$carousel
.one('slid.bs.carousel', function (e) {
- assert.ok(e.direction, 'direction present on prev')
+ assert.notStrictEqual(e.direction, 'undefined', 'direction present on prev')
assert.strictEqual(e.direction, 'right', 'direction is right on prev')
done()
})
$(template)
.on('slide.bs.carousel', function (e) {
- assert.ok(e.relatedTarget, 'relatedTarget present')
- assert.ok($(e.relatedTarget).hasClass('carousel-item'), 'relatedTarget has class "item"')
+ assert.notStrictEqual(e.relatedTarget, 'undefined', 'relatedTarget present')
+ assert.true($(e.relatedTarget).hasClass('carousel-item'), 'relatedTarget has class "item"')
done()
})
.bootstrapCarousel('next')
$(template)
.on('slid.bs.carousel', function (e) {
- assert.ok(e.relatedTarget, 'relatedTarget present')
- assert.ok($(e.relatedTarget).hasClass('carousel-item'), 'relatedTarget has class "item"')
+ assert.notStrictEqual(e.relatedTarget, 'undefined', 'relatedTarget present')
+ assert.true($(e.relatedTarget).hasClass('carousel-item'), 'relatedTarget has class "item"')
done()
})
.bootstrapCarousel('next')
var done = assert.async()
$(template)
.on('slid.bs.carousel', function (e) {
- assert.ok(typeof e.from !== 'undefined', 'from present')
- assert.ok(typeof e.to !== 'undefined', 'to present')
+ assert.notStrictEqual(typeof e.from, 'undefined', 'from present')
+ assert.notStrictEqual(typeof e.to, 'undefined', 'to present')
$(this).off()
done()
})
.on('slide.bs.carousel', function (e) {
- assert.ok(typeof e.from !== 'undefined', 'from present')
- assert.ok(typeof e.to !== 'undefined', 'to present')
+ assert.notStrictEqual(typeof e.from, 'undefined', 'from present')
+ assert.notStrictEqual(typeof e.to, 'undefined', 'to present')
$(this).off('slide.bs.carousel')
})
.bootstrapCarousel('next')
$carousel.attr('data-interval', false)
$carousel.appendTo('body')
$carousel.bootstrapCarousel(1)
- assert.strictEqual($carousel.data('bs.carousel')._config.interval, false, 'data attribute has higher priority than default options')
+ assert.false($carousel.data('bs.carousel')._config.interval, 'data attribute has higher priority than default options')
$carousel.remove()
})
})
$template.one('keydown', function (event) {
- assert.strictEqual(event.isDefaultPrevented(), false)
+ assert.false(event.isDefaultPrevented())
})
$template.trigger(eventArrowDown)
$template.one('keydown', function (event) {
- assert.strictEqual(event.isDefaultPrevented(), false)
+ assert.false(event.isDefaultPrevented())
done()
})
which: 65
}) // 65 for "a"
$inputText.on('keydown', function (event) {
- assert.strictEqual(event.isDefaultPrevented(), false)
+ assert.false(event.isDefaultPrevented())
})
$inputText.trigger(eventKeyDown)
$textArea.on('keydown', function (event) {
- assert.strictEqual(event.isDefaultPrevented(), false)
+ assert.false(event.isDefaultPrevented())
done()
})
$textArea.trigger(eventKeyDown)
var $firstItem = $('#firstItem')
setTimeout(function () {
- assert.ok($firstItem.hasClass('active'))
+ assert.true($firstItem.hasClass('active'))
$html
.bootstrapCarousel('dispose')
.attr('style', 'visibility: hidden;')
.bootstrapCarousel()
setTimeout(function () {
- assert.ok($firstItem.hasClass('active'))
+ assert.true($firstItem.hasClass('active'))
done()
}, 80)
}, 80)
var $firstItem = $('#firstItem')
setTimeout(function () {
- assert.ok($firstItem.hasClass('active'))
+ assert.true($firstItem.hasClass('active'))
$carousel.bootstrapCarousel('dispose')
$parent.attr('style', 'visibility: hidden;')
$carousel.bootstrapCarousel()
setTimeout(function () {
- assert.ok($firstItem.hasClass('active'))
+ assert.true($firstItem.hasClass('active'))
done()
}, 80)
}, 80)
$carousel.one('slid.bs.carousel', function () {
assert.ok(true, 'slid event fired')
- assert.ok($item.hasClass('active'))
- assert.ok(spy.called)
+ assert.true($item.hasClass('active'))
+ assert.true(spy.called)
$styles.remove()
delete document.documentElement.ontouchstart
done()
$carousel.one('slid.bs.carousel', function () {
assert.ok(true, 'slid event fired')
- assert.ok($item.hasClass('active'))
- assert.ok(spy.called)
+ assert.true($item.hasClass('active'))
+ assert.true(spy.called)
delete document.documentElement.ontouchstart
restorePointerEvents()
done()
$carousel.one('slid.bs.carousel', function () {
assert.ok(true, 'slid event fired')
- assert.ok(!$item.hasClass('active'))
- assert.ok(spy.called)
+ assert.false($item.hasClass('active'))
+ assert.true(spy.called)
assert.strictEqual(carousel.touchDeltaX, 0)
$styles.remove()
delete document.documentElement.ontouchstart
$carousel.one('slid.bs.carousel', function () {
assert.ok(true, 'slid event fired')
- assert.ok(!$item.hasClass('active'))
- assert.ok(spy.called)
+ assert.false($item.hasClass('active'))
+ assert.true(spy.called)
assert.strictEqual(carousel.touchDeltaX, 0)
restorePointerEvents()
delete document.documentElement.ontouchstart
carousel.next()
- assert.strictEqual(spy.called, false)
+ assert.false(spy.called)
})
QUnit.test('should call next when the page is visible', function (assert) {
carousel.nextWhenVisible()
- assert.strictEqual(spy.called, true)
+ assert.true(spy.called)
sandbox.restore()
})
$carousel.appendTo('#qunit-fixture')
$carousel.bootstrapCarousel()
- assert.strictEqual(spy.called, false)
+ assert.false(spy.called)
spy.restore()
})
$carousel.appendTo('#qunit-fixture')
$carousel.bootstrapCarousel()
- assert.strictEqual(spy.called, true)
+ assert.true(spy.called)
spy.restore()
})
$(window).trigger($.Event('load'))
setTimeout(function () {
- assert.strictEqual(spy.called, true)
+ assert.true(spy.called)
spy.restore()
done()
}, 5)
$carousel.appendTo('#qunit-fixture')
$carousel.bootstrapCarousel()
- assert.strictEqual(spy.called, false)
+ assert.false(spy.called)
spy.restore()
})
})
assert.expect(2)
var $el = $('<div/>')
var $collapse = $el.bootstrapCollapse()
- assert.ok($collapse instanceof $, 'returns jquery collection')
+ assert.true($collapse instanceof $, 'returns jquery collection')
assert.strictEqual($collapse[0], $el[0], 'collection contains element')
})
var $el = $('<div class="collapse"/>')
$el.one('shown.bs.collapse', function () {
- assert.ok($el.hasClass('show'), 'has class "show"')
- assert.ok(!/height/i.test($el.attr('style')), 'has height reset')
+ assert.true($el.hasClass('show'), 'has class "show"')
+ assert.false(/height/i.test($el.attr('style')), 'has height reset')
done()
}).bootstrapCollapse('show')
})
var $el = $('<div class="collapse multi"/>').appendTo('#qunit-fixture')
var $el2 = $('<div class="collapse multi"/>').appendTo('#qunit-fixture')
$el.one('shown.bs.collapse', function () {
- assert.ok($el.hasClass('show'), 'has class "show"')
- assert.ok(!/height/i.test($el.attr('style')), 'has height reset')
+ assert.true($el.hasClass('show'), 'has class "show"')
+ assert.false(/height/i.test($el.attr('style')), 'has height reset')
})
$el2.one('shown.bs.collapse', function () {
- assert.ok($el2.hasClass('show'), 'has class "show"')
- assert.ok(!/height/i.test($el2.attr('style')), 'has height reset')
+ assert.true($el2.hasClass('show'), 'has class "show"')
+ assert.false(/height/i.test($el2.attr('style')), 'has height reset')
done()
})
$target.trigger('click')
var $el1 = $('#collapse1')
var $el2 = $('#collapse2')
$el1.one('shown.bs.collapse', function () {
- assert.ok($el1.hasClass('show'))
- assert.ok($el2.hasClass('show'))
+ assert.true($el1.hasClass('show'))
+ assert.true($el2.hasClass('show'))
done()
}).bootstrapCollapse('show')
})
assert.expect(1)
var $el = $('<div class="collapse"/>').bootstrapCollapse('hide')
- assert.ok(!$el.hasClass('show'), 'does not have class "show"')
+ assert.false($el.hasClass('show'), 'does not have class "show"')
})
QUnit.test('should not fire shown when show is prevented', function (assert) {
$('<div id="test1"/>')
.appendTo('#qunit-fixture')
.on('shown.bs.collapse', function () {
- assert.ok(!$target.hasClass('collapsed'), 'target does not have collapsed class')
+ assert.false($target.hasClass('collapsed'), 'target does not have collapsed class')
done()
})
$('<div id="test1" class="show"/>')
.appendTo('#qunit-fixture')
.on('hidden.bs.collapse', function () {
- assert.ok($target.hasClass('collapsed'), 'target has collapsed class')
+ assert.true($target.hasClass('collapsed'), 'target has collapsed class')
done()
})
$('<div id="test1"/>')
.appendTo('#qunit-fixture')
.on('shown.bs.collapse', function () {
- assert.ok(!$target.hasClass('collapsed'), 'target trigger does not have collapsed class')
- assert.ok(!$alt.hasClass('collapsed'), 'alt trigger does not have collapsed class')
+ assert.false($target.hasClass('collapsed'), 'target trigger does not have collapsed class')
+ assert.false($alt.hasClass('collapsed'), 'alt trigger does not have collapsed class')
done()
})
$('<div id="test1" class="show"/>')
.appendTo('#qunit-fixture')
.on('hidden.bs.collapse', function () {
- assert.ok($target.hasClass('collapsed'), 'target has collapsed class')
- assert.ok($alt.hasClass('collapsed'), 'alt trigger has collapsed class')
+ assert.true($target.hasClass('collapsed'), 'target has collapsed class')
+ assert.true($alt.hasClass('collapsed'), 'alt trigger has collapsed class')
done()
})
$target.trigger('click')
})
+ // eslint-disable-next-line qunit/resolve-async
QUnit.test('should not close a collapse when initialized with "show" option if already shown', function (assert) {
assert.expect(0)
var done = assert.async()
setTimeout(done, 0)
})
+ // eslint-disable-next-line qunit/resolve-async
QUnit.test('should open a collapse when initialized with "show" option if not already shown', function (assert) {
assert.expect(1)
var done = assert.async()
setTimeout(done, 0)
})
+ // eslint-disable-next-line qunit/resolve-async
QUnit.test('should not show a collapse when initialized with "hide" option if already hidden', function (assert) {
assert.expect(0)
var done = assert.async()
setTimeout(done, 0)
})
+ // eslint-disable-next-line qunit/resolve-async
QUnit.test('should hide a collapse when initialized with "hide" option if not already hidden', function (assert) {
assert.expect(1)
var done = assert.async()
$('<div id="body3" data-parent="#accordion"/>')
.appendTo($groups.eq(2))
.on('shown.bs.collapse', function () {
- assert.ok($target1.hasClass('collapsed'), 'inactive target 1 does have class "collapsed"')
- assert.ok($target2.hasClass('collapsed'), 'inactive target 2 does have class "collapsed"')
- assert.ok(!$target3.hasClass('collapsed'), 'active target 3 does not have class "collapsed"')
+ assert.true($target1.hasClass('collapsed'), 'inactive target 1 does have class "collapsed"')
+ assert.true($target2.hasClass('collapsed'), 'inactive target 2 does have class "collapsed"')
+ assert.false($target3.hasClass('collapsed'), 'active target 3 does not have class "collapsed"')
done()
})
$('<div id="body3" data-parent=".accordion"/>')
.appendTo($groups.eq(2))
.on('shown.bs.collapse', function () {
- assert.ok($target1.hasClass('collapsed'), 'inactive target 1 does have class "collapsed"')
- assert.ok($target2.hasClass('collapsed'), 'inactive target 2 does have class "collapsed"')
- assert.ok(!$target3.hasClass('collapsed'), 'active target 3 does not have class "collapsed"')
+ assert.true($target1.hasClass('collapsed'), 'inactive target 1 does have class "collapsed"')
+ assert.true($target2.hasClass('collapsed'), 'inactive target 2 does have class "collapsed"')
+ assert.false($target3.hasClass('collapsed'), 'active target 3 does not have class "collapsed"')
done()
})
$target1.trigger('click')
setTimeout(function () {
- assert.ok(!showFired, 'show event did not fire')
+ assert.false(showFired, 'show event did not fire')
done()
}, 1)
})
$('<div id="test1" class="show"/>')
.appendTo('#qunit-fixture')
.on('hidden.bs.collapse', function () {
- assert.ok($target.hasClass('collapsed'))
+ assert.true($target.hasClass('collapsed'))
done()
})
.bootstrapCollapse('hide')
$('<div id="test1"/>')
.appendTo('#qunit-fixture')
.on('shown.bs.collapse', function () {
- assert.ok(!$target.hasClass('collapsed'))
+ assert.false($target.hasClass('collapsed'))
done()
})
.bootstrapCollapse('show')
var $collapseOne = $('#collapseOne')
var $collapseTwo = $('#collapseTwo')
$collapseOne.on('shown.bs.collapse', function () {
- assert.ok($collapseOne.hasClass('show'), '#collapseOne is shown')
- assert.ok(!$collapseTwo.hasClass('show'), '#collapseTwo is not shown')
+ assert.true($collapseOne.hasClass('show'), '#collapseOne is shown')
+ assert.false($collapseTwo.hasClass('show'), '#collapseTwo is not shown')
$collapseTwo.on('shown.bs.collapse', function () {
- assert.ok(!$collapseOne.hasClass('show'), '#collapseOne is not shown')
- assert.ok($collapseTwo.hasClass('show'), '#collapseTwo is shown')
+ assert.false($collapseOne.hasClass('show'), '#collapseOne is not shown')
+ assert.true($collapseTwo.hasClass('show'), '#collapseTwo is shown')
done()
})
$triggerTwo.trigger($.Event('click'))
var $collapseOne = $('#collapseOne')
var $collapseTwo = $('#collapseTwo')
$collapseOne.on('shown.bs.collapse', function () {
- assert.ok($collapseOne.hasClass('show'), '#collapseOne is shown')
- assert.ok(!$collapseTwo.hasClass('show'), '#collapseTwo is not shown')
+ assert.true($collapseOne.hasClass('show'), '#collapseOne is shown')
+ assert.false($collapseTwo.hasClass('show'), '#collapseTwo is not shown')
$collapseTwo.on('shown.bs.collapse', function () {
- assert.ok(!$collapseOne.hasClass('show'), '#collapseOne is not shown')
- assert.ok($collapseTwo.hasClass('show'), '#collapseTwo is shown')
+ assert.false($collapseOne.hasClass('show'), '#collapseOne is not shown')
+ assert.true($collapseTwo.hasClass('show'), '#collapseTwo is shown')
done()
})
$triggerTwo.trigger($.Event('click'))
}
function firstTest() {
- assert.ok($collapseOneOne.hasClass('show'), '#collapseOneOne is shown')
- assert.ok($collapseOneTwo.hasClass('show'), '#collapseOneTwo is shown')
- assert.ok(!$collapseTwoOne.hasClass('show'), '#collapseTwoOne is not shown')
- assert.ok(!$collapseTwoTwo.hasClass('show'), '#collapseTwoTwo is not shown')
+ assert.true($collapseOneOne.hasClass('show'), '#collapseOneOne is shown')
+ assert.true($collapseOneTwo.hasClass('show'), '#collapseOneTwo is shown')
+ assert.false($collapseTwoOne.hasClass('show'), '#collapseTwoOne is not shown')
+ assert.false($collapseTwoTwo.hasClass('show'), '#collapseTwoTwo is not shown')
$triggerTwo.trigger($.Event('click'))
}
function secondTest() {
- assert.ok(!$collapseOneOne.hasClass('show'), '#collapseOneOne is not shown')
- assert.ok(!$collapseOneTwo.hasClass('show'), '#collapseOneTwo is not shown')
- assert.ok($collapseTwoOne.hasClass('show'), '#collapseTwoOne is shown')
- assert.ok($collapseTwoTwo.hasClass('show'), '#collapseTwoTwo is shown')
+ assert.false($collapseOneOne.hasClass('show'), '#collapseOneOne is not shown')
+ assert.false($collapseOneTwo.hasClass('show'), '#collapseOneTwo is not shown')
+ assert.true($collapseTwoOne.hasClass('show'), '#collapseTwoOne is shown')
+ assert.true($collapseTwoTwo.hasClass('show'), '#collapseTwoTwo is shown')
done()
}
var $nestedCollapseOne = $('#nestedCollapseOne')
$collapseOne.one('shown.bs.collapse', function () {
- assert.ok($collapseOne.hasClass('show'), '#collapseOne is shown')
- assert.ok(!$collapseTwo.hasClass('show'), '#collapseTwo is not shown')
- assert.ok(!$('#nestedCollapseOne').hasClass('show'), '#nestedCollapseOne is not shown')
+ assert.true($collapseOne.hasClass('show'), '#collapseOne is shown')
+ assert.false($collapseTwo.hasClass('show'), '#collapseTwo is not shown')
+ assert.false($('#nestedCollapseOne').hasClass('show'), '#nestedCollapseOne is not shown')
$nestedCollapseOne.one('shown.bs.collapse', function () {
- assert.ok($collapseOne.hasClass('show'), '#collapseOne is shown')
- assert.ok(!$collapseTwo.hasClass('show'), '#collapseTwo is not shown')
- assert.ok($nestedCollapseOne.hasClass('show'), '#nestedCollapseOne is shown')
+ assert.true($collapseOne.hasClass('show'), '#collapseOne is shown')
+ assert.false($collapseTwo.hasClass('show'), '#collapseTwo is not shown')
+ assert.true($nestedCollapseOne.hasClass('show'), '#nestedCollapseOne is shown')
$collapseTwo.one('shown.bs.collapse', function () {
- assert.ok(!$collapseOne.hasClass('show'), '#collapseOne is not shown')
- assert.ok($collapseTwo.hasClass('show'), '#collapseTwo is shown')
- assert.ok($nestedCollapseOne.hasClass('show'), '#nestedCollapseOne is shown')
+ assert.false($collapseOne.hasClass('show'), '#collapseOne is not shown')
+ assert.true($collapseTwo.hasClass('show'), '#collapseTwo is shown')
+ assert.true($nestedCollapseOne.hasClass('show'), '#nestedCollapseOne is shown')
done()
})
$triggerTwo.trigger($.Event('click'))
$('<div id="collapsediv1"/>')
.appendTo('#qunit-fixture')
.on('shown.bs.collapse', function () {
- assert.ok($(this).hasClass('show'))
- assert.ok($target.attr('aria-expanded') === 'true')
- assert.ok($target.prop('checked'))
+ assert.true($(this).hasClass('show'))
+ assert.strictEqual($target.attr('aria-expanded'), 'true')
+ assert.true($target.prop('checked'))
done()
})
var $target2 = $('<div id="test2" class="multi"/>').appendTo('#qunit-fixture')
$target2.one('shown.bs.collapse', function () {
- assert.ok(!$trigger1.hasClass('collapsed'), 'trigger1 does not have collapsed class')
- assert.ok(!$trigger2.hasClass('collapsed'), 'trigger2 does not have collapsed class')
- assert.ok(!$trigger3.hasClass('collapsed'), 'trigger3 does not have collapsed class')
+ assert.false($trigger1.hasClass('collapsed'), 'trigger1 does not have collapsed class')
+ assert.false($trigger2.hasClass('collapsed'), 'trigger2 does not have collapsed class')
+ assert.false($trigger3.hasClass('collapsed'), 'trigger3 does not have collapsed class')
$target2.one('hidden.bs.collapse', function () {
- assert.ok(!$trigger1.hasClass('collapsed'), 'trigger1 does not have collapsed class')
- assert.ok($trigger2.hasClass('collapsed'), 'trigger2 has collapsed class')
- assert.ok(!$trigger3.hasClass('collapsed'), 'trigger3 does not have collapsed class')
+ assert.false($trigger1.hasClass('collapsed'), 'trigger1 does not have collapsed class')
+ assert.true($trigger2.hasClass('collapsed'), 'trigger2 has collapsed class')
+ assert.false($trigger3.hasClass('collapsed'), 'trigger3 does not have collapsed class')
$target1.one('hidden.bs.collapse', function () {
- assert.ok($trigger1.hasClass('collapsed'), 'trigger1 has collapsed class')
- assert.ok($trigger2.hasClass('collapsed'), 'trigger2 has collapsed class')
- assert.ok($trigger3.hasClass('collapsed'), 'trigger3 has collapsed class')
+ assert.true($trigger1.hasClass('collapsed'), 'trigger1 has collapsed class')
+ assert.true($trigger2.hasClass('collapsed'), 'trigger2 has collapsed class')
+ assert.true($trigger3.hasClass('collapsed'), 'trigger3 has collapsed class')
done()
})
$trigger1.trigger('click')
$(htmlCollapse)
.appendTo('#qunit-fixture')
.on('shown.bs.collapse', function () {
- assert.ok($target.prop('checked'), '$trigger is checked')
+ assert.true($target.prop('checked'), '$trigger is checked')
var $testCheckbox = $('#testCheckbox')
$testCheckbox.trigger($.Event('click'))
setTimeout(function () {
- assert.ok($testCheckbox.prop('checked'), '$testCheckbox is checked too')
+ assert.true($testCheckbox.prop('checked'), '$testCheckbox is checked too')
done()
}, 5)
})
})
$collapse2.on('shown.bs.collapse', function () {
- assert.ok($collapse2.hasClass('show'))
- assert.ok(!$('#collapse1').hasClass('show'))
+ assert.true($collapse2.hasClass('show'))
+ assert.false($('#collapse1').hasClass('show'))
done()
})
assert.expect(2)
var $el = $('<div/>')
var $dropdown = $el.bootstrapDropdown()
- assert.ok($dropdown instanceof $, 'returns jquery collection')
+ assert.true($dropdown instanceof $, 'returns jquery collection')
assert.strictEqual($dropdown[0], $el[0], 'collection contains element')
})
$(dropdownHTML).appendTo('#qunit-fixture')
var $dropdown = $('#qunit-fixture').find('[data-toggle="dropdown"]').bootstrapDropdown()
$dropdown.on('click', function () {
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'))
+ assert.false($dropdown.parent('.dropdown').hasClass('show'))
done()
})
$dropdown.trigger($.Event('click'))
$button.trigger('focus').trigger($.Event('keydown', {
which: 27
}))
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown after escape pressed')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown after escape pressed')
done()
})
$dropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok(!$dropdown.parent('.dropdown').hasClass('position-static'), '"position-static" class not added')
+ assert.false($dropdown.parent('.dropdown').hasClass('position-static'), '"position-static" class not added')
done()
})
$dropdown.trigger('click')
$dropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('position-static'), '"position-static" class added')
+ assert.true($dropdown.parent('.dropdown').hasClass('position-static'), '"position-static" class added')
done()
})
$dropdown.trigger('click')
$(dropdownHTML).appendTo('#qunit-fixture')
var $dropdown = $('#qunit-fixture').find('[data-toggle="dropdown"]').bootstrapDropdown()
$dropdown.on('click', function () {
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'))
+ assert.false($dropdown.parent('.dropdown').hasClass('show'))
done()
})
$dropdown.trigger($.Event('click'))
$dropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), '"show" class added on click')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), '"show" class added on click')
done()
})
$dropdown.trigger('click')
$dropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), '"show" class added on click')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), '"show" class added on click')
$(document.body).trigger('click')
}).on('hidden.bs.dropdown', function () {
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), '"show" class removed')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), '"show" class removed')
done()
})
$dropdown.trigger('click')
$dropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), '"show" class added on click')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), '"show" class added on click')
var e = $.Event('keyup')
e.which = 9 // Tab
$(document.body).trigger(e)
}).on('hidden.bs.dropdown', function () {
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), '"show" class removed')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), '"show" class removed')
done()
})
$dropdown.trigger('click')
$dropdown.parent('.dropdown')
.on('hide.bs.dropdown', function (e) {
- assert.ok(e.clickEvent)
+ assert.notStrictEqual(e.clickEvent, 'undefined')
})
.on('hidden.bs.dropdown', function (e) {
- assert.ok(e.clickEvent)
+ assert.notStrictEqual(e.clickEvent, 'undefined')
})
.on('shown.bs.dropdown', function () {
assert.ok(true, 'shown was fired')
$dropdown.parent('.dropdown')
.on('hide.bs.dropdown', function (e) {
- assert.notOk(e.clickEvent)
+ assert.strictEqual(typeof e.clickEvent, 'undefined')
})
.on('hidden.bs.dropdown', function (e) {
- assert.notOk(e.clickEvent)
+ assert.strictEqual(typeof e.clickEvent, 'undefined')
})
.on('shown.bs.dropdown', function () {
assert.ok(true, 'shown was fired')
$input.trigger('focus').trigger($.Event('keydown', {
which: 38
}))
- assert.ok($(document.activeElement).is($input), 'input still focused')
+ assert.true($(document.activeElement).is($input), 'input still focused')
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 38
}))
- assert.ok($(document.activeElement).is($textarea), 'textarea still focused')
+ assert.true($(document.activeElement).is($textarea), 'textarea still focused')
done()
})
$dropdown.trigger($.Event('keydown', {
which: 40
}))
- assert.ok(!$(document.activeElement).is('.disabled'), '.disabled is not focused')
- assert.ok(!$(document.activeElement).is(':disabled'), ':disabled is not focused')
+ assert.false($(document.activeElement).is('.disabled'), '.disabled is not focused')
+ assert.false($(document.activeElement).is(':disabled'), ':disabled is not focused')
done()
})
$dropdown.trigger('click')
$dropdown.trigger($.Event('keydown', {
which: 40
}))
- assert.ok($(document.activeElement).is($('#item1')), 'item1 is focused')
+ assert.true($(document.activeElement).is($('#item1')), 'item1 is focused')
$(document.activeElement).trigger($.Event('keydown', {
which: 40
}))
- assert.ok($(document.activeElement).is($('#item2')), 'item2 is focused')
+ assert.true($(document.activeElement).is($('#item2')), 'item2 is focused')
$(document.activeElement).trigger($.Event('keydown', {
which: 38
}))
- assert.ok($(document.activeElement).is($('#item1')), 'item1 is focused')
+ assert.true($(document.activeElement).is($('#item1')), 'item1 is focused')
done()
})
$dropdown.trigger('click')
var $textfield = $('#textField')
$textfield.on('click', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
done()
})
$dropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
$textfield.trigger($.Event('click'))
})
$dropdown.trigger('click')
var $textarea = $('#textArea')
$textarea.on('click', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
done()
})
$dropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
$textarea.trigger($.Event('click'))
})
$dropdown.trigger('click')
$triggerDropdown
.parent('.dropdown')
.on('shown.bs.dropdown', function () {
- assert.ok(typeof $dropdownMenu.attr('style') === 'undefined', 'No inline style applied by Popper')
+ assert.strictEqual(typeof $dropdownMenu.attr('style'), 'undefined', 'No inline style applied by Popper')
done()
})
$triggerDropdown.trigger($.Event('click'))
.on('shown.bs.dropdown', function () {
// Forcibly focus first item
$item[0].focus()
- assert.ok($(document.activeElement)[0] === $item[0], 'menu item initial focus set')
+ assert.strictEqual($(document.activeElement)[0], $item[0], 'menu item initial focus set')
// Key escape
$item.trigger('focus').trigger($.Event('keydown', {
which: 27
}))
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu was closed after escape')
- assert.ok($(document.activeElement)[0] === $toggle[0], 'toggle has focus again once menu was closed after escape')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu was closed after escape')
+ assert.strictEqual($(document.activeElement)[0], $toggle[0], 'toggle has focus again once menu was closed after escape')
done()
})
$input.trigger('focus').trigger($.Event('keydown', {
which: 32
}))
- assert.ok($(document.activeElement)[0] === $input[0], 'input still focused')
+ assert.strictEqual($(document.activeElement)[0], $input[0], 'input still focused')
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 32
}))
- assert.ok($(document.activeElement)[0] === $textarea[0], 'textarea still focused')
+ assert.strictEqual($(document.activeElement)[0], $textarea[0], 'textarea still focused')
// Key up
$input.trigger('focus').trigger($.Event('keydown', {
which: 38
}))
- assert.ok($(document.activeElement)[0] === $input[0], 'input still focused')
+ assert.strictEqual($(document.activeElement)[0], $input[0], 'input still focused')
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 38
}))
- assert.ok($(document.activeElement)[0] === $textarea[0], 'textarea still focused')
+ assert.strictEqual($(document.activeElement)[0], $textarea[0], 'textarea still focused')
// Key down
$input.trigger('focus').trigger($.Event('keydown', {
which: 40
}))
- assert.ok($(document.activeElement)[0] === $input[0], 'input still focused')
+ assert.strictEqual($(document.activeElement)[0], $input[0], 'input still focused')
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 40
}))
- assert.ok($(document.activeElement)[0] === $textarea[0], 'textarea still focused')
+ assert.strictEqual($(document.activeElement)[0], $textarea[0], 'textarea still focused')
// Key escape
$input.trigger('focus').trigger($.Event('keydown', {
which: 27
}))
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown')
done()
})
$input.trigger('focus').trigger($.Event('keydown', {
which: 32
}))
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
- assert.ok($(document.activeElement).is($input), 'input is still focused')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($(document.activeElement).is($input), 'input is still focused')
// Key escape
$input.trigger('focus').trigger($.Event('keydown', {
which: 27
}))
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown')
$dropdown
.parent('.dropdown')
$input.trigger('focus').trigger($.Event('keydown', {
which: 40
}))
- assert.ok(document.activeElement === $('#item1')[0], 'item1 is focused')
+ assert.strictEqual(document.activeElement, $('#item1')[0], 'item1 is focused')
$dropdown
.parent('.dropdown')
$input.trigger('focus').trigger($.Event('keydown', {
which: 38
}))
- assert.ok(document.activeElement === $('#item1')[0], 'item1 is focused')
+ assert.strictEqual(document.activeElement, $('#item1')[0], 'item1 is focused')
done()
}).bootstrapDropdown('toggle')
$input.trigger('click')
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 32
}))
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
- assert.ok($(document.activeElement).is($textarea), 'textarea is still focused')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($(document.activeElement).is($textarea), 'textarea is still focused')
// Key escape
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 27
}))
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is not shown')
$dropdown
.parent('.dropdown')
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 40
}))
- assert.ok(document.activeElement === $('#item1')[0], 'item1 is focused')
+ assert.strictEqual(document.activeElement, $('#item1')[0], 'item1 is focused')
$dropdown
.parent('.dropdown')
$textarea.trigger('focus').trigger($.Event('keydown', {
which: 38
}))
- assert.ok(document.activeElement === $('#item1')[0], 'item1 is focused')
+ assert.strictEqual(document.activeElement, $('#item1')[0], 'item1 is focused')
done()
}).bootstrapDropdown('toggle')
$textarea.trigger('click')
which: 27
}))
- assert.ok($body.hasClass('event-handled'), 'ESC key event was propagated')
+ assert.true($body.hasClass('event-handled'), 'ESC key event was propagated')
done()
})
which: 27
}))
- assert.ok($body.hasClass('event-handled'), 'ESC key event was propagated')
+ assert.true($body.hasClass('event-handled'), 'ESC key event was propagated')
done()
})
var dropdown = $dropdown.data('bs.dropdown')
dropdown.toggle()
- assert.ok(dropdown._popper)
+ assert.notStrictEqual(dropdown._popper, null)
var spyPopper = sinon.spy(dropdown._popper, 'scheduleUpdate')
var spyDetectNavbar = sinon.spy(dropdown, '_detectNavbar')
dropdown.update()
- assert.ok(spyPopper.called)
- assert.ok(spyDetectNavbar.called)
+ assert.true(spyPopper.called)
+ assert.true(spyDetectNavbar.called)
})
QUnit.test('should just detect navbar on update', function (assert) {
dropdown.update()
- assert.notOk(dropdown._popper)
- assert.ok(spyDetectNavbar.called)
+ assert.strictEqual(dropdown._popper, null)
+ assert.true(spyDetectNavbar.called)
})
QUnit.test('should dispose dropdown with Popper', function (assert) {
var dropdown = $dropdown.data('bs.dropdown')
dropdown.toggle()
- assert.ok(dropdown._popper)
- assert.ok(dropdown._menu !== null)
- assert.ok(dropdown._element !== null)
+ assert.notStrictEqual(dropdown._popper, null)
+ assert.notStrictEqual(dropdown._menu, null)
+ assert.notStrictEqual(dropdown._element, null)
var spyDestroy = sinon.spy(dropdown._popper, 'destroy')
dropdown.dispose()
- assert.ok(spyDestroy.called)
- assert.ok(dropdown._menu === null)
- assert.ok(dropdown._element === null)
+ assert.true(spyDestroy.called)
+ assert.strictEqual(dropdown._menu, null)
+ assert.strictEqual(dropdown._element, null)
})
QUnit.test('should dispose dropdown', function (assert) {
var dropdown = $dropdown.data('bs.dropdown')
- assert.notOk(dropdown._popper)
- assert.ok(dropdown._menu !== null)
- assert.ok(dropdown._element !== null)
+ assert.strictEqual(dropdown._popper, null)
+ assert.notStrictEqual(dropdown._menu, null)
+ assert.notStrictEqual(dropdown._element, null)
dropdown.dispose()
- assert.ok(dropdown._menu === null)
- assert.ok(dropdown._element === null)
+ assert.strictEqual(dropdown._menu, null)
+ assert.strictEqual(dropdown._element, null)
})
QUnit.test('should show dropdown', function (assert) {
assert.ok(true, 'show was fired')
})
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
done()
})
assert.ok(true, 'hide was fired')
})
.on('hidden.bs.dropdown', function () {
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is hidden')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is hidden')
done()
})
$dropdown.trigger('click')
dropdown.show()
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is still shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is still shown')
})
QUnit.test('should not show dropdown', function (assert) {
var dropdown = $dropdown.data('bs.dropdown')
dropdown.hide()
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is still hidden')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is still hidden')
})
QUnit.test('should show dropdown', function (assert) {
$dropdown
.parent('.dropdown')
.on('show.bs.dropdown', function () {
- assert.ok(dropdown._popper === null)
+ assert.strictEqual(dropdown._popper, null)
assert.ok(true, 'show was fired')
})
.on('shown.bs.dropdown', function () {
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
done()
})
})
dropdown.show()
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is hidden')
+ assert.false($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is hidden')
})
QUnit.test('should prevent default event on hide method call', function (assert) {
})
dropdown.hide()
- assert.ok($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
+ assert.true($dropdown.parent('.dropdown').hasClass('show'), 'dropdown menu is shown')
})
QUnit.test('should not open dropdown via show method if target is disabled via attribute', function (assert) {
$(dropdownHTML).appendTo('#qunit-fixture')
var $dropdown = $('#qunit-fixture').find('[data-toggle="dropdown"]').bootstrapDropdown()
$dropdown.show()
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'))
+ assert.false($dropdown.parent('.dropdown').hasClass('show'))
})
QUnit.test('should not open dropdown via show method if target is disabled via class', function (assert) {
$(dropdownHTML).appendTo('#qunit-fixture')
var $dropdown = $('#qunit-fixture').find('[data-toggle="dropdown"]').bootstrapDropdown()
$dropdown.show()
- assert.ok(!$dropdown.parent('.dropdown').hasClass('show'))
+ assert.false($dropdown.parent('.dropdown').hasClass('show'))
})
QUnit.test('should not hide dropdown via hide method if target is disabled via attribute', function (assert) {
$(dropdownHTML).appendTo('#qunit-fixture')
var $dropdown = $('#qunit-fixture').find('[data-toggle="dropdown"]').bootstrapDropdown()
$dropdown.hide()
- assert.ok($dropdown.parent('.dropdown').hasClass('show'))
+ assert.true($dropdown.parent('.dropdown').hasClass('show'))
})
QUnit.test('should not hide dropdown via hide method if target is disabled via class', function (assert) {
$(dropdownHTML).appendTo('#qunit-fixture')
var $dropdown = $('#qunit-fixture').find('[data-toggle="dropdown"]').bootstrapDropdown()
$dropdown.hide()
- assert.ok($dropdown.parent('.dropdown').hasClass('show'))
+ assert.true($dropdown.parent('.dropdown').hasClass('show'))
})
QUnit.test('should create offset modifier correctly when offset option is a function', function (assert) {
var dropdown = $dropdown.data('bs.dropdown')
var offset = dropdown._getOffset()
- assert.ok(typeof offset.offset === 'undefined')
- assert.ok(typeof offset.fn === 'function')
+ assert.strictEqual(typeof offset.offset, 'undefined')
+ assert.strictEqual(typeof offset.fn, 'function')
})
QUnit.test('should create offset modifier correctly when offset option is not a function', function (assert) {
var offset = dropdown._getOffset()
assert.strictEqual(offset.offset, myOffset)
- assert.ok(typeof offset.fn === 'undefined')
+ assert.strictEqual(typeof offset.fn, 'undefined')
})
QUnit.test('should allow to pass config to Popper with `popperConfig`', function (assert) {
var spyPopper
$firstDropdownEl.one('shown.bs.dropdown', function () {
- assert.strictEqual($firstDropdownEl.hasClass('show'), true)
+ assert.true($firstDropdownEl.hasClass('show'))
spyPopper = sinon.spy(dropdown1._popper, 'destroy')
dropdown2.toggle()
})
$secondDropdownEl.one('shown.bs.dropdown', function () {
- assert.strictEqual($secondDropdownEl.hasClass('show'), true)
- assert.ok(spyPopper.called)
+ assert.true($secondDropdownEl.hasClass('show'))
+ assert.true(spyPopper.called)
done()
})
})
$dropdownEl.one('hidden.bs.dropdown', function () {
- assert.ok(spyPopper.called)
+ assert.true(spyPopper.called)
done()
})
which: 40
}))
- assert.strictEqual($(document.activeElement).hasClass('d-none'), false, '.d-none not focused')
- assert.strictEqual($(document.activeElement).css('display') === 'none', false, '"display: none" not focused')
- assert.strictEqual(document.activeElement.style.visibility === 'hidden', false, '"visibility: hidden" not focused')
+ assert.false($(document.activeElement).hasClass('d-none'), '.d-none not focused')
+ assert.notStrictEqual($(document.activeElement).css('display'), 'none', '"display: none" not focused')
+ assert.notStrictEqual(document.activeElement.style.visibility, 'hidden', '"visibility: hidden" not focused')
done()
})
assert.expect(2)
var $el = $('<div id="modal-test"/>')
var $modal = $el.bootstrapModal()
- assert.ok($modal instanceof $, 'returns jquery collection')
+ assert.true($modal instanceof $, 'returns jquery collection')
assert.strictEqual($modal[0], $el[0], 'collection contains element')
})
}
})
.on('shown.bs.modal', function () {
- assert.ok(prevented, 'show prevented')
- assert.ok($el.hasClass('fade'))
+ assert.true(prevented, 'show prevented')
+ assert.true($el.hasClass('fade'))
done()
})
.bootstrapModal('show')
$('<div id="modal-test"/>')
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').is(':visible'), 'modal visible')
+ assert.true($('#modal-test').is(':visible'), 'modal visible')
assert.notStrictEqual($('#modal-test').length, 0, 'modal inserted into dom')
$(this).bootstrapModal('hide')
})
.on('hidden.bs.modal', function () {
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
done()
})
.bootstrapModal('show')
$('<div id="modal-test"/>')
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').is(':visible'), 'modal visible')
+ assert.true($('#modal-test').is(':visible'), 'modal visible')
assert.notStrictEqual($('#modal-test').length, 0, 'modal inserted into dom')
$(this).bootstrapModal('toggle')
})
.on('hidden.bs.modal', function () {
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
done()
})
.bootstrapModal('toggle')
$('<div id="modal-test"><span class="close" data-dismiss="modal"/></div>')
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').is(':visible'), 'modal visible')
+ assert.true($('#modal-test').is(':visible'), 'modal visible')
assert.notStrictEqual($('#modal-test').length, 0, 'modal inserted into dom')
$(this).find('.close').trigger('click')
})
.on('hidden.bs.modal', function () {
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
done()
})
.bootstrapModal('toggle')
$('<div id="modal-test" data-backdrop="false"/>')
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').is(':visible'), 'modal visible')
+ assert.true($('#modal-test').is(':visible'), 'modal visible')
$(this).bootstrapModal('hide')
})
.on('hidden.bs.modal', function () {
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
done()
})
.bootstrapModal('show')
.on('shown.bs.modal', function () {
assert.notStrictEqual($('#modal-test').length, 0, 'modal inserted into dom')
$('.contents').trigger('click')
- assert.ok($('#modal-test').is(':visible'), 'modal visible')
+ assert.true($('#modal-test').is(':visible'), 'modal visible')
$('#modal-test').trigger('click')
})
.on('hidden.bs.modal', function () {
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
done()
})
.bootstrapModal('show')
$('<div id="modal-test" data-backdrop="false"><div class="contents"/></div>')
.on('shown.bs.modal', function () {
$('#modal-test').trigger('click')
- assert.ok($('#modal-test').is(':visible'), 'modal not hidden')
+ assert.true($('#modal-test').is(':visible'), 'modal not hidden')
done()
})
.bootstrapModal('show')
var $div = $('<div id="modal-test"/>')
$div
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').length, 'modal inserted into dom')
- assert.ok($('#modal-test').is(':visible'), 'modal visible')
+ assert.notStrictEqual($('#modal-test').length, 0, 'modal inserted into dom')
+ assert.true($('#modal-test').is(':visible'), 'modal visible')
$div.trigger($.Event('keydown', {
which: 27
}))
setTimeout(function () {
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
$div.remove()
done()
}, 0)
var $div = $('<div id="modal-test"/>')
$div
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').length, 'modal inserted into dom')
- assert.ok($('#modal-test').is(':visible'), 'modal visible')
+ assert.notStrictEqual($('#modal-test').length, 0, 'modal inserted into dom')
+ assert.true($('#modal-test').is(':visible'), 'modal visible')
$div.trigger($.Event('keyup', {
which: 27
}))
setTimeout(function () {
- assert.ok($div.is(':visible'), 'modal still visible')
+ assert.true($div.is(':visible'), 'modal still visible')
$div.remove()
done()
}, 0)
$('<div id="modal-test" aria-hidden="true"/>')
.on('shown.bs.modal', function () {
- assert.notOk($('#modal-test').is('[aria-hidden]'), 'aria-hidden attribute removed')
+ assert.false($('#modal-test').is('[aria-hidden]'), 'aria-hidden attribute removed')
$(this).bootstrapModal('hide')
})
.on('hidden.bs.modal', function () {
- assert.ok($('#modal-test').is('[aria-hidden]'), 'aria-hidden attribute added')
+ assert.true($('#modal-test').is('[aria-hidden]'), 'aria-hidden attribute added')
assert.strictEqual($('#modal-test').attr('aria-hidden'), 'true', 'correct aria-hidden="true" added')
done()
})
$('<div id="modal-test"/>')
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').is('[aria-modal]'), 'aria-modal attribute added')
+ assert.true($('#modal-test').is('[aria-modal]'), 'aria-modal attribute added')
assert.strictEqual($('#modal-test').attr('aria-modal'), 'true', 'correct aria-modal="true" added')
$(this).bootstrapModal('hide')
})
.on('hidden.bs.modal', function () {
- assert.notOk($('#modal-test').is('[aria-modal]'), 'aria-modal attribute removed')
+ assert.false($('#modal-test').is('[aria-modal]'), 'aria-modal attribute removed')
done()
})
.bootstrapModal('show')
$('<div id="modal-test"/>')
.on('shown.bs.modal', function () {
- assert.ok($('#modal-test').is('[role]'), 'role attribute added')
+ assert.true($('#modal-test').is('[role]'), 'role attribute added')
assert.strictEqual($('#modal-test').attr('role'), 'dialog', 'correct role="dialog" added')
$(this).bootstrapModal('hide')
})
.on('hidden.bs.modal', function () {
- assert.notOk($('#modal-test').is('[role]'), 'role attribute removed')
+ assert.false($('#modal-test').is('[role]'), 'role attribute removed')
done()
})
.bootstrapModal('show')
})
.one('hidden.bs.modal', function () {
// After one open-close cycle
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
$(this)
.one('shown.bs.modal', function () {
$('#close').trigger('click')
})
.one('hidden.bs.modal', function () {
- assert.ok(!$('#modal-test').is(':visible'), 'modal hidden')
+ assert.false($('#modal-test').is(':visible'), 'modal hidden')
done()
})
.bootstrapModal('show')
$('<div id="modal-test"><div class="contents"><div id="close" data-dismiss="modal"/></div></div>')
.on('hidden.bs.modal', function () {
setTimeout(function () {
- assert.ok($(document.activeElement).is($toggleBtn), 'toggling element is once again focused')
+ assert.true($(document.activeElement).is($toggleBtn), 'toggling element is once again focused')
done()
}, 0)
})
})
.on('hidden.bs.modal', function () {
setTimeout(function () {
- assert.ok($(document.activeElement).is($otherBtn), 'focus returned to toggling element')
+ assert.true($(document.activeElement).is($otherBtn), 'focus returned to toggling element')
done()
}, 0)
})
$('#test')
.on('click.bs.modal.data-api', function (event) {
- assert.notOk(event.isDefaultPrevented(), 'navigating to href will happen')
+ assert.false(event.isDefaultPrevented(), 'navigating to href will happen')
setTimeout(function () {
- assert.ok(event.isDefaultPrevented(), 'model shown instead of navigating to href')
+ assert.true(event.isDefaultPrevented(), 'model shown instead of navigating to href')
done()
}, 1)
})
}, 0)
})
+ // eslint-disable-next-line qunit/resolve-async
QUnit.test('should not execute js from target', function (assert) {
assert.expect(0)
var done = assert.async()
var spy = sinon.spy(Util, 'getTransitionDurationFromElement')
$modal.on('shown.bs.modal', function () {
- assert.ok(spy.returned(expectedTransitionDuration))
+ assert.true(spy.returned(expectedTransitionDuration))
$style.remove()
spy.restore()
done()
}
})
- assert.ok(typeof $(this).data('bs.modal') === 'undefined', 'modal data object was disposed')
+ assert.strictEqual(typeof $(this).data('bs.modal'), 'undefined', 'modal data object was disposed')
- assert.ok(spy.callCount === 4, '`jQuery.off` was called')
+ assert.strictEqual(spy.callCount, 4, '`jQuery.off` was called')
- assert.ok(modalDataApiEvent.length === 1, '`Event.CLICK_DATA_API` on `document` was not removed')
+ assert.strictEqual(modalDataApiEvent.length, 1, '`Event.CLICK_DATA_API` on `document` was not removed')
$.fn.off.restore()
done()
var spyDocOn = sinon.spy($(document), 'on')
$modal.one('shown.bs.modal', function () {
- assert.ok(spy.called, '_enforceFocus called')
+ assert.true(spy.called, '_enforceFocus called')
assert.ok(spyDocOff.withArgs('focusin.bs.modal'))
assert.ok(spyDocOn.withArgs('focusin.bs.modal'))
})
$(document).one('focusin', function () {
- assert.ok(spyFocus.called)
+ assert.true(spyFocus.called)
done()
})
})
QUnit.test('should scroll to top of the modal body if the modal has .modal-dialog-scrollable class', function (assert) {
- assert.expect(2)
+ assert.expect(3)
var done = assert.async()
var $modal = $([
var $modalBody = $('.modal-body')
$modalBody.scrollTop(100)
- assert.ok($modalBody.scrollTop() > 95 && $modalBody.scrollTop() <= 100)
+ assert.true($modalBody.scrollTop() > 95)
+ assert.true($modalBody.scrollTop() <= 100)
$modal.on('shown.bs.modal', function () {
assert.strictEqual($modalBody.scrollTop(), 0, 'modal body scrollTop should be 0 when opened')
setTimeout(function () {
var modal = $modal.data('bs.modal')
- assert.strictEqual(modal._isShown, true)
+ assert.true(modal._isShown)
done()
}, 10)
})
.on('hidden.bs.modal', function () {
- assert.strictEqual(true, false, 'should not hide the modal')
+ assert.true(false, 'should not hide the modal')
})
.bootstrapModal({
backdrop: 'static'
setTimeout(function () {
var modal = $modal.data('bs.modal')
- assert.strictEqual(modal._isShown, false)
+ assert.false(modal._isShown)
done()
}, 10)
})
setTimeout(function () {
var modal = $modal.data('bs.modal')
- assert.strictEqual(modal._isShown, true)
+ assert.true(modal._isShown)
done()
}, 10)
})
.on('hidden.bs.modal', function () {
- assert.strictEqual(false, true, 'should not hide the modal')
+ assert.false(true, 'should not hide the modal')
})
.bootstrapModal({
keyboard: false
$modal.on('shown.bs.modal', function () {
$modal.trigger('click')
setTimeout(function () {
- assert.ok($modal.hasClass('modal-static'), 'has modal-static class')
+ assert.true($modal.hasClass('modal-static'), 'has modal-static class')
done()
}, 0)
})
$modal.on('shown.bs.modal', function () {
$modal.trigger('click')
setTimeout(function () {
- assert.notOk($modal.hasClass('modal-static'), 'should not have modal-static class')
+ assert.false($modal.hasClass('modal-static'), 'should not have modal-static class')
done()
}, 0)
})
assert.expect(2)
var $el = $('<div/>')
var $popover = $el.bootstrapPopover()
- assert.ok($popover instanceof $, 'returns jquery collection')
+ assert.true($popover instanceof $, 'returns jquery collection')
assert.strictEqual($popover[0], $el[0], 'collection contains element')
})
$('<a href="#" title="mdo" data-content="https://twitter.com/mdo" data-custom-class="a b">@mdo</a>')
.appendTo('#qunit-fixture')
.on('shown.bs.popover', function () {
- assert.strictEqual($('.popover').hasClass('popover fade bs-popover-right show'), true, 'has default classes')
- assert.strictEqual($('.popover').hasClass('a b'), true, 'has custom classes')
+ assert.true($('.popover').hasClass('popover fade bs-popover-right show'), 'has default classes')
+ assert.true($('.popover').hasClass('a b'), 'has custom classes')
done()
})
.bootstrapPopover('show')
assert.notStrictEqual($('.popover').length, 0, 'popover inserted')
assert.strictEqual($('.popover .popover-header').text(), '@glebm <3 writing tests', 'title inserted')
- assert.ok(!$.contains($('.popover').get(0), title), 'title node copied, not moved')
+ assert.false($.contains($('.popover').get(0), title), 'title node copied, not moved')
assert.strictEqual($('.popover .popover-body').html(), '¯\\_(ツ)_/¯', 'content inserted')
- assert.ok(!$.contains($('.popover').get(0), content), 'content node copied, not moved')
+ assert.false($.contains($('.popover').get(0), content), 'content node copied, not moved')
})
QUnit.test('should not duplicate HTML object', function (assert) {
})
.one('shown.bs.popover', function () {
assert.notStrictEqual($('.popover').length, 0, 'popover was inserted')
- assert.ok($('.popover').hasClass('foobar'), 'custom class is present')
+ assert.true($('.popover').hasClass('foobar'), 'custom class is present')
$popover.bootstrapPopover('hide')
})
.one('hidden.bs.popover', function () {
})
QUnit.test('should destroy popover', function (assert) {
- assert.expect(7)
+ assert.expect(9)
var $popover = $('<div/>')
.bootstrapPopover({
trigger: 'hover'
.on('click.foo', $.noop)
assert.ok($popover.data('bs.popover'), 'popover has data')
- assert.ok($._data($popover[0], 'events').mouseover && $._data($popover[0], 'events').mouseout, 'popover has hover event')
+ assert.ok($._data($popover[0], 'events').mouseover, 'popover has mouseover event')
+ assert.ok($._data($popover[0], 'events').mouseout, 'popover has mouseout event')
assert.strictEqual($._data($popover[0], 'events').click[0].namespace, 'foo', 'popover has extra click.foo event')
$popover.bootstrapPopover('show')
$popover.bootstrapPopover('dispose')
- assert.ok(!$popover.hasClass('show'), 'popover is hidden')
- assert.ok(!$popover.data('popover'), 'popover does not have data')
+ assert.false($popover.hasClass('show'), 'popover is hidden')
+ assert.strictEqual(typeof $popover.data('popover'), 'undefined', 'popover does not have data')
assert.strictEqual($._data($popover[0], 'events').click[0].namespace, 'foo', 'popover still has click.foo')
- assert.ok(!$._data($popover[0], 'events').mouseover && !$._data($popover[0], 'events').mouseout, 'popover does not have any events')
+ assert.strictEqual(typeof $._data($popover[0], 'events').mouseover, 'undefined', 'popover does not have mouseover event')
+ assert.strictEqual(typeof $._data($popover[0], 'events').mouseout, 'undefined', 'popover does not have mouseout event')
})
QUnit.test('should render popover element using delegated selector', function (assert) {
$div
.one('shown.bs.popover', function () {
$('.content-with-handler .btn').trigger('click')
- assert.ok(handlerCalled, 'content\'s event handler still present')
+ assert.true(handlerCalled, 'content\'s event handler still present')
$div.bootstrapPopover('dispose')
done()
})
content: 'with disable/enable'
})
.on('shown.bs.popover', function () {
- assert.strictEqual($('.popover').hasClass('show'), true)
+ assert.true($('.popover').hasClass('show'))
done()
})
$popover.bootstrapPopover('disable')
$popover.trigger($.Event('click'))
setTimeout(function () {
- assert.strictEqual($('.popover').length === 0, true)
+ assert.strictEqual($('.popover').length, 0)
$popover.bootstrapPopover('enable')
$popover.trigger($.Event('click'))
}, 200)
assert.expect(2)
var $el = $('<div/>').appendTo('#qunit-fixture')
var $scrollspy = $el.bootstrapScrollspy()
- assert.ok($scrollspy instanceof $, 'returns jquery collection')
+ assert.true($scrollspy instanceof $, 'returns jquery collection')
assert.strictEqual($scrollspy[0], $el[0], 'collection contains element')
})
})
$scrollspy.one('scroll', function () {
- assert.ok($section.hasClass('active'), '"active" class still on root node')
+ assert.true($section.hasClass('active'), '"active" class still on root node')
done()
})
})
$scrollspy.one('scroll', function () {
- assert.ok($section.hasClass('active'), '"active" class still on root node')
+ assert.true($section.hasClass('active'), '"active" class still on root node')
done()
})
})
$scrollspy.one('scroll', function () {
- assert.ok($section.hasClass('active'), '"active" class still on root node')
+ assert.true($section.hasClass('active'), '"active" class still on root node')
done()
})
target: $('.container')
})
- assert.ok($('.container').attr('id').length > 0, '`target` has an ID attribute')
+ assert.notStrictEqual($('.container').attr('id').length, 0, '`target` has an ID attribute')
$scrollspy.one('scroll', function () {
- assert.ok($section.hasClass('active'), '"active" class still on root node')
+ assert.true($section.hasClass('active'), '"active" class still on root node')
done()
})
})
$scrollspy.one('scroll', function () {
- assert.ok(!$section.find('#one-link').hasClass('active'), '"active" class removed from first section')
- assert.ok($section.find('#two-link').hasClass('active'), '"active" class on middle section')
- assert.ok(!$section.find('#three-link').hasClass('active'), '"active" class not on last section')
+ assert.false($section.find('#one-link').hasClass('active'), '"active" class removed from first section')
+ assert.true($section.find('#two-link').hasClass('active'), '"active" class on middle section')
+ assert.false($section.find('#three-link').hasClass('active'), '"active" class not on last section')
done()
})
var paddingTop = 5
var scrollHeight = Math.ceil($content.scrollTop() + $(target).position().top) + paddingTop
$content.one('scroll', function () {
- assert.ok($(element).hasClass('active'), 'target:' + target + ', element' + element)
+ assert.true($(element).hasClass('active'), 'target:' + target + ', element' + element)
deferred.resolve()
})
$content.scrollTop(scrollHeight)
var paddingTop = 5
var scrollHeight = Math.ceil($content.scrollTop() + $(target).position().top) + paddingTop
$content.one('scroll', function () {
- assert.ok($(element).hasClass('active'), 'target:' + target + ', element' + element)
+ assert.true($(element).hasClass('active'), 'target:' + target + ', element' + element)
deferred.resolve()
})
$content.scrollTop(scrollHeight)
var paddingTop = 5
var scrollHeight = Math.ceil($content.scrollTop() + $(target).position().top) + paddingTop
$content.one('scroll', function () {
- assert.ok($(element).hasClass('active'), 'target:' + target + ', element' + element)
+ assert.true($(element).hasClass('active'), 'target:' + target + ', element' + element)
deferred.resolve()
})
$content.scrollTop(scrollHeight)
}
$content.one('scroll', function () {
- assert.ok($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
- assert.ok($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
+ assert.true($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
+ assert.true($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
testActiveElements()
})
}
$content.one('scroll', function () {
- assert.ok($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
- assert.ok($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
+ assert.true($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
+ assert.true($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
testActiveElements()
})
}
$content.one('scroll', function () {
- assert.ok($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
- assert.ok($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
+ assert.true($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
+ assert.true($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
testActiveElements()
})
}
$content.one('scroll', function () {
- assert.ok($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
- assert.ok($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
+ assert.true($('#a-1').hasClass('active'), 'nav item for outer element has "active" class')
+ assert.true($('#a-2').hasClass('active'), 'nav item for inner element has "active" class')
testActiveElements()
})
})
.one('scroll', function () {
assert.strictEqual($('.active').length, 1, '"active" class on only one element present')
- assert.strictEqual($('.active').is('#two-link'), true, '"active" class on second section')
+ assert.true($('.active').is('#two-link'), '"active" class on second section')
$scrollspy
.one('scroll', function () {
assert.strictEqual($('.active').length, 0, 'selection cleared')
})
.one('scroll', function () {
assert.strictEqual($('.active').length, 1, '"active" class on only one element present')
- assert.strictEqual($('.active').is('#two-link'), true, '"active" class on second section')
+ assert.true($('.active').is('#two-link'), '"active" class on second section')
$scrollspy
.one('scroll', function () {
assert.strictEqual($('.active').length, 1, '"active" class on only one element present')
- assert.strictEqual($('.active').is('#one-link'), true, '"active" class on first section')
+ assert.true($('.active').is('#one-link'), '"active" class on first section')
done()
})
.scrollTop(negativeHeight)
var paddingTop = 5
var scrollHeight = Math.ceil($content.scrollTop() + $(target).position().top) + paddingTop
$content.one('scroll', function () {
- assert.ok($(element).hasClass('active'), 'target:' + target + ', element: ' + element)
+ assert.true($(element).hasClass('active'), 'target:' + target + ', element: ' + element)
deferred.resolve()
})
$content.scrollTop(scrollHeight)
var $target = $('#div-' + type + 'm-2')
var scrollspy = $content.data('bs.scrollspy')
- assert.ok(scrollspy._offsets[1] === $target.offset().top, 'offset method with ' + type + ' option')
- assert.ok(scrollspy._offsets[1] !== $target.position().top, 'position method with ' + type + ' option')
+ assert.strictEqual(scrollspy._offsets[1], $target.offset().top, 'offset method with ' + type + ' option')
+ assert.notStrictEqual(scrollspy._offsets[1], $target.position().top, 'position method with ' + type + ' option')
$navbar.remove()
$content.remove()
}
var $target = $('#div-' + type + 'm-2')
var scrollspy = $content.data('bs.scrollspy')
- assert.ok(scrollspy._offsets[1] !== $target.offset().top, 'offset method with ' + type + ' option')
- assert.ok(scrollspy._offsets[1] === $target.position().top, 'position method with ' + type + ' option')
+ assert.notStrictEqual(scrollspy._offsets[1], $target.offset().top, 'offset method with ' + type + ' option')
+ assert.strictEqual(scrollspy._offsets[1], $target.position().top, 'position method with ' + type + ' option')
$navbar.remove()
$content.remove()
}
assert.expect(2)
var $el = $('<div/>')
var $tab = $el.bootstrapTab()
- assert.ok($tab instanceof $, 'returns jquery collection')
+ assert.true($tab instanceof $, 'returns jquery collection')
assert.strictEqual($tab[0], $el[0], 'collection contains element')
})
var $tabs = $(tabsHTML).appendTo('#qunit-fixture')
$tabs.find('li:last-child a').trigger('click')
- assert.notOk($tabs.find('li:first-child a').hasClass('active'))
- assert.ok($tabs.find('li:last-child a').hasClass('active'))
+ assert.false($tabs.find('li:first-child a').hasClass('active'))
+ assert.true($tabs.find('li:last-child a').hasClass('active'))
})
QUnit.test('selected tab should deactivate previous selected link in dropdown', function (assert) {
var $tabs = $(tabsHTML).appendTo('#qunit-fixture')
$tabs.find('li:first-child a').trigger('click')
- assert.ok($tabs.find('li:first-child a').hasClass('active'))
- assert.notOk($tabs.find('li:last-child a').hasClass('active'))
- assert.notOk($tabs.find('li:last-child .dropdown-menu a:first-child').hasClass('active'))
+ assert.true($tabs.find('li:first-child a').hasClass('active'))
+ assert.false($tabs.find('li:last-child a').hasClass('active'))
+ assert.false($tabs.find('li:last-child .dropdown-menu a:first-child').hasClass('active'))
})
QUnit.test('should support li > .dropdown-item', function (assert) {
var $tabs = $(tabsHTML).appendTo('#qunit-fixture')
$tabs.find('.dropdown-item').trigger('click')
- assert.ok($tabs.find('.dropdown-item').hasClass('active'))
- assert.notOk($tabs.find('.nav-link:not(.dropdown-toggle)').hasClass('active'))
+ assert.true($tabs.find('.dropdown-item').hasClass('active'))
+ assert.false($tabs.find('.nav-link:not(.dropdown-toggle)').hasClass('active'))
})
QUnit.test('Nested tabs', function (assert) {
$(tabsHTML).appendTo('#qunit-fixture')
$('#tabNested2').on('shown.bs.tab', function () {
- assert.ok($('#x-tab1').hasClass('active'))
+ assert.true($('#x-tab1').hasClass('active'))
done()
})
$('#tab1').on('shown.bs.tab', function () {
- assert.ok($('#x-tab1').hasClass('active'))
+ assert.true($('#x-tab1').hasClass('active'))
$('#tabNested2').trigger($.Event('click'))
})
.trigger($.Event('click'))
$(tabsHTML).appendTo('#qunit-fixture')
$('#tab-profile')
.on('shown.bs.tab', function () {
- assert.ok($('#profile').hasClass('fade'))
- assert.ok($('#profile').hasClass('show'))
+ assert.true($('#profile').hasClass('fade'))
+ assert.true($('#profile').hasClass('show'))
$('#tab-home')
.on('shown.bs.tab', function () {
- assert.ok($('#profile').hasClass('fade'))
- assert.notOk($('#profile').hasClass('show'))
- assert.ok($('#home').hasClass('fade'))
- assert.ok($('#home').hasClass('show'))
+ assert.true($('#profile').hasClass('fade'))
+ assert.false($('#profile').hasClass('show'))
+ assert.true($('#home').hasClass('fade'))
+ assert.true($('#home').hasClass('show'))
done()
})
var $el = $('<div/>')
var $toast = $el.bootstrapToast()
- assert.ok($toast instanceof $, 'returns jquery collection')
+ assert.true($toast instanceof $, 'returns jquery collection')
assert.strictEqual($toast[0], $el[0], 'collection contains element')
})
.appendTo($('#qunit-fixture'))
$toast.on('hidden.bs.toast', function () {
- assert.strictEqual($toast.hasClass('show'), false)
+ assert.false($toast.hasClass('show'))
done()
})
.bootstrapToast('show')
.appendTo($('#qunit-fixture'))
$toast.on('shown.bs.toast', function () {
- assert.strictEqual($toast.hasClass('fade'), false)
+ assert.false($toast.hasClass('fade'))
done()
})
.bootstrapToast('show')
$toast.bootstrapToast('hide')
})
.on('hidden.bs.toast', function () {
- assert.strictEqual($toast.hasClass('show'), false)
+ assert.false($toast.hasClass('show'))
done()
})
.bootstrapToast('show')
$toast.bootstrapToast('hide')
- assert.strictEqual(spy.called, true)
+ assert.true(spy.called)
})
QUnit.test('should allow to destroy toast', function (assert) {
.bootstrapToast()
.appendTo($('#qunit-fixture'))
- assert.ok(typeof $toast.data('bs.toast') !== 'undefined')
+ assert.notStrictEqual(typeof $toast.data('bs.toast'), 'undefined')
$toast.bootstrapToast('dispose')
- assert.ok(typeof $toast.data('bs.toast') === 'undefined')
+ assert.strictEqual(typeof $toast.data('bs.toast'), 'undefined')
})
QUnit.test('should allow to destroy toast and hide it before that', function (assert) {
$toast.one('shown.bs.toast', function () {
setTimeout(function () {
- assert.ok($toast.hasClass('show'))
- assert.ok(typeof $toast.data('bs.toast') !== 'undefined')
+ assert.true($toast.hasClass('show'))
+ assert.notStrictEqual(typeof $toast.data('bs.toast'), 'undefined')
$toast.bootstrapToast('dispose')
- assert.ok(typeof $toast.data('bs.toast') === 'undefined')
- assert.ok($toast.hasClass('show') === false)
+ assert.strictEqual(typeof $toast.data('bs.toast'), 'undefined')
+ assert.false($toast.hasClass('show'))
done()
}, 1)
.appendTo($('#qunit-fixture'))
$toast.on('shown.bs.toast', function () {
- assert.strictEqual($toast.hasClass('show'), true)
+ assert.true($toast.hasClass('show'))
done()
})
.bootstrapToast('show')
$toast
.on('shown.bs.toast', function () {
- assert.strictEqual($toast.hasClass('show'), true)
+ assert.true($toast.hasClass('show'))
var button = $toast.find('.close')
button.trigger('click')
})
.on('hidden.bs.toast', function () {
- assert.strictEqual($toast.hasClass('show'), false)
+ assert.false($toast.hasClass('show'))
done()
})
.bootstrapToast('show')
var shownCalled = false
function assertDone() {
setTimeout(function () {
- assert.strictEqual(shownCalled, false)
+ assert.false(shownCalled)
done()
}, 20)
}
setTimeout(function () {
toast._config.autohide = false
$toast.on('shown.bs.toast', function () {
- assert.ok(spyClearTimeout.called)
- assert.ok(toast._timeout === null)
+ assert.true(spyClearTimeout.called)
+ assert.strictEqual(toast._timeout, null)
done()
})
$toast.bootstrapToast('show')
var hiddenCalled = false
function assertDone() {
setTimeout(function () {
- assert.strictEqual(hiddenCalled, false)
+ assert.false(hiddenCalled)
done()
}, 20)
}
assert.expect(2)
var $el = $('<div/>')
var $tooltip = $el.bootstrapTooltip()
- assert.ok($tooltip instanceof $, 'returns jquery collection')
+ assert.true($tooltip instanceof $, 'returns jquery collection')
assert.strictEqual($tooltip[0], $el[0], 'collection contains element')
})
QUnit.test('should expose default settings', function (assert) {
assert.expect(1)
- assert.ok($.fn.bootstrapTooltip.Constructor.Default, 'defaults is defined')
+ assert.ok($.fn.bootstrapTooltip.Constructor.Default, 'defaults are defined')
})
QUnit.test('should empty title attribute', function (assert) {
assert.strictEqual($('#' + id).length, 1, 'has a unique id')
assert.strictEqual($('.tooltip').attr('aria-describedby'), $trigger.attr('id'), 'tooltip id and aria-describedby on trigger match')
- assert.ok($trigger[0].hasAttribute('aria-describedby'), 'trigger has aria-describedby')
+ assert.true($trigger[0].hasAttribute('aria-describedby'), 'trigger has aria-describedby')
})
QUnit.test('should remove aria-describedby from trigger on hide', function (assert) {
$trigger
.one('shown.bs.tooltip', function () {
- assert.ok($trigger[0].hasAttribute('aria-describedby'), 'trigger has aria-describedby')
+ assert.true($trigger[0].hasAttribute('aria-describedby'), 'trigger has aria-describedby')
$trigger.bootstrapTooltip('hide')
})
.one('hidden.bs.tooltip', function () {
- assert.ok(!$trigger[0].hasAttribute('aria-describedby'), 'trigger does not have aria-describedby')
+ assert.false($trigger[0].hasAttribute('aria-describedby'), 'trigger does not have aria-describedby')
done()
})
.bootstrapTooltip('show')
$tooltip
.one('shown.bs.tooltip', function () {
- assert.ok($('.tooltip')
- .is('.fade.bs-tooltip-bottom.show'), 'has correct classes applied')
+ assert.true($('.tooltip').is('.fade.bs-tooltip-bottom.show'), 'has correct classes applied')
$tooltip.bootstrapTooltip('hide')
})
.one('shown.bs.tooltip', function () {
assert.notStrictEqual($('.tooltip').length, 0, 'tooltip inserted')
assert.strictEqual($('.tooltip').text(), '<3 writing tests', 'title inserted')
- assert.ok(!$.contains($('.tooltip').get(0), title), 'title node copied, not moved')
+ assert.false($.contains($('.tooltip').get(0), title), 'title node copied, not moved')
done()
})
.bootstrapTooltip('show')
$tooltip
.one('shown.bs.tooltip', function () {
- assert.ok($('.tooltip').hasClass('some-class'), 'custom class is present')
+ assert.true($('.tooltip').hasClass('some-class'), 'custom class is present')
$tooltip.bootstrapTooltip('hide')
})
.one('hidden.bs.tooltip', function () {
})
QUnit.test('should destroy tooltip', function (assert) {
- assert.expect(7)
+ assert.expect(9)
var $tooltip = $('<div/>')
.bootstrapTooltip()
.on('click.foo', function () {})
assert.ok($tooltip.data('bs.tooltip'), 'tooltip has data')
- assert.ok($._data($tooltip[0], 'events').mouseover && $._data($tooltip[0], 'events').mouseout, 'tooltip has hover events')
+ assert.ok($._data($tooltip[0], 'events').mouseover, 'tooltip has mouseover event')
+ assert.ok($._data($tooltip[0], 'events').mouseout, 'tooltip has mouseout event')
assert.strictEqual($._data($tooltip[0], 'events').click[0].namespace, 'foo', 'tooltip has extra click.foo event')
$tooltip.bootstrapTooltip('show')
$tooltip.bootstrapTooltip('dispose')
- assert.ok(!$tooltip.hasClass('show'), 'tooltip is hidden')
- assert.ok(!$._data($tooltip[0], 'bs.tooltip'), 'tooltip does not have data')
+ assert.false($tooltip.hasClass('show'), 'tooltip is hidden')
+ assert.strictEqual(typeof $._data($tooltip[0], 'bs.tooltip'), 'undefined', 'tooltip does not have data')
assert.strictEqual($._data($tooltip[0], 'events').click[0].namespace, 'foo', 'tooltip still has click.foo')
- assert.ok(!$._data($tooltip[0], 'events').mouseover && !$._data($tooltip[0], 'events').mouseout, 'tooltip does not have hover events')
+ assert.strictEqual(typeof $._data($tooltip[0], 'events').mouseover, 'undefined', 'tooltip does not have mouseover event')
+ assert.strictEqual(typeof $._data($tooltip[0], 'events').mouseout, 'undefined', 'tooltip does not have mouseout event')
})
// QUnit.test('should show tooltip with delegate selector on click', function (assert) {
// })
// $div.find('a').trigger('click')
- // assert.ok($('.tooltip').is('.fade.in'), 'tooltip is faded in')
+ // assert.true($('.tooltip').is('.fade.in'), 'tooltip is faded in')
// $div.find('a').trigger('click')
// assert.strictEqual($div.data('bs.tooltip').tip.parentNode, null, 'tooltip removed')
})
.bootstrapTooltip('toggle')
- assert.ok($('.tooltip').is('.fade.show'), 'tooltip is faded active')
+ assert.true($('.tooltip').is('.fade.show'), 'tooltip is faded active')
})
QUnit.test('should hide previously shown tooltip when toggle is called on tooltip', function (assert) {
})
.on('inserted.bs.tooltip', function () {
var $tooltip = $($(this).data('bs.tooltip').tip)
- assert.ok($tooltip.hasClass('bs-tooltip-right'))
- assert.ok(typeof $tooltip.attr('style') === 'undefined')
+ assert.true($tooltip.hasClass('bs-tooltip-right'))
+ assert.strictEqual(typeof $tooltip.attr('style'), 'undefined')
$styles.remove()
done()
})
passed = false
}
- assert.ok(passed, '.tooltip(\'show\') should not throw an error if element no longer is in dom')
+ assert.true(passed, '.tooltip(\'show\') should not throw an error if element no longer is in dom')
})
QUnit.test('should show tooltip if leave event hasn\'t occurred before delay expires', function (assert) {
})
setTimeout(function () {
- assert.ok(!$('.tooltip').is('.fade.show'), '100ms: tooltip is not faded active')
+ assert.false($('.tooltip').is('.fade.show'), '100ms: tooltip is not faded active')
}, 100)
setTimeout(function () {
- assert.ok($('.tooltip').is('.fade.show'), '200ms: tooltip is faded active')
+ assert.true($('.tooltip').is('.fade.show'), '200ms: tooltip is faded active')
done()
}, 200)
})
setTimeout(function () {
- assert.ok(!$('.tooltip').is('.fade.show'), '100ms: tooltip not faded active')
+ assert.false($('.tooltip').is('.fade.show'), '100ms: tooltip not faded active')
$tooltip.trigger('mouseout')
}, 100)
setTimeout(function () {
- assert.ok(!$('.tooltip').is('.fade.show'), '200ms: tooltip not faded active')
+ assert.false($('.tooltip').is('.fade.show'), '200ms: tooltip not faded active')
done()
}, 200)
})
setTimeout(function () {
- assert.ok($('.tooltip').is('.fade.show'), '1ms: tooltip faded active')
+ assert.true($('.tooltip').is('.fade.show'), '1ms: tooltip faded active')
$tooltip.trigger('mouseout')
setTimeout(function () {
- assert.ok($('.tooltip').is('.fade.show'), '100ms: tooltip still faded active')
+ assert.true($('.tooltip').is('.fade.show'), '100ms: tooltip still faded active')
$tooltip.trigger('mouseenter')
}, 100)
setTimeout(function () {
- assert.ok($('.tooltip').is('.fade.show'), '200ms: tooltip still faded active')
+ assert.true($('.tooltip').is('.fade.show'), '200ms: tooltip still faded active')
done()
}, 200)
}, 0)
})
setTimeout(function () {
- assert.ok(!$('.tooltip').is('.fade.show'), '100ms: tooltip not faded active')
+ assert.false($('.tooltip').is('.fade.show'), '100ms: tooltip not faded active')
$tooltip.trigger('mouseout')
}, 100)
setTimeout(function () {
- assert.ok(!$('.tooltip').is('.fade.show'), '200ms: tooltip not faded active')
+ assert.false($('.tooltip').is('.fade.show'), '200ms: tooltip not faded active')
done()
}, 200)
})
setTimeout(function () {
- assert.ok(!$('.tooltip').is('.fade.show'), '100ms: tooltip not faded active')
+ assert.false($('.tooltip').is('.fade.show'), '100ms: tooltip not faded active')
$tooltip.trigger('mouseout')
}, 100)
setTimeout(function () {
- assert.ok(!$('.tooltip').is('.fade.show'), '250ms: tooltip not faded active')
+ assert.false($('.tooltip').is('.fade.show'), '250ms: tooltip not faded active')
done()
}, 250)
})
setTimeout(function () {
- assert.ok($($tooltip.data('bs.tooltip').tip).is('.fade.show'), '1ms: tooltip faded active')
+ assert.true($($tooltip.data('bs.tooltip').tip).is('.fade.show'), '1ms: tooltip faded active')
$tooltip.trigger('mouseout')
setTimeout(function () {
- assert.ok($($tooltip.data('bs.tooltip').tip).is('.fade.show'), '100ms: tooltip still faded active')
+ assert.true($($tooltip.data('bs.tooltip').tip).is('.fade.show'), '100ms: tooltip still faded active')
}, 100)
setTimeout(function () {
- assert.ok(!$($tooltip.data('bs.tooltip').tip).is('.show'), '200ms: tooltip removed')
+ assert.false($($tooltip.data('bs.tooltip').tip).is('.show'), '200ms: tooltip removed')
done()
}, 200)
}, 0)
$('#tt-outer').trigger('mouseleave')
assert.strictEqual(currentUid, $('#tt-content').text())
- assert.ok(obj._hoverState === 'out', 'the tooltip hoverState should be set to "out"')
+ assert.strictEqual(obj._hoverState, 'out', 'the tooltip hoverState should be set to "out"')
$('#tt-outer').trigger('mouseenter')
- assert.ok(obj._hoverState === 'show', 'the tooltip hoverState should be set to "show"')
+ assert.strictEqual(obj._hoverState, 'show', 'the tooltip hoverState should be set to "show"')
assert.strictEqual(currentUid, $('#tt-content').text())
})
['mouseenter', 'focusin', 'click', 'click', 'mouseleave', 'focusout']
]
- assert.ok(!showingTooltip())
+ assert.false(showingTooltip())
$.each(tests, function (idx, triggers) {
for (var i = 0, len = triggers.length; i < len; i++) {
}
$el.trigger('click')
- assert.ok(showingTooltip(), 'tooltip is faded in')
+ assert.true(showingTooltip(), 'tooltip is faded in')
$el.bootstrapTooltip('hide')
- assert.ok(!showingTooltip(), 'tooltip was faded out')
+ assert.false(showingTooltip(), 'tooltip was faded out')
$el.trigger('click')
- assert.ok(showingTooltip(), 'tooltip is faded in again')
+ assert.true(showingTooltip(), 'tooltip is faded in again')
})
QUnit.test('should hide tooltip when their containing modal is closed', function (assert) {
.on('hidden.bs.tooltip', function () {
var tooltip = $el.data('bs.tooltip')
var $tooltip = $(tooltip.getTipElement())
- assert.ok($tooltip.hasClass('tooltip'))
- assert.ok($tooltip.hasClass('fade'))
+ assert.true($tooltip.hasClass('tooltip'))
+ assert.true($tooltip.hasClass('fade'))
done()
})
.appendTo('#qunit-fixture')
.bootstrapTooltip()
.on('shown.bs.tooltip', function () {
- assert.strictEqual($('.tooltip').hasClass('show'), true)
+ assert.true($('.tooltip').hasClass('show'))
done()
})
$trigger.bootstrapTooltip('disable')
$trigger.trigger($.Event('click'))
setTimeout(function () {
- assert.strictEqual($('.tooltip').length === 0, true)
+ assert.strictEqual($('.tooltip').length, 0)
$trigger.bootstrapTooltip('enable')
$trigger.trigger($.Event('click'))
}, 200)
var spyPopper = sinon.spy(tooltip._popper, 'scheduleUpdate')
tooltip.update()
- assert.ok(spyPopper.called)
+ assert.true(spyPopper.called)
})
QUnit.test('should not call Popper to update', function (assert) {
var tooltip = $tooltip.data('bs.tooltip')
tooltip.update()
- assert.ok(tooltip._popper === null)
+ assert.strictEqual(tooltip._popper, null)
})
QUnit.test('should use Popper to get the tip on placement change', function (assert) {
placement: 'auto'
})
- assert.ok(tooltip.tip === $tipTest[0])
+ assert.strictEqual(tooltip.tip, $tipTest[0])
})
QUnit.test('should toggle enabled', function (assert) {
var tooltip = $tooltip.data('bs.tooltip')
- assert.strictEqual(tooltip._isEnabled, true)
+ assert.true(tooltip._isEnabled)
tooltip.toggleEnabled()
- assert.strictEqual(tooltip._isEnabled, false)
+ assert.false(tooltip._isEnabled)
tooltip.toggleEnabled()
- assert.strictEqual(tooltip._isEnabled, true)
+ assert.true(tooltip._isEnabled)
})
QUnit.test('should create offset modifier correctly when offset option is a function', function (assert) {
var tooltip = $trigger.data('bs.tooltip')
var offset = tooltip._getOffset()
- assert.ok(typeof offset.offset === 'undefined')
- assert.ok(typeof offset.fn === 'function')
+ assert.strictEqual(typeof offset.offset, 'undefined')
+ assert.strictEqual(typeof offset.fn, 'function')
})
QUnit.test('should create offset modifier correctly when offset option is not a function', function (assert) {
var offset = tooltip._getOffset()
assert.strictEqual(offset.offset, myOffset)
- assert.ok(typeof offset.fn === 'undefined')
+ assert.strictEqual(typeof offset.fn, 'undefined')
})
QUnit.test('should disable sanitizer', function (assert) {
})
var tooltip = $trigger.data('bs.tooltip')
- assert.strictEqual(tooltip.config.sanitize, false)
+ assert.false(tooltip.config.sanitize)
})
QUnit.test('should sanitize template by removing disallowed tags', function (assert) {
var tooltip = $trigger.data('bs.tooltip')
assert.strictEqual(tooltip.config.template.indexOf('<a'), -1)
- assert.ok(tooltip.config.template.indexOf('span') !== -1)
+ assert.notStrictEqual(tooltip.config.template.indexOf('span'), -1)
})
QUnit.test('should allow passing a custom function for sanitization', function (assert) {
var tooltip = $trigger.data('bs.tooltip')
- assert.ok(tooltip.config.template.indexOf('span') !== -1)
+ assert.notStrictEqual(tooltip.config.template.indexOf('span'), -1)
})
QUnit.test('should allow passing aria attributes', function (assert) {
var tooltip = $trigger.data('bs.tooltip')
- assert.ok(tooltip.config.template.indexOf('aria-pressed') !== -1)
+ assert.notStrictEqual(tooltip.config.template.indexOf('aria-pressed'), -1)
})
QUnit.test('should not sanitize element content', function (assert) {
var tooltip = $trigger.data('bs.tooltip')
- assert.strictEqual(tooltip.config.sanitize, true)
+ assert.true(tooltip.config.sanitize)
})
QUnit.test('should allow to pass config to Popper with `popperConfig`', function (assert) {
var tooltip = $('.tooltip')
- assert.strictEqual(tooltip.hasClass('a b'), true)
- assert.strictEqual(tooltip.hasClass('tooltip fade bs-tooltip-top show'), true)
+ assert.true(tooltip.hasClass('a b'))
+ assert.true(tooltip.hasClass('tooltip fade bs-tooltip-top show'))
})
QUnit.test('additional classes can be applied via config string', function (assert) {
var tooltip = $('.tooltip')
- assert.strictEqual(tooltip.hasClass('a b'), true)
- assert.strictEqual(tooltip.hasClass('tooltip fade bs-tooltip-top show'), true)
+ assert.true(tooltip.hasClass('a b'))
+ assert.true(tooltip.hasClass('tooltip fade bs-tooltip-top show'))
})
QUnit.test('additional classes can be applied via function', function (assert) {
var tooltip = $('.tooltip')
- assert.strictEqual(tooltip.hasClass('a b'), true)
- assert.strictEqual(tooltip.hasClass('tooltip fade bs-tooltip-top show'), true)
+ assert.true(tooltip.hasClass('a b'))
+ assert.true(tooltip.hasClass('tooltip fade bs-tooltip-top show'))
})
QUnit.test('HTML content can be passed through sanitation multiple times', function (assert) {
Util.typeCheckConfig(namePlugin, config, defaultType)
- assert.strictEqual(true, true)
+ assert.true(true)
})
QUnit.test('Util.isElement should check if we passed an element or not', function (assert) {
assert.strictEqual(Util.isElement($div), 1)
assert.strictEqual(Util.isElement($div[0]), 1)
- assert.strictEqual(typeof Util.isElement({}) === 'undefined', true)
+ assert.strictEqual(typeof Util.isElement({}), 'undefined')
})
QUnit.test('Util.getTransitionDurationFromElement should accept transition durations in milliseconds', function (assert) {
var id = Util.getUID('test')
var id2 = Util.getUID('test')
- assert.ok(id !== id2, id + ' !== ' + id2)
+ assert.notStrictEqual(id, id2, id + ' !== ' + id2)
id = Util.getUID('test')
$('<div id="' + id + '"></div>').appendTo($('#qunit-fixture'))
id2 = Util.getUID('test')
- assert.ok(id !== id2, id + ' !== ' + id2)
+ assert.notStrictEqual(id, id2, id + ' !== ' + id2)
})
QUnit.test('Util.supportsTransitionEnd should return true', function (assert) {
assert.expect(1)
- assert.ok(Util.supportsTransitionEnd())
+ assert.true(Util.supportsTransitionEnd())
})
QUnit.test('Util.findShadowRoot should find the shadow DOM root', function (assert) {
var $div = $('<div id="test"></div>').appendTo($('#qunit-fixture'))
if (!document.documentElement.attachShadow) {
- assert.strictEqual(null, Util.findShadowRoot($div[0]))
+ assert.strictEqual(Util.findShadowRoot($div[0]), null)
} else {
var sandbox = sinon.createSandbox()
return $div
})
- assert.strictEqual(null, Util.findShadowRoot($div[0]))
+ assert.strictEqual(Util.findShadowRoot($div[0]), null)
sandbox.restore()
}
})
projects / thirdparty / bootstrap.git / commitdiff
