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

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

277 lines
7.2 KiB
JavaScript
Raw Normal View History

import { isEmpty } from "@ember/utils";
import { later } from "@ember/runloop";
/* global QUnit, resetSite */
import sessionFixtures from "fixtures/session-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";
import { initSearchData } from "discourse/widgets/search-menu";
import { resetDecorators } from "discourse/widgets/widget";
import { resetWidgetCleanCallbacks } from "discourse/components/mount-widget";
import { resetTopicTitleDecorators } from "discourse/components/topic-title";
import { resetDecorators as resetPostCookedDecorators } from "discourse/widgets/post-cooked";
import { resetDecorators as resetPluginOutletDecorators } from "discourse/components/plugin-connector";
import { resetUsernameDecorators } from "discourse/helpers/decorate-username-selector";
import { resetCache as resetOneboxCache } from "pretty-text/oneboxer";
import { resetCustomPostMessageCallbacks } from "discourse/controllers/topic";
import { _clearSnapshots } from "select-kit/components/composer-actions";
import User from "discourse/models/user";
import { mapRoutes } from "discourse/mapping-router";
export function currentUser() {
return User.create(sessionFixtures["/session/current.json"].current_user);
}
export function updateCurrentUser(properties) {
User.current().setProperties(properties);
}
// Note: do not use this in acceptance tests. Use `loggedIn: true` instead
export function logIn() {
User.resetCurrent(currentUser());
}
// Note: Only use if `loggedIn: true` has been used in an acceptance test
export function loggedInUser() {
return User.current();
}
export function fakeTime(timeString, timezone = null, advanceTime = false) {
let now = moment.tz(timeString, timezone);
return sandbox.useFakeTimers({
now: now.valueOf(),
shouldAdvanceTime: advanceTime
});
}
export async function acceptanceUseFakeClock(
timeString,
callback,
timezone = null
) {
if (!timezone) {
let user = loggedInUser();
if (user) {
timezone = user.resolvedTimezone(user);
} else {
timezone = "America/Denver";
}
}
let clock = fakeTime(timeString, timezone, true);
await callback();
clock.reset();
}
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
);
2018-06-15 11:03:24 -04:00
if (!data) $this.data("bs.modal", (data = new Modal(this, options)));
data.$body = $("#ember-testing");
2018-06-15 11:03:24 -04:00
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(name, server, helper) {
const cb = _pretenderCallbacks[name];
if (cb) cb(server, helper);
}
export function controllerModule(name, args = {}) {
moduleFor(name, name, {
setup() {
this.registry.register("router:main", mapRoutes());
let controller = this.subject();
controller.siteSettings = Discourse.SiteSettings;
if (args.setupController) {
args.setupController(controller);
}
},
needs: args.needs
});
}
export function discourseModule(name, hooks) {
QUnit.module(name, {
beforeEach() {
// Give us an API to change site settings without `Discourse.SiteSettings` in tests
this.siteSettings = Discourse.SiteSettings;
if (hooks && hooks.beforeEach) {
hooks.beforeEach.call(this);
}
},
afterEach() {
if (hooks && hooks.afterEach) {
hooks.afterEach.call(this);
}
}
});
}
export function acceptance(name, options) {
options = options || {};
if (options.pretend) {
_pretenderCallbacks[name] = options.pretend;
}
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();
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
);
}
this.siteSettings = Discourse.SiteSettings;
if (options.site) {
resetSite(Discourse.SiteSettings, 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();
2017-11-02 18:38:51 -04:00
localStorage.clear();
User.resetCurrent();
resetSite(Discourse.SiteSettings);
resetExtraClasses();
2016-11-23 12:57:50 -05:00
clearOutletCache();
clearHTMLCache();
2016-11-22 15:36:18 -05:00
resetPluginApi();
clearRewrites();
initSearchData();
resetDecorators();
resetPostCookedDecorators();
resetPluginOutletDecorators();
resetTopicTitleDecorators();
resetUsernameDecorators();
resetOneboxCache();
resetCustomPostMessageCallbacks();
_clearSnapshots();
Discourse._runInitializer("instanceInitializers", function(
initName,
initializer
) {
if (initializer && initializer.teardown) {
initializer.teardown(Discourse.__container__);
}
});
2013-06-20 13:58:54 -04:00
Discourse.reset();
// We do this after reset so that the willClearRender will have already fired
resetWidgetCleanCallbacks();
2013-06-20 13:58:54 -04:00
}
});
}
export 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
}
export 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: isEmpty(actual),
2017-06-14 13:57:58 -04:00
actual,
message
});
};
2017-06-14 13:57:58 -04:00
QUnit.assert.present = function(actual, message) {
this.pushResult({
result: !isEmpty(actual),
2017-06-14 13:57:58 -04:00
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;
2017-06-14 13:57:58 -04:00
const done = assert.async();
later(() => {
callback();
2017-06-14 13:57:58 -04:00
done();
}, timeout);
}