discourse/test/javascripts/helpers/qunit-helpers.js.es6

171 lines
4.2 KiB
Plaintext
Raw Normal View History

2017-06-14 13:57:58 -04:00
/* global QUnit, fixtures */
import sessionFixtures from 'fixtures/session-fixtures';
import siteFixtures from 'fixtures/site-fixtures';
import HeaderComponent from 'discourse/components/site-header';
import { forceMobile, resetMobile } from 'discourse/lib/mobile';
2016-11-22 15:36:18 -05:00
import { resetPluginApi } from 'discourse/lib/plugin-api';
import { clearCache as clearOutletCache, resetExtraClasses } from 'discourse/lib/plugin-connectors';
2016-11-23 12:57:50 -05:00
import { clearHTMLCache } from 'discourse/helpers/custom-html';
import { flushMap } from 'discourse/models/store';
import { clearRewrites } from 'discourse/lib/url';
function currentUser() {
return Discourse.User.create(sessionFixtures['/session/current.json'].current_user);
}
function logIn() {
Discourse.User.resetCurrent(currentUser());
}
const Plugin = $.fn.modal;
const Modal = Plugin.Constructor;
function AcceptanceModal(option, _relatedTarget) {
return this.each(function () {
var $this = $(this);
var data = $this.data('bs.modal');
var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option === 'object' && option);
if (!data) $this.data('bs.modal', (data = new Modal(this, options)));
data.$body = $('#ember-testing');
if (typeof option === 'string') data[option](_relatedTarget);
else if (options.show) data.show(_relatedTarget);
});
}
window.bootbox.$body = $('#ember-testing');
$.fn.modal = AcceptanceModal;
function acceptance(name, options) {
2017-07-05 14:14:30 -04:00
QUnit.module("Acceptance: " + name, {
2017-06-14 13:57:58 -04:00
beforeEach() {
resetMobile();
// For now don't do scrolling stuff in Test Mode
HeaderComponent.reopen({examineDockHeader: function() { }});
resetExtraClasses();
const siteJson = siteFixtures['site.json'].site;
if (options) {
2017-06-14 13:57:58 -04:00
if (options.beforeEach) {
options.beforeEach.call(this);
}
if (options.mobileView) {
forceMobile();
}
if (options.loggedIn) {
logIn();
}
if (options.settings) {
Discourse.SiteSettings = jQuery.extend(true, Discourse.SiteSettings, options.settings);
}
if (options.site) {
Discourse.Site.resetCurrent(Discourse.Site.create(jQuery.extend(true, {}, siteJson, options.site)));
}
}
2016-11-23 12:57:50 -05:00
clearOutletCache();
clearHTMLCache();
2016-11-23 10:41:21 -05:00
resetPluginApi();
2014-07-30 18:56:01 -04:00
Discourse.reset();
2013-06-20 13:58:54 -04:00
},
2017-06-14 13:57:58 -04:00
afterEach() {
if (options && options.afterEach) {
options.afterEach.call(this);
}
flushMap();
2015-04-30 16:04:58 -04:00
Discourse.User.resetCurrent();
Discourse.Site.resetCurrent(Discourse.Site.create(jQuery.extend(true, {}, fixtures['site.json'].site)));
resetExtraClasses();
2016-11-23 12:57:50 -05:00
clearOutletCache();
clearHTMLCache();
2016-11-22 15:36:18 -05:00
resetPluginApi();
clearRewrites();
2013-06-20 13:58:54 -04:00
Discourse.reset();
}
});
}
2015-02-06 13:25:48 -05:00
function controllerFor(controller, model) {
controller = Discourse.__container__.lookup('controller:' + controller);
if (model) { controller.set('model', model ); }
return controller;
2013-07-15 19:47:13 -04:00
}
2015-02-06 13:25:48 -05:00
function asyncTestDiscourse(text, func) {
2017-06-14 13:57:58 -04:00
QUnit.test(text, function(assert) {
const done = assert.async();
Ember.run(() => {
func.call(this, assert);
done();
2013-07-15 19:47:13 -04:00
});
});
}
2015-02-06 13:25:48 -05:00
function fixture(selector) {
if (selector) {
return $("#qunit-fixture").find(selector);
}
return $("#qunit-fixture");
}
2015-02-06 13:25:48 -05:00
2017-06-14 13:57:58 -04:00
QUnit.assert.not = function(actual, message) {
this.pushResult({
result: !actual,
actual,
expected: !actual,
message
});
};
2017-06-14 13:57:58 -04:00
QUnit.assert.blank = function(actual, message) {
this.pushResult({
result: Ember.isEmpty(actual),
actual,
message
});
};
2017-06-14 13:57:58 -04:00
QUnit.assert.present = function(actual, message) {
this.pushResult({
result: !Ember.isEmpty(actual),
actual,
message
});
};
QUnit.assert.containsInstance = function(collection, klass, message) {
const result = klass.detectInstance(_.first(collection));
this.pushResult({
result,
message
});
};
function waitFor(assert, callback, timeout) {
timeout = timeout || 500;
2017-06-14 13:57:58 -04:00
const done = assert.async();
Ember.run.later(() => {
callback();
2017-06-14 13:57:58 -04:00
done();
}, timeout);
}
export { acceptance,
controllerFor,
asyncTestDiscourse,
fixture,
logIn,
currentUser,
waitFor };