add injection tests

libs/kit-generator/test/kit_generator/generator_test.clj

@@ -1,43 +1,47 @@
 (ns kit-generator.generator-test
   (:require
-    [clojure.java.io :as io]
-    [clojure.test :refer :all]
-    [kit-generator.io :refer [delete-folder]]
-    [kit.generator.modules.generator :as g]
-    [kit.generator.modules :as m]
-    [kit.generator.modules.injections :as ij]))
-
-
+   [clojure.java.io :as io]
+   [clojure.test :refer [use-fixtures deftest testing is]]
+   [kit-generator.io :refer [delete-folder folder-mismatches write-file read-edn-safe]]
+   [kit.generator.modules :as m]
+   [kit.generator.modules.generator :as g]))
 
 (def source-folder "test/resources")
 (def target-folder "test/resources/generated")
 (def ctx (read-string (slurp "test/resources/kit.edn")))
 
-(defn write-file [source target]
-  (io/make-parents target)
-  (->> (slurp source)
-       (spit target)))
+(defn module-installed? [module-key]
+  (when-let [install-log (read-edn-safe (str source-folder "/modules/install-log.edn"))]
+    (= :success (get install-log module-key))))
 
 (use-fixtures :once
-              (fn [f]
-                (let [files       ["/sample-system.edn" "/resources/system.edn"
-                                   "/core.clj" "/src/myapp/core.clj"]
-                      install-log (io/file "test/resources/modules/install-log.edn")]
-                  (when (.exists install-log)
-                    (.delete install-log))
-                  (delete-folder target-folder)
-                  (doseq [[source target] (partition 2 files)]
-                    (write-file (str source-folder source) (str target-folder target)))
-                  (f))))
+  (fn [f]
+    (let [files       ["/sample-system.edn" "/resources/system.edn"
+                       "/core.clj" "/src/myapp/core.clj"]
+          install-log (io/file "test/resources/modules/install-log.edn")]
+      (when (.exists install-log)
+        (.delete install-log))
+      (delete-folder target-folder)
+      (doseq [[source target] (partition 2 files)]
+        (write-file (str source-folder source) (str target-folder target)))
+      (f))))
 
 (deftest test-edn-injection
   (testing "testing EDN injection"
+    (is (not (module-installed? :html)))
     (let [ctx (m/load-modules ctx)]
-      (g/generate ctx :html :default))
-    ;;todo add some validation
-    #_(is (= 0 1))))
+      (g/generate ctx :html {:feature-flag :default}))
+    (is (module-installed? :html))
+    (let [expected-files {"resources/system.edn"               [#"^\{:system/env"
+                                                                #":templating/selmer \{}}$"]
+                          "resources/public/home.html"         [#"^$"]
+                          "resources/public/img/luminus.png"   []
+                          "src/myapp/core.clj"                 [#"^\(ns myapp.core"]
+                          "src/clj/myapp/web/routes/pages.clj" [#"^\(ns resources\.modules"]}]
+      (is (empty? (folder-mismatches target-folder expected-files))))))
 
 (comment
+  (slurp (str target-folder "/src/clj/myapp/web/routes/pages.clj"))
 
   (let [files       ["/sample-system.edn" "/resources/system.edn"
                      "/core.clj" "/src/myapp/core.clj"]
@@ -46,6 +50,4 @@
       (.delete install-log))
     (delete-folder target-folder)
     (doseq [[source target] (partition 2 files)]
-      (write-file (str source-folder source) (str target-folder target))))
-  )
-
+      (write-file (str source-folder source) (str target-folder target)))))

libs/kit-generator/test/kit_generator/io.clj

@@ -1,5 +1,9 @@
 (ns kit-generator.io
-  (:require [clojure.java.io :as io]))
+  (:require
+   [clojure.edn :as edn]
+   [clojure.java.io :as io]
+   [clojure.set :as set]
+   [clojure.test :as t]))
 
 (defn delete-folder [file-name]
   (letfn [(func [f]
@@ -9,3 +13,87 @@
                   (func f2)))
               (io/delete-file f)))]
     (func (io/file file-name))))
+
+(defn ls-R
+  "Walks dir recursively and returns a map of relative file paths to their contents."
+  [dir]
+  (let [root (io/file dir)
+        root-path (.toPath root)]
+    (->> (file-seq root)
+         (filter #(.isFile %))
+         (reduce (fn [acc f]
+                   (let [rel-path (str (.relativize root-path (.toPath f)))]
+                     (assoc acc rel-path (slurp f))))
+                 {}))))
+
+(defn- file-mismatches
+  "Checks content against expectation. Returns set of errors or nil if matches."
+  [content expectation]
+  (cond
+    (string? expectation)
+    (when (not= content expectation)
+      #{"content mismatch"})
+
+    (seq expectation)
+    (let [failed (keep (fn [regex]
+                         (when-not (re-find regex content)
+                           (str "regex not found: " regex)))
+                       expectation)]
+      (when (seq failed)
+        (set failed)))
+
+    (empty? expectation) ; [] means any content is acceptable
+    nil
+
+    :else (throw (ex-info "Unsupported expectation type" {:expectation expectation}))))
+
+(defn folder-mismatches
+  "Compares directory contents against expectations map.
+   Map of path -> set of errors, or empty map if all match."
+  {:test (fn []
+           (let [dir "test/resources/snippets"]
+             (t/are [expectations mismatches] (= mismatches (folder-mismatches dir expectations))
+               (ls-R dir)                       {}
+               (-> (ls-R dir)
+                   (dissoc "kit/routing.md")
+                   (assoc "foo/bar.txt"
+                          "X"))                  {"kit/routing.md" #{"unexpected file"}
+                                                  "foo/bar.txt"   #{"file missing"}}
+               (-> (ls-R dir)
+                   (assoc "kit/routing.md"
+                          #{#"reitit"}))         {}
+               (-> (ls-R dir)
+                   (assoc "kit/routing.md"
+                          [#"NOMATCH"]))        {"kit/routing.md" #{"regex not found: NOMATCH"}})))}
+  [dir expectations]
+  (let [actual (ls-R dir)
+        expected-paths (set (keys expectations))
+        actual-paths (set (keys actual))
+        missing (set/difference expected-paths actual-paths)
+        extra (set/difference actual-paths expected-paths)
+        content-errors (reduce (fn [acc [path expectation]]
+                                 (if-let [errors (some-> (get actual path)
+                                                         (file-mismatches expectation))]
+                                   (assoc acc path errors)
+                                   acc))
+                               {}
+                               expectations)]
+    (cond-> content-errors
+      (seq missing) (merge (zipmap missing (repeat #{"file missing"})))
+      (seq extra) (merge (zipmap extra (repeat #{"unexpected file"}))))))
+
+(defn write-file [source target]
+  (io/make-parents target)
+  (->> (slurp source)
+       (spit target)))
+
+(defn read-safe [path]
+  (when (.exists (io/file path))
+    (slurp path)))
+
+(defn read-edn-safe [path]
+  (when-let [content (read-safe path)]
+    (edn/read-string content)))
+
+(comment
+  (t/run-tests 'kit-generator.io))

libs/kit-generator/test/resources/modules/kit/html/assets/pages.clj

@@ -0,0 +1 @@
+(ns resources.modules.kit.html.assets.pages)