mirror of
https://github.com/discourse/discourse.git
synced 2024-12-14 17:13:45 +08:00
264 lines
6.3 KiB
JavaScript
264 lines
6.3 KiB
JavaScript
import { setResolverOption, buildResolver } from "discourse-common/resolver";
|
|
|
|
let originalTemplates;
|
|
let resolver;
|
|
|
|
function lookupTemplate(assert, name, expectedTemplate, message) {
|
|
var parseName = resolver.parseName(name);
|
|
var result = resolver.resolveTemplate(parseName);
|
|
assert.equal(result, expectedTemplate, message);
|
|
}
|
|
|
|
function setTemplates(lookupTemplateStrings) {
|
|
lookupTemplateStrings.forEach(function(lookupTemplateString) {
|
|
Ember.TEMPLATES[lookupTemplateString] = lookupTemplateString;
|
|
});
|
|
}
|
|
|
|
const DiscourseResolver = buildResolver("discourse");
|
|
|
|
QUnit.module("lib:resolver", {
|
|
beforeEach() {
|
|
originalTemplates = Ember.TEMPLATES;
|
|
Ember.TEMPLATES = {};
|
|
|
|
resolver = DiscourseResolver.create();
|
|
},
|
|
|
|
afterEach() {
|
|
Ember.TEMPLATES = originalTemplates;
|
|
}
|
|
});
|
|
|
|
QUnit.test("finds templates in top level dir", assert => {
|
|
setTemplates(["foobar", "fooBar", "foo_bar", "foo.bar"]);
|
|
|
|
lookupTemplate(assert, "template:foobar", "foobar", "by lowcased name");
|
|
lookupTemplate(assert, "template:fooBar", "fooBar", "by camel cased name");
|
|
lookupTemplate(assert, "template:foo_bar", "foo_bar", "by underscored name");
|
|
lookupTemplate(assert, "template:foo.bar", "foo.bar", "by dotted name");
|
|
});
|
|
|
|
QUnit.test("finds templates in first-level subdir", assert => {
|
|
setTemplates(["foo/bar_baz"]);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo/bar_baz",
|
|
"foo/bar_baz",
|
|
"with subdir defined by slash"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo.bar_baz",
|
|
"foo/bar_baz",
|
|
"with subdir defined by dot"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:fooBarBaz",
|
|
"foo/bar_baz",
|
|
"with subdir defined by first camel case and the rest of camel cases converted to underscores"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo_bar_baz",
|
|
"foo/bar_baz",
|
|
"with subdir defined by first underscore"
|
|
);
|
|
});
|
|
|
|
QUnit.test(
|
|
"resolves precedence between overlapping top level dir and first level subdir templates",
|
|
assert => {
|
|
setTemplates(["fooBar", "foo_bar", "foo.bar", "foo/bar"]);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo.bar",
|
|
"foo/bar",
|
|
"preferring first level subdir for dotted name"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:fooBar",
|
|
"fooBar",
|
|
"preferring top level dir for camel cased name"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo_bar",
|
|
"foo_bar",
|
|
"preferring top level dir for underscored name"
|
|
);
|
|
}
|
|
);
|
|
|
|
QUnit.test("finds templates in subdir deeper than one level", assert => {
|
|
setTemplates(["foo/bar/baz/qux"]);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo/bar/baz/qux",
|
|
"foo/bar/baz/qux",
|
|
"for subdirs defined by slashes"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo.bar.baz.qux",
|
|
"foo/bar/baz/qux",
|
|
"for subdirs defined by dots"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo/bar/bazQux",
|
|
"foo/bar/baz/qux",
|
|
"for subdirs defined by slashes plus one camel case"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo/bar/baz_qux",
|
|
"foo/bar/baz/qux",
|
|
"for subdirs defined by slashes plus one underscore"
|
|
);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:fooBarBazQux",
|
|
undefined,
|
|
"but not for subdirs defined by more than one camel case"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo_bar_baz_qux",
|
|
undefined,
|
|
"but not for subdirs defined by more than one underscore"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo.bar.bazQux",
|
|
undefined,
|
|
"but not for subdirs defined by dots plus one camel case"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo.bar.baz_qux",
|
|
undefined,
|
|
"but not for subdirs defined by dots plus one underscore"
|
|
);
|
|
});
|
|
|
|
QUnit.test("resolves mobile templates to 'mobile/' namespace", assert => {
|
|
setTemplates(["mobile/foo", "bar", "mobile/bar", "baz"]);
|
|
|
|
setResolverOption("mobileView", true);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo",
|
|
"mobile/foo",
|
|
"finding mobile version even if normal one is not present"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:bar",
|
|
"mobile/bar",
|
|
"preferring mobile version when both mobile and normal versions are present"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:baz",
|
|
"baz",
|
|
"falling back to a normal version when mobile version is not present"
|
|
);
|
|
});
|
|
|
|
QUnit.test("resolves plugin templates to 'javascripts/' namespace", assert => {
|
|
setTemplates(["javascripts/foo", "bar", "javascripts/bar", "baz"]);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:foo",
|
|
"javascripts/foo",
|
|
"finding plugin version even if normal one is not present"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:bar",
|
|
"javascripts/bar",
|
|
"preferring plugin version when both versions are present"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:baz",
|
|
"baz",
|
|
"falling back to a normal version when plugin version is not present"
|
|
);
|
|
});
|
|
|
|
QUnit.test(
|
|
"resolves templates with 'admin' prefix to 'admin/templates/' namespace",
|
|
assert => {
|
|
setTemplates([
|
|
"admin/templates/foo",
|
|
"adminBar",
|
|
"admin_bar",
|
|
"admin.bar",
|
|
"admin/templates/bar"
|
|
]);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:adminFoo",
|
|
"admin/templates/foo",
|
|
"when prefix is separated by camel case"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:admin_foo",
|
|
"admin/templates/foo",
|
|
"when prefix is separated by underscore"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:admin.foo",
|
|
"admin/templates/foo",
|
|
"when prefix is separated by dot"
|
|
);
|
|
|
|
lookupTemplate(
|
|
assert,
|
|
"template:adminfoo",
|
|
undefined,
|
|
"but not when prefix is not separated in any way"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:adminBar",
|
|
"adminBar",
|
|
"but not when template with the exact camel cased name exists"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:admin_bar",
|
|
"admin_bar",
|
|
"but not when template with the exact underscored name exists"
|
|
);
|
|
lookupTemplate(
|
|
assert,
|
|
"template:admin.bar",
|
|
"admin.bar",
|
|
"but not when template with the exact dotted name exists"
|
|
);
|
|
}
|
|
);
|
|
|
|
QUnit.test(
|
|
"returns 'not_found' template when template name cannot be resolved",
|
|
assert => {
|
|
setTemplates(["not_found"]);
|
|
|
|
lookupTemplate(assert, "template:foo/bar/baz", "not_found", "");
|
|
}
|
|
);
|