1015 lines
25 KiB
JavaScript
1015 lines
25 KiB
JavaScript
import assert from "assert";
|
|
import fs from "fs";
|
|
import path from "path";
|
|
import buildConfigChain from "../lib/config/build-config-chain";
|
|
|
|
function fixture() {
|
|
const args = [__dirname, "fixtures", "config"];
|
|
for (let i = 0; i < arguments.length; i++) {
|
|
args.push(arguments[i]);
|
|
}
|
|
return path.join.apply(path, args);
|
|
}
|
|
|
|
function base() {
|
|
return process.cwd();
|
|
}
|
|
|
|
describe("buildConfigChain", function() {
|
|
let oldBabelEnv;
|
|
let oldNodeEnv;
|
|
|
|
beforeEach(function() {
|
|
oldBabelEnv = process.env.BABEL_ENV;
|
|
oldNodeEnv = process.env.NODE_ENV;
|
|
|
|
delete process.env.BABEL_ENV;
|
|
delete process.env.NODE_ENV;
|
|
});
|
|
|
|
afterEach(function() {
|
|
process.env.BABEL_ENV = oldBabelEnv;
|
|
process.env.NODE_ENV = oldNodeEnv;
|
|
});
|
|
|
|
describe("ignore", () => {
|
|
it("should ignore files that match", () => {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("nonexistant-fake", "src.js"),
|
|
babelrc: false,
|
|
ignore: [
|
|
fixture("nonexistant-fake", "src.js"),
|
|
|
|
// We had a regression where multiple ignore patterns broke things, so
|
|
// we keep some extra random items in here.
|
|
fixture("nonexistant-fake", "other.js"),
|
|
fixture("nonexistant-fake", "misc.js"),
|
|
],
|
|
});
|
|
|
|
assert.equal(chain, null);
|
|
});
|
|
|
|
it("should not ignore files that don't match", () => {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("nonexistant-fake", "src.js"),
|
|
babelrc: false,
|
|
ignore: [
|
|
fixture("nonexistant-fake", "other.js"),
|
|
fixture("nonexistant-fake", "misc.js"),
|
|
],
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("nonexistant-fake", "src.js"),
|
|
babelrc: false,
|
|
ignore: [
|
|
fixture("nonexistant-fake", "other.js"),
|
|
fixture("nonexistant-fake", "misc.js"),
|
|
],
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
});
|
|
|
|
describe("only", () => {
|
|
it("should ignore files that don't match", () => {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("nonexistant-fake", "src.js"),
|
|
babelrc: false,
|
|
only: [
|
|
fixture("nonexistant-fake", "other.js"),
|
|
fixture("nonexistant-fake", "misc.js"),
|
|
],
|
|
});
|
|
|
|
assert.equal(chain, null);
|
|
});
|
|
|
|
it("should not ignore files that match", () => {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("nonexistant-fake", "src.js"),
|
|
babelrc: false,
|
|
only: [
|
|
fixture("nonexistant-fake", "src.js"),
|
|
fixture("nonexistant-fake", "misc.js"),
|
|
],
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("nonexistant-fake", "src.js"),
|
|
babelrc: false,
|
|
only: [
|
|
fixture("nonexistant-fake", "src.js"),
|
|
fixture("nonexistant-fake", "misc.js"),
|
|
],
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
});
|
|
|
|
describe("ignore/only", () => {
|
|
it("should ignore files that match ignore and don't match only", () => {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("nonexistant-fake", "src.js"),
|
|
babelrc: false,
|
|
ignore: [fixture("nonexistant-fake", "src.js")],
|
|
only: [fixture("nonexistant-fake", "src.js")],
|
|
});
|
|
|
|
assert.equal(chain, null);
|
|
});
|
|
});
|
|
|
|
describe("caching", function() {
|
|
describe("programmatic options", function() {
|
|
it("should not cache the input options by identity", () => {
|
|
const comments = false;
|
|
|
|
const chain1 = buildConfigChain({ comments });
|
|
const chain2 = buildConfigChain({ comments });
|
|
|
|
assert.equal(chain1.length, 1);
|
|
assert.equal(chain2.length, 1);
|
|
assert.notStrictEqual(chain1[0], chain2[0]);
|
|
});
|
|
|
|
it("should cache the env options by identity", () => {
|
|
process.env.NODE_ENV = "foo";
|
|
const env = {
|
|
foo: {
|
|
comments: false,
|
|
},
|
|
};
|
|
|
|
const chain1 = buildConfigChain({ env });
|
|
const chain2 = buildConfigChain({ env });
|
|
|
|
assert.equal(chain1.length, 2);
|
|
assert.equal(chain2.length, 2);
|
|
assert.strictEqual(chain1[0], chain2[0]);
|
|
assert.strictEqual(chain1[1], chain2[1]);
|
|
});
|
|
|
|
it("should cache the plugin options by identity", () => {
|
|
const plugins = [];
|
|
|
|
const chain1 = buildConfigChain({ plugins });
|
|
const chain2 = buildConfigChain({ plugins });
|
|
|
|
assert.equal(chain1.length, 1);
|
|
assert.equal(chain2.length, 1);
|
|
assert.strictEqual(chain1[0], chain2[0]);
|
|
});
|
|
|
|
it("should cache the presets options by identity", () => {
|
|
const presets = [];
|
|
|
|
const chain1 = buildConfigChain({ presets });
|
|
const chain2 = buildConfigChain({ presets });
|
|
|
|
assert.equal(chain1.length, 1);
|
|
assert.equal(chain2.length, 1);
|
|
assert.strictEqual(chain1[0], chain2[0]);
|
|
});
|
|
|
|
it("should not cache the presets options with passPerPreset", () => {
|
|
const presets = [];
|
|
|
|
const chain1 = buildConfigChain({ presets });
|
|
const chain2 = buildConfigChain({ presets, passPerPreset: true });
|
|
const chain3 = buildConfigChain({ presets, passPerPreset: false });
|
|
|
|
assert.equal(chain1.length, 1);
|
|
assert.equal(chain2.length, 1);
|
|
assert.equal(chain3.length, 1);
|
|
assert.notStrictEqual(chain1[0], chain2[0]);
|
|
assert.strictEqual(chain1[0], chain3[0]);
|
|
assert.notStrictEqual(chain2[0], chain3[0]);
|
|
});
|
|
});
|
|
|
|
describe("config file options", function() {
|
|
function touch(filepath) {
|
|
const s = fs.statSync(filepath);
|
|
fs.utimesSync(
|
|
filepath,
|
|
s.atime,
|
|
s.mtime + Math.random() > 0.5 ? 1 : -1,
|
|
);
|
|
}
|
|
|
|
it("should cache package.json files by mtime", () => {
|
|
const filename = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"pkg",
|
|
"src.js",
|
|
);
|
|
const pkgJSON = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"pkg",
|
|
"package.json",
|
|
);
|
|
|
|
const chain1 = buildConfigChain({ filename });
|
|
const chain2 = buildConfigChain({ filename });
|
|
|
|
touch(pkgJSON);
|
|
|
|
const chain3 = buildConfigChain({ filename });
|
|
const chain4 = buildConfigChain({ filename });
|
|
|
|
assert.equal(chain1.length, 3);
|
|
assert.equal(chain2.length, 3);
|
|
assert.equal(chain3.length, 3);
|
|
assert.equal(chain4.length, 3);
|
|
assert.equal(chain1[1].alias, pkgJSON);
|
|
assert.equal(chain2[1].alias, pkgJSON);
|
|
assert.equal(chain3[1].alias, pkgJSON);
|
|
assert.equal(chain4[1].alias, pkgJSON);
|
|
assert.strictEqual(chain1[1], chain2[1]);
|
|
|
|
// Identity changed after touch().
|
|
assert.notStrictEqual(chain3[1], chain1[1]);
|
|
assert.strictEqual(chain3[1], chain4[1]);
|
|
});
|
|
|
|
it("should cache .babelrc files by mtime", () => {
|
|
const filename = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"babelrc",
|
|
"src.js",
|
|
);
|
|
const babelrcFile = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"babelrc",
|
|
".babelrc",
|
|
);
|
|
|
|
const chain1 = buildConfigChain({ filename });
|
|
const chain2 = buildConfigChain({ filename });
|
|
|
|
touch(babelrcFile);
|
|
|
|
const chain3 = buildConfigChain({ filename });
|
|
const chain4 = buildConfigChain({ filename });
|
|
|
|
assert.equal(chain1.length, 3);
|
|
assert.equal(chain2.length, 3);
|
|
assert.equal(chain3.length, 3);
|
|
assert.equal(chain4.length, 3);
|
|
assert.equal(chain1[1].alias, babelrcFile);
|
|
assert.equal(chain2[1].alias, babelrcFile);
|
|
assert.equal(chain3[1].alias, babelrcFile);
|
|
assert.equal(chain4[1].alias, babelrcFile);
|
|
assert.strictEqual(chain1[1], chain2[1]);
|
|
|
|
// Identity changed after touch().
|
|
assert.notStrictEqual(chain3[1], chain1[1]);
|
|
assert.strictEqual(chain3[1], chain4[1]);
|
|
});
|
|
|
|
it("should cache .babelignore files by mtime", () => {
|
|
const filename = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"babelignore",
|
|
"src.js",
|
|
);
|
|
const babelignoreFile = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"babelignore",
|
|
".babelignore",
|
|
);
|
|
|
|
const chain1 = buildConfigChain({ filename });
|
|
const chain2 = buildConfigChain({ filename });
|
|
|
|
touch(babelignoreFile);
|
|
|
|
const chain3 = buildConfigChain({ filename });
|
|
const chain4 = buildConfigChain({ filename });
|
|
|
|
assert.equal(chain1.length, 6);
|
|
assert.equal(chain2.length, 6);
|
|
assert.equal(chain3.length, 6);
|
|
assert.equal(chain4.length, 6);
|
|
assert.equal(chain1[4].alias, babelignoreFile);
|
|
assert.equal(chain2[4].alias, babelignoreFile);
|
|
assert.equal(chain3[4].alias, babelignoreFile);
|
|
assert.equal(chain4[4].alias, babelignoreFile);
|
|
assert.strictEqual(chain1[4], chain2[4]);
|
|
|
|
// Identity changed after touch().
|
|
assert.notStrictEqual(chain3[4], chain1[4]);
|
|
assert.strictEqual(chain3[4], chain4[4]);
|
|
});
|
|
|
|
it("should cache .babelrc.js files programmable behavior", () => {
|
|
const filename = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"babelrc-js",
|
|
"src.js",
|
|
);
|
|
const babelrcFile = fixture(
|
|
"complex-plugin-config",
|
|
"config-identity",
|
|
"babelrc-js",
|
|
".babelrc.js",
|
|
);
|
|
|
|
const chain1 = buildConfigChain({ filename });
|
|
const chain2 = buildConfigChain({ filename });
|
|
|
|
process.env.NODE_ENV = "new-env";
|
|
|
|
const chain3 = buildConfigChain({ filename });
|
|
const chain4 = buildConfigChain({ filename });
|
|
|
|
assert.equal(chain1.length, 3);
|
|
assert.equal(chain2.length, 3);
|
|
assert.equal(chain3.length, 3);
|
|
assert.equal(chain4.length, 3);
|
|
assert.equal(chain1[1].alias, babelrcFile);
|
|
assert.equal(chain2[1].alias, babelrcFile);
|
|
assert.equal(chain3[1].alias, babelrcFile);
|
|
assert.equal(chain4[1].alias, babelrcFile);
|
|
assert.strictEqual(chain1[1], chain2[1]);
|
|
|
|
// Identity changed after changing the NODE_ENV.
|
|
assert.notStrictEqual(chain3[1], chain1[1]);
|
|
assert.strictEqual(chain3[1], chain4[1]);
|
|
});
|
|
});
|
|
});
|
|
|
|
it("dir1", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("dir1", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["extended"],
|
|
},
|
|
alias: fixture("extended.babelrc.json"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
extends: "./extended.babelrc.json",
|
|
plugins: ["root"],
|
|
},
|
|
alias: fixture(".babelrc"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("dir1", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("dir2", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("dir2", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["dir2"],
|
|
},
|
|
alias: fixture("dir2", ".babelrc"),
|
|
dirname: fixture("dir2"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("dir2", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("dir3", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("dir3", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["extended"],
|
|
},
|
|
alias: fixture("extended.babelrc.json"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
extends: "./extended.babelrc.json",
|
|
plugins: ["root"],
|
|
},
|
|
alias: fixture(".babelrc"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("dir3", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("env - base", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("env", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
env: {
|
|
bar: {
|
|
plugins: ["env-bar"],
|
|
},
|
|
foo: {
|
|
plugins: ["env-foo"],
|
|
},
|
|
},
|
|
plugins: ["env-base"],
|
|
},
|
|
alias: fixture("env", ".babelrc"),
|
|
dirname: fixture("env"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("env", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("env - foo", function() {
|
|
process.env.NODE_ENV = "foo";
|
|
|
|
const chain = buildConfigChain({
|
|
filename: fixture("env", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
env: {
|
|
bar: {
|
|
plugins: ["env-bar"],
|
|
},
|
|
foo: {
|
|
plugins: ["env-foo"],
|
|
},
|
|
},
|
|
plugins: ["env-base"],
|
|
},
|
|
alias: fixture("env", ".babelrc"),
|
|
dirname: fixture("env"),
|
|
},
|
|
{
|
|
type: "env",
|
|
options: {
|
|
plugins: ["env-foo"],
|
|
},
|
|
alias: fixture("env", ".babelrc.env.foo"),
|
|
dirname: fixture("env"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("env", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("env - bar", function() {
|
|
process.env.NODE_ENV = "foo"; // overridden
|
|
process.env.NODE_ENV = "bar";
|
|
|
|
const chain = buildConfigChain({
|
|
filename: fixture("env", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
env: {
|
|
bar: {
|
|
plugins: ["env-bar"],
|
|
},
|
|
foo: {
|
|
plugins: ["env-foo"],
|
|
},
|
|
},
|
|
plugins: ["env-base"],
|
|
},
|
|
alias: fixture("env", ".babelrc"),
|
|
dirname: fixture("env"),
|
|
},
|
|
{
|
|
type: "env",
|
|
options: {
|
|
plugins: ["env-bar"],
|
|
},
|
|
alias: fixture("env", ".babelrc.env.bar"),
|
|
dirname: fixture("env"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("env", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("env - foo", function() {
|
|
process.env.NODE_ENV = "foo";
|
|
|
|
const chain = buildConfigChain({
|
|
filename: fixture("pkg", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["pkg-plugin"],
|
|
},
|
|
alias: fixture("pkg", "package.json"),
|
|
dirname: fixture("pkg"),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["pkg-ignore"],
|
|
},
|
|
alias: fixture("pkg", ".babelignore"),
|
|
dirname: fixture("pkg"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("pkg", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("js-config", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("js-config", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["foo", "bar"],
|
|
},
|
|
alias: fixture("js-config", ".babelrc.js"),
|
|
dirname: fixture("js-config"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("js-config", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("js-config-function", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("js-config-function", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
compact: true,
|
|
},
|
|
alias: fixture("js-config-function", ".babelrc.js"),
|
|
dirname: fixture("js-config-function"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("js-config-function", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it("js-config-default - should read transpiled export default", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("js-config-default", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["foo", "bar"],
|
|
},
|
|
alias: fixture("js-config-default", ".babelrc.js"),
|
|
dirname: fixture("js-config-default"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("js-config-default", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
it("js-config-extended", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("js-config-extended", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["extended"],
|
|
},
|
|
alias: fixture("extended.babelrc.json"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
extends: "../extended.babelrc.json",
|
|
plugins: ["foo", "bar"],
|
|
},
|
|
alias: fixture("js-config-extended", ".babelrc.js"),
|
|
dirname: fixture("js-config-extended"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("js-config-extended", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
});
|
|
|
|
it(
|
|
"json-pkg-config-no-babel - should not throw if" +
|
|
" package.json doesn't contain a `babel` field",
|
|
function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("json-pkg-config-no-babel", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
plugins: ["json"],
|
|
},
|
|
alias: fixture("json-pkg-config-no-babel", ".babelrc"),
|
|
dirname: fixture("json-pkg-config-no-babel"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("json-pkg-config-no-babel", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
},
|
|
);
|
|
|
|
it("should not ignore file matching negated file pattern", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("ignore-negate", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["*", "!src.js"],
|
|
},
|
|
alias: fixture("ignore-negate", ".babelrc"),
|
|
dirname: fixture("ignore-negate"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("ignore-negate", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
|
|
const chain2 = buildConfigChain({
|
|
filename: fixture("ignore-negate", "src2.js"),
|
|
});
|
|
|
|
assert.equal(chain2, null);
|
|
});
|
|
|
|
it("should not ignore file matching negated folder pattern", function() {
|
|
const chain = buildConfigChain({
|
|
filename: fixture("ignore-negate-folder", "folder", "src.js"),
|
|
});
|
|
|
|
const expected = [
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["root-ignore"],
|
|
},
|
|
alias: fixture(".babelignore"),
|
|
dirname: fixture(),
|
|
},
|
|
{
|
|
type: "file",
|
|
options: {
|
|
ignore: ["*", "!folder"],
|
|
},
|
|
alias: fixture("ignore-negate-folder", ".babelrc"),
|
|
dirname: fixture("ignore-negate-folder"),
|
|
},
|
|
{
|
|
type: "arguments",
|
|
options: {
|
|
filename: fixture("ignore-negate-folder", "folder", "src.js"),
|
|
},
|
|
alias: "base",
|
|
dirname: base(),
|
|
},
|
|
];
|
|
|
|
assert.deepEqual(chain, expected);
|
|
|
|
const chain2 = buildConfigChain({
|
|
filename: fixture("ignore-negate-folder", "src2.js"),
|
|
});
|
|
|
|
assert.equal(chain2, null);
|
|
});
|
|
|
|
it(
|
|
"js-json-config - should throw an error if both a .babelrc" +
|
|
" and a .babelrc.js are present",
|
|
function() {
|
|
assert.throws(function() {
|
|
buildConfigChain({
|
|
filename: fixture("js-json-config", "src.js"),
|
|
});
|
|
}, /Multiple configuration files found\.(.|\n)*\.babelrc(.|\n)*\.babelrc\.js/);
|
|
},
|
|
);
|
|
|
|
it(
|
|
"js-pkg-config - should throw an error if both a .babelrc.js" +
|
|
" and a package.json with a babel field are present",
|
|
function() {
|
|
assert.throws(function() {
|
|
buildConfigChain({
|
|
filename: fixture("js-pkg-config", "src.js"),
|
|
});
|
|
}, /Multiple configuration files found\.(.|\n)*\.babelrc\.js(.|\n)*package\.json/);
|
|
},
|
|
);
|
|
|
|
it(
|
|
"json-pkg-config - should throw an error if both a .babelrc" +
|
|
" and a package.json with a babel field are present",
|
|
function() {
|
|
assert.throws(function() {
|
|
buildConfigChain({
|
|
filename: fixture("json-pkg-config", "src.js"),
|
|
});
|
|
}, /Multiple configuration files found\.(.|\n)*\.babelrc(.|\n)*package\.json/);
|
|
},
|
|
);
|
|
|
|
it("js-config-error", function() {
|
|
assert.throws(function() {
|
|
buildConfigChain({
|
|
filename: fixture("js-config-error", "src.js"),
|
|
});
|
|
}, /Error while loading config/);
|
|
});
|
|
|
|
it("js-config-error2", function() {
|
|
assert.throws(function() {
|
|
buildConfigChain({
|
|
filename: fixture("js-config-error2", "src.js"),
|
|
});
|
|
}, /Configuration should be an exported JavaScript object/);
|
|
});
|
|
|
|
it("js-config-error3", function() {
|
|
assert.throws(function() {
|
|
buildConfigChain({
|
|
filename: fixture("js-config-error3", "src.js"),
|
|
});
|
|
}, /Configuration should be an exported JavaScript object/);
|
|
});
|
|
|
|
it("json-config-error", function() {
|
|
assert.throws(function() {
|
|
buildConfigChain({
|
|
filename: fixture("json-config-error", "src.js"),
|
|
});
|
|
}, /Error while parsing config/);
|
|
});
|
|
});
|