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

198 lines
4.6 KiB
JavaScript

/* global QUnit, resetSite */
import sessionFixtures from "fixtures/session-fixtures";
import HeaderComponent from "discourse/components/site-header";
import { forceMobile, resetMobile } from "discourse/lib/mobile";
import { resetPluginApi } from "discourse/lib/plugin-api";
import {
clearCache as clearOutletCache,
resetExtraClasses
} from "discourse/lib/plugin-connectors";
import { clearHTMLCache } from "discourse/helpers/custom-html";
import { flushMap } from "discourse/models/store";
import { clearRewrites } from "discourse/lib/url";
import { initSearchData } from "discourse/widgets/search-menu";
import { resetDecorators } from "discourse/widgets/widget";
import { resetCustomPostMessageCallbacks } from "discourse/controllers/topic";
export function currentUser() {
return Discourse.User.create(
sessionFixtures["/session/current.json"].current_user
);
}
export function replaceCurrentUser(properties) {
const user = Discourse.User.current();
user.setProperties(properties);
Discourse.User.resetCurrent(user);
}
export 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;
let _pretenderCallbacks = [];
export function applyPretender(server, helper) {
_pretenderCallbacks.forEach(cb => cb(server, helper));
}
export function acceptance(name, options) {
options = options || {};
if (options.pretend) {
_pretenderCallbacks.push(options.pretend);
}
QUnit.module("Acceptance: " + name, {
beforeEach() {
resetMobile();
// For now don't do scrolling stuff in Test Mode
HeaderComponent.reopen({ examineDockHeader: function() {} });
resetExtraClasses();
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) {
resetSite(Discourse.SiteSettings, options.site);
}
clearOutletCache();
clearHTMLCache();
resetPluginApi();
Discourse.reset();
},
afterEach() {
if (options && options.afterEach) {
options.afterEach.call(this);
}
flushMap();
localStorage.clear();
Discourse.User.resetCurrent();
resetSite(Discourse.SiteSettings);
resetExtraClasses();
clearOutletCache();
clearHTMLCache();
resetPluginApi();
clearRewrites();
initSearchData();
resetDecorators();
resetCustomPostMessageCallbacks();
Discourse.reset();
}
});
}
export function controllerFor(controller, model) {
controller = Discourse.__container__.lookup("controller:" + controller);
if (model) {
controller.set("model", model);
}
return controller;
}
export function asyncTestDiscourse(text, func) {
QUnit.test(text, function(assert) {
const done = assert.async();
Ember.run(() => {
func.call(this, assert);
done();
});
});
}
export function fixture(selector) {
if (selector) {
return $("#qunit-fixture").find(selector);
}
return $("#qunit-fixture");
}
QUnit.assert.not = function(actual, message) {
this.pushResult({
result: !actual,
actual,
expected: !actual,
message
});
};
QUnit.assert.blank = function(actual, message) {
this.pushResult({
result: Ember.isEmpty(actual),
actual,
message
});
};
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
});
};
export function waitFor(assert, callback, timeout) {
timeout = timeout || 500;
const done = assert.async();
Ember.run.later(() => {
callback();
done();
}, timeout);
}