Right click or ctrl click on the select for it to bring up a search for its options:
122 |
123 | Right click or ctrl click on the select for it to bring up a search for its options:
122 |
123 | ')
98 | .attr('id', this.containerId)
99 | .html(html)
100 |
101 | $(document.body).append(container)
102 | return container
103 | }
104 |
105 | jasmine.Fixtures.prototype.addToContainer_ = function (html){
106 | var container = $(document.body).find('#'+this.containerId).append(html)
107 |
108 | if (!container.length) {
109 | this.createContainer_(html)
110 | }
111 | }
112 |
113 | jasmine.Fixtures.prototype.getFixtureHtml_ = function (url) {
114 | if (typeof this.fixturesCache_[url] === 'undefined') {
115 | this.loadFixtureIntoCache_(url)
116 | }
117 | return this.fixturesCache_[url]
118 | }
119 |
120 | jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function (relativeUrl) {
121 | var self = this
122 | , url = this.makeFixtureUrl_(relativeUrl)
123 | , htmlText = ''
124 | , request = $.ajax({
125 | async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
126 | cache: false,
127 | url: url,
128 | success: function (data, status, $xhr) {
129 | htmlText = $xhr.responseText
130 | }
131 | }).fail(function ($xhr, status, err) {
132 | throw new Error('Fixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + err.message + ')')
133 | })
134 |
135 | var scripts = $($.parseHTML(htmlText, true)).find('script[src]') || [];
136 |
137 | scripts.each(function(){
138 | $.ajax({
139 | async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
140 | cache: false,
141 | dataType: 'script',
142 | url: $(this).attr('src'),
143 | success: function (data, status, $xhr) {
144 | htmlText += ''
145 | },
146 | error: function ($xhr, status, err) {
147 | throw new Error('Script could not be loaded: ' + scriptSrc + ' (status: ' + status + ', message: ' + err.message + ')')
148 | }
149 | });
150 | })
151 |
152 | self.fixturesCache_[relativeUrl] = htmlText;
153 | }
154 |
155 | jasmine.Fixtures.prototype.makeFixtureUrl_ = function (relativeUrl){
156 | return this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl
157 | }
158 |
159 | jasmine.Fixtures.prototype.proxyCallTo_ = function (methodName, passedArguments) {
160 | return this[methodName].apply(this, passedArguments)
161 | }
162 |
163 |
164 | jasmine.StyleFixtures = function () {
165 | this.fixturesCache_ = {}
166 | this.fixturesNodes_ = []
167 | this.fixturesPath = 'spec/javascripts/fixtures'
168 | }
169 |
170 | jasmine.StyleFixtures.prototype.set = function (css) {
171 | this.cleanUp()
172 | this.createStyle_(css)
173 | }
174 |
175 | jasmine.StyleFixtures.prototype.appendSet = function (css) {
176 | this.createStyle_(css)
177 | }
178 |
179 | jasmine.StyleFixtures.prototype.preload = function () {
180 | this.read_.apply(this, arguments)
181 | }
182 |
183 | jasmine.StyleFixtures.prototype.load = function () {
184 | this.cleanUp()
185 | this.createStyle_(this.read_.apply(this, arguments))
186 | }
187 |
188 | jasmine.StyleFixtures.prototype.appendLoad = function () {
189 | this.createStyle_(this.read_.apply(this, arguments))
190 | }
191 |
192 | jasmine.StyleFixtures.prototype.cleanUp = function () {
193 | while(this.fixturesNodes_.length) {
194 | this.fixturesNodes_.pop().remove()
195 | }
196 | }
197 |
198 | jasmine.StyleFixtures.prototype.createStyle_ = function (html) {
199 | var styleText = $('
').html(html).text()
200 | , style = $('')
201 |
202 | this.fixturesNodes_.push(style)
203 | $('head').append(style)
204 | }
205 |
206 | jasmine.StyleFixtures.prototype.clearCache = jasmine.Fixtures.prototype.clearCache
207 | jasmine.StyleFixtures.prototype.read_ = jasmine.Fixtures.prototype.read
208 | jasmine.StyleFixtures.prototype.getFixtureHtml_ = jasmine.Fixtures.prototype.getFixtureHtml_
209 | jasmine.StyleFixtures.prototype.loadFixtureIntoCache_ = jasmine.Fixtures.prototype.loadFixtureIntoCache_
210 | jasmine.StyleFixtures.prototype.makeFixtureUrl_ = jasmine.Fixtures.prototype.makeFixtureUrl_
211 | jasmine.StyleFixtures.prototype.proxyCallTo_ = jasmine.Fixtures.prototype.proxyCallTo_
212 |
213 | jasmine.getJSONFixtures = function () {
214 | return jasmine.currentJSONFixtures_ = jasmine.currentJSONFixtures_ || new jasmine.JSONFixtures()
215 | }
216 |
217 | jasmine.JSONFixtures = function () {
218 | this.fixturesCache_ = {}
219 | this.fixturesPath = 'spec/javascripts/fixtures/json'
220 | }
221 |
222 | jasmine.JSONFixtures.prototype.load = function () {
223 | this.read.apply(this, arguments)
224 | return this.fixturesCache_
225 | }
226 |
227 | jasmine.JSONFixtures.prototype.read = function () {
228 | var fixtureUrls = arguments
229 |
230 | for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
231 | this.getFixtureData_(fixtureUrls[urlIndex])
232 | }
233 |
234 | return this.fixturesCache_
235 | }
236 |
237 | jasmine.JSONFixtures.prototype.clearCache = function () {
238 | this.fixturesCache_ = {}
239 | }
240 |
241 | jasmine.JSONFixtures.prototype.getFixtureData_ = function (url) {
242 | if (!this.fixturesCache_[url]) this.loadFixtureIntoCache_(url)
243 | return this.fixturesCache_[url]
244 | }
245 |
246 | jasmine.JSONFixtures.prototype.loadFixtureIntoCache_ = function (relativeUrl) {
247 | var self = this
248 | , url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl
249 |
250 | $.ajax({
251 | async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
252 | cache: false,
253 | dataType: 'json',
254 | url: url,
255 | success: function (data) {
256 | self.fixturesCache_[relativeUrl] = data
257 | },
258 | error: function ($xhr, status, err) {
259 | throw new Error('JSONFixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + err.message + ')')
260 | }
261 | })
262 | }
263 |
264 | jasmine.JSONFixtures.prototype.proxyCallTo_ = function (methodName, passedArguments) {
265 | return this[methodName].apply(this, passedArguments)
266 | }
267 |
268 | jasmine.jQuery = function () {}
269 |
270 | jasmine.jQuery.browserTagCaseIndependentHtml = function (html) {
271 | return $('
').append(html).html()
272 | }
273 |
274 | jasmine.jQuery.elementToString = function (element) {
275 | return $(element).map(function () { return this.outerHTML; }).toArray().join(', ')
276 | }
277 |
278 | var data = {
279 | spiedEvents: {}
280 | , handlers: []
281 | }
282 |
283 | jasmine.jQuery.events = {
284 | spyOn: function (selector, eventName) {
285 | var handler = function (e) {
286 | data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] = jasmine.util.argsToArray(arguments)
287 | }
288 |
289 | $(selector).on(eventName, handler)
290 | data.handlers.push(handler)
291 |
292 | return {
293 | selector: selector,
294 | eventName: eventName,
295 | handler: handler,
296 | reset: function (){
297 | delete data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
298 | }
299 | }
300 | },
301 |
302 | args: function (selector, eventName) {
303 | var actualArgs = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
304 |
305 | if (!actualArgs) {
306 | throw "There is no spy for " + eventName + " on " + selector.toString() + ". Make sure to create a spy using spyOnEvent."
307 | }
308 |
309 | return actualArgs
310 | },
311 |
312 | wasTriggered: function (selector, eventName) {
313 | return !!(data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)])
314 | },
315 |
316 | wasTriggeredWith: function (selector, eventName, expectedArgs, util, customEqualityTesters) {
317 | var actualArgs = jasmine.jQuery.events.args(selector, eventName).slice(1)
318 |
319 | if (Object.prototype.toString.call(expectedArgs) !== '[object Array]')
320 | actualArgs = actualArgs[0]
321 |
322 | return util.equals(expectedArgs, actualArgs, customEqualityTesters)
323 | },
324 |
325 | wasPrevented: function (selector, eventName) {
326 | var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
327 | , e = args ? args[0] : undefined
328 |
329 | return e && e.isDefaultPrevented()
330 | },
331 |
332 | wasStopped: function (selector, eventName) {
333 | var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
334 | , e = args ? args[0] : undefined
335 | return e && e.isPropagationStopped()
336 | },
337 |
338 | cleanUp: function () {
339 | data.spiedEvents = {}
340 | data.handlers = []
341 | }
342 | }
343 |
344 | var hasProperty = function (actualValue, expectedValue) {
345 | if (expectedValue === undefined)
346 | return actualValue !== undefined
347 |
348 | return actualValue === expectedValue
349 | }
350 |
351 | beforeEach(function () {
352 | jasmine.addMatchers({
353 | toHaveClass: function () {
354 | return {
355 | compare: function (actual, className) {
356 | return { pass: $(actual).hasClass(className) }
357 | }
358 | }
359 | },
360 |
361 | toHaveCss: function () {
362 | return {
363 | compare: function (actual, css) {
364 | for (var prop in css){
365 | var value = css[prop]
366 | // see issue #147 on gh
367 | ;if (value === 'auto' && $(actual).get(0).style[prop] === 'auto') continue
368 | if ($(actual).css(prop) !== value) return { pass: false }
369 | }
370 | return { pass: true }
371 | }
372 | }
373 | },
374 |
375 | toBeVisible: function () {
376 | return {
377 | compare: function (actual) {
378 | return { pass: $(actual).is(':visible') }
379 | }
380 | }
381 | },
382 |
383 | toBeHidden: function () {
384 | return {
385 | compare: function (actual) {
386 | return { pass: $(actual).is(':hidden') }
387 | }
388 | }
389 | },
390 |
391 | toBeSelected: function () {
392 | return {
393 | compare: function (actual) {
394 | return { pass: $(actual).is(':selected') }
395 | }
396 | }
397 | },
398 |
399 | toBeChecked: function () {
400 | return {
401 | compare: function (actual) {
402 | return { pass: $(actual).is(':checked') }
403 | }
404 | }
405 | },
406 |
407 | toBeEmpty: function () {
408 | return {
409 | compare: function (actual) {
410 | return { pass: $(actual).is(':empty') }
411 | }
412 | }
413 | },
414 |
415 | toBeInDOM: function () {
416 | return {
417 | compare: function (actual) {
418 | return { pass: $.contains(document.documentElement, $(actual)[0]) }
419 | }
420 | }
421 | },
422 |
423 | toExist: function () {
424 | return {
425 | compare: function (actual) {
426 | return { pass: $(actual).length }
427 | }
428 | }
429 | },
430 |
431 | toHaveLength: function () {
432 | return {
433 | compare: function (actual, length) {
434 | return { pass: $(actual).length === length }
435 | }
436 | }
437 | },
438 |
439 | toHaveAttr: function () {
440 | return {
441 | compare: function (actual, attributeName, expectedAttributeValue) {
442 | return { pass: hasProperty($(actual).attr(attributeName), expectedAttributeValue) }
443 | }
444 | }
445 | },
446 |
447 | toHaveProp: function () {
448 | return {
449 | compare: function (actual, propertyName, expectedPropertyValue) {
450 | return { pass: hasProperty($(actual).prop(propertyName), expectedPropertyValue) }
451 | }
452 | }
453 | },
454 |
455 | toHaveId: function () {
456 | return {
457 | compare: function (actual, id) {
458 | return { pass: $(actual).attr('id') == id }
459 | }
460 | }
461 | },
462 |
463 | toHaveHtml: function () {
464 | return {
465 | compare: function (actual, html) {
466 | return { pass: $(actual).html() == jasmine.jQuery.browserTagCaseIndependentHtml(html) }
467 | }
468 | }
469 | },
470 |
471 | toContainHtml: function () {
472 | return {
473 | compare: function (actual, html) {
474 | var actualHtml = $(actual).html()
475 | , expectedHtml = jasmine.jQuery.browserTagCaseIndependentHtml(html)
476 |
477 | return { pass: (actualHtml.indexOf(expectedHtml) >= 0) }
478 | }
479 | }
480 | },
481 |
482 | toHaveText: function () {
483 | return {
484 | compare: function (actual, text) {
485 | var actualText = $(actual).text()
486 | var trimmedText = $.trim(actualText)
487 |
488 | if (text && $.isFunction(text.test)) {
489 | return { pass: text.test(actualText) || text.test(trimmedText) }
490 | } else {
491 | return { pass: (actualText == text || trimmedText == text) }
492 | }
493 | }
494 | }
495 | },
496 |
497 | toContainText: function () {
498 | return {
499 | compare: function (actual, text) {
500 | var trimmedText = $.trim($(actual).text())
501 |
502 | if (text && $.isFunction(text.test)) {
503 | return { pass: text.test(trimmedText) }
504 | } else {
505 | return { pass: trimmedText.indexOf(text) != -1 }
506 | }
507 | }
508 | }
509 | },
510 |
511 | toHaveValue: function () {
512 | return {
513 | compare: function (actual, value) {
514 | return { pass: $(actual).val() === value }
515 | }
516 | }
517 | },
518 |
519 | toHaveData: function () {
520 | return {
521 | compare: function (actual, key, expectedValue) {
522 | return { pass: hasProperty($(actual).data(key), expectedValue) }
523 | }
524 | }
525 | },
526 |
527 | toContainElement: function () {
528 | return {
529 | compare: function (actual, selector) {
530 | if (window.debug) debugger
531 | return { pass: $(actual).find(selector).length }
532 | }
533 | }
534 | },
535 |
536 | toBeMatchedBy: function () {
537 | return {
538 | compare: function (actual, selector) {
539 | return { pass: $(actual).filter(selector).length }
540 | }
541 | }
542 | },
543 |
544 | toBeDisabled: function () {
545 | return {
546 | compare: function (actual, selector) {
547 | return { pass: $(actual).is(':disabled') }
548 | }
549 | }
550 | },
551 |
552 | toBeFocused: function (selector) {
553 | return {
554 | compare: function (actual, selector) {
555 | return { pass: $(actual)[0] === $(actual)[0].ownerDocument.activeElement }
556 | }
557 | }
558 | },
559 |
560 | toHandle: function () {
561 | return {
562 | compare: function (actual, event) {
563 | var events = $._data($(actual).get(0), "events")
564 |
565 | if (!events || !event || typeof event !== "string") {
566 | return { pass: false }
567 | }
568 |
569 | var namespaces = event.split(".")
570 | , eventType = namespaces.shift()
571 | , sortedNamespaces = namespaces.slice(0).sort()
572 | , namespaceRegExp = new RegExp("(^|\\.)" + sortedNamespaces.join("\\.(?:.*\\.)?") + "(\\.|$)")
573 |
574 | if (events[eventType] && namespaces.length) {
575 | for (var i = 0; i < events[eventType].length; i++) {
576 | var namespace = events[eventType][i].namespace
577 |
578 | if (namespaceRegExp.test(namespace))
579 | return { pass: true }
580 | }
581 | } else {
582 | return { pass: (events[eventType] && events[eventType].length > 0) }
583 | }
584 |
585 | return { pass: false }
586 | }
587 | }
588 | },
589 |
590 | toHandleWith: function () {
591 | return {
592 | compare: function (actual, eventName, eventHandler) {
593 | var normalizedEventName = eventName.split('.')[0]
594 | , stack = $._data($(actual).get(0), "events")[normalizedEventName]
595 |
596 | for (var i = 0; i < stack.length; i++) {
597 | if (stack[i].handler == eventHandler) return { pass: true }
598 | }
599 |
600 | return { pass: false }
601 | }
602 | }
603 | },
604 |
605 | toHaveBeenTriggeredOn: function () {
606 | return {
607 | compare: function (actual, selector) {
608 | var result = { pass: jasmine.jQuery.events.wasTriggered(selector, actual) }
609 |
610 | result.message = result.pass ?
611 | "Expected event " + $(actual) + " not to have been triggered on " + selector :
612 | "Expected event " + $(actual) + " to have been triggered on " + selector
613 |
614 | return result;
615 | }
616 | }
617 | },
618 |
619 | toHaveBeenTriggered: function (){
620 | return {
621 | compare: function (actual) {
622 | var eventName = actual.eventName
623 | , selector = actual.selector
624 | , result = { pass: jasmine.jQuery.events.wasTriggered(selector, eventName) }
625 |
626 | result.message = result.pass ?
627 | "Expected event " + eventName + " not to have been triggered on " + selector :
628 | "Expected event " + eventName + " to have been triggered on " + selector
629 |
630 | return result
631 | }
632 | }
633 | },
634 |
635 | toHaveBeenTriggeredOnAndWith: function (j$, customEqualityTesters) {
636 | return {
637 | compare: function (actual, selector, expectedArgs) {
638 | var wasTriggered = jasmine.jQuery.events.wasTriggered(selector, actual)
639 | , result = { pass: wasTriggered && jasmine.jQuery.events.wasTriggeredWith(selector, actual, expectedArgs, j$, customEqualityTesters) }
640 |
641 | if (wasTriggered) {
642 | var actualArgs = jasmine.jQuery.events.args(selector, actual, expectedArgs)[1]
643 | result.message = result.pass ?
644 | "Expected event " + actual + " not to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs) :
645 | "Expected event " + actual + " to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs)
646 |
647 | } else {
648 | // todo check on this
649 | result.message = result.pass ?
650 | "Expected event " + actual + " not to have been triggered on " + selector :
651 | "Expected event " + actual + " to have been triggered on " + selector
652 | }
653 |
654 | return result
655 | }
656 | }
657 | },
658 |
659 | toHaveBeenPreventedOn: function () {
660 | return {
661 | compare: function (actual, selector) {
662 | var result = { pass: jasmine.jQuery.events.wasPrevented(selector, actual) }
663 |
664 | result.message = result.pass ?
665 | "Expected event " + actual + " not to have been prevented on " + selector :
666 | "Expected event " + actual + " to have been prevented on " + selector
667 |
668 | return result
669 | }
670 | }
671 | },
672 |
673 | toHaveBeenPrevented: function () {
674 | return {
675 | compare: function (actual) {
676 | var eventName = actual.eventName
677 | , selector = actual.selector
678 | , result = { pass: jasmine.jQuery.events.wasPrevented(selector, eventName) }
679 |
680 | result.message = result.pass ?
681 | "Expected event " + eventName + " not to have been prevented on " + selector :
682 | "Expected event " + eventName + " to have been prevented on " + selector
683 |
684 | return result
685 | }
686 | }
687 | },
688 |
689 | toHaveBeenStoppedOn: function () {
690 | return {
691 | compare: function (actual, selector) {
692 | var result = { pass: jasmine.jQuery.events.wasStopped(selector, actual) }
693 |
694 | result.message = result.pass ?
695 | "Expected event " + actual + " not to have been stopped on " + selector :
696 | "Expected event " + actual + " to have been stopped on " + selector
697 |
698 | return result;
699 | }
700 | }
701 | },
702 |
703 | toHaveBeenStopped: function () {
704 | return {
705 | compare: function (actual) {
706 | var eventName = actual.eventName
707 | , selector = actual.selector
708 | , result = { pass: jasmine.jQuery.events.wasStopped(selector, eventName) }
709 |
710 | result.message = result.pass ?
711 | "Expected event " + eventName + " not to have been stopped on " + selector :
712 | "Expected event " + eventName + " to have been stopped on " + selector
713 |
714 | return result
715 | }
716 | }
717 | }
718 | })
719 |
720 | jasmine.getEnv().addCustomEqualityTester(function(a, b) {
721 | if (a && b) {
722 | if (a instanceof $ || jasmine.isDomNode(a)) {
723 | var $a = $(a)
724 |
725 | if (b instanceof $)
726 | return $a.length == b.length && a.is(b)
727 |
728 | return $a.is(b);
729 | }
730 |
731 | if (b instanceof $ || jasmine.isDomNode(b)) {
732 | var $b = $(b)
733 |
734 | if (a instanceof $)
735 | return a.length == $b.length && $b.is(a)
736 |
737 | return $(b).is(a);
738 | }
739 | }
740 | })
741 |
742 | jasmine.getEnv().addCustomEqualityTester(function (a, b) {
743 | if (a instanceof $ && b instanceof $ && a.size() == b.size())
744 | return a.is(b)
745 | })
746 | })
747 |
748 | afterEach(function () {
749 | jasmine.getFixtures().cleanUp()
750 | jasmine.getStyleFixtures().cleanUp()
751 | jasmine.jQuery.events.cleanUp()
752 | })
753 |
754 | window.readFixtures = function () {
755 | return jasmine.getFixtures().proxyCallTo_('read', arguments)
756 | }
757 |
758 | window.preloadFixtures = function () {
759 | jasmine.getFixtures().proxyCallTo_('preload', arguments)
760 | }
761 |
762 | window.loadFixtures = function () {
763 | jasmine.getFixtures().proxyCallTo_('load', arguments)
764 | }
765 |
766 | window.appendLoadFixtures = function () {
767 | jasmine.getFixtures().proxyCallTo_('appendLoad', arguments)
768 | }
769 |
770 | window.setFixtures = function (html) {
771 | return jasmine.getFixtures().proxyCallTo_('set', arguments)
772 | }
773 |
774 | window.appendSetFixtures = function () {
775 | jasmine.getFixtures().proxyCallTo_('appendSet', arguments)
776 | }
777 |
778 | window.sandbox = function (attributes) {
779 | return jasmine.getFixtures().sandbox(attributes)
780 | }
781 |
782 | window.spyOnEvent = function (selector, eventName) {
783 | return jasmine.jQuery.events.spyOn(selector, eventName)
784 | }
785 |
786 | window.preloadStyleFixtures = function () {
787 | jasmine.getStyleFixtures().proxyCallTo_('preload', arguments)
788 | }
789 |
790 | window.loadStyleFixtures = function () {
791 | jasmine.getStyleFixtures().proxyCallTo_('load', arguments)
792 | }
793 |
794 | window.appendLoadStyleFixtures = function () {
795 | jasmine.getStyleFixtures().proxyCallTo_('appendLoad', arguments)
796 | }
797 |
798 | window.setStyleFixtures = function (html) {
799 | jasmine.getStyleFixtures().proxyCallTo_('set', arguments)
800 | }
801 |
802 | window.appendSetStyleFixtures = function (html) {
803 | jasmine.getStyleFixtures().proxyCallTo_('appendSet', arguments)
804 | }
805 |
806 | window.loadJSONFixtures = function () {
807 | return jasmine.getJSONFixtures().proxyCallTo_('load', arguments)
808 | }
809 |
810 | window.getJSONFixture = function (url) {
811 | return jasmine.getJSONFixtures().proxyCallTo_('read', arguments)[url]
812 | }
813 | }(window, window.jasmine, window.jQuery);
--------------------------------------------------------------------------------