BUILD.bazel

load(":inline_tests.bzl", "sh_inline_test")
load("@bazel_tools//tools/build_rules:test_rules.bzl", "rule_test")
load("@os_info//:os_info.bzl", "is_windows")
load("//tests:rule_test_exe.bzl", "rule_test_exe")
load(
    "//haskell:c2hs.bzl",
    "c2hs_toolchain",
)
load(
    "//haskell:defs.bzl",
    "haskell_binary",
    "haskell_doc",
    "haskell_library",
    "haskell_repl",
)
load(
    "//haskell:doctest.bzl",
    "haskell_doctest_toolchain",
)
load(
    "//haskell:protobuf.bzl",
    "haskell_proto_toolchain",
)
load(
    "//:constants.bzl",
    "test_ghc_version",
)

exports_files(
    [
        "run-start-script.sh",
        "scripts/exec.sh",
    ],
    visibility = ["//tests/shellcheck:__pkg__"],
)

package(default_testonly = 1)

config_setting(
    name = "nix",
    constraint_values = [
        "@io_tweag_rules_nixpkgs//nixpkgs/constraints:support_nix",
    ],
)

alias(
    name = "zlib",
    # This is a dependency to @stackage-zlib.
    testonly = 0,
    actual = select({
        ":nix": "@zlib.dev//:zlib",
        "//conditions:default": "@zlib.hs//:zlib",
    }),
    visibility = ["//visibility:public"],
)

haskell_doctest_toolchain(
    name = "doctest-toolchain",
    doctest = "@stackage-exe//doctest",
)

# This toolchain is morally testonly. However, that would break our
# tests of haskell_library_rules: aspects of non-testonly
# proto_library rules (from com_google_protobuf) can't themselves be
# testonly.

haskell_proto_toolchain(
    name = "protobuf-toolchain",
    testonly = 0,
    plugin = "@stackage-exe//proto-lens-protoc",
    protoc = "@com_google_protobuf//:protoc",
    deps = [
        "@stackage//:base",
        "@stackage//:bytestring",
        "@stackage//:containers",
        "@stackage//:data-default-class",
        "@stackage//:deepseq",
        "@stackage//:lens-family",
        "@stackage//:lens-family-core",
        "@stackage//:mtl",
        "@stackage//:proto-lens",
        "@stackage//:proto-lens-runtime",
        "@stackage//:text",
        "@stackage//:vector",
    ],
)

c2hs_toolchain(
    name = "c2hs-toolchain",
    c2hs = "@stackage-exe//c2hs",
)

rule_test_exe(
    name = "test-binary-simple",
    size = "small",
    generates = ["binary-simple"],
    rule = "//tests/binary-simple",
)

rule_test_exe(
    name = "test-binary-custom-main",
    size = "small",
    generates = ["binary-custom-main"],
    rule = "//tests/binary-custom-main",
)

rule_test_exe(
    name = "test-binary-with-lib",
    size = "small",
    generates = ["binary-with-lib"],
    rule = "//tests/binary-with-lib",
)

rule_test_exe(
    name = "test-binary-with-prebuilt",
    size = "small",
    generates = ["binary-with-prebuilt"],
    rule = "//tests/binary-with-prebuilt",
)

rule_test_exe(
    name = "test-binary-with-main",
    size = "small",
    generates = ["binary-with-main"],
    rule = "//tests/binary-with-main",
)

rule_test_exe(
    name = "test-binary-with-sysdeps",
    size = "small",
    generates = ["binary-with-sysdeps"],
    rule = "//tests/binary-with-sysdeps",
)

sh_test(
    name = "test-binary-with-data{}".format(".exe" if is_windows else ""),
    size = "small",
    srcs = ["//tests/binary-with-data"],
    args = ["$(location //tests/binary-with-data:bin1)"],
    data = ["//tests/binary-with-data:bin1"],
)

config_setting(
    name = "debug_build",
    values = {
        "compilation_mode": "dbg",
    },
)

config_setting(
    name = "fastbuild_darwin",
    values = {
        "compilation_mode": "fastbuild",
        "cpu": "darwin",
    },
)

config_setting(
    name = "fastbuild_windows",
    values = {
        "compilation_mode": "fastbuild",
        "cpu": "x64_windows",
    },
)

rule_test(
    name = "test-library-deps",
    size = "small",
    # Bazel does not allow nested select statements. Therefore we flatten
    # compilation_mode and cpu conditions into one select statement.
    generates = select({
        ":debug_build": [
            # In profiling build we only generate profiling static archives.
            "libHStestsZSlibrary-depsZSlibrary-deps_p.a",
        ],
        ":fastbuild_darwin": [
            "libHStestsZSlibrary-depsZSlibrary-deps-ghc{}.dylib".format(test_ghc_version),
            "libHStestsZSlibrary-depsZSlibrary-deps.a",
        ],
        ":fastbuild_windows": [
            "libHStestsZSlibrary-depsZSlibrary-deps.a",
        ],
        "//conditions:default": [
            "libHStestsZSlibrary-depsZSlibrary-deps-ghc{}.so".format(test_ghc_version),
            "libHStestsZSlibrary-depsZSlibrary-deps.a",
        ],
    }),
    rule = "//tests/library-deps",
)

rule_test_exe(
    name = "test-hsc",
    size = "small",
    generates = ["hsc"],
    rule = "//tests/hsc",
)

rule_test(
    name = "test-haddock",
    size = "small",
    generates = select({
        # Windows uses an older Stackage snapshot until we can update GHC.
        ":fastbuild_windows": [
            "haddock/array-0.5.3.0",
            "haddock/base-4.12.0.0",
            "haddock/deepseq-1.4.4.0",
            "haddock/ghc-boot-th-8.6.5",
            "haddock/ghc-prim-0.5.3",
            "haddock/index",
            "haddock/integer-gmp-1.0.2.0",
            "haddock/pretty-1.1.3.6",
            "haddock/template-haskell-2.14.0.0",
            "haddock/testsZShaddockZShaddock-lib-a",
            "haddock/testsZShaddockZShaddock-lib-b",
            "haddock/testsZShaddockZShaddock-lib-deep",
        ],
        "//conditions:default": [
            "haddock/array-0.5.4.0",
            "haddock/base-4.13.0.0",
            "haddock/deepseq-1.4.4.0",
            "haddock/ghc-boot-th-8.8.3",
            "haddock/ghc-prim-0.5.3",
            "haddock/index",
            "haddock/integer-gmp-1.0.2.0",
            "haddock/pretty-1.1.3.6",
            "haddock/template-haskell-2.15.0.0",
            "haddock/testsZShaddockZShaddock-lib-a",
            "haddock/testsZShaddockZShaddock-lib-b",
            "haddock/testsZShaddockZShaddock-lib-deep",
        ],
    }),
    rule = "//tests/haddock",
)

rule_test(
    name = "test-haskell_doctest",
    size = "small",
    generates = [
        "doctest-log-doctest-lib-lib-b",
    ],
    rule = "//tests/haskell_doctest:doctest-lib",
)

rule_test_exe(
    name = "test-haskell_test",
    size = "small",
    generates = ["haskell_test"],
    rule = "//tests/haskell_test:haskell_test",
)

rule_test_exe(
    name = "test-java_classpath",
    size = "small",
    generates = ["java_classpath"],
    rule = "//tests/java_classpath",
)

rule_test_exe(
    name = "test-cc_haskell_import-cc-link",
    size = "small",
    generates = ["cc-bin"],
    rule = "//tests/cc_haskell_import:cc-bin",
    tags = ["requires_threaded_rts"],
)

sh_test(
    name = "test-cc_haskell_import_python",
    size = "small",
    srcs = ["scripts/exec.sh"],
    args = ["tests/cc_haskell_import/python_add_one"],
    data = [
        "//tests/cc_haskell_import:python_add_one",
        "@bazel_tools//tools/bash/runfiles",
    ],
    tags = [
        "requires_dynamic",
        "requires_threaded_rts",
    ],
)

sh_inline_test(
    name = "test-haskell_binary-with-link-flags",
    size = "small",
    args = ["$(location //tests/binary-with-link-flags:binary-with-link-flags)"],
    data = ["//tests/binary-with-link-flags"],
    script = """\
set -e

# Fails if executable was linked without -threaded flag.
$1 +RTS -N
""",
    tags = [
        # On Windows this needs to use rlocation to determine the runtime location of the binary.
        "dont_test_on_windows",
    ],
)

rule_test_exe(
    name = "test-lhs",
    size = "small",
    generates = ["lhs-bin"],
    rule = "//tests/lhs:lhs-bin",
)

rule_test_exe(
    name = "test-hs-boot",
    size = "small",
    generates = ["hs-boot"],
    rule = "//tests/hs-boot:hs-boot",
)

rule_test_exe(
    name = "test-textual-hdrs",
    size = "small",
    generates = ["textual-hdrs"],
    rule = "//tests/textual-hdrs:textual-hdrs",
)

rule_test_exe(
    name = "test-two-libs",
    size = "small",
    generates = ["two-libs"],
    rule = "//tests/two-libs:two-libs",
)

genrule(
    name = "run-bin-with-lib",
    outs = ["dummy"],
    cmd = """sh -c '
    set -e
    $(location //tests/binary-with-lib:binary-with-lib)
    touch $(location dummy)
'""",
    tools = ["//tests/binary-with-lib"],
)

rule_test(
    name = "test-run-bin-with-lib",
    size = "small",
    generates = ["dummy"],
    rule = "//tests:run-bin-with-lib",
)

genrule(
    name = "run-bin-with-lib-dynamic",
    outs = ["dyn-dummy"],
    cmd = """sh -c '
    set -e
    $(location //tests/binary-with-lib-dynamic:binary-with-lib-dynamic)
    touch $(location dyn-dummy)
'""",
    tools = ["//tests/binary-with-lib-dynamic"],
)

rule_test(
    name = "test-run-bin-with-lib-dynamic",
    size = "small",
    generates = ["dyn-dummy"],
    rule = "//tests:run-bin-with-lib-dynamic",
)

genrule(
    name = "run-bin-with-c-lib",
    outs = ["c-dummy"],
    cmd = """sh -c '
    set -e
    $(location //tests/c-compiles)
    touch $(location c-dummy)
'""",
    tools = ["//tests/c-compiles"],
)

rule_test(
    name = "test-run-bin-with-c-lib",
    size = "small",
    generates = ["c-dummy"],
    rule = "//tests:run-bin-with-c-lib",
)

# This is the test runner
haskell_binary(
    name = "run-tests",
    srcs = ["RunTests.hs"],
    deps = [
        "//tests/hackage:base",
        "//tests/hackage:directory",
        "//tests/hackage:filepath",
        "//tests/hackage:process",
        "@stackage//:hspec",
        "@stackage//:hspec-core",
        "@stackage//:safe-exceptions",
        "@stackage//:temporary",
    ],
)

haskell_library(
    name = "lz4",
    srcs = [
        "LZ4.hs",
    ],
    tags = ["requires_lz4"],
    deps = [
        "//tests/hackage:base",
        "//tests/hackage:bytestring",
        "@nixpkgs_lz4",
    ],
)

haskell_library(
    name = "utils",
    srcs = ["Foo.hs"],
    tags = ["requires_lz4"],
    deps = [
        ":lz4",
        "//tests/hackage:base",
    ],
)

haskell_doc(
    name = "toto",
    tags = [
        "dont_test_on_windows",
        "requires_lz4",
    ],
    deps = [":utils"],
)

haskell_repl(
    name = "hie-bios",
    collect_data = False,
    deps = [
        "//tests:run-tests",
        "//tests/binary-with-lib",
    ],
)

sh_test(
    name = "ghcide-smoke-test{}".format(".exe" if is_windows else ""),
    srcs = ["@ghcide-exe//ghcide"],
    args = ["--version"],
    tags = [
        # Building ghcide fails in profiling mode with:
        #
        #   exe/Rules.hs:106:28: fatal:
        #       cannot find object file ‘/run/user/1000/tmp7b54rlve/build/ghcide/ghcide-tmp/Util.dyn_o’
        #       while linking an interpreted expression
        "requires_dynamic",
    ],
)