Fix tests

Author: ericdallo

src/eca/features/context.clj

@@ -126,7 +126,7 @@
                                  (map :uri)
                                  (map shared/uri->filename)
                                  (mapcat #(contexts-for % query config))
-                                 (take 200) ;; for performance, user can always make query specific for better results.
+                                 (take 100) ;; for performance, user can always make query specific for better results.
                                  (map file->context))
                                 (:workspace-folders @db*)))
         root-dirs (mapv (fn [{:keys [uri]}] {:type "directory"

test/eca/features/context_test.clj

@@ -6,60 +6,67 @@
    [eca.features.context :as f.context]
    [eca.features.index :as f.index]
    [eca.features.tools.mcp :as f.mcp]
-   [eca.test-helper :as h]))
+   [eca.test-helper :as h]
+   [matcher-combinators.test :refer [match?]]))
+
+(h/reset-components-before-test)
 
 (deftest all-contexts-test
   (testing "includes repoMap, root directories, files/dirs, and mcp resources"
+    (h/reset-components!)
     (let [root (h/file-path "/fake/repo")
           ;; Fake filesystem entries under the root
           fake-paths [(str root "/dir")
                       (str root "/foo.txt")
                       (str root "/dir/nested.txt")
-                      (str root "/bar.txt")]
-          db* (atom {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]})]
-      (with-redefs [fs/glob (fn [_root-filename pattern]
+                      (str root "/bar.txt")]]
+      (swap! (h/db*) assoc :workspace-folders [{:uri (h/file-uri "file:///fake/repo")}])
+      (with-redefs [f.context/all-files-from #'f.context/all-files-from*
+                    fs/glob (fn [_root-filename pattern]
                               ;; Very simple glob: filter by substring present in pattern ("**<q>**")
                               (let [q (string/replace pattern #"\*" "")]
                                 (filter #(string/includes? (str %) q) fake-paths)))
                     fs/directory? (fn [p] (string/ends-with? (str p) "/dir"))
-                    fs/canonicalize identity
                     f.index/filter-allowed (fn [file-paths _root _config] file-paths)
                     f.mcp/all-resources (fn [_db] [{:uri "mcp://r1"}])]
-        (let [result (f.context/all-contexts nil db* {})]
-          ;; Starts with repoMap
-          (is (= "repoMap" (:type (first result))))
-          ;; Contains root directory entries
-          (is (some #(= {:type "directory" :path root} %) result))
-          ;; Contains file and directory entries from the fake paths
-          (is (some #(= {:type "directory" :path (str root "/dir")} %) result))
-          (is (some #(= {:type "file" :path (str root "/foo.txt")} %) result))
-          (is (some #(= {:type "file" :path (str root "/dir/nested.txt")} %) result))
-          ;; MCP resources appended with proper type
-          (is (some #(= {:type "mcpResource" :uri "mcp://r1"} %) result))))))
+        (is (match?
+             [{:type "repoMap"}
+              {:type "cursor"}
+              {:type "directory" :path root}
+              {:type "directory" :path (str root "/dir")}
+              {:type "file" :path (str root "/foo.txt")}
+              {:type "file" :path (str root "/dir/nested.txt")}
+              {:type "file" :path (str root "/bar.txt")}
+              {:type "mcpResource" :uri "mcp://r1"}]
+             (f.context/all-contexts nil (h/db*) (h/config)))))))
 
   (testing "respects the query by limiting glob results"
+    (h/reset-components!)
     (let [root (h/file-path "/fake/repo")
           fake-paths [(str root "/foo.txt")
-                      (str root "/bar.txt")]
-          db* (atom {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]})]
-      (with-redefs [fs/glob (fn [_root-filename pattern]
+                      (str root "/bar.txt")]]
+      (swap! (h/db*) assoc :workspace-folders [{:uri (h/file-uri "file:///fake/repo")}])
+      (with-redefs [f.context/all-files-from #'f.context/all-files-from*
+                    fs/glob (fn [_root-filename pattern]
                               (let [q (string/replace pattern #"\*" "")]
                                 (filter #(string/includes? (str %) q) fake-paths)))
                     fs/directory? (constantly false)
                     fs/canonicalize identity
                     f.index/filter-allowed (fn [file-paths _root _config] file-paths)
                     f.mcp/all-resources (fn [_db] [])]
-        (let [result (f.context/all-contexts "foo" db* {})]
+        (let [result (f.context/all-contexts "foo" (h/db*) {})]
           ;; Should include foo.txt but not bar.txt
           (is (some #(= {:type "file" :path (str root "/foo.txt")} %) result))
           (is (not (some #(= {:type "file" :path (str root "/bar.txt")} %) result)))))))
 
   (testing "aggregates entries across multiple workspace roots"
+    (h/reset-components!)
     (let [root1 (h/file-path "/fake/repo1")
-          root2 (h/file-path "/fake/repo2")
-          db* (atom {:workspace-folders [{:uri (h/file-uri "file:///fake/repo1")}
-                                         {:uri (h/file-uri "file:///fake/repo2")}]})]
-      (with-redefs [fs/glob (fn [root-filename pattern]
+          root2 (h/file-path "/fake/repo2")]
+      (swap! (h/db*) assoc :workspace-folders [{:uri (h/file-uri "file:///fake/repo1")}
+                                               {:uri (h/file-uri "file:///fake/repo2")}])
+      (with-redefs [f.context/all-files-from #'f.context/all-files-from*
+                    fs/glob (fn [root-filename pattern]
                               (let [q (string/replace pattern #"\*" "")]
                                 (cond
                                   (string/includes? (str root-filename) (h/file-path "/fake/repo1"))
@@ -75,7 +82,7 @@
                     fs/canonicalize identity
                     f.index/filter-allowed (fn [file-paths _root _config] file-paths)
                     f.mcp/all-resources (fn [_db] [])]
-        (let [result (f.context/all-contexts nil db* {})]
+        (let [result (f.context/all-contexts nil (h/db*) {})]
           ;; Root directories present
           (is (some #(= {:type "directory" :path root1} %) result))
           (is (some #(= {:type "directory" :path root2} %) result))