common.js

/**
 * @author Toru Nagashima
 * @copyright 2016 Toru Nagashima. All rights reserved.
 * See LICENSE file in root directory for full license.
 */
"use strict"

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const assert = require("power-assert")
const nodeApi = require("../lib")
const BufferStream = require("./lib/buffer-stream")
const util = require("./lib/util")
const result = util.result
const removeResult = util.removeResult
const runAll = util.runAll
const runPar = util.runPar
const runSeq = util.runSeq

//------------------------------------------------------------------------------
// Test
//------------------------------------------------------------------------------

describe("[common]", () => {
    before(() => process.chdir("test-workspace"))
    after(() => process.chdir(".."))

    beforeEach(removeResult)

    describe("should print a help text if arguments are nothing.", () => {
        it("npm-run-all command", async () => {
            const buf = new BufferStream()
            await runAll([], buf)
            assert(/Usage:/.test(buf.value))
        })

        it("run-s command", async () => {
            const buf = new BufferStream()
            await runSeq([], buf)
            assert(/Usage:/.test(buf.value))
        })

        it("run-p command", async () => {
            const buf = new BufferStream()
            await runPar([], buf)
            assert(/Usage:/.test(buf.value))
        })
    })

    describe("should print a help text if the first argument is --help (-h)", () => {
        it("npm-run-all command (-h)", async () => {
            const buf = new BufferStream()
            await runAll(["-h"], buf)
            assert(/Usage:/.test(buf.value))
        })

        it("run-s command (-h)", async () => {
            const buf = new BufferStream()
            await runSeq(["-h"], buf)
            assert(/Usage:/.test(buf.value))
        })

        it("run-p command (-h)", async () => {
            const buf = new BufferStream()
            await runPar(["-h"], buf)
            assert(/Usage:/.test(buf.value))
        })

        it("npm-run-all command (--help)", async () => {
            const buf = new BufferStream()
            await runAll(["--help"], buf)
            assert(/Usage:/.test(buf.value))
        })

        it("run-s command (--help)", async () => {
            const buf = new BufferStream()
            await runSeq(["--help"], buf)
            assert(/Usage:/.test(buf.value))
        })

        it("run-p command (--help)", async () => {
            const buf = new BufferStream()
            await runPar(["--help"], buf)
            assert(/Usage:/.test(buf.value))
        })
    })

    describe("should print a version number if the first argument is --version (-v)", () => {
        it("npm-run-all command (-v)", async () => {
            const buf = new BufferStream()
            await runAll(["-v"], buf)
            assert(/v[0-9]+\.[0-9]+\.[0-9]+/.test(buf.value))
        })

        it("run-s command (-v)", async () => {
            const buf = new BufferStream()
            await runSeq(["-v"], buf)
            assert(/v[0-9]+\.[0-9]+\.[0-9]+/.test(buf.value))
        })

        it("run-p command (-v)", async () => {
            const buf = new BufferStream()
            await runPar(["-v"], buf)
            assert(/v[0-9]+\.[0-9]+\.[0-9]+/.test(buf.value))
        })

        it("npm-run-all command (--version)", async () => {
            const buf = new BufferStream()
            await runAll(["--version"], buf)
            assert(/v[0-9]+\.[0-9]+\.[0-9]+/.test(buf.value))
        })

        it("run-s command (--version)", async () => {
            const buf = new BufferStream()
            await runSeq(["--version"], buf)
            assert(/v[0-9]+\.[0-9]+\.[0-9]+/.test(buf.value))
        })

        it("run-p command (--version)", async () => {
            const buf = new BufferStream()
            await runPar(["--version"], buf)
            assert(/v[0-9]+\.[0-9]+\.[0-9]+/.test(buf.value))
        })
    })

    describe("should do nothing if a task list is empty.", () => {
        it("Node API", async () => {
            await nodeApi(null)
            assert(result() == null)
        })
    })

    describe("should run a task by npm (check an environment variable):", () => {
        it("Node API", async () => {
            await nodeApi("test-task:package-config")
            assert(result() === "OK")
        })

        it("npm-run-all command", async () => {
            await runAll(["test-task:package-config"])
            assert(result() === "OK")
        })

        it("run-s command", async () => {
            await runSeq(["test-task:package-config"])
            assert(result() === "OK")
        })

        it("run-p command", async () => {
            await runPar(["test-task:package-config"])
            assert(result() === "OK")
        })
    })

    describe("stdin can be used in tasks:", () => {
        it("Node API", async () => {
            await nodeApi("test-task:stdin")
            assert(result().trim() === "STDIN")
        })

        it("npm-run-all command", async () => {
            await runAll(["test-task:stdin"])
            assert(result().trim() === "STDIN")
        })

        it("run-s command", async () => {
            await runSeq(["test-task:stdin"])
            assert(result().trim() === "STDIN")
        })

        it("run-p command", async () => {
            await runPar(["test-task:stdin"])
            assert(result().trim() === "STDIN")
        })
    })

    describe("stdout can be used in tasks:", () => {
        it("Node API", async () => {
            await nodeApi("test-task:stdout")
            assert(result() === "STDOUT")
        })

        it("npm-run-all command", async () => {
            await runAll(["test-task:stdout"])
            assert(result() === "STDOUT")
        })

        it("run-s command", async () => {
            await runSeq(["test-task:stdout"])
            assert(result() === "STDOUT")
        })

        it("run-p command", async () => {
            await runPar(["test-task:stdout"])
            assert(result() === "STDOUT")
        })
    })

    describe("stderr can be used in tasks:", () => {
        it("Node API", async () => {
            await nodeApi("test-task:stderr")
            assert(result() === "STDERR")
        })

        it("npm-run-all command", async () => {
            await runAll(["test-task:stderr"])
            assert(result() === "STDERR")
        })

        it("run-s command", async () => {
            await runSeq(["test-task:stderr"])
            assert(result() === "STDERR")
        })

        it("run-p command", async () => {
            await runPar(["test-task:stderr"])
            assert(result() === "STDERR")
        })
    })

    describe("should be able to use `restart` built-in task:", () => {
        it("Node API", () => nodeApi("restart"))
        it("npm-run-all command", () => runAll(["restart"]))
        it("run-s command", () => runSeq(["restart"]))
        it("run-p command", () => runPar(["restart"]))
    })

    describe("should be able to use `env` built-in task:", () => {
        it("Node API", () => nodeApi("env"))
        it("npm-run-all command", () => runAll(["env"]))
        it("run-s command", () => runSeq(["env"]))
        it("run-p command", () => runPar(["env"]))
    })

    if (process.platform === "win32") {
        describe("issue14", () => {
            it("Node API", () => nodeApi("test-task:issue14:win32"))
            it("npm-run-all command", () => runAll(["test-task:issue14:win32"]))
            it("run-s command", () => runSeq(["test-task:issue14:win32"]))
            it("run-p command", () => runPar(["test-task:issue14:win32"]))
        })
    }
    else {
        describe("issue14", () => {
            it("Node API", () => nodeApi("test-task:issue14:posix"))
            it("npm-run-all command", () => runAll(["test-task:issue14:posix"]))
            it("run-s command", () => runSeq(["test-task:issue14:posix"]))
            it("run-p command", () => runPar(["test-task:issue14:posix"]))
        })
    }

    describe("should not print log if silent option was given:", () => {
        it("Node API", async () => {
            const stdout = new BufferStream()
            const stderr = new BufferStream()
            try {
                await nodeApi("test-task:error", { silent: true, stdout, stderr })
            }
            catch (_err) {
                assert(stdout.value === "" && stderr.value === "")
                return
            }
            assert(false, "Should fail.")
        })

        /**
         * Strip unknown istanbul's warnings.
         * @param {string} str - The string to be stripped.
         * @returns {string} The stripped string.
         */
        function stripIstanbulWarnings(str) {
            return str.replace(/File \[.+?] ignored, nothing could be mapped\r?\n/, "")
        }

        it("npm-run-all command", async () => {
            const stdout = new BufferStream()
            const stderr = new BufferStream()
            try {
                await runAll(["--silent", "test-task:error"], stdout, stderr)
            }
            catch (_err) {
                assert(stdout.value === "" && stripIstanbulWarnings(stderr.value) === "")
                return
            }
            assert(false, "Should fail.")
        })

        it("run-s command", async () => {
            const stdout = new BufferStream()
            const stderr = new BufferStream()
            try {
                await runSeq(["--silent", "test-task:error"], stdout, stderr)
            }
            catch (_err) {
                assert(stdout.value === "" && stripIstanbulWarnings(stderr.value) === "")
                return
            }
            assert(false, "Should fail.")
        })

        it("run-p command", async () => {
            const stdout = new BufferStream()
            const stderr = new BufferStream()
            try {
                await runPar(["--silent", "test-task:error"], stdout, stderr)
            }
            catch (_err) {
                assert(stdout.value === "" && stripIstanbulWarnings(stderr.value) === "")
                return
            }
            assert(false, "Should fail.")
        })
    })

    // https://github.com/mysticatea/npm-run-all/issues/105
    describe("should not print MaxListenersExceededWarning when it runs 10 tasks:", () => {
        const tasks = Array.from({ length: 10 }, () => "test-task:append:a")

        it("npm-run-all command", async () => {
            const buf = new BufferStream()
            await runAll(tasks, null, buf)
            assert(buf.value.indexOf("MaxListenersExceededWarning") === -1)
        })

        it("run-s command", async () => {
            const buf = new BufferStream()
            await runSeq(tasks, null, buf)
            assert(buf.value.indexOf("MaxListenersExceededWarning") === -1)
        })

        it("run-p command", async () => {
            const buf = new BufferStream()
            await runPar(tasks, null, buf)
            assert(buf.value.indexOf("MaxListenersExceededWarning") === -1)
        })
    })
})