init commit

2026-09-19 05:42:17 -09:00
commit b57e1a406d
19 changed files with 754 additions and 0 deletions
@@ -0,0 +1,79 @@
+(ns integration-tasks
+  "Shared implementation for the dockerized integration bb tasks (see bb.edn)."
+  (:require [babashka.process :refer [shell]]))
+
+(defn run-integration
+  "Builds the app image, starts it on a random port, runs the integration suite against
+   it, then tears everything down and exits with the suite's exit code.
+
+   With :coverage? the app runs under Cloverage (docker-compose.coverage.yml); after the
+   suite finishes the app is stopped gracefully so it writes its report, which is copied
+   to target/coverage/integration."
+  [{:keys [coverage?]}]
+  (let [free-port-in-range
+        ;; Picks a random port in [lo, hi] that's currently bindable on this
+        ;; host; retries on collision since another process could grab it first.
+        (fn [lo hi]
+          (loop [attempts 20]
+            (let [port (+ lo (rand-int (inc (- hi lo))))]
+              (if (try
+                    (.close (java.net.ServerSocket. port))
+                    true
+                    (catch java.io.IOException _ false))
+                port
+                (if (pos? attempts)
+                  (recur (dec attempts))
+                  (throw (ex-info "no free port found in range" {:lo lo :hi hi})))))))
+        port (free-port-in-range 30000 40000)
+        _ (println (format "[test] starting vibe-app on random port %d%s" port
+                           (if coverage? " (under coverage instrumentation)" "")))
+        builder-name "vibe-builder"
+        compose (into ["docker" "compose"]
+                      (when coverage?
+                        ["-f" "docker-compose.yml" "-f" "docker-compose.coverage.yml"]))
+        ;; Works around an LXC/AppArmor bug in runc (opencontainers/runc#5007) that
+        ;; fails RUN steps during image build; a docker-container builder with
+        ;; apparmor disabled sidesteps it.
+        _ (let [{:keys [exit]} (shell {:continue true} "docker" "buildx" "inspect" builder-name)]
+            (when-not (zero? exit)
+              (shell "docker" "buildx" "create" "--name" builder-name
+                     "--driver" "docker-container"
+                     "--buildkitd-config" "buildkitd.toml")))
+        _ (shell "docker" "buildx" "use" builder-name)
+        ;; Runs from a JVM shutdown hook (normal exit and Ctrl-C), where
+        ;; babashka.process/shell fails: it registers its own shutdown hook,
+        ;; which the JVM rejects with "Shutdown in progress". Plain
+        ;; ProcessBuilder has no such hook and lets us wait for `down` to finish.
+        teardown (fn []
+                   (-> (doto (ProcessBuilder. ^java.util.List (vec (concat compose ["down" "-v"])))
+                         (.directory (java.io.File. "integration-tests"))
+                         (.inheritIO))
+                       .start
+                       .waitFor))
+        _ (.addShutdownHook (Runtime/getRuntime) (Thread. teardown))
+        {:keys [exit]} (apply shell {:dir "integration-tests" :continue true
+                                     :extra-env {"VIBE_PORT" (str port)}}
+                              ;; `run` returns the test container's own exit code; `up --abort-on-container-exit`
+                              ;; can leak the app's SIGTERM exit (143) during teardown instead.
+                              (concat compose ["--ansi" "never" "--progress" "plain"
+                                               "run" "--build" "--rm" "integration-test"]))]
+    (when coverage?
+      ;; SIGTERM is what makes Cloverage write its report, so stop (not kill) the app
+      ;; and pull the report out of the stopped container before `down` removes it.
+      (let [out-dir (java.io.File. "target/coverage")
+            dest (java.io.File. out-dir "integration")]
+        (println "[test] stopping vibe-app to flush coverage report")
+        (apply shell {:dir "integration-tests" :continue true}
+               (concat compose ["stop" "-t" "120" "vibe-app"]))
+        (when (.exists dest)
+          (run! (fn [^java.io.File f] (.delete f)) (reverse (file-seq dest))))
+        (.mkdirs out-dir)
+        (let [{cp-exit :exit} (apply shell {:dir "integration-tests" :continue true}
+                                     (concat compose ["cp" "vibe-app:/app/target/coverage/integration"
+                                                      (.getAbsolutePath out-dir)]))]
+          (when-not (and (zero? cp-exit) (.exists (java.io.File. dest "lcov.info")))
+            (println "[test] WARNING: no integration coverage report was produced")))))
+    ;; Only exit early on failure so chained tasks (`bb coverage`) can carry on after a pass;
+    ;; the teardown hook still runs when bb exits.
+    (when-not (zero? exit)
+      (System/exit exit))))