414 lines
12 KiB
JavaScript
414 lines
12 KiB
JavaScript
require("../../lib/babel/api/node");
|
|
|
|
var buildExternalHelpers = require("../../lib/babel/tools/build-external-helpers");
|
|
var PluginManager = require("../../lib/babel/transformation/file/plugin-manager");
|
|
var Transformer = require("../../lib/babel/transformation/transformer");
|
|
var transform = require("../../lib/babel/transformation");
|
|
var assert = require("assert");
|
|
var File = require("../../lib/babel/transformation/file");
|
|
|
|
suite("api", function () {
|
|
test("code option false", function () {
|
|
var result = transform("foo('bar');", { code: false });
|
|
assert.ok(!result.code);
|
|
});
|
|
|
|
test("ast option false", function () {
|
|
var result = transform("foo('bar');", { ast: false });
|
|
assert.ok(!result.ast);
|
|
});
|
|
|
|
test("auxiliaryCommentBefore option", function () {
|
|
assert.ok(transform("class Foo {}", {
|
|
auxiliaryCommentBefore: "foobar"
|
|
}).code.indexOf("foobar") >= 0);
|
|
|
|
assert.ok(transform("for (let i in bar) { foo(function () { i; }); break; continue; }", {
|
|
auxiliaryCommentBefore: "foobar"
|
|
}).code.indexOf("foobar") >= 0);
|
|
});
|
|
|
|
test("auxiliaryCommentAfter option", function () {
|
|
assert.ok(transform("class Foo {}", {
|
|
auxiliaryCommentAfter: "foobar"
|
|
}).code.indexOf("foobar") >= 0);
|
|
|
|
assert.ok(transform("for (let i in bar) { foo(function () { i; }); break; continue; }", {
|
|
auxiliaryCommentAfter: "foobar"
|
|
}).code.indexOf("foobar") >= 0);
|
|
});
|
|
|
|
test("modules metadata", function () {
|
|
assert.deepEqual(transform('import { externalName as localName } from "external";').metadata.modules.imports[0], {
|
|
source: "external",
|
|
imported: ["externalName"],
|
|
specifiers: [{
|
|
kind: "named",
|
|
imported: "externalName",
|
|
local: "localName"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('import * as localName2 from "external";').metadata.modules.imports[0], {
|
|
source: "external",
|
|
imported: ["*"],
|
|
specifiers: [{
|
|
kind: "namespace",
|
|
local: "localName2"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('import localName3 from "external";').metadata.modules.imports[0], {
|
|
source: "external",
|
|
imported: ["default"],
|
|
specifiers: [{
|
|
kind: "named",
|
|
imported: "default",
|
|
local: "localName3"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('import localName from "./array";', {
|
|
resolveModuleSource: function() {
|
|
return 'override-source';
|
|
}
|
|
}).metadata.modules.imports, [
|
|
{
|
|
source: "override-source",
|
|
imported: ["default"],
|
|
specifiers: [
|
|
{
|
|
"kind": "named",
|
|
"imported": "default",
|
|
"local": "localName"
|
|
}
|
|
]
|
|
}
|
|
]);
|
|
|
|
assert.deepEqual(transform('export * as externalName1 from "external";', {
|
|
stage: 0
|
|
}).metadata.modules.exports, {
|
|
exported: ['externalName1'],
|
|
specifiers: [{
|
|
kind: "external-namespace",
|
|
exported: "externalName1",
|
|
source: "external",
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('export externalName2 from "external";', {
|
|
stage: 0
|
|
}).metadata.modules.exports, {
|
|
exported: ["externalName2"],
|
|
specifiers: [{
|
|
kind: "external",
|
|
local: "externalName2",
|
|
exported: "externalName2",
|
|
source: "external"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('export function namedFunction() {}').metadata.modules.exports, {
|
|
exported: ["namedFunction"],
|
|
specifiers: [{
|
|
kind: "local",
|
|
local: "namedFunction",
|
|
exported: "namedFunction"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('export var foo = "bar";').metadata.modules.exports, {
|
|
"exported": ["foo"],
|
|
specifiers: [{
|
|
kind: "local",
|
|
local: "foo",
|
|
exported: "foo"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform("export { localName as externalName3 };").metadata.modules.exports, {
|
|
exported: ["externalName3"],
|
|
specifiers: [{
|
|
kind: "local",
|
|
local: "localName",
|
|
exported: "externalName3"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('export { externalName4 } from "external";').metadata.modules.exports, {
|
|
exported: ["externalName4"],
|
|
specifiers: [{
|
|
kind: "external",
|
|
local: "externalName4",
|
|
exported: "externalName4",
|
|
source: "external"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform('export * from "external";').metadata.modules.exports, {
|
|
exported: [],
|
|
specifiers: [{
|
|
kind: "external-all",
|
|
source: "external"
|
|
}]
|
|
});
|
|
|
|
assert.deepEqual(transform("export default function defaultFunction() {}").metadata.modules.exports, {
|
|
exported: ["defaultFunction"],
|
|
specifiers: [{
|
|
kind: "local",
|
|
local: "defaultFunction",
|
|
exported: "default"
|
|
}]
|
|
});
|
|
});
|
|
|
|
test("ignore option", function () {
|
|
assert.ok(transform("", {
|
|
ignore: "node_modules",
|
|
filename: "/foo/node_modules/bar"
|
|
}).ignored);
|
|
|
|
assert.ok(transform("", {
|
|
ignore: "foo/node_modules",
|
|
filename: "/foo/node_modules/bar"
|
|
}).ignored);
|
|
|
|
assert.ok(transform("", {
|
|
ignore: "foo/node_modules/*.bar",
|
|
filename: "/foo/node_modules/foo.bar"
|
|
}).ignored);
|
|
});
|
|
|
|
test("only option", function () {
|
|
assert.ok(!transform("", {
|
|
only: "node_modules",
|
|
filename: "/foo/node_modules/bar"
|
|
}).ignored);
|
|
|
|
assert.ok(!transform("", {
|
|
only: "foo/node_modules",
|
|
filename: "/foo/node_modules/bar"
|
|
}).ignored);
|
|
|
|
assert.ok(!transform("", {
|
|
only: "foo/node_modules/*.bar",
|
|
filename: "/foo/node_modules/foo.bar"
|
|
}).ignored);
|
|
|
|
assert.ok(transform("", {
|
|
only: "node_modules",
|
|
filename: "/foo/node_module/bar"
|
|
}).ignored);
|
|
|
|
assert.ok(transform("", {
|
|
only: "foo/node_modules",
|
|
filename: "/bar/node_modules/foo"
|
|
}).ignored);
|
|
|
|
assert.ok(transform("", {
|
|
only: "foo/node_modules/*.bar",
|
|
filename: "/foo/node_modules/bar.foo"
|
|
}).ignored);
|
|
});
|
|
|
|
suite("getModuleId option", function () {
|
|
// As of this commit, `getModuleId` is the only option that isn't JSON
|
|
// compatible which is why it's not inside /test/core/fixtures/transformation
|
|
|
|
function getModuleNameTest(moduleFormat, expected) {
|
|
var result = transform("foo('bar');", {
|
|
filename: "/foo/bar/index",
|
|
modules: moduleFormat,
|
|
moduleIds: true,
|
|
getModuleId: function (name) {
|
|
return name.replace(/\/index$/, "");
|
|
}
|
|
});
|
|
|
|
assert.equal(result.code, expected);
|
|
}
|
|
|
|
test("amd", function () {
|
|
var expected = [
|
|
"define('/foo/bar', ['exports'], function (exports) {",
|
|
" 'use strict';",
|
|
"",
|
|
" foo('bar');",
|
|
"});"
|
|
].join("\n");
|
|
|
|
getModuleNameTest("amd", expected);
|
|
});
|
|
|
|
test("umd", function () {
|
|
var expected = [
|
|
"(function (global, factory) {",
|
|
" if (typeof define === 'function' && define.amd) {",
|
|
" define('/foo/bar', ['exports'], factory);",
|
|
" } else if (typeof exports !== 'undefined') {",
|
|
" factory(exports);",
|
|
" } else {",
|
|
" var mod = {",
|
|
" exports: {}",
|
|
" };",
|
|
" factory(mod.exports);",
|
|
" global.fooBar = mod.exports;",
|
|
" }",
|
|
"})(this, function (exports) {",
|
|
" 'use strict';",
|
|
"",
|
|
" foo('bar');",
|
|
"});",
|
|
].join("\n");
|
|
|
|
getModuleNameTest("umd", expected);
|
|
});
|
|
|
|
test("system", function () {
|
|
var expected = [
|
|
"System.register('/foo/bar', [], function (_export) {",
|
|
" 'use strict';",
|
|
"",
|
|
" return {",
|
|
" setters: [],",
|
|
" execute: function () {",
|
|
" foo('bar');",
|
|
" }",
|
|
" };",
|
|
"});",
|
|
].join("\n");
|
|
|
|
getModuleNameTest("system", expected);
|
|
});
|
|
});
|
|
|
|
suite("env option", function () {
|
|
var oldBabelEnv = process.env.BABEL_ENV;
|
|
var oldNodeEnv = process.env.NODE_ENV;
|
|
|
|
before(function () {
|
|
delete process.env.BABEL_ENV;
|
|
delete process.env.NODE_ENV;
|
|
});
|
|
|
|
after(function () {
|
|
process.env.BABEL_ENV = oldBabelEnv;
|
|
process.env.NODE_ENV = oldNodeEnv;
|
|
});
|
|
|
|
test("default", function () {
|
|
assert.equal(transform("foo;", {
|
|
env: {
|
|
development: { blacklist: "strict" }
|
|
}
|
|
}).code, "foo;");
|
|
});
|
|
|
|
test("BABEL_ENV", function () {
|
|
process.env.BABEL_ENV = "foo";
|
|
assert.equal(transform("foo;", {
|
|
env: {
|
|
foo: { blacklist: "strict" }
|
|
}
|
|
}).code, "foo;");
|
|
});
|
|
|
|
test("NODE_ENV", function () {
|
|
process.env.NODE_ENV = "foo";
|
|
assert.equal(transform("foo;", {
|
|
env: {
|
|
foo: { blacklist: "strict" }
|
|
}
|
|
}).code, "foo;");
|
|
});
|
|
});
|
|
|
|
test("addHelper unknown", function () {
|
|
var file = new File({}, transform.pipeline);
|
|
assert.throws(function () {
|
|
file.addHelper("foob");
|
|
}, /Unknown helper foob/);
|
|
});
|
|
|
|
test("resolveModuleSource option", function () {
|
|
var actual = 'import foo from "foo-import-default";\nimport "foo-import-bare";\nexport { foo } from "foo-export-named";';
|
|
var expected = 'import foo from "resolved/foo-import-default";\nimport "resolved/foo-import-bare";\nexport { foo } from "resolved/foo-export-named";';
|
|
|
|
actual = transform(actual, {
|
|
blacklist: ["es6.modules", "strict"],
|
|
resolveModuleSource: function (originalSource) {
|
|
return "resolved/" + originalSource;
|
|
}
|
|
}).code.trim();
|
|
|
|
assert.equal(actual, expected);
|
|
});
|
|
|
|
test("extra options", function () {
|
|
var file1 = new File({ extra: { foo: "bar" } }, transform.pipeline);
|
|
assert.equal(file1.opts.extra.foo, "bar");
|
|
|
|
var file2 = new File({}, transform.pipeline);
|
|
var file3 = new File({}, transform.pipeline);
|
|
assert.ok(file2.opts.extra !== file3.opts.extra);
|
|
});
|
|
|
|
suite("buildExternalHelpers", function () {
|
|
test("all", function () {
|
|
var script = buildExternalHelpers();
|
|
assert.ok(script.indexOf("classCallCheck") >= -1);
|
|
assert.ok(script.indexOf("inherits") >= 0);
|
|
});
|
|
|
|
test("whitelist", function () {
|
|
var script = buildExternalHelpers(["inherits"]);
|
|
assert.ok(script.indexOf("classCallCheck") === -1);
|
|
assert.ok(script.indexOf("inherits") >= 0);
|
|
});
|
|
|
|
test("empty whitelist", function () {
|
|
var script = buildExternalHelpers([]);
|
|
assert.ok(script.indexOf("classCallCheck") === -1);
|
|
assert.ok(script.indexOf("inherits") === -1);
|
|
});
|
|
});
|
|
|
|
suite("plugins", function () {
|
|
test("unknown plugin", function () {
|
|
assert.throws(function () {
|
|
new PluginManager().subnormaliseString("foo bar");
|
|
}, /Unknown plugin/);
|
|
});
|
|
|
|
test("key collision", function () {
|
|
assert.throws(function () {
|
|
new PluginManager({
|
|
transformers: { "es6.arrowFunctions": true }
|
|
}).validate("foobar", { key: "es6.arrowFunctions" });
|
|
}, /collides with another/);
|
|
});
|
|
|
|
test("not transformer", function () {
|
|
assert.throws(function () {
|
|
new PluginManager().validate("foobar", {});
|
|
}, /didn't export a Plugin instance/);
|
|
|
|
assert.throws(function () {
|
|
new PluginManager().validate("foobar", "");
|
|
}, /didn't export a Plugin instance/);
|
|
|
|
assert.throws(function () {
|
|
new PluginManager().validate("foobar", []);
|
|
}, /didn't export a Plugin instance/);
|
|
});
|
|
|
|
test("object request");
|
|
|
|
test("string request");
|
|
|
|
test("transformer request");
|
|
});
|
|
});
|