2019-10-31 13:37:24 -04:00
|
|
|
import { isEmpty } from "@ember/utils";
|
2019-10-30 09:48:24 -04:00
|
|
|
import { later } from "@ember/runloop";
|
2017-11-01 15:08:18 -04:00
|
|
|
/* global QUnit, resetSite */
|
2014-09-26 14:48:34 -04:00
|
|
|
|
2015-04-01 14:18:46 -04:00
|
|
|
import sessionFixtures from "fixtures/session-fixtures";
|
2016-04-14 15:23:05 -04:00
|
|
|
import HeaderComponent from "discourse/components/site-header";
|
2016-05-05 12:49:12 -04:00
|
|
|
import { forceMobile, resetMobile } from "discourse/lib/mobile";
|
2016-11-22 15:36:18 -05:00
|
|
|
import { resetPluginApi } from "discourse/lib/plugin-api";
|
2016-12-19 11:19:10 -05:00
|
|
|
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";
|
2016-12-19 11:19:10 -05:00
|
|
|
import { flushMap } from "discourse/models/store";
|
2017-03-27 15:34:54 -04:00
|
|
|
import { clearRewrites } from "discourse/lib/url";
|
2017-12-19 22:04:23 -05:00
|
|
|
import { initSearchData } from "discourse/widgets/search-menu";
|
2018-03-12 07:46:41 -04:00
|
|
|
import { resetDecorators } from "discourse/widgets/widget";
|
2019-06-12 11:49:02 -04:00
|
|
|
import { resetWidgetCleanCallbacks } from "discourse/components/mount-widget";
|
2020-03-27 11:50:31 -04:00
|
|
|
import { resetTopicTitleDecorators } from "discourse/components/topic-title";
|
2019-06-11 04:02:10 -04:00
|
|
|
import { resetDecorators as resetPostCookedDecorators } from "discourse/widgets/post-cooked";
|
2020-02-13 17:44:34 -05:00
|
|
|
import { resetDecorators as resetPluginOutletDecorators } from "discourse/components/plugin-connector";
|
2020-05-25 13:09:55 -04:00
|
|
|
import { resetUsernameDecorators } from "discourse/helpers/decorate-username-selector";
|
2018-11-27 03:00:31 -05:00
|
|
|
import { resetCache as resetOneboxCache } from "pretty-text/oneboxer";
|
2018-05-24 01:28:54 -04:00
|
|
|
import { resetCustomPostMessageCallbacks } from "discourse/controllers/topic";
|
2020-07-09 12:58:23 -04:00
|
|
|
import { _clearSnapshots } from "select-kit/components/composer-actions";
|
2019-11-13 12:35:19 -05:00
|
|
|
import User from "discourse/models/user";
|
2020-07-09 15:54:53 -04:00
|
|
|
import { mapRoutes } from "discourse/mapping-router";
|
2016-12-19 11:19:10 -05:00
|
|
|
|
2017-09-13 11:54:49 -04:00
|
|
|
export function currentUser() {
|
2019-11-13 12:35:19 -05:00
|
|
|
return User.create(sessionFixtures["/session/current.json"].current_user);
|
2015-04-01 14:18:46 -04:00
|
|
|
}
|
|
|
|
|
2019-06-14 08:54:20 -04:00
|
|
|
export function updateCurrentUser(properties) {
|
2019-11-13 12:35:19 -05:00
|
|
|
User.current().setProperties(properties);
|
2018-04-05 23:36:57 -04:00
|
|
|
}
|
|
|
|
|
2019-06-14 08:54:20 -04:00
|
|
|
// Note: do not use this in acceptance tests. Use `loggedIn: true` instead
|
2017-09-13 11:54:49 -04:00
|
|
|
export function logIn() {
|
2019-11-13 12:35:19 -05:00
|
|
|
User.resetCurrent(currentUser());
|
2015-04-01 14:18:46 -04:00
|
|
|
}
|
|
|
|
|
2020-04-30 00:58:26 -04:00
|
|
|
// Note: Only use if `loggedIn: true` has been used in an acceptance test
|
|
|
|
export function loggedInUser() {
|
|
|
|
return User.current();
|
|
|
|
}
|
|
|
|
|
2020-05-13 01:16:07 -04:00
|
|
|
export function fakeTime(timeString, timezone = null, advanceTime = false) {
|
2020-05-06 19:10:32 -04:00
|
|
|
let now = moment.tz(timeString, timezone);
|
2020-05-13 01:16:07 -04:00
|
|
|
return sandbox.useFakeTimers({
|
|
|
|
now: now.valueOf(),
|
|
|
|
shouldAdvanceTime: advanceTime
|
|
|
|
});
|
2020-05-06 19:10:32 -04:00
|
|
|
}
|
|
|
|
|
2020-05-13 01:16:07 -04:00
|
|
|
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();
|
2020-05-06 19:10:32 -04:00
|
|
|
}
|
|
|
|
|
2015-04-01 14:18:46 -04:00
|
|
|
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
|
|
|
|
2015-04-01 14:18:46 -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
|
|
|
|
2015-04-01 14:18:46 -04:00
|
|
|
if (typeof option === "string") data[option](_relatedTarget);
|
|
|
|
else if (options.show) data.show(_relatedTarget);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
window.bootbox.$body = $("#ember-testing");
|
|
|
|
$.fn.modal = AcceptanceModal;
|
|
|
|
|
2019-05-27 22:40:27 -04:00
|
|
|
let _pretenderCallbacks = {};
|
2017-09-13 11:54:49 -04:00
|
|
|
|
2019-05-27 22:40:27 -04:00
|
|
|
export function applyPretender(name, server, helper) {
|
|
|
|
const cb = _pretenderCallbacks[name];
|
|
|
|
if (cb) cb(server, helper);
|
2017-09-13 11:54:49 -04:00
|
|
|
}
|
|
|
|
|
2020-07-09 15:54:53 -04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-09-13 11:54:49 -04:00
|
|
|
export function acceptance(name, options) {
|
|
|
|
options = options || {};
|
|
|
|
|
|
|
|
if (options.pretend) {
|
2019-05-27 22:40:27 -04:00
|
|
|
_pretenderCallbacks[name] = options.pretend;
|
2017-09-13 11:54:49 -04:00
|
|
|
}
|
|
|
|
|
2017-07-05 14:14:30 -04:00
|
|
|
QUnit.module("Acceptance: " + name, {
|
2017-06-14 13:57:58 -04:00
|
|
|
beforeEach() {
|
2016-05-05 12:49:12 -04:00
|
|
|
resetMobile();
|
|
|
|
|
2015-04-01 14:18:46 -04:00
|
|
|
// For now don't do scrolling stuff in Test Mode
|
2017-06-13 15:59:48 -04:00
|
|
|
HeaderComponent.reopen({ examineDockHeader: function() {} });
|
2015-04-01 14:18:46 -04:00
|
|
|
|
2016-12-19 11:19:10 -05:00
|
|
|
resetExtraClasses();
|
2017-09-13 11:54:49 -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
|
|
|
|
);
|
|
|
|
}
|
2020-07-09 15:54:53 -04:00
|
|
|
this.siteSettings = Discourse.SiteSettings;
|
2017-09-13 11:54:49 -04:00
|
|
|
|
|
|
|
if (options.site) {
|
2017-11-01 15:08:18 -04:00
|
|
|
resetSite(Discourse.SiteSettings, options.site);
|
2014-07-31 13:24:07 -04:00
|
|
|
}
|
2014-09-26 14:48:34 -04:00
|
|
|
|
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);
|
2013-11-05 11:42:37 -05:00
|
|
|
}
|
2016-12-19 11:19:10 -05:00
|
|
|
flushMap();
|
2017-11-02 18:38:51 -04:00
|
|
|
localStorage.clear();
|
2019-11-13 12:35:19 -05:00
|
|
|
User.resetCurrent();
|
2017-11-01 15:08:18 -04:00
|
|
|
resetSite(Discourse.SiteSettings);
|
2016-12-19 11:19:10 -05:00
|
|
|
resetExtraClasses();
|
2016-11-23 12:57:50 -05:00
|
|
|
clearOutletCache();
|
|
|
|
clearHTMLCache();
|
2016-11-22 15:36:18 -05:00
|
|
|
resetPluginApi();
|
2017-03-27 15:34:54 -04:00
|
|
|
clearRewrites();
|
2017-12-19 22:04:23 -05:00
|
|
|
initSearchData();
|
2018-03-12 07:46:41 -04:00
|
|
|
resetDecorators();
|
2019-06-11 04:02:10 -04:00
|
|
|
resetPostCookedDecorators();
|
2020-02-13 17:44:34 -05:00
|
|
|
resetPluginOutletDecorators();
|
2020-03-27 11:50:31 -04:00
|
|
|
resetTopicTitleDecorators();
|
2020-05-25 13:09:55 -04:00
|
|
|
resetUsernameDecorators();
|
2018-11-27 03:00:31 -05:00
|
|
|
resetOneboxCache();
|
2018-05-24 01:28:54 -04:00
|
|
|
resetCustomPostMessageCallbacks();
|
2020-07-09 12:58:23 -04:00
|
|
|
_clearSnapshots();
|
2019-06-14 08:54:20 -04:00
|
|
|
Discourse._runInitializer("instanceInitializers", function(
|
|
|
|
initName,
|
|
|
|
initializer
|
|
|
|
) {
|
|
|
|
if (initializer && initializer.teardown) {
|
|
|
|
initializer.teardown(Discourse.__container__);
|
|
|
|
}
|
|
|
|
});
|
2013-06-20 13:58:54 -04:00
|
|
|
Discourse.reset();
|
2019-06-14 13:29:13 -04:00
|
|
|
|
|
|
|
// We do this after reset so that the willClearRender will have already fired
|
|
|
|
resetWidgetCleanCallbacks();
|
2013-06-20 13:58:54 -04:00
|
|
|
}
|
|
|
|
});
|
2013-06-20 17:20:08 -04:00
|
|
|
}
|
|
|
|
|
2017-09-13 11:54:49 -04:00
|
|
|
export function controllerFor(controller, model) {
|
2014-03-11 02:30:49 -04:00
|
|
|
controller = Discourse.__container__.lookup("controller:" + controller);
|
2013-06-20 17:20:08 -04:00
|
|
|
if (model) {
|
|
|
|
controller.set("model", model);
|
|
|
|
}
|
|
|
|
return controller;
|
2013-07-15 19:47:13 -04:00
|
|
|
}
|
|
|
|
|
2017-09-13 11:54:49 -04:00
|
|
|
export function fixture(selector) {
|
2013-11-07 13:46:38 -05:00
|
|
|
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
|
|
|
|
});
|
|
|
|
};
|
2015-08-11 12:27:07 -04:00
|
|
|
|
2017-06-14 13:57:58 -04:00
|
|
|
QUnit.assert.blank = function(actual, message) {
|
|
|
|
this.pushResult({
|
2019-10-31 13:37:24 -04:00
|
|
|
result: isEmpty(actual),
|
2017-06-14 13:57:58 -04:00
|
|
|
actual,
|
|
|
|
message
|
|
|
|
});
|
|
|
|
};
|
2015-08-11 12:27:07 -04:00
|
|
|
|
2017-06-14 13:57:58 -04:00
|
|
|
QUnit.assert.present = function(actual, message) {
|
|
|
|
this.pushResult({
|
2019-10-31 13:37:24 -04:00
|
|
|
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
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2017-09-13 11:54:49 -04:00
|
|
|
export function waitFor(assert, callback, timeout) {
|
2016-10-06 15:18:05 -04:00
|
|
|
timeout = timeout || 500;
|
2017-06-14 13:57:58 -04:00
|
|
|
|
|
|
|
const done = assert.async();
|
2019-10-30 09:48:24 -04:00
|
|
|
later(() => {
|
2016-10-06 15:18:05 -04:00
|
|
|
callback();
|
2017-06-14 13:57:58 -04:00
|
|
|
done();
|
2016-10-06 15:18:05 -04:00
|
|
|
}, timeout);
|
|
|
|
}
|