BUILD.bazel

load("@aspect_bazel_lib//lib:copy_to_bin.bzl", "copy_to_bin")
load("@aspect_bazel_lib//lib:directory_path.bzl", "directory_path")
load("@bazel_skylib//rules:diff_test.bzl", "diff_test")
load("@bazel_skylib//rules:write_file.bzl", "write_file")
load("@example_npm_deps//:defs.bzl", "link_js_packages", "package", "package_dir")
load("@example_npm_deps//uvu:package_json.bzl", uvu_bin = "bin")
load("@example_npm_deps__acorn__8.4.0__links//:link_js_package.bzl", link_acorn = "link_js_package")
load("@example_npm_deps__rollup__2.70.2//:package_json.bzl", "rollup", "rollup_binary", "rollup_test")
load("//js:defs.bzl", "js_binary", "js_test", "link_js_package")
load("//js:run_js_binary.bzl", "run_js_binary")

# gazelle:exclude npm_imports.bzl
# gazelle:exclude translate_pnpm_lock.bzl

###########################

link_acorn()

link_js_packages()

link_js_package(
    name = package("@mycorp/mylib").name,
    src = "//example/lib",
    deps = [package("acorn")],
)

###########################
# Fixtures for tests in this file

# Trivial test fixture: a nodejs program that writes to a file
write_file(
    name = "js",
    out = "some.js",
    content = ["require('fs').writeFileSync(process.argv[2], 'stuff')"],
)

# The output produced by that program, for assertions
write_file(
    name = "write_expected",
    out = "expected",
    content = ["stuff"],
)

# Trivial test fixture: the shortest legal JS program
write_file(
    name = "write_one",
    out = "one.js",
    content = ["1"],
)

# For using acorn as our test fixture, this is
# the serialized AST for the that shortest legal JS program
write_file(
    name = "write_expected_one_ast",
    out = "expected_ast.json",
    content = [
        """{"type":"Program","start":0,"end":1,"body":[{"type":"ExpressionStatement","start":0,"end":1,"expression":{"type":"Literal","start":0,"end":1,"value":1,"raw":"1"}}],"sourceType":"script"}\n""",
    ],
)

#############################
# Test case 1
# Show that you can use the node toolchain together with a genrule().
# This gives you complete control over starting the interpreter, but you also have to
# manually handle module resolution.
genrule(
    name = "use_node_toolchain",
    srcs = ["some.js"],
    outs = ["actual1"],
    cmd = "$(NODE_PATH) $(execpath some.js) $@",
    toolchains = ["@nodejs_toolchains//:resolved_toolchain"],
    tools = ["@nodejs_toolchains//:resolved_toolchain"],
)

diff_test(
    name = "test_genrule",
    file1 = "expected",
    file2 = "actual1",
)

##########################################################
# Test case 2
# Directly invoke a bin from a package from npm to transform inputs to bazel-out
# Similar to build_bazel_rules_nodejs generated npm_package_bin targets

genrule(
    name = "call_acorn",
    srcs = [
        "one.js",
        package("acorn"),
        package_dir("acorn"),
    ],
    outs = ["actual2"],
    cmd = """
        $(NODE_PATH) \\
        ./$(execpath %s)/bin/acorn \\
        --compact \\
        $(execpath one.js) \\
        > $@""" % package_dir("acorn"),
    toolchains = ["@nodejs_toolchains//:resolved_toolchain"],
    tools = ["@nodejs_toolchains//:resolved_toolchain"],
)

diff_test(
    name = "test_acorn",
    file1 = "actual2",
    file2 = "expected_ast.json",
)

################################################
# Test case 3
# Run a first-party program that requires a package from npm
# Use a genrule to prove that works

copy_to_bin(
    name = "require_acorn_js",
    srcs = ["require_acorn.js"],
)

genrule(
    name = "require_acorn",
    srcs = [
        ":require_acorn_js",
        package("acorn"),
    ],
    outs = ["actual3"],
    cmd = """
        $(NODE_PATH) \\
        ./$(execpath :require_acorn_js) \\
        $@""",
    toolchains = ["@nodejs_toolchains//:resolved_toolchain"],
    tools = ["@nodejs_toolchains//:resolved_toolchain"],
)

diff_test(
    name = "test_require_acorn",
    file1 = "actual3",
    file2 = "expected_ast.json",
)

####################################################
# Test case 4
# Show that a js_binary can be used with run_js_binary
# because everything it needs to run is in the runfiles

js_binary(
    name = "bin",
    data = [package("acorn")],
    entry_point = "require_acorn.js",
)

run_js_binary(
    name = "run4",
    srcs = [],
    outs = ["actual4"],
    args = ["actual4"],
    chdir = package_name(),
    tool = ":bin",
)

diff_test(
    name = "test_js_binary_under_run_js_binary",
    file1 = "expected_ast.json",
    file2 = "actual4",
)

################################
# Test case 5
# js_test is just a js_binary

js_test(
    name = "test_test",
    data = ["@example_npm_deps//@types/node"],
    entry_point = "test.js",
)

###############################
# Test case 6
# a first-party library which we want to run as a program

write_file(
    name = "write6",
    out = "case6.js",
    content = [
        """require('fs').writeFileSync(process.argv[2], require("@mycorp/mylib").toAst("1"))""",
    ],
)

js_binary(
    name = "bin6",
    data = [package("@mycorp/mylib")],
    entry_point = "case6.js",
)

run_js_binary(
    name = "run6",
    outs = ["actual6"],
    args = ["actual6"],
    chdir = package_name(),
    tool = ":bin6",
)

diff_test(
    name = "test6",
    file1 = "expected_ast.json",
    file2 = "actual6",
)

#######################################
# Test case 7
# transitive npm dependencies

write_file(
    name = "write7",
    out = "case7.js",
    content = ["require('fs').writeFileSync(process.argv[2], require('@gregmagolan/test-b'))"],
)

write_file(
    name = "expected7",
    out = "expected7.txt",
    content = ["test-b-0.0.2/test-a-0.0.1"],
)

js_binary(
    name = "bin7",
    data = ["@example_npm_deps//@gregmagolan/test-b"],
    entry_point = "case7.js",
)

run_js_binary(
    name = "run7",
    srcs = [],
    outs = ["actual7"],
    args = ["example/actual7"],
    tool = ":bin7",
)

diff_test(
    name = "test7",
    file1 = "expected7",
    file2 = "actual7",
)

#######################################
# Test case 8
# run_js_binary
write_file(
    name = "write8",
    out = "case8.js",
    content = ["""
require('fs').writeFileSync(process.argv[2], JSON.stringify(require(require('path').join(process.cwd(), "case8.json"))))"""],
)

write_file(
    name = "expected8",
    out = "expected8.txt",
    content = ["{\"case7\":42}"],
)

js_binary(
    name = "bin8",
    entry_point = "case8.js",
)

run_js_binary(
    name = "run8",
    srcs = ["case8.json"],
    outs = ["actual8"],
    args = ["actual8"],
    chdir = package_name(),
    tool = ":bin8",
)

diff_test(
    name = "test8",
    file1 = "expected8",
    file2 = "actual8",
)

#######################################
# Test case 9
# set env variable and node_options

write_file(
    name = "write9",
    out = "case9.js",
    content = ["require('fs').writeFileSync(process.argv[2], process.env.FOO + process.title)"],
)

write_file(
    name = "expected9",
    out = "expected9.txt",
    content = ["BARbin9"],
)

js_binary(
    name = "bin9",
    entry_point = "case9.js",
    env = {
        "FOO": "BAR",
    },
    node_options = [
        "--title=bin9",
        "--throw-deprecation",
    ],
)

run_js_binary(
    name = "run9",
    outs = ["actual9"],
    args = ["../../../$@"],
    tool = ":bin9",
)

diff_test(
    name = "test9",
    file1 = "expected9",
    file2 = "actual9",
)

#######################################
# Test case 10
# capture stdout, stderr & exit code and --node_options

write_file(
    name = "write10",
    out = "case10.js",
    content = ["""process.stdout.write("to stdout")
process.stderr.write("to stderr")
require('fs').writeFileSync(process.argv[2], process.env.FOO + process.title)
process.exit(42)
"""],
)

write_file(
    name = "expected10",
    out = "expected10.txt",
    content = ["BARbin10"],
)

write_file(
    name = "expected10_stdout",
    out = "expected10_stdout.txt",
    content = ["to stdout"],
)

write_file(
    name = "expected10_stderr",
    out = "expected10_stderr.txt",
    content = ["to stderr"],
)

write_file(
    name = "expected10_result",
    out = "expected10_result.txt",
    content = ["42"],
)

js_binary(
    name = "bin10",
    entry_point = "case10.js",
    env = {
        "FOO": "BAR",
    },
)

js_test(
    name = "test10_test",
    args = ["dummy"],
    entry_point = "case10.js",
    env = {
        "FOO": "BAR",
    },
    expected_exit_code = 42,
    verbose = True,
)

# bazel run //example:test10_binary
js_binary(
    name = "test10_binary",
    args = ["dummy"],
    entry_point = "case10.js",
    env = {
        "FOO": "BAR",
    },
    expected_exit_code = 42,
    verbose = True,
)

run_js_binary(
    name = "run10",
    outs = [
        "actual10",
    ],
    args = [
        "--node_options=--title=bin10",
        "actual10",
    ],
    chdir = package_name(),
    exit_code_out = "actual10_result",
    stderr = "actual10_stderr",
    stdout = "actual10_stdout",
    tool = ":bin10",
)

#######################################
# Test case 11
# peer deps
js_test(
    name = "test_peer",
    data = [
        "@example_npm_deps//@rollup/plugin-commonjs",
        "@example_npm_deps//mobx-react",
        "@example_npm_deps//react",
        # TODO: fix this test so we test a peer dependency without requiring it as a direct
        # dependency https://github.com/aspect-build/rules_js/issues/92
        "@example_npm_deps//rollup",
    ],
    entry_point = "peer.js",
)

## Diff tests
diff_test(
    name = "test10",
    file1 = "expected10",
    file2 = "actual10",
)

diff_test(
    name = "test10_stdout",
    file1 = "expected10_stdout",
    file2 = "actual10_stdout",
)

diff_test(
    name = "test10_stderr",
    file1 = "expected10_stderr",
    file2 = "actual10_stderr",
)

diff_test(
    name = "test10_result",
    file1 = "expected10_result",
    file2 = "actual10_result",
)

#######################################
# Test case 11
# postinstall creates a file
# The @aspect-test/c package's postinstall creates a data.json file

write_file(
    name = "write11",
    out = "case11.js",
    content = ["""
const content = require('@aspect-test/c/data.json')
if (content.answer !== '42*') {
    console.error(`expected answer to be '42*', but got '${content.answer}'`)
    process.exit(1);
}
"""],
)

js_test(
    name = "test11",
    data = [
        package("@aspect-test/c"),
    ],
    entry_point = "case11.js",
)

#######################################
# Test case 12
# custom postinstall creates a file
# See postinstall on @aspect-test/c in WORKSPACE

write_file(
    name = "write12",
    out = "case12.js",
    content = ["""
const fs = require('fs')
const path = require('path')
const content = fs.readFileSync(path.join(process.argv[2], 'cow.txt'), 'utf-8')
console.log(content)
if (!/^moo\\s+mooo\\s*$/.test(content)) {
    console.error("expected file to contain cow sounds")
    process.exit(1);
}
"""],
)

js_test(
    name = "test12",
    args = ["$(rootpath %s)" % package_dir("@aspect-test/c")],
    data = [
        package_dir("@aspect-test/c"),
    ],
    entry_point = "case12.js",
)

####################################################
# Test case 13
# Show that a js_binary can use a DirectoryPathInfo entry point

directory_path(
    name = "acorn_entry_point",
    directory = package_dir("acorn"),
    path = "bin/acorn",
)

js_binary(
    name = "acorn_bin",
    args = ["--help"],
    entry_point = ":acorn_entry_point",
)

run_js_binary(
    name = "run13",
    args = ["--help"],
    stdout = "actual13",
    tool = ":acorn_bin",
)

write_file(
    name = "expected13",
    out = "expected13.txt",
    content = [
        "usage: acorn [--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|...|--ecma2015|--ecma2016|--ecma2017|--ecma2018|...]",
        "        [--tokenize] [--locations] [---allow-hash-bang] [--allow-await-outside-function] [--compact] [--silent] [--module] [--help] [--] [infile]",
        "",
    ],
)

diff_test(
    name = "test13",
    file1 = ":expected13",
    file2 = ":actual13",
)

####################################################
# Test case 14
# Use a generated rollup and rollup_binary targets from an npm_import

rollup(
    name = "actual14",
    args = ["--version"],
    stdout = "actual14.txt",
)

rollup_binary(
    name = "rollup_bin",
    args = ["--version"],
)

rollup_test(
    name = "rollup_version_test",
    args = ["--version"],
)

write_file(
    name = "expected14",
    out = "expected14.txt",
    content = [
        "rollup v2.70.2",
        "",
    ],
)

diff_test(
    name = "test14",
    file1 = ":expected14",
    file2 = ":actual14",
)

run_js_binary(
    name = "actual14_alt",
    args = ["--version"],
    stdout = "actual14_alt.txt",
    tool = ":rollup_bin",
)

diff_test(
    name = "test14_alt",
    file1 = ":expected14",
    file2 = ":actual14_alt",
)

####################################################
# Test case 15
# Use a generated bin.uvo_test target from an translate_pnpm_lock

# Generated bin test as a test target
write_file(
    name = "acorn_spec",
    out = "acorn.spec.js",
    content = [
        "const { test } = require('uvu');",
        "const assert = require('uvu/assert');",
        "const mylib = require('@mycorp/mylib');",
        "test('version', () => {",
        "  assert.is(mylib.getAcornVersion(), '8.4.0');",
        "})",
        "test.run()",
    ],
)

# @unused
uvu = uvu_bin.uvu

# @unused
uvu_binary = uvu_bin.uvu_binary

uvu_test = uvu_bin.uvu_test

uvu_test(
    name = "test_acorn_version",
    args = [
        "--color",
        "false",
    ],
    data = [
        ":acorn_spec",
        "@example_npm_deps//uvu",
        package("@mycorp/mylib"),
    ],
)