function-with-env.test.js

"use strict";
const { existsSync } = require("fs");
const { resolve } = require("path");
const { run, readFile } = require("../../../../utils/test-utils");

describe("function configuration", () => {
  it("should throw when env is not supplied", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, ["--env"]);

    expect(exitCode).toBe(2);
    expect(stderr).toContain("Error: Option '--env <value...>' argument missing");
    expect(stdout).toBeFalsy();
  });

  it("is able to understand a configuration file as a function", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, ["--env", "isProd"]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/prod.js"))).toBeTruthy();
  });

  it("is able to understand a configuration file as a function", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, ["--env", "isDev"]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/dev.js"))).toBeTruthy();
  });

  it("Supports passing string in env", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, [
      "--env",
      "environment=production",
      "--env",
      "app.title=Luffy",
      "-c",
      "webpack.env.config.js",
    ]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/Luffy.js"))).toBeTruthy();
  });

  it("Supports long nested values in env", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, [
      "--env",
      "file.name.is.this=Atsumu",
      "--env",
      "environment=production",
      "-c",
      "webpack.env.config.js",
    ]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/Atsumu.js"))).toBeTruthy();
  });

  it("Supports multiple equal in a string", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, [
      "--env",
      "file=name=is=Eren",
      "--env",
      "environment=multipleq",
      "-c",
      "webpack.env.config.js",
    ]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/name=is=Eren.js"))).toBeTruthy();
  });

  it("Supports dot at the end", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, [
      "--env",
      "name.=Hisoka",
      "--env",
      "environment=dot",
      "-c",
      "webpack.env.config.js",
    ]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/Hisoka.js"))).toBeTruthy();
  });

  it("Supports dot at the end", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, [
      "--env",
      "name.",
      "--env",
      "environment=dot",
      "-c",
      "webpack.env.config.js",
    ]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/true.js"))).toBeTruthy();
  });

  it("Supports empty string", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, ["--env", `foo=''`]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/empty-string.js"))).toBeTruthy();
  });

  it('Supports empty string with multiple "="', async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, ["--env", `foo=bar=''`]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/new-empty-string.js"))).toBeTruthy();
  });

  it('Supports env variable with "=" at the end', async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, ["--env", `foo=`]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/equal-at-the-end.js"))).toBeTruthy();
  });

  it("is able to understand multiple env flags", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, [
      "--env",
      "isDev",
      "--env",
      "verboseStats",
      "--env",
      "envMessage",
    ]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // check that the verbose env is respected
    expect(stdout).toContain("LOG from webpack");

    let data;

    try {
      data = await readFile(resolve(__dirname, "./dist/dev.js"), "utf-8");
    } catch (error) {
      expect(error).toBe(null);
    }

    // check if the values from DefinePlugin make it to the compiled code
    expect(data).toContain("env message present");
  });

  it("is able to apply last flag with same name", async () => {
    const { exitCode, stderr, stdout } = await run(__dirname, [
      "--env",
      "name.=foo",
      "--env",
      "name.=baz",
      "--env",
      "environment=dot",
      "-c",
      "webpack.env.config.js",
    ]);

    expect(exitCode).toBe(0);
    expect(stderr).toBeFalsy();
    expect(stdout).toBeTruthy();
    // Should generate the appropriate files
    expect(existsSync(resolve(__dirname, "./dist/baz.js"))).toBeTruthy();
  });
});