Browse Source

Updates testing js

pull/912/head
jlukic 11 years ago
parent
commit
7ce0e353d9
4 changed files with 1909 additions and 1011 deletions
  1. 69
      package.json
  2. 713
      test/helpers/jasmine-jquery.js
  3. 315
      test/helpers/jasmine-sinon.js
  4. 1823
      test/helpers/sinon.js

69
package.json

@ -1,6 +1,6 @@
{ {
"name": "semantic", "name": "semantic",
"version": "0.15.0",
"version": "0.15.4",
"title": "Semantic UI", "title": "Semantic UI",
"description": "Semantic empowers designers and developers by creating a shared vocabulary for UI.", "description": "Semantic empowers designers and developers by creating a shared vocabulary for UI.",
"homepage": "http://www.semantic-ui.com", "homepage": "http://www.semantic-ui.com",
@ -13,36 +13,41 @@
"type": "git", "type": "git",
"url": "git://github.com/Semantic-Org/Semantic-UI.git" "url": "git://github.com/Semantic-Org/Semantic-UI.git"
}, },
"dependencies": {},
"dependencies": {
"jquery": "x.x.x"
},
"devDependencies": { "devDependencies": {
"docpad": "~6.63.3",
"docpad-plugin-eco": "~2.0.3",
"docpad-plugin-ghpages": "~2.4.3",
"docpad-plugin-partials": "~2.8.1",
"grunt": "~0.4.1",
"grunt-contrib-watch": "~0.5.3",
"grunt-contrib-clean": "~0.5.0",
"grunt-contrib-uglify": "~0.2.2",
"grunt-contrib-cssmin": "~0.6.1",
"grunt-contrib-less": "~0.7.0",
"grunt-contrib-copy": "~0.4.1",
"grunt-docco": "~0.2.0",
"grunt-bower-task": "~0.3.1",
"grunt-css": "~0.5.4",
"grunt-contrib-compress": "~0.5.2",
"grunt-contrib-concat": "~0.3.0",
"grunt-docco-multi": "0.0.2",
"grunt-cssjanus": "~0.1.1",
"karma": "~0.10.2",
"grunt-karma": "~0.6.2",
"karma-spec-reporter": "0.0.5",
"grunt-clear": "~0.2.1",
"grunt-autoprefixer": "~0.4.0",
"grunt-karma-coveralls": "~2.2.0",
"karma-coverage": "~0.1.4",
"docpad-plugin-partials": "~2.8.1",
"docpad-plugin-ghpages": "~2.4.3",
"docpad-plugin-eco": "~2.0.3",
"docpad": "~6.63.3"
"docpad": "x.x.x",
"docpad-plugin-eco": "x.x.x",
"docpad-plugin-ghpages": "x.x.x",
"docpad-plugin-partials": "x.x.x",
"grunt": "x.x.x",
"grunt-contrib-watch": "x.x.x",
"grunt-contrib-clean": "x.x.x",
"grunt-contrib-uglify": "x.x.x",
"grunt-contrib-cssmin": "x.x.x",
"grunt-contrib-less": "x.x.x",
"grunt-contrib-copy": "x.x.x",
"grunt-docco": "x.x.x",
"grunt-bower-task": "x.x.x",
"grunt-css": "x.x.x",
"grunt-contrib-compress": "x.x.x",
"grunt-contrib-concat": "x.x.x",
"grunt-replace": "x.x.x",
"grunt-docco-multi": "x.x.x",
"grunt-cssjanus": "x.x.x",
"karma": "x.x.x",
"grunt-karma": "x.x.x",
"karma-spec-reporter": "x.x.x",
"karma-phantomjs-launcher": "x.x.x",
"karma-jasmine": "x.x.x",
"grunt-clear": "x.x.x",
"grunt-autoprefixer": "x.x.x",
"grunt-karma-coveralls": "x.x.x",
"karma-coverage": "~0.x.x",
"docpad-plugin-partials": "x.x.x",
"docpad-plugin-ghpages": "x.x.x",
"docpad-plugin-eco": "x.x.x",
"docpad": "x.x.x"
} }
}
}

713
test/helpers/jasmine-jquery.js

@ -1,11 +1,11 @@
/*! /*!
Jasmine-jQuery: a set of jQuery helpers for Jasmine tests. Jasmine-jQuery: a set of jQuery helpers for Jasmine tests.
Version 1.5.91
Version 2.1.0
https://github.com/velesin/jasmine-jquery https://github.com/velesin/jasmine-jquery
Copyright (c) 2010-2013 Wojciech Zawistowski, Travis Jeffery
Copyright (c) 2010-2014 Wojciech Zawistowski, Travis Jeffery
Permission is hereby granted, free of charge, to any person obtaining Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the a copy of this software and associated documentation files (the
@ -27,7 +27,7 @@ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ */
+function (jasmine, $) { "use strict";
+function (window, jasmine, $) { "use strict";
jasmine.spiedEventsKey = function (selector, eventName) { jasmine.spiedEventsKey = function (selector, eventName) {
return [$(selector).selector, eventName].toString() return [$(selector).selector, eventName].toString()
@ -104,7 +104,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
jasmine.Fixtures.prototype.addToContainer_ = function (html){ jasmine.Fixtures.prototype.addToContainer_ = function (html){
var container = $(document.body).find('#'+this.containerId).append(html) var container = $(document.body).find('#'+this.containerId).append(html)
if(!container.length){
if (!container.length) {
this.createContainer_(html) this.createContainer_(html)
} }
} }
@ -119,17 +120,36 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function (relativeUrl) { jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function (relativeUrl) {
var self = this var self = this
, url = this.makeFixtureUrl_(relativeUrl) , url = this.makeFixtureUrl_(relativeUrl)
, htmlText = ''
, request = $.ajax({ , request = $.ajax({
async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
cache: false, cache: false,
url: url, url: url,
success: function (data, status, $xhr) { success: function (data, status, $xhr) {
self.fixturesCache_[relativeUrl] = $xhr.responseText
},
error: function (jqXHR, status, errorThrown) {
throw new Error('Fixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + errorThrown.message + ')')
htmlText = $xhr.responseText
} }
}).fail(function ($xhr, status, err) {
throw new Error('Fixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + err.message + ')')
})
var scripts = $($.parseHTML(htmlText, true)).find('script[src]') || [];
scripts.each(function(){
$.ajax({
async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
cache: false,
dataType: 'script',
url: $(this).attr('src'),
success: function (data, status, $xhr) {
htmlText += '<script>' + $xhr.responseText + '</script>'
},
error: function ($xhr, status, err) {
throw new Error('Script could not be loaded: ' + scriptSrc + ' (status: ' + status + ', message: ' + err.message + ')')
}
});
}) })
self.fixturesCache_[relativeUrl] = htmlText;
} }
jasmine.Fixtures.prototype.makeFixtureUrl_ = function (relativeUrl){ jasmine.Fixtures.prototype.makeFixtureUrl_ = function (relativeUrl){
@ -235,8 +255,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
success: function (data) { success: function (data) {
self.fixturesCache_[relativeUrl] = data self.fixturesCache_[relativeUrl] = data
}, },
error: function (jqXHR, status, errorThrown) {
throw new Error('JSONFixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + errorThrown.message + ')')
error: function ($xhr, status, err) {
throw new Error('JSONFixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + err.message + ')')
} }
}) })
} }
@ -245,461 +265,548 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
return this[methodName].apply(this, passedArguments) return this[methodName].apply(this, passedArguments)
} }
jasmine.JQuery = function () {}
jasmine.jQuery = function () {}
jasmine.JQuery.browserTagCaseIndependentHtml = function (html) {
jasmine.jQuery.browserTagCaseIndependentHtml = function (html) {
return $('<div/>').append(html).html() return $('<div/>').append(html).html()
} }
jasmine.JQuery.elementToString = function (element) {
var domEl = $(element).get(0)
jasmine.jQuery.elementToString = function (element) {
return $(element).map(function () { return this.outerHTML; }).toArray().join(', ')
}
if (domEl === undefined || domEl.cloneNode)
return $('<div />').append($(element).clone()).html()
else
return element.toString()
var data = {
spiedEvents: {}
, handlers: []
} }
jasmine.JQuery.matchersClass = {}
jasmine.jQuery.events = {
spyOn: function (selector, eventName) {
var handler = function (e) {
data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] = jasmine.util.argsToArray(arguments)
}
!function (namespace) {
var data = {
spiedEvents: {}
, handlers: []
}
$(selector).on(eventName, handler)
data.handlers.push(handler)
namespace.events = {
spyOn: function (selector, eventName) {
var handler = function (e) {
data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] = jasmine.util.argsToArray(arguments)
return {
selector: selector,
eventName: eventName,
handler: handler,
reset: function (){
delete data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
} }
}
},
$(selector).on(eventName, handler)
data.handlers.push(handler)
args: function (selector, eventName) {
var actualArgs = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
return {
selector: selector,
eventName: eventName,
handler: handler,
reset: function (){
delete data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
}
}
},
if (!actualArgs) {
throw "There is no spy for " + eventName + " on " + selector.toString() + ". Make sure to create a spy using spyOnEvent."
}
args: function (selector, eventName) {
var actualArgs = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
return actualArgs
},
if (!actualArgs) {
throw "There is no spy for " + eventName + " on " + selector.toString() + ". Make sure to create a spy using spyOnEvent."
}
wasTriggered: function (selector, eventName) {
return !!(data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)])
},
return actualArgs
},
wasTriggeredWith: function (selector, eventName, expectedArgs, util, customEqualityTesters) {
var actualArgs = jasmine.jQuery.events.args(selector, eventName).slice(1)
wasTriggered: function (selector, eventName) {
return !!(data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)])
},
if (Object.prototype.toString.call(expectedArgs) !== '[object Array]')
actualArgs = actualArgs[0]
wasTriggeredWith: function (selector, eventName, expectedArgs, env) {
var actualArgs = jasmine.JQuery.events.args(selector, eventName).slice(1)
if (Object.prototype.toString.call(expectedArgs) !== '[object Array]') {
actualArgs = actualArgs[0]
}
return env.equals_(expectedArgs, actualArgs)
},
return util.equals(expectedArgs, actualArgs, customEqualityTesters)
},
wasPrevented: function (selector, eventName) {
var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
, e = args ? args[0] : undefined
wasPrevented: function (selector, eventName) {
var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
, e = args ? args[0] : undefined
return e && e.isDefaultPrevented()
},
return e && e.isDefaultPrevented()
},
wasStopped: function (selector, eventName) {
var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
, e = args ? args[0] : undefined
return e && e.isPropagationStopped()
},
wasStopped: function (selector, eventName) {
var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
, e = args ? args[0] : undefined
return e && e.isPropagationStopped()
},
cleanUp: function () {
data.spiedEvents = {}
data.handlers = []
}
cleanUp: function () {
data.spiedEvents = {}
data.handlers = []
} }
}(jasmine.JQuery)
}
var hasProperty = function (actualValue, expectedValue) {
if (expectedValue === undefined)
return actualValue !== undefined
return actualValue === expectedValue
}
!function (){
var jQueryMatchers = {
toHaveClass: function (className) {
return this.actual.hasClass(className)
beforeEach(function () {
jasmine.addMatchers({
toHaveClass: function () {
return {
compare: function (actual, className) {
return { pass: $(actual).hasClass(className) }
}
}
}, },
toHaveCss: function (css){
for (var prop in css){
var value = css[prop]
// see issue #147 on gh
;if (value === 'auto' && this.actual.get(0).style[prop] === 'auto') continue
if (this.actual.css(prop) !== value) return false
toHaveCss: function () {
return {
compare: function (actual, css) {
for (var prop in css){
var value = css[prop]
// see issue #147 on gh
;if (value === 'auto' && $(actual).get(0).style[prop] === 'auto') continue
if ($(actual).css(prop) !== value) return { pass: false }
}
return { pass: true }
}
} }
return true
}, },
toBeVisible: function () { toBeVisible: function () {
return this.actual.is(':visible')
return {
compare: function (actual) {
return { pass: $(actual).is(':visible') }
}
}
}, },
toBeHidden: function () { toBeHidden: function () {
return this.actual.is(':hidden')
return {
compare: function (actual) {
return { pass: $(actual).is(':hidden') }
}
}
}, },
toBeSelected: function () { toBeSelected: function () {
return this.actual.is(':selected')
return {
compare: function (actual) {
return { pass: $(actual).is(':selected') }
}
}
}, },
toBeChecked: function () { toBeChecked: function () {
return this.actual.is(':checked')
return {
compare: function (actual) {
return { pass: $(actual).is(':checked') }
}
}
}, },
toBeEmpty: function () { toBeEmpty: function () {
return this.actual.is(':empty')
return {
compare: function (actual) {
return { pass: $(actual).is(':empty') }
}
}
}, },
toExist: function () {
return this.actual.length
toBeInDOM: function () {
return {
compare: function (actual) {
return { pass: $.contains(document.documentElement, $(actual)[0]) }
}
}
}, },
toHaveLength: function (length) {
return this.actual.length === length
toExist: function () {
return {
compare: function (actual) {
return { pass: $(actual).length }
}
}
}, },
toHaveAttr: function (attributeName, expectedAttributeValue) {
return hasProperty(this.actual.attr(attributeName), expectedAttributeValue)
toHaveLength: function () {
return {
compare: function (actual, length) {
return { pass: $(actual).length === length }
}
}
}, },
toHaveProp: function (propertyName, expectedPropertyValue) {
return hasProperty(this.actual.prop(propertyName), expectedPropertyValue)
toHaveAttr: function () {
return {
compare: function (actual, attributeName, expectedAttributeValue) {
return { pass: hasProperty($(actual).attr(attributeName), expectedAttributeValue) }
}
}
}, },
toHaveId: function (id) {
return this.actual.attr('id') == id
toHaveProp: function () {
return {
compare: function (actual, propertyName, expectedPropertyValue) {
return { pass: hasProperty($(actual).prop(propertyName), expectedPropertyValue) }
}
}
}, },
toHaveHtml: function (html) {
return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html)
toHaveId: function () {
return {
compare: function (actual, id) {
return { pass: $(actual).attr('id') == id }
}
}
}, },
toContainHtml: function (html){
var actualHtml = this.actual.html()
, expectedHtml = jasmine.JQuery.browserTagCaseIndependentHtml(html)
return (actualHtml.indexOf(expectedHtml) >= 0)
toHaveHtml: function () {
return {
compare: function (actual, html) {
return { pass: $(actual).html() == jasmine.jQuery.browserTagCaseIndependentHtml(html) }
}
}
}, },
toHaveText: function (text) {
var trimmedText = $.trim(this.actual.text())
toContainHtml: function () {
return {
compare: function (actual, html) {
var actualHtml = $(actual).html()
, expectedHtml = jasmine.jQuery.browserTagCaseIndependentHtml(html)
if (text && $.isFunction(text.test)) {
return text.test(trimmedText)
} else {
return trimmedText == text
return { pass: (actualHtml.indexOf(expectedHtml) >= 0) }
}
} }
}, },
toContainText: function (text) {
var trimmedText = $.trim(this.actual.text())
toHaveText: function () {
return {
compare: function (actual, text) {
var trimmedText = $.trim($(actual).text())
if (text && $.isFunction(text.test)) {
return text.test(trimmedText)
} else {
return trimmedText.indexOf(text) != -1
if (text && $.isFunction(text.test)) {
return { pass: text.test(trimmedText) }
} else {
return { pass: trimmedText == text }
}
}
} }
}, },
toHaveValue: function (value) {
return this.actual.val() === value
toContainText: function () {
return {
compare: function (actual, text) {
var trimmedText = $.trim($(actual).text())
if (text && $.isFunction(text.test)) {
return { pass: text.test(trimmedText) }
} else {
return { pass: trimmedText.indexOf(text) != -1 }
}
}
}
}, },
toHaveData: function (key, expectedValue) {
return hasProperty(this.actual.data(key), expectedValue)
toHaveValue: function () {
return {
compare: function (actual, value) {
return { pass: $(actual).val() === value }
}
}
}, },
toBe: function (selector) {
return this.actual.is(selector)
toHaveData: function () {
return {
compare: function (actual, key, expectedValue) {
return { pass: hasProperty($(actual).data(key), expectedValue) }
}
}
}, },
toContain: function (selector) {
return this.actual.find(selector).length
toContainElement: function () {
return {
compare: function (actual, selector) {
if (window.debug) debugger
return { pass: $(actual).find(selector).length }
}
}
}, },
toBeMatchedBy: function (selector) {
return this.actual.filter(selector).length
toBeMatchedBy: function () {
return {
compare: function (actual, selector) {
return { pass: $(actual).filter(selector).length }
}
}
}, },
toBeDisabled: function (selector){
return this.actual.is(':disabled')
toBeDisabled: function () {
return {
compare: function (actual, selector) {
return { pass: $(actual).is(':disabled') }
}
}
}, },
toBeFocused: function (selector) { toBeFocused: function (selector) {
return this.actual[0] === this.actual[0].ownerDocument.activeElement
return {
compare: function (actual, selector) {
return { pass: $(actual)[0] === $(actual)[0].ownerDocument.activeElement }
}
}
}, },
toHandle: function (event) {
var events = $._data(this.actual.get(0), "events")
toHandle: function () {
return {
compare: function (actual, event) {
var events = $._data($(actual).get(0), "events")
if(!events || !event || typeof event !== "string") {
return false
}
if (!events || !event || typeof event !== "string") {
return { pass: false }
}
var namespaces = event.split(".")
, eventType = namespaces.shift()
, sortedNamespaces = namespaces.slice(0).sort()
, namespaceRegExp = new RegExp("(^|\\.)" + sortedNamespaces.join("\\.(?:.*\\.)?") + "(\\.|$)")
var namespaces = event.split(".")
, eventType = namespaces.shift()
, sortedNamespaces = namespaces.slice(0).sort()
, namespaceRegExp = new RegExp("(^|\\.)" + sortedNamespaces.join("\\.(?:.*\\.)?") + "(\\.|$)")
if(events[eventType] && namespaces.length) {
for(var i = 0; i < events[eventType].length; i++) {
var namespace = events[eventType][i].namespace
if (events[eventType] && namespaces.length) {
for (var i = 0; i < events[eventType].length; i++) {
var namespace = events[eventType][i].namespace
if(namespaceRegExp.test(namespace)) {
return true
if (namespaceRegExp.test(namespace))
return { pass: true }
}
} else {
return { pass: (events[eventType] && events[eventType].length > 0) }
} }
return { pass: false }
} }
} else {
return events[eventType] && events[eventType].length > 0
} }
}, },
toHandleWith: function (eventName, eventHandler) {
var normalizedEventName = eventName.split('.')[0]
, stack = $._data(this.actual.get(0), "events")[normalizedEventName]
toHandleWith: function () {
return {
compare: function (actual, eventName, eventHandler) {
var normalizedEventName = eventName.split('.')[0]
, stack = $._data($(actual).get(0), "events")[normalizedEventName]
for (var i = 0; i < stack.length; i++) {
if (stack[i].handler == eventHandler) return true
for (var i = 0; i < stack.length; i++) {
if (stack[i].handler == eventHandler) return { pass: true }
}
return { pass: false }
}
} }
},
return false
}
}
toHaveBeenTriggeredOn: function () {
return {
compare: function (actual, selector) {
var result = { pass: jasmine.jQuery.events.wasTriggered(selector, actual) }
var hasProperty = function (actualValue, expectedValue) {
if (expectedValue === undefined) return actualValue !== undefined
result.message = result.pass ?
"Expected event " + $(actual) + " not to have been triggered on " + selector :
"Expected event " + $(actual) + " to have been triggered on " + selector
return actualValue == expectedValue
}
return result;
}
}
},
var bindMatcher = function (methodName) {
var builtInMatcher = jasmine.Matchers.prototype[methodName]
toHaveBeenTriggered: function (){
return {
compare: function (actual) {
var eventName = actual.eventName
, selector = actual.selector
, result = { pass: jasmine.jQuery.events.wasTriggered(selector, eventName) }
result.message = result.pass ?
"Expected event " + eventName + " not to have been triggered on " + selector :
"Expected event " + eventName + " to have been triggered on " + selector
jasmine.JQuery.matchersClass[methodName] = function () {
if (this.actual
&& (this.actual instanceof $
|| jasmine.isDomNode(this.actual))) {
this.actual = $(this.actual)
var result = jQueryMatchers[methodName].apply(this, arguments)
, element
return result
}
}
},
if (this.actual.get && (element = this.actual.get()[0]) && !$.isWindow(element) && element.tagName !== "HTML")
this.actual = jasmine.JQuery.elementToString(this.actual)
toHaveBeenTriggeredOnAndWith: function (j$, customEqualityTesters) {
return {
compare: function (actual, selector, expectedArgs) {
var wasTriggered = jasmine.jQuery.events.wasTriggered(selector, actual)
, result = { pass: wasTriggered && jasmine.jQuery.events.wasTriggeredWith(selector, actual, expectedArgs, j$, customEqualityTesters) }
if (wasTriggered) {
var actualArgs = jasmine.jQuery.events.args(selector, actual, expectedArgs)[1]
result.message = result.pass ?
"Expected event " + actual + " not to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs) :
"Expected event " + actual + " to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs)
} else {
// todo check on this
result.message = result.pass ?
"Expected event " + actual + " not to have been triggered on " + selector :
"Expected event " + actual + " to have been triggered on " + selector
}
return result return result
}
}
}
},
if (builtInMatcher) {
return builtInMatcher.apply(this, arguments)
}
toHaveBeenPreventedOn: function () {
return {
compare: function (actual, selector) {
var result = { pass: jasmine.jQuery.events.wasPrevented(selector, actual) }
return false
}
}
result.message = result.pass ?
"Expected event " + actual + " not to have been prevented on " + selector :
"Expected event " + actual + " to have been prevented on " + selector
for(var methodName in jQueryMatchers) {
bindMatcher(methodName)
}
}()
return result
}
}
},
beforeEach(function () {
this.addMatchers(jasmine.JQuery.matchersClass)
this.addMatchers({
toHaveBeenTriggeredOn: function (selector) {
this.message = function () {
return [
"Expected event " + this.actual + " to have been triggered on " + selector,
"Expected event " + this.actual + " not to have been triggered on " + selector
]
}
return jasmine.JQuery.events.wasTriggered(selector, this.actual)
}
})
this.addMatchers({
toHaveBeenTriggered: function (){
var eventName = this.actual.eventName
, selector = this.actual.selector
toHaveBeenPrevented: function () {
return {
compare: function (actual) {
var eventName = actual.eventName
, selector = actual.selector
, result = { pass: jasmine.jQuery.events.wasPrevented(selector, eventName) }
this.message = function () {
return [
"Expected event " + eventName + " to have been triggered on " + selector,
"Expected event " + eventName + " not to have been triggered on " + selector
]
}
result.message = result.pass ?
"Expected event " + eventName + " not to have been prevented on " + selector :
"Expected event " + eventName + " to have been prevented on " + selector
return jasmine.JQuery.events.wasTriggered(selector, eventName)
}
})
this.addMatchers({
toHaveBeenTriggeredOnAndWith: function () {
var selector = arguments[0]
, expectedArgs = arguments[1]
, wasTriggered = jasmine.JQuery.events.wasTriggered(selector, this.actual)
this.message = function () {
if (wasTriggered) {
var actualArgs = jasmine.JQuery.events.args(selector, this.actual, expectedArgs)[1]
return [
"Expected event " + this.actual + " to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs),
"Expected event " + this.actual + " not to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs)
]
} else {
return [
"Expected event " + this.actual + " to have been triggered on " + selector,
"Expected event " + this.actual + " not to have been triggered on " + selector
]
}
}
return wasTriggered && jasmine.JQuery.events.wasTriggeredWith(selector, this.actual, expectedArgs, this.env)
}
})
this.addMatchers({
toHaveBeenPreventedOn: function (selector) {
this.message = function () {
return [
"Expected event " + this.actual + " to have been prevented on " + selector,
"Expected event " + this.actual + " not to have been prevented on " + selector
]
return result
}
} }
},
return jasmine.JQuery.events.wasPrevented(selector, this.actual)
}
})
this.addMatchers({
toHaveBeenPrevented: function () {
var eventName = this.actual.eventName
, selector = this.actual.selector
this.message = function () {
return [
"Expected event " + eventName + " to have been prevented on " + selector,
"Expected event " + eventName + " not to have been prevented on " + selector
]
}
toHaveBeenStoppedOn: function () {
return {
compare: function (actual, selector) {
var result = { pass: jasmine.jQuery.events.wasStopped(selector, actual) }
return jasmine.JQuery.events.wasPrevented(selector, eventName)
}
})
this.addMatchers({
toHaveBeenStoppedOn: function (selector) {
this.message = function () {
return [
"Expected event " + this.actual + " to have been stopped on " + selector,
"Expected event " + this.actual + " not to have been stopped on " + selector
]
result.message = result.pass ?
"Expected event " + actual + " not to have been stopped on " + selector :
"Expected event " + actual + " to have been stopped on " + selector
return result;
}
} }
},
return jasmine.JQuery.events.wasStopped(selector, this.actual)
}
})
this.addMatchers({
toHaveBeenStopped: function () { toHaveBeenStopped: function () {
var eventName = this.actual.eventName
, selector = this.actual.selector
this.message = function () {
return [
"Expected event " + eventName + " to have been stopped on " + selector,
"Expected event " + eventName + " not to have been stopped on " + selector
]
}
return jasmine.JQuery.events.wasStopped(selector, eventName)
}
})
jasmine.getEnv().addEqualityTester(function (a, b) {
if(a instanceof jQuery && b instanceof jQuery) {
if(a.size() != b.size()) {
return jasmine.undefined
}
else if(a.is(b)) {
return true
return {
compare: function (actual) {
var eventName = actual.eventName
, selector = actual.selector
, result = { pass: jasmine.jQuery.events.wasStopped(selector, eventName) }
result.message = result.pass ?
"Expected event " + eventName + " not to have been stopped on " + selector :
"Expected event " + eventName + " to have been stopped on " + selector
return result
}
} }
} }
})
jasmine.getEnv().addCustomEqualityTester(function(a, b) {
if (a && b) {
if (a instanceof $ || jasmine.isDomNode(a)) {
var $a = $(a)
if (b instanceof $)
return $a.length == b.length && a.is(b)
return $a.is(b);
}
return jasmine.undefined
if (b instanceof $ || jasmine.isDomNode(b)) {
var $b = $(b)
if (a instanceof jQuery)
return a.length == $b.length && $b.is(a)
return $(b).is(a);
}
}
})
jasmine.getEnv().addCustomEqualityTester(function (a, b) {
if (a instanceof jQuery && b instanceof jQuery && a.size() == b.size())
return a.is(b)
}) })
}) })
afterEach(function () { afterEach(function () {
jasmine.getFixtures().cleanUp() jasmine.getFixtures().cleanUp()
jasmine.getStyleFixtures().cleanUp() jasmine.getStyleFixtures().cleanUp()
jasmine.JQuery.events.cleanUp()
jasmine.jQuery.events.cleanUp()
}) })
}(window.jasmine, window.jQuery)
+function (jasmine, global) { "use strict";
global.readFixtures = function () {
window.readFixtures = function () {
return jasmine.getFixtures().proxyCallTo_('read', arguments) return jasmine.getFixtures().proxyCallTo_('read', arguments)
} }
global.preloadFixtures = function () {
window.preloadFixtures = function () {
jasmine.getFixtures().proxyCallTo_('preload', arguments) jasmine.getFixtures().proxyCallTo_('preload', arguments)
} }
global.loadFixtures = function () {
window.loadFixtures = function () {
jasmine.getFixtures().proxyCallTo_('load', arguments) jasmine.getFixtures().proxyCallTo_('load', arguments)
} }
global.appendLoadFixtures = function () {
window.appendLoadFixtures = function () {
jasmine.getFixtures().proxyCallTo_('appendLoad', arguments) jasmine.getFixtures().proxyCallTo_('appendLoad', arguments)
} }
global.setFixtures = function (html) {
window.setFixtures = function (html) {
return jasmine.getFixtures().proxyCallTo_('set', arguments) return jasmine.getFixtures().proxyCallTo_('set', arguments)
} }
global.appendSetFixtures = function () {
window.appendSetFixtures = function () {
jasmine.getFixtures().proxyCallTo_('appendSet', arguments) jasmine.getFixtures().proxyCallTo_('appendSet', arguments)
} }
global.sandbox = function (attributes) {
window.sandbox = function (attributes) {
return jasmine.getFixtures().sandbox(attributes) return jasmine.getFixtures().sandbox(attributes)
} }
global.spyOnEvent = function (selector, eventName) {
return jasmine.JQuery.events.spyOn(selector, eventName)
window.spyOnEvent = function (selector, eventName) {
return jasmine.jQuery.events.spyOn(selector, eventName)
} }
global.preloadStyleFixtures = function () {
window.preloadStyleFixtures = function () {
jasmine.getStyleFixtures().proxyCallTo_('preload', arguments) jasmine.getStyleFixtures().proxyCallTo_('preload', arguments)
} }
global.loadStyleFixtures = function () {
window.loadStyleFixtures = function () {
jasmine.getStyleFixtures().proxyCallTo_('load', arguments) jasmine.getStyleFixtures().proxyCallTo_('load', arguments)
} }
global.appendLoadStyleFixtures = function () {
window.appendLoadStyleFixtures = function () {
jasmine.getStyleFixtures().proxyCallTo_('appendLoad', arguments) jasmine.getStyleFixtures().proxyCallTo_('appendLoad', arguments)
} }
global.setStyleFixtures = function (html) {
window.setStyleFixtures = function (html) {
jasmine.getStyleFixtures().proxyCallTo_('set', arguments) jasmine.getStyleFixtures().proxyCallTo_('set', arguments)
} }
global.appendSetStyleFixtures = function (html) {
window.appendSetStyleFixtures = function (html) {
jasmine.getStyleFixtures().proxyCallTo_('appendSet', arguments) jasmine.getStyleFixtures().proxyCallTo_('appendSet', arguments)
} }
global.loadJSONFixtures = function () {
window.loadJSONFixtures = function () {
return jasmine.getJSONFixtures().proxyCallTo_('load', arguments) return jasmine.getJSONFixtures().proxyCallTo_('load', arguments)
} }
global.getJSONFixture = function (url) {
window.getJSONFixture = function (url) {
return jasmine.getJSONFixtures().proxyCallTo_('read', arguments)[url] return jasmine.getJSONFixtures().proxyCallTo_('read', arguments)[url]
} }
}(jasmine, window);
}(window, window.jasmine, window.jQuery);

315
test/helpers/jasmine-sinon.js

@ -1,43 +1,300 @@
/* global jasmine */
(function() {
var createCustomMatcher, createMatcher, jasmineMessageGenerator, jasmineName, sinonMatchers, sinonName, sinonToJasmineMap, spies,
__slice = [].slice;
'use strict';
sinonMatchers = {};
(function(jasmine, beforeEach) {
sinonToJasmineMap = {
'called': 'toHaveBeenCalled',
'calledOnce': 'toHaveBeenCalledOnce',
'calledTwice': 'toHaveBeenCalledTwice',
'calledThrice': 'toHaveBeenCalledThrice',
'calledBefore': 'toHaveBeenCalledBefore',
'calledAfter': 'toHaveBeenCalledAfter',
'calledOn': 'toHaveBeenCalledOn',
'alwaysCalledOn': 'toHaveBeenAlwaysCalledOn',
'calledWith': 'toHaveBeenCalledWith',
'alwaysCalledWith': 'toHaveBeenAlwaysCalledWith',
'calledWithExactly': 'toHaveBeenCalledWithExactly',
'alwaysCalledWithExactly': 'toHaveBeenAlwaysCalledWithExactly',
'calledWithMatch': 'toHaveBeenCalledWithMatch',
'alwaysCalledWithMatch': 'toHaveBeenAlwaysCalledWithMatch',
'returned': 'toHaveReturned',
'alwaysReturned': 'toHaveAlwaysReturned',
'threw': 'toHaveThrown',
'alwaysThrew': 'toHaveAlwaysThrown'
};
var spyMatchers = 'called calledOnce calledTwice calledThrice calledBefore calledAfter calledOn alwaysCalledOn calledWith alwaysCalledWith calledWithExactly alwaysCalledWithExactly calledWithMatch alwaysCalledWithMatch'.split(' '),
i = spyMatchers.length,
spyMatcherHash = {},
unusualMatchers = {
"returned": "toHaveReturned",
"alwaysReturned": "toHaveAlwaysReturned",
"threw": "toHaveThrown",
"alwaysThrew": "toHaveAlwaysThrown"
jasmineMessageGenerator = {
'toHaveBeenCalled': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalled";
return message.trim();
}, },
'toHaveBeenCalledOnce': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledOnce";
return message.trim();
},
'toHaveBeenCalledTwice': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledTwice";
return message.trim();
},
'toHaveBeenCalledThrice': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledThrice";
return message.trim();
},
'toHaveBeenCalledBefore': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledBefore ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was CalledBefore " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenCalledAfter': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledAfter ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was CalledAfter " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenCalledOn': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledOn ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was CalledOn " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenAlwaysCalledOn': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenAlwaysCalledOn ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was AlwaysCalledOn " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenCalledWith': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledWith ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was CalledWith " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenAlwaysCalledWith': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenAlwaysCalledWith ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was AlwaysCalledWith " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenCalledWithExactly': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledWithExactly ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was CalledWithExactly " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenAlwaysCalledWithExactly': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenAlwaysCalledWithExactly ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was AlwaysCalledWithExactly " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenCalledWithMatch': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenCalledWithMatch ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was CalledWithMatch " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveBeenAlwaysCalledWithMatch': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveBeenAlwaysCalledWithMatch ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but was AlwaysCalledWithMatch " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveReturned': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveReturned ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but returned " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveAlwaysReturned': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveAlwaysReturned ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but returned " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveThrown': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveThrown ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but threw " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
},
'toHaveAlwaysThrown': function(passed, spy, other_args) {
var message;
message = "Expected spy '" + spy + "' ";
if (passed) {
message += "not ";
}
message += "toHaveAlwaysThrown ";
if ((other_args != null ? other_args.length : void 0) > 0) {
message += jasmine.pp(other_args) + (" but threw " + (jasmine.pp(spy.lastCall.args)));
}
return message.trim();
}
};
getMatcherFunction = function(sinonName, matcherName) {
var original = jasmine.Matchers.prototype[matcherName];
return function () {
if (jasmine.isSpy(this.actual) && original) {
return original.apply(this, arguments);
createCustomMatcher = function(arg, util, customEqualityTesters) {
return sinon.match(function(val) {
return util.equals(val, arg, customEqualityTesters);
});
};
createMatcher = function(sinonName, jasmineName) {
var original;
original = jasmineRequire[jasmineName];
return function(util, customEqualityTesters) {
return {
compare: function() {
var arg, args, compare, i, message, pass, sinonProperty, spy, _i, _len;
args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
spy = args[0];
if (original && jasmine.isSpy(spy)) {
compare = original(jasmine)(util, customEqualityTesters).compare;
return compare.apply(null, args);
}
sinonProperty = spy[sinonName];
for (i = _i = 0, _len = args.length; _i < _len; i = ++_i) {
arg = args[i];
if (arg != null) {
if ((typeof arg.jasmineMatches === 'function') || (arg instanceof jasmine.ObjectContaining)) {
args[i] = createCustomMatcher(arg, util, customEqualityTesters);
}
}
}
if (typeof sinonProperty === 'function') {
pass = sinonProperty.apply(spy, args.slice(1));
} else {
pass = sinonProperty;
}
message = jasmineMessageGenerator[jasmineName](pass, spy, args.slice(1));
return {
pass: pass,
message: message
};
} }
var sinonProperty = this.actual[sinonName];
return (typeof sinonProperty === 'function') ? sinonProperty.apply(this.actual, arguments) : sinonProperty;
}; };
}; };
};
while(i--) {
var sinonName = spyMatchers[i],
matcherName = "toHaveBeen" + sinonName.charAt(0).toUpperCase() + sinonName.slice(1);
spyMatcherHash[matcherName] = getMatcherFunction(sinonName, matcherName);
for (sinonName in sinonToJasmineMap) {
jasmineName = sinonToJasmineMap[sinonName];
sinonMatchers[jasmineName] = createMatcher(sinonName, jasmineName);
} }
for (var j in unusualMatchers) {
spyMatcherHash[unusualMatchers[j]] = getMatcherFunction(j, unusualMatchers[j]);
}
jasmine.Expectation.addCoreMatchers(sinonMatchers);
spies = [];
this.sinonSpyOn = function(obj, method) {
return spies.push(sinon.spy(obj, method));
};
beforeEach(function() {
this.addMatchers(spyMatcherHash);
afterEach(function() {
var spy, _i, _len;
for (_i = 0, _len = spies.length; _i < _len; _i++) {
spy = spies[_i];
spy.restore();
}
return spies = [];
}); });
})(jasmine, beforeEach);
}).call(this);

1823
test/helpers/sinon.js
File diff suppressed because it is too large
View File

Loading…
Cancel
Save