mirror of
https://github.com/meteor/meteor.git
synced 2026-05-02 03:01:46 -04:00
287 lines
8.5 KiB
JavaScript
287 lines
8.5 KiB
JavaScript
import assert from "assert";
|
|
import { Meteor } from "meteor/meteor";
|
|
|
|
function assertDeepEqual(a, b) {
|
|
const aWithoutDefault = Object.assign({}, a);
|
|
delete aWithoutDefault.default;
|
|
|
|
const bWithoutDefault = Object.assign({}, b);
|
|
delete bWithoutDefault.default;
|
|
|
|
assert.deepEqual(aWithoutDefault, bWithoutDefault);
|
|
}
|
|
|
|
describe("dynamic import(...)", function () {
|
|
maybeClearDynamicImportCache();
|
|
|
|
it("ignores bad __meteor__/dynamic-import/fetch requests (#10147)", function () {
|
|
return fetch(Meteor.absoluteUrl("/__meteor__/dynamic-import/fetch"), {
|
|
// POST request with empty body.
|
|
method: "POST"
|
|
}).then(async (res) => {
|
|
assert.strictEqual(res.status, 400);
|
|
if (Meteor.isProduction) {
|
|
assert.strictEqual(await res.json(), "bad request");
|
|
} else {
|
|
assert.strictEqual(await res.json(), "Unexpected end of JSON input");
|
|
}
|
|
});
|
|
});
|
|
|
|
it("import same module both statically and dynamically", function () {
|
|
import moment from "moment";
|
|
return import("./imports/date").then(date => {
|
|
assert.strictEqual(date.moment, moment);
|
|
});
|
|
});
|
|
|
|
it("import builtin stub dynamically", function () {
|
|
const stubId = "console";
|
|
let missing = false;
|
|
|
|
try {
|
|
require(stubId);
|
|
} catch (e) {
|
|
missing = true;
|
|
}
|
|
|
|
if (Meteor.isClient) {
|
|
assert.strictEqual(missing, true);
|
|
}
|
|
|
|
return import("console").then(console => {
|
|
assertDeepEqual(console, require(stubId));
|
|
assert.strictEqual(typeof console.log, "function");
|
|
});
|
|
});
|
|
|
|
it("static package.json, static package", function () {
|
|
import { name } from "acorn/package.json";
|
|
import acorn from "acorn";
|
|
assert.strictEqual(name, "acorn");
|
|
assert.strictEqual(typeof acorn.parse, "function");
|
|
});
|
|
|
|
it("static package.json, dynamic package", function () {
|
|
import { name } from "private/package.json";
|
|
return import("private").then(priv => {
|
|
assert.strictEqual(name, "private");
|
|
assert.strictEqual(typeof priv.makeAccessor, "function");
|
|
assertDeepEqual(priv, require("pri" + "vate"));
|
|
});
|
|
});
|
|
|
|
it("dynamic package.json, static package", function () {
|
|
import arson from "arson";
|
|
return import("arson/package.json").then(({ name }) => {
|
|
assert.strictEqual(name, "arson");
|
|
assert.strictEqual(typeof arson.encode, "function");
|
|
assertDeepEqual(arson, require("ar" + "son"));
|
|
});
|
|
});
|
|
|
|
it("dynamic package.json, dynamic package", function () {
|
|
return Promise.all([
|
|
import("react/package.json"),
|
|
import("react")
|
|
]).then(([{ name }, React]) => {
|
|
assert.strictEqual(name, "react");
|
|
assert.strictEqual(typeof React.createElement, "function");
|
|
assertDeepEqual(React, require("re" + "act"));
|
|
});
|
|
});
|
|
|
|
it("mutual dynamic imports", function () {
|
|
return import("./imports/mutual-a").then(a => {
|
|
assert.strictEqual(a.name, "/imports/mutual-a.js");
|
|
return a.promise;
|
|
}).then(b => {
|
|
assert.strictEqual(b.name, "/imports/mutual-b.js");
|
|
return b.promise;
|
|
});
|
|
});
|
|
|
|
it("imports from lazy packages", function () {
|
|
let missing = false;
|
|
const dynamicId = [
|
|
"meteor", "lazy-test-package", "dynamic"
|
|
].join("/");
|
|
|
|
try {
|
|
// Synchronous dynamic requires should fail if the module has not
|
|
// been fetched dynamically yet.
|
|
require(dynamicId);
|
|
} catch (e) {
|
|
missing = true;
|
|
}
|
|
|
|
if (Meteor.isClient) {
|
|
// Dynamic modules only exist on the client. On the server, modules
|
|
// imported via dynamic import(...) are treated the same as
|
|
// statically imported modules.
|
|
assert.strictEqual(missing, true);
|
|
}
|
|
|
|
return Promise.all([
|
|
import("meteor/lazy-test-package").then(lazy => {
|
|
const requiredName = require([
|
|
"meteor", "lazy-test-package"
|
|
].join("/")).name;
|
|
|
|
assert.strictEqual(
|
|
lazy.name,
|
|
"/node_modules/meteor/lazy-test-package/main.js"
|
|
);
|
|
|
|
assert.strictEqual(lazy.name, requiredName);
|
|
}),
|
|
|
|
import("meteor/lazy-test-package/dynamic").then(dynamic => {
|
|
assert.strictEqual(
|
|
dynamic.name,
|
|
"/node_modules/meteor/lazy-test-package/dynamic.js"
|
|
);
|
|
|
|
// Now the synchronous dynamic require succeeds because the module
|
|
// has been fetched dynamically.
|
|
assert.strictEqual(
|
|
require(dynamicId).name,
|
|
dynamic.name
|
|
);
|
|
})
|
|
]);
|
|
});
|
|
|
|
it("gives dynamic modules access to package variables", async function () {
|
|
const dynamic = await import("meteor/lazy-test-package/dynamic");
|
|
dynamic.checkHelper();
|
|
|
|
const a = await import("meteor/helper-package/dynamic/a");
|
|
const b = await import("meteor/helper-package/dynamic/b.coffee");
|
|
|
|
assert.strictEqual(a.shared, b.shared);
|
|
assertDeepEqual(a.shared, {
|
|
"/node_modules/meteor/helper-package/dynamic/a.js": true,
|
|
"/node_modules/meteor/helper-package/dynamic/b.coffee": true
|
|
});
|
|
|
|
assert.strictEqual(
|
|
(await import("meteor/helper-package")).Helper,
|
|
// Since these tests are defined in an application that uses the
|
|
// global scope for imported package variables, global.Helper should
|
|
// be identical to the Helper symbol exported by helper-package.
|
|
global.Helper
|
|
);
|
|
});
|
|
|
|
it("works with module.prefetch(id)", async function () {
|
|
import { shared } from "./imports/prefetch-child";
|
|
assertDeepEqual(shared, {});
|
|
|
|
const rejection = module.prefetch("./imports/nonexistent.js");
|
|
let threw = false;
|
|
try {
|
|
await rejection;
|
|
} catch (e) {
|
|
assert.ok(e instanceof Error);
|
|
assert.ok(e.message.startsWith("Cannot find module"));
|
|
threw = true;
|
|
}
|
|
assert.strictEqual(threw, true);
|
|
|
|
assert.strictEqual(
|
|
await module.prefetch("./tests"),
|
|
"/tests.js"
|
|
);
|
|
|
|
return module.prefetch("./imports/prefetch").then(() => {
|
|
assertDeepEqual(shared, {});
|
|
}).then(() => {
|
|
import { name } from "./imports/prefetch.js";
|
|
assert.strictEqual(name, "/imports/prefetch.js");
|
|
assertDeepEqual(shared, { [name]: true });
|
|
});
|
|
});
|
|
|
|
it("can import module.exports = {...}-style modules", () => {
|
|
return import("./imports/module-exports-esModule").then(m => {
|
|
assert.strictEqual(typeof m, "object");
|
|
assert.deepEqual(Object.keys(m), []);
|
|
});
|
|
});
|
|
|
|
it("should work for package names containing colons", () => {
|
|
const expectedAbsId =
|
|
"/node_modules/meteor/user:colon-name/dynamic.js";
|
|
|
|
const version = require(
|
|
"meteor/dynamic-import/dynamic-versions.js"
|
|
).get(expectedAbsId);
|
|
|
|
if (Meteor.isClient) {
|
|
assert.strictEqual(typeof version, "string");
|
|
} else {
|
|
assert.strictEqual(version, null);
|
|
}
|
|
|
|
return import("meteor/user:colon-name/dynamic.js").then(dynamic => {
|
|
assert.strictEqual(dynamic.name, expectedAbsId);
|
|
});
|
|
});
|
|
|
|
it("should track dynamic peer imports from packages (#9187)", () => {
|
|
const absId = require.resolve("optimism");
|
|
const version = require(
|
|
"meteor/dynamic-import/dynamic-versions.js"
|
|
).get(absId);
|
|
|
|
if (Meteor.isClient) {
|
|
assert.strictEqual(typeof version, "string");
|
|
} else {
|
|
assert.strictEqual(version, null);
|
|
}
|
|
|
|
return import("meteor/helper-package/import-peer.js").then(m => {
|
|
assert.strictEqual(typeof m.wrap, "function");
|
|
});
|
|
});
|
|
|
|
it('should support object-valued package.json "browser" fields', () => {
|
|
return import("uuid").then(({ v4: uuid }) => {
|
|
const id = uuid();
|
|
assert.strictEqual(typeof id, "string");
|
|
assert.strictEqual(id.split("-").length, 5);
|
|
|
|
if (Meteor.isClient) {
|
|
assert.strictEqual(
|
|
require.resolve("uuid/dist/esm-node/index.js"),
|
|
"/node_modules/uuid/dist/esm-browser/index.js"
|
|
);
|
|
const uuidPkgJsonId = ["uuid", "package.json"].join("/");
|
|
const { browser } = require(uuidPkgJsonId);
|
|
assert.strictEqual(typeof browser, "object");
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
function maybeClearDynamicImportCache() {
|
|
if (global.indexedDB) {
|
|
const saveCache = process.env.METEOR_SAVE_DYNAMIC_IMPORT_CACHE;
|
|
if (! (saveCache && JSON.parse(saveCache))) {
|
|
it("cleared the IndexedDB cache", function () {
|
|
return new Promise((resolve, reject) => {
|
|
const deleteRequest =
|
|
global.indexedDB.deleteDatabase("MeteorDynamicImportCache");
|
|
deleteRequest.onerror =
|
|
deleteRequest.onblocked =
|
|
deleteRequest.onsuccess = function (arg) {
|
|
resolve(arg);
|
|
return true;
|
|
};
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}
|