Implement hs-bin@repl test as go bazel test

.bazelrc

@@ -23,6 +23,7 @@ test --test_env=LANG=C.UTF-8 --test_env=LOCALE_ARCHIVE
 build:linux-nixpkgs --config=nixpkgs
 build:macos-nixpkgs --config=nixpkgs
 build:nixpkgs --host_platform=@io_tweag_rules_nixpkgs//nixpkgs/platforms:host
+test:nixpkgs --define=nixpkgs=true
 # Use this configuration when targeting Windows. Eventually this will
 # no longer be required:
 # https://bazel.build/roadmaps/platforms.html#replace---cpu-and---host_cpu-flags.

haskell/BUILD.bazel

@@ -167,6 +167,7 @@ filegroup(
     name = "all_files",
     testonly = True,
     srcs = glob(["**"]) + [
+        "//haskell/asterius:all_files",
         "//haskell/c2hs:all_files",
         "//haskell/experimental:all_files",
         "//haskell/platforms:all_files",

haskell/asterius/BUILD.bazel

@@ -27,3 +27,10 @@ toolchain_type(
     name = "toolchain_type",
     visibility = ["//visibility:public"],
 )
+
+filegroup(
+    name = "all_files",
+    testonly = True,
+    srcs = glob(["**"]),
+    visibility = ["//visibility:public"],
+)

tests/RunTests.hs

@@ -58,8 +58,6 @@ main = hspec $ do
       assertSuccess (bazel ["run", "//tests/repl-targets:hs-lib-bad@repl", "--", "-ignore-dot-ghci", "-e", "1 + 2"])
 
     it "for binaries" $ do
-      assertSuccess (bazel ["run", "//tests/repl-targets:hs-bin@repl", "--", "-ignore-dot-ghci", "-e", ":main"])
-
       assertSuccess (bazel ["run", "//tests/binary-indirect-cbits:binary-indirect-cbits@repl", "--", "-ignore-dot-ghci", "-e", ":main"])
 
       assertSuccess (bazel ["run", "//tests/repl-targets:hs-test-bad@repl", "--", "-ignore-dot-ghci", "-e", "1 + 2"])

tests/integration_tests.bzl

@@ -0,0 +1,22 @@
+load("@io_bazel_rules_go//go/tools/bazel_testing:def.bzl", "go_bazel_test")
+
+def integration_test(name, **kwargs):
+    test_src = name + ".go"
+    size = kwargs.pop("size", "medium")
+
+    native.config_setting(
+        name = "nixpkgs",
+        values = {"define": "nixpkgs=true"},
+    )
+
+    go_bazel_test(
+        name = name,
+        srcs = [test_src],
+        size = size,
+        rule_files = ["//:distribution"],
+        args = select({
+            ":nixpkgs": ["nixpkgs=true"],
+            "//conditions:default": ["nixpkgs=false"],
+        }),
+        **kwargs
+    )

tests/repl-targets/BUILD.bazel

@@ -4,6 +4,8 @@ load(
     "haskell_library",
     "haskell_test",
 )
+load("@io_bazel_rules_go//go/tools/bazel_testing:def.bzl", "go_bazel_test")
+load("//tests:integration_tests.bzl", "integration_test")
 
 package(default_testonly = 1)
 
@@ -112,6 +114,11 @@ haskell_library(
     deps = ["//tests/hackage:base"],
 )
 
+integration_test(
+    name = "hs_bin_repl_test",
+    size = "medium",
+)
+
 filegroup(
     name = "all_files",
     testonly = True,

tests/repl-targets/hs_bin_repl_test.go

@@ -0,0 +1,162 @@
+package hs_bin_repl_test
+
+import (
+        "bytes"
+        "fmt"
+        "os"
+        "os/exec"
+        "testing"
+        "github.com/bazelbuild/rules_go/go/tools/bazel_testing"
+)
+
+
+
+func Workspace() string {
+        return `
+-- WORKSPACE --
+local_repository(
+        name = "rules_haskell",
+        path = "../rules_haskell",
+)
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@rules_haskell//haskell:repositories.bzl", "rules_haskell_dependencies")
+
+rules_haskell_dependencies()
+
+load("@rules_haskell//haskell:nixpkgs.bzl", "haskell_register_ghc_nixpkgs")
+
+haskell_register_ghc_nixpkgs(
+    attribute_path = "haskell.compiler.ghc8104",
+    repository = "@rules_haskell//nixpkgs:default.nix",
+    version = "8.10.4",
+)
+
+load("@rules_haskell//haskell:toolchain.bzl", "rules_haskell_toolchains")
+
+rules_haskell_toolchains(version = "8.10.4")
+
+load(
+    "@io_tweag_rules_nixpkgs//nixpkgs:nixpkgs.bzl",
+    "nixpkgs_cc_configure",
+    "nixpkgs_python_configure",
+)
+
+nixpkgs_cc_configure(
+    name = "nixpkgs_config_cc",
+    repository = "@rules_haskell//nixpkgs:default.nix",
+)
+
+nixpkgs_python_configure(
+    repository = "@rules_haskell//nixpkgs:default.nix",
+)
+
+-- BUILD.bazel --
+load(
+    "@rules_haskell//haskell:defs.bzl",
+    "haskell_library",
+    "haskell_test",
+)
+
+load(
+    "@rules_haskell//haskell:defs.bzl",
+    "haskell_toolchain_library",
+)
+
+[
+    haskell_toolchain_library(name = name)
+    for name in [
+        "base",
+    ]
+]
+
+haskell_library(
+    name = "QuuxLib",
+    srcs = ["QuuxLib.hs"],
+    deps = [":base"],
+)
+
+haskell_test(
+    name = "hs-bin",
+    srcs = ["Quux.hs"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":QuuxLib",
+        ":base",
+    ],
+)
+
+-- Quux.hs --
+module Main (main) where
+
+import QuuxLib (message)
+
+main :: IO ()
+main = putStrLn message
+-- QuuxLib.hs --
+module QuuxLib (message) where
+
+message :: String
+message = "Hello GHCi!"
+`
+}
+
+func TestMain(m *testing.M) {
+        bazel_testing.TestMain(m, bazel_testing.Args{
+                Main: Workspace() + GenerateBazelrc(UseNixpkgs()),
+        })
+}
+
+func AssertOutput(t *testing.T, output []byte, expected string) {
+        if string(output) != expected {
+                t.Fatalf("output of bazel process is invalid.\nExpected: %v\n, Actual: %v\n", expected, string(output))
+        }
+}
+
+func UseNixpkgs() bool {
+        for _, arg := range os.Args {
+                if arg == "nixpkgs=true" {
+                        return true
+                }
+        }
+        return false
+}
+
+func GenerateBazelrc(use_nixpkgs bool) string {
+        if use_nixpkgs {
+                return `
+-- .bazelrc --
+build --host_platform=@io_tweag_rules_nixpkgs//nixpkgs/platforms:host
+`
+        } else {
+                return ""
+        }
+}
+
+func BazelOutput(args ...string) ([]byte, error) {
+        cmd := bazel_testing.BazelCmd(args...)
+        // It's important value of $HOME to be invariant between different integration test runs
+        // and to be writable directory for bazel test. Probably TEST_TMPDIR is a valid choice
+        // but documentation is not clear about it's default value
+        // cmd.Env = append(cmd.Env, fmt.Sprintf("HOME=%s", os.Getenv("TEST_TMPDIR")))
+        cmd.Env = append(cmd.Env, fmt.Sprintf("HOME=%s", os.TempDir()))
+        stdout := &bytes.Buffer{}
+        stderr := &bytes.Buffer{}
+        cmd.Stdout = stdout
+        cmd.Stderr = stderr
+        err := cmd.Run()
+        if eErr, ok := err.(*exec.ExitError); ok {
+                eErr.Stderr = stderr.Bytes()
+                err = &bazel_testing.StderrExitError{Err: eErr}
+        }
+        fmt.Fprintf(os.Stderr, string(stdout.Bytes()))
+        fmt.Fprintf(os.Stderr, string(stderr.Bytes()))
+        return stdout.Bytes(), err
+}
+
+func TestHsBinRepl(t *testing.T) {
+        out, err := BazelOutput("run", "//:hs-bin@repl", "--", "-ignore-dot-ghci", "-e", ":main")
+        if err != nil {
+                t.Fatal(err)
+        }
+        AssertOutput(t, out, "Hello GHCi!\n")
+}