542 lines
26 KiB
Clojure
542 lines
26 KiB
Clojure
(ns babashka.bb-edn-test
|
|
(:require
|
|
[babashka.fs :as fs]
|
|
[babashka.impl.classpath :as cp]
|
|
[babashka.impl.common :as common]
|
|
[babashka.main :as main]
|
|
[babashka.test-utils :as test-utils]
|
|
[borkdude.deps]
|
|
[clojure.edn :as edn]
|
|
[clojure.string :as str]
|
|
[clojure.test :as test :refer [deftest is testing]]
|
|
[babashka.test-utils :as tu]))
|
|
|
|
(defn bb [& args]
|
|
(let [args (map str args)
|
|
ret (apply test-utils/bb nil args)]
|
|
;; (.println System/out :args)
|
|
;; (.println System/out (vec args))
|
|
;; (.println System/out :ret)
|
|
;; (.println System/out ret)
|
|
(edn/read-string
|
|
{:readers *data-readers*
|
|
:eof nil}
|
|
ret)))
|
|
|
|
(deftest deps-test
|
|
(test-utils/with-config '{:deps {medley/medley {:mvn/version "1.3.0"}}}
|
|
(is (= '{1 {:id 1}, 2 {:id 2}}
|
|
(bb "-e" "(require 'medley.core)" "-e" "(medley.core/index-by :id [{:id 1} {:id 2}])"))))
|
|
(test-utils/with-config '{:deps {medley/medley {:mvn/version "1.3.0"}}}
|
|
(let [cp (bb "-e" "(do (require '[babashka.classpath :as cp])
|
|
(cp/split-classpath (cp/get-classpath)))")]
|
|
(is (= 1 (count cp)))
|
|
(is (str/includes? (first cp) "medley"))))
|
|
(testing "--classpath option overrides bb.edn"
|
|
(test-utils/with-config '{:deps {medley/medley {:mvn/version "1.3.0"}}}
|
|
(is (= "src"
|
|
(bb "-cp" "src" "-e" "(babashka.classpath/get-classpath)"))))))
|
|
|
|
(deftest print-deps-test
|
|
(test-utils/with-config '{:deps {medley/medley {:mvn/version "1.3.0"}}}
|
|
(testing "deps output"
|
|
(let [edn (bb "print-deps")
|
|
deps (:deps edn)]
|
|
(is deps)
|
|
(is (map? (get deps 'selmer/selmer)))
|
|
(is (string? (:mvn/version (get deps 'selmer/selmer))))
|
|
(testing "user provided lib"
|
|
(is (map? (get deps 'medley/medley))))))
|
|
(testing "classpath output"
|
|
(let [classpath (test-utils/bb nil "print-deps" "--format" "classpath")]
|
|
(is (str/includes? classpath "selmer"))
|
|
(is (str/includes? classpath (System/getProperty "path.separator")))
|
|
(is (str/includes? classpath "medley"))))))
|
|
|
|
(deftest task-test
|
|
(test-utils/with-config '{:tasks {foo (+ 1 2 3)}}
|
|
(is (= 6 (bb "run" "--prn" "foo"))))
|
|
(testing "init test"
|
|
(test-utils/with-config '{:tasks {:init (def x 1)
|
|
foo x}}
|
|
(is (= 1 (bb "run" "--prn" "foo")))))
|
|
(testing "requires test"
|
|
(test-utils/with-config '{:tasks {:requires ([babashka.fs :as fs])
|
|
foo (fs/exists? ".")}}
|
|
(is (= true (bb "run" "--prn" "foo"))))
|
|
(test-utils/with-config '{:tasks {foo {:requires ([babashka.fs :as fs])
|
|
:task (fs/exists? ".")}}}
|
|
(is (= true (bb "run" "--prn" "foo"))))
|
|
(test-utils/with-config '{:tasks {bar {:requires ([babashka.fs :as fs])}
|
|
foo {:depends [bar]
|
|
:task (fs/exists? ".")}}}
|
|
(is (= true (bb "run" "--prn" "foo")))))
|
|
(testing "map returned from task"
|
|
(test-utils/with-config '{:tasks {foo {:task {:a 1 :b 2}}}}
|
|
(is (= {:a 1 :b 2} (bb "run" "--prn" "foo")))))
|
|
(let [tmp-dir (fs/create-temp-dir)
|
|
out (str (fs/file tmp-dir "out.txt"))
|
|
echo-cmd (if main/windows? "cmd /c echo" "echo")
|
|
ls-cmd (if main/windows? "cmd /c dir" "ls")
|
|
fix-lines test-utils/normalize]
|
|
(testing "shell test"
|
|
(test-utils/with-config {:tasks {'foo (list 'shell {:out out}
|
|
echo-cmd "hello")}}
|
|
(bb "foo")
|
|
(is (= "hello\n" (fix-lines (slurp out))))))
|
|
(fs/delete out)
|
|
(testing "shell test with :continue fn"
|
|
(test-utils/with-config {:tasks {'foo (list '-> (list 'shell {:out out
|
|
:err out
|
|
:continue '(fn [proc]
|
|
(contains? proc :exit))}
|
|
ls-cmd "foobar")
|
|
:exit)}}
|
|
(is (pos? (bb "run" "--prn" "foo")))))
|
|
(testing "shell test with :error"
|
|
(test-utils/with-config
|
|
{:tasks {'foo (list '-> (list 'shell {:out out
|
|
:err out
|
|
:error-fn '(constantly 1337)}
|
|
ls-cmd "foobar"))}}
|
|
(is (= 1337 (bb "run" "--prn" "foo"))))
|
|
(test-utils/with-config
|
|
{:tasks {'foo (list '-> (list 'shell {:out out
|
|
:err out
|
|
:error-fn
|
|
'(fn [opts]
|
|
(and (:task opts)
|
|
(:proc opts)
|
|
(not (zero? (:exit (:proc opts))))))}
|
|
ls-cmd "foobar"))}}
|
|
(is (true? (bb "run" "--prn" "foo")))))
|
|
(fs/delete out)
|
|
(testing "clojure test"
|
|
(test-utils/with-config {:tasks {'foo (list 'clojure {:out out}
|
|
"-M -e" "(println :yolo)")}}
|
|
(bb "foo")
|
|
(is (= ":yolo\n" (fix-lines (slurp out))))))
|
|
(fs/delete out)
|
|
(testing "depends"
|
|
(test-utils/with-config {:tasks {'quux (list 'spit out "quux\n")
|
|
'baz (list 'spit out "baz\n" :append true)
|
|
'bar {:depends ['baz]
|
|
:task (list 'spit out "bar\n" :append true)}
|
|
'foo {:depends ['quux 'bar 'baz]
|
|
:task (list 'spit out "foo\n" :append true)}}}
|
|
(bb "foo")
|
|
(is (= "quux\nbaz\nbar\nfoo\n" (slurp out)))))
|
|
(fs/delete out)
|
|
;; This is why we don't support :when for now
|
|
#_(testing "depends with :when"
|
|
(test-utils/with-config {:tasks {'quux (list 'spit out "quux\n")
|
|
'baz (list 'spit out "baz\n" :append true)
|
|
'bar {:when false
|
|
:depends ['baz]
|
|
:task (list 'spit out "bar\n" :append true)}
|
|
'foo {:depends ['quux 'bar]
|
|
:task (list 'spit out "foo\n" :append true)}}}
|
|
(bb "foo")
|
|
(is (= "quux\nbaz\nbar\nfoo\n" (slurp out))))))
|
|
(testing "fully qualified symbol execution"
|
|
(test-utils/with-config {:paths ["test-resources/task_scripts"]
|
|
:tasks '{foo tasks/foo}}
|
|
(is (= :foo (bb "run" "--prn" "foo"))))
|
|
(test-utils/with-config {:paths ["test-resources/task_scripts"]
|
|
:tasks '{:requires ([tasks :as t])
|
|
foo t/foo}}
|
|
(is (= :foo (bb "run" "--prn" "foo"))))
|
|
(test-utils/with-config {:paths ["test-resources/task_scripts"]
|
|
:tasks '{foo {:requires ([tasks :as t])
|
|
:task t/foo}}}
|
|
(is (= :foo (bb "run" "--prn" "foo")))))
|
|
(testing "extra-paths"
|
|
(test-utils/with-config {:paths ["test-resources/task_scripts"]
|
|
:tasks '{:requires ([tasks :as t])
|
|
foo {:extra-paths ["test-resources/task_test_scripts"]
|
|
:requires ([task-test :as tt])
|
|
:task tt/task-test-fn}}}
|
|
(is (= :task-test-fn (bb "run" "--prn" "foo")))))
|
|
(testing "extra-deps"
|
|
(test-utils/with-config {:tasks '{foo {:extra-deps {medley/medley {:mvn/version "1.3.0"}}
|
|
:requires ([medley.core :as m])
|
|
:task (m/index-by :id [{:id 1} {:id 2}])}}}
|
|
(is (= {1 {:id 1}, 2 {:id 2}} (bb "run" "--prn" "foo")))))
|
|
(testing "enter / leave"
|
|
(test-utils/with-config '{:tasks {:init (do (def enter-ctx (atom []))
|
|
(def leave-ctx (atom [])))
|
|
:enter (swap! enter-ctx conj (:name (current-task)))
|
|
:leave (swap! leave-ctx conj (:name (current-task)))
|
|
foo {:depends [bar]
|
|
:task [@enter-ctx @leave-ctx]}
|
|
bar {:depends [baz]}
|
|
baz {:enter nil
|
|
:leave nil}}}
|
|
(is (= '[[bar foo] [bar]] (bb "run" "--prn" "foo")))))
|
|
(testing "run"
|
|
(test-utils/with-config '{:tasks {a (+ 1 2 3)
|
|
b (prn (run 'a))}}
|
|
(is (= 6 (bb "run" "b")))))
|
|
(testing "no such task"
|
|
(test-utils/with-config '{:tasks {a (+ 1 2 3)}}
|
|
(is (thrown-with-msg?
|
|
Exception #"No such task: b"
|
|
(bb "run" "b")))))
|
|
(testing "unresolved dependency"
|
|
(test-utils/with-config '{:tasks {a (+ 1 2 3)
|
|
b {:depends [x]
|
|
:task (+ a 4 5 6)}}}
|
|
(is (thrown-with-msg?
|
|
Exception #"No such task: x"
|
|
(bb "run" "b")))))
|
|
(testing "cyclic task"
|
|
(test-utils/with-config '{:tasks {b {:depends [b]
|
|
:task (+ a 4 5 6)}}}
|
|
(is (thrown-with-msg?
|
|
Exception #"Cyclic task: b"
|
|
(bb "run" "b"))))
|
|
(test-utils/with-config '{:tasks {c {:depends [b]}
|
|
b {:depends [c]
|
|
:task (+ a 4 5 6)}}}
|
|
(is (thrown-with-msg?
|
|
Exception #"Cyclic task: b"
|
|
(bb "run" "b")))))
|
|
(testing "friendly regex literal error handling"
|
|
(test-utils/with-config
|
|
"{:tasks {something (clojure.string/split \"1-2\" #\"-\")}}"
|
|
(is (thrown-with-msg?
|
|
Exception #"Invalid regex literal"
|
|
(bb "run" "something")))))
|
|
(testing "doc"
|
|
(test-utils/with-config '{:tasks {b {:doc "Beautiful docstring"}}}
|
|
(let [s (test-utils/bb nil "doc" "b")]
|
|
(is (= "-------------------------\nb\nTask\nBeautiful docstring\n" s)))))
|
|
(testing "system property"
|
|
(test-utils/with-config '{:tasks {b (System/getProperty "babashka.task")}}
|
|
(let [s (bb "run" "--prn" "b")]
|
|
(is (= "b" s)))))
|
|
(testing "parallel test"
|
|
(test-utils/with-config (edn/read-string (slurp "test-resources/coffee-tasks.edn"))
|
|
(let [tree [:made-coffee [[:ground-beans [:measured-beans]] [:heated-water [:poured-water]] :filter :mug]]
|
|
t0 (System/currentTimeMillis)
|
|
s (bb "run" "--prn" "coffeep")
|
|
t1 (System/currentTimeMillis)
|
|
delta-sequential (- t1 t0)]
|
|
(is (= tree s))
|
|
(test-utils/with-config (edn/read-string (slurp "test-resources/coffee-tasks.edn"))
|
|
(let [t0 (System/currentTimeMillis)
|
|
s (bb "run" "--parallel" "--prn" "coffeep")
|
|
t1 (System/currentTimeMillis)
|
|
delta-parallel (- t1 t0)]
|
|
(is (= tree s))
|
|
(when (>= (doto (-> (Runtime/getRuntime) (.availableProcessors))
|
|
(prn))
|
|
2)
|
|
(is (< delta-parallel delta-sequential)))))))
|
|
(testing "exception"
|
|
(test-utils/with-config '{:tasks {a (Thread/sleep 10000)
|
|
b (do (Thread/sleep 10)
|
|
(throw (ex-info "0 noes" {})))
|
|
c {:depends [a b]}}}
|
|
(is (thrown-with-msg? Exception #"0 noes"
|
|
(bb "run" "--parallel" "c")))))
|
|
(testing "edge case"
|
|
(test-utils/with-config '{:tasks
|
|
{a (run '-a {:parallel true})
|
|
-a {:depends [a:a a:b c]
|
|
:task (prn [a:a a:b c])}
|
|
a:a {:depends [c]
|
|
:task (+ 1 2 3)}
|
|
a:b {:depends [c]
|
|
:task (do (Thread/sleep 10)
|
|
(+ 1 2 3))}
|
|
c (do (Thread/sleep 10) :c)}}
|
|
(is (= [6 6 :c] (bb "run" "--prn" "a"))))))
|
|
(testing "dynamic vars"
|
|
(test-utils/with-config '{:tasks
|
|
{:init (def ^:dynamic *foo* true)
|
|
a (do
|
|
(def ^:dynamic *bar* false)
|
|
(binding [*foo* false
|
|
*bar* true]
|
|
[*foo* *bar*]))}}
|
|
(is (= [false true] (bb "run" "--prn" "a")))))
|
|
(testing "stable namespace name"
|
|
(test-utils/with-config '{:tasks
|
|
{:init (do (def ^:dynamic *jdk*)
|
|
(def ^:dynamic *server*))
|
|
server [*jdk* *server*]
|
|
run-all (for [jdk [8 11 15]
|
|
server [:foo :bar]]
|
|
(binding [*jdk* jdk
|
|
*server* server]
|
|
(babashka.tasks/run 'server)))}}
|
|
(is (= '([8 :foo] [8 :bar] [11 :foo] [11 :bar] [15 :foo] [15 :bar])
|
|
(bb "run" "--prn" "run-all")))))
|
|
;; TODO: disabled because of " Volume in drive C has no label.\r\n Volume Serial Number is 1CB8-D4AA\r\n\r\n Directory of C:\\projects\\babashka\r\n\r\n" on Appveyor. See https://ci.appveyor.com/project/borkdude/babashka/builds/40003094.
|
|
(testing "shell test with :continue"
|
|
(let [ls-cmd (if main/windows? "cmd /c dir" "ls")]
|
|
(test-utils/with-config {:tasks {'foo (list 'do
|
|
(list 'shell {:continue true}
|
|
(str ls-cmd " foobar"))
|
|
(list 'println :hello))}}
|
|
(is (str/includes? (test-utils/bb nil "foo") ":hello"))))))
|
|
|
|
(deftest ^:skip-windows unix-task-test
|
|
(testing "shell pipe test"
|
|
(test-utils/with-config '{:tasks {a (-> (shell {:out :string}
|
|
"echo hello")
|
|
(shell {:out :string} "cat")
|
|
:out)}}
|
|
(let [s (bb "run" "--prn" "a")]
|
|
(is (= "hello\n" s))))))
|
|
|
|
(deftest ^:windows-only win-task-test
|
|
(when main/windows?
|
|
(testing "shell pipe test"
|
|
; this task prints the contents of deps.edn
|
|
(test-utils/with-config '{:tasks {a (->> (shell {:out :string}
|
|
"cmd /c echo deps.edn")
|
|
:out
|
|
clojure.string/trim-newline
|
|
(shell {:out :string} "cmd /c type")
|
|
:out)}}
|
|
(let [s (bb "run" "--prn" "a")]
|
|
(is (str/includes? s "paths")))))))
|
|
|
|
(deftest tasks:clojure-test
|
|
(testing "tokenization when called from tasks"
|
|
(test-utils/with-config
|
|
(pr-str '{:tasks {foo (-> (clojure {:out :string} "-J-Dfoo=\"{:port 5555 :accept clojure.core.server/repl}\" -M -e \"(clojure.edn/read-string (System/getProperty (name :foo)))\"") :out clojure.edn/read-string prn)}})
|
|
(is (= '{:port 5555, :accept clojure.core.server/repl}
|
|
(bb "run" "foo")))))
|
|
(testing "can be called without args"
|
|
(test-utils/with-config
|
|
(pr-str '{:tasks {foo (-> (clojure {:in "(+ 1 2 3)" :out :string}) :out prn)}})
|
|
(is (str/includes? (bb "run" "foo") "6")))
|
|
;; can't properly test this, but `(clojure)` should work with zero args
|
|
#_(test-utils/with-config
|
|
(pr-str '{:tasks {foo (-> (clojure) :out prn)}})
|
|
(is (str/includes? (test-utils/bb "(+ 1 2 3)" "run" "foo") "6"))))
|
|
(testing "call to run in missing dir gives 'cannot run program' message"
|
|
(test-utils/with-config
|
|
(pr-str '{:tasks {foo (clojure {:dir "../missingdir"} "-M" "-r")}})
|
|
; check rough text of error message, specific message about missing directory is OS-dependent
|
|
(is (thrown-with-msg? Exception #"Cannot run program .* \(in directory \"\.\.[/\\]missingdir\"\)"
|
|
(bb "run" "foo"))))))
|
|
|
|
(deftest list-tasks-test
|
|
(test-utils/with-config {}
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (str/includes? res "No tasks found."))))
|
|
(test-utils/with-config '{:tasks {:x 1}}
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (str/includes? res "No tasks found."))))
|
|
(test-utils/with-config '{:tasks {-xyz 5}}
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (str/includes? res "No tasks found."))))
|
|
(test-utils/with-config '{:tasks {xyz {:private true}}}
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (str/includes? res "No tasks found."))))
|
|
(test-utils/with-config '{:tasks {abc 1 xyz 2}}
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (= "The following tasks are available:\n\nabc\nxyz\n" res))))
|
|
(test-utils/with-config '{:tasks {abc 1 xyz {:doc "some text" :tasks 5}
|
|
-xyz 3 qrs {:private true}}}
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (= "The following tasks are available:\n\nabc\nxyz some text\n" res))))
|
|
(test-utils/with-config '{:tasks {xyz 1 abc 2}}
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (= "The following tasks are available:\n\nxyz\nabc\n" res))))
|
|
(test-utils/with-config "{:paths [\"test-resources/task_scripts\"]
|
|
:tasks {:requires ([tasks :as t])
|
|
task1
|
|
{:doc \"task1 doc
|
|
more stuff here
|
|
even more stuff here\"
|
|
:task (+ 1 2 3)}
|
|
task2
|
|
{:doc \"task2 doc\"
|
|
:task (+ 4 5 6)}
|
|
-task3
|
|
{:task (+ 1 2 3)}
|
|
task4
|
|
{:task (+ 1 2 3)
|
|
:private true}
|
|
foo tasks/foo
|
|
bar t/foo
|
|
baz non-existing/bar
|
|
quux {:requires ([tasks :as t2])
|
|
:task t2/foo}}}"
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (= "The following tasks are available:\n\ntask1 task1 doc\ntask2 task2 doc\nfoo Foo docstring\nbar Foo docstring\nbaz \nquux Foo docstring\n"
|
|
res))))
|
|
(testing ":tasks is the first node"
|
|
(test-utils/with-config "{:tasks {task1
|
|
{:doc \"task1 doc\"
|
|
:task (+ 1 2 3)}}}"
|
|
(let [res (test-utils/bb nil "tasks")]
|
|
(is (= "The following tasks are available:\n\ntask1 task1 doc\n"
|
|
res))))))
|
|
|
|
(deftest task-priority-test
|
|
(when-not test-utils/native?
|
|
(testing "FILE > TASK > SUBCOMMAND"
|
|
(is (= "foo.jar" (:uberjar (main/parse-opts ["uberjar" "foo.jar"]))))
|
|
(vreset! common/bb-edn '{:tasks {uberjar (+ 1 2 3)}})
|
|
(is (= "uberjar" (:run (main/parse-opts ["uberjar"]))))
|
|
(try
|
|
(spit "uberjar" "#!/usr/bin/env bb\n(+ 1 2 3)")
|
|
(vreset! common/bb-edn '{:tasks {uberjar (+ 1 2 3)}})
|
|
(is (= "uberjar" (:file (main/parse-opts ["uberjar"]))))
|
|
(finally (fs/delete "uberjar"))))))
|
|
|
|
(deftest min-bb-version-test
|
|
(fs/with-temp-dir [dir {}]
|
|
(let [config (str (fs/file dir "bb.edn"))]
|
|
(spit config '{:min-bb-version "300.0.0"})
|
|
(let [sw (java.io.StringWriter.)]
|
|
(binding [*err* sw]
|
|
(main/main "--config" config "-e" "nil"))
|
|
(is (str/includes? (str sw)
|
|
"WARNING: this project requires babashka 300.0.0 or newer, but you have: "))))))
|
|
|
|
(deftest classpath-other-bb-edn-test
|
|
(fs/with-temp-dir [dir {}]
|
|
(let [config (str (fs/file dir "bb.edn"))]
|
|
(spit config '{:paths ["src"]
|
|
:tasks {cp (prn (babashka.classpath/get-classpath))}})
|
|
(let [out (bb "--config" config "cp")
|
|
entries (cp/split-classpath out)
|
|
entry (first entries)]
|
|
(is (= 1 (count entries)))
|
|
(is (= (fs/parent config) (fs/parent entry)))
|
|
(is (str/ends-with? entry "src"))))))
|
|
|
|
(deftest without-deps-test
|
|
(when-not test-utils/native?
|
|
(with-redefs [borkdude.deps/-main (fn [& _]
|
|
(throw (ex-info "This ain't allowed!" {})))]
|
|
(testing "bb.edn without :deps should not require deps.clj"
|
|
(test-utils/with-config '{:tasks {a 1}}
|
|
(bb "-e" "(+ 1 2 3)"))))))
|
|
|
|
(deftest deps-race-condition-test
|
|
(test-utils/with-config
|
|
(pr-str '{:tasks {task-b (do
|
|
(Thread/sleep 10)
|
|
:task00-out)
|
|
task-c {:depends [task-b]
|
|
:task (do
|
|
(println
|
|
"task-b: "
|
|
(type task-b))
|
|
{})}
|
|
task-a {:task (do
|
|
(Thread/sleep 10)
|
|
:task0-out)}
|
|
task-e {:depends [task-e1] :task {}}
|
|
task-e2 {:depends [task-a] :task {}}
|
|
task-e3 {:depends [task-b] :task {}}
|
|
task-e1 {:depends [task-e2 task-e3]
|
|
:task {}}
|
|
task-h {:depends [task-a task-b]
|
|
:task {}}
|
|
task-d {:task (do (Thread/sleep 2) {})}
|
|
task-f {:depends [task-d task-e task-a]
|
|
:task {}}
|
|
task-g {:depends [task-f
|
|
task-d
|
|
task-a
|
|
task-c
|
|
task-h]
|
|
:task {}}}})
|
|
(time (dotimes [_ 50]
|
|
(is (str/includes? (test-utils/bb nil "run" "--parallel" "task-g")
|
|
"task-b: clojure.lang.Keyword"))))))
|
|
|
|
(deftest parallel-nil-results-test
|
|
(test-utils/with-config
|
|
(pr-str '{:tasks {a (do nil)
|
|
b (do nil)
|
|
c (do nil)
|
|
d {:depends [a b c]
|
|
:task (prn [a b c])}}})
|
|
(is (= [nil nil nil] (bb "run" "--parallel" "d")))))
|
|
|
|
(deftest current-task-result-test
|
|
(test-utils/with-config
|
|
(pr-str '{:tasks {:leave (prn [(:name (current-task)) (:result (current-task))])
|
|
a 1
|
|
b 2
|
|
c {:depends [a b]
|
|
:task [a b]}}})
|
|
(is (= ["[a 1]" "[b 2]" "[c [1 2]]"] (str/split-lines (test-utils/bb nil "run" "c"))))))
|
|
|
|
(deftest pod-from-registry-test
|
|
(when (= "amd64" (System/getProperty "os.arch")) ; TODO: Build bootleg for aarch64 too or use a different pod
|
|
(test-utils/with-config
|
|
(pr-str '{:paths ["test-resources"]
|
|
:pods {retrogradeorbit/bootleg {:version "0.1.9"}}})
|
|
(is (= "\"<div><p>Test</p></div>\"\n"
|
|
(test-utils/bb nil "--prn" "-m" "pod-tests.bootleg"))))))
|
|
|
|
(deftest ^:skip-windows local-pod-test
|
|
(test-utils/with-config
|
|
(pr-str '{:paths ["test-resources"]
|
|
:pods {pod/test-pod {:path "test-resources/pod"}}})
|
|
(is (= "42\n" (test-utils/bb nil "-m" "pod-tests.local")))))
|
|
|
|
(deftest tag-test
|
|
(test-utils/with-config
|
|
"{:deps {}
|
|
:aliases {:foo {:env-vars {:dude #env \"DUDE\"}}}}"
|
|
(is (= 6 (bb "-e" "(+ 1 2 3)")))))
|
|
|
|
(deftest merge-deps-test
|
|
(test-utils/with-config
|
|
"{:deps {}}"
|
|
(is (= {1 {:a 1}}
|
|
(bb "-Sdeps" "{:deps {medley/medley {:mvn/version \"1.4.0\"}}}" "-e" "(require 'medley.core) (medley.core/index-by :a [{:a 1}])")))))
|
|
|
|
(deftest deps-root-test
|
|
(fs/with-temp-dir [dir {}]
|
|
(let [f (fs/file dir "bb.edn")
|
|
config (str f)]
|
|
(spit config
|
|
'{:paths ["src"]
|
|
:tasks {cp (prn (babashka.classpath/get-classpath))}})
|
|
(testing "custom deps-root path"
|
|
(let [out (bb "--config" config "--deps-root" (str dir) "cp")
|
|
entries (cp/split-classpath out)]
|
|
(is (= 1 (count entries)))
|
|
(is (= (fs/file dir "src") (fs/file (first entries))))))
|
|
(testing "default deps-root path is same as bb.edn"
|
|
(let [out (bb "--config" config "cp")
|
|
entries (cp/split-classpath out)]
|
|
(is (= (fs/parent f) (fs/parent (first entries))))))
|
|
(spit config
|
|
'{:paths ["src"]
|
|
:deps {local/dep {:local/root "local-dep"}}
|
|
:tasks {cp (prn (babashka.classpath/get-classpath))}})
|
|
(testing "relative paths in deps should be relative to bb.edn"
|
|
(let [root (fs/create-dir (fs/file dir "local-dep"))
|
|
_ (spit (str (fs/file root "deps.edn")) {})
|
|
out (bb "--config" config "cp")
|
|
entries (cp/split-classpath out)]
|
|
(is (= (fs/parent f) (fs/parent (first entries)))))))))
|
|
|
|
(deftest adjacent-bb-edn-test
|
|
(is (= {1 {:id 1}} (bb "test-resources/adjacent_bb/medley.bb")))
|
|
(is (= {1 {:id 1}} (bb "-f" "test-resources/adjacent_bb/medley.bb"))))
|
|
|
|
(deftest non-existing-tasks-in-run-gives-exit-code-1
|
|
(is (thrown? Exception (bb "-Sdeps" "{:tasks {foo {:task (run (quote bar))}}}" "foo"))))
|
|
|
|
(deftest empty-bb-edn-test
|
|
(is (= 6 (bb "-Sdeps" "" "-e" "(+ 1 2 3)"))))
|
|
|
|
(deftest warning-on-override-task
|
|
(when-not tu/native?
|
|
(binding [*out* *err*]
|
|
(is (str/includes? (with-out-str (bb "-Sdeps" "{:tasks {run {:task 1}}}" "run")) "'run' override")))))
|