From 4a0256d374d9c530a97fc0b4562a6be15afd111b Mon Sep 17 00:00:00 2001 From: Kit Langton Date: Fri, 28 Aug 2026 15:14:36 -0400 Subject: [PATCH] test(core): use effect search harness (#45682) --- packages/core/test/filesystem/search.test.ts | 281 +++++++++---------- 1 file changed, 140 insertions(+), 141 deletions(-) diff --git a/packages/core/test/filesystem/search.test.ts b/packages/core/test/filesystem/search.test.ts index 19c34b9b573..dc2de5bbc60 100644 --- a/packages/core/test/filesystem/search.test.ts +++ b/packages/core/test/filesystem/search.test.ts @@ -1,6 +1,6 @@ -import { describe, expect, spyOn, test } from "bun:test" +import { describe, expect, spyOn } from "bun:test" import fuzzysort from "fuzzysort" -import { mkdir, mkdtemp, rm } from "node:fs/promises" +import { mkdir } from "node:fs/promises" import os from "os" import path from "path" import { Deferred, Effect, Layer } from "effect" @@ -14,6 +14,8 @@ import { Ripgrep } from "@opencode-ai/core/ripgrep" import { AbsolutePath, RelativePath } from "@opencode-ai/core/schema" import { Workspace } from "@opencode-ai/core/workspace" import { location } from "../fixture/location" +import { tmpdir } from "../fixture/tmpdir" +import { it } from "../lib/effect" const ripgrepStub = (entry: string, onFind: (input: Ripgrep.FindInput) => void) => Layer.succeed( @@ -32,14 +34,13 @@ const ripgrepStub = (entry: string, onFind: (input: Ripgrep.FindInput) => void) ) describe("FileSystemSearch", () => { - test("honors wildcard directory rules from .gitignore", async () => { - const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-fff-ignore-")) - try { - await mkdir(path.join(directory, "rust/target/debug/deps"), { recursive: true }) - await Bun.write(path.join(directory, ".gitignore"), "**/target/\n") - await Bun.write(path.join(directory, "rust/target/debug/deps/ignored.rs"), "ignored") - const git = Bun.spawnSync(["git", "init", "-q"], { cwd: directory }) - expect(git.exitCode).toBe(0) + it.live("honors wildcard directory rules from .gitignore", () => + Effect.gen(function* () { + const directory = (yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-fff-ignore-")))).path + yield* Effect.promise(() => mkdir(path.join(directory, "rust/target/debug/deps"), { recursive: true })) + yield* Effect.promise(() => Bun.write(path.join(directory, ".gitignore"), "**/target/\n")) + yield* Effect.promise(() => Bun.write(path.join(directory, "rust/target/debug/deps/ignored.rs"), "ignored")) + expect(Bun.spawnSync(["git", "init", "-q"], { cwd: directory }).exitCode).toBe(0) const ref = Location.Ref.make({ directory: AbsolutePath.make(directory) }) const layer = FileSystemSearch.fffLayer.pipe( @@ -54,26 +55,22 @@ describe("FileSystemSearch", () => { ), ), ) - const entries = await Effect.runPromise( - Effect.gen(function* () { - const search = yield* FileSystemSearch.Service - return yield* search.find({ query: "target" }) - }).pipe(Effect.provide(layer), Effect.scoped), - ) + yield* Effect.gen(function* () { + const search = yield* FileSystemSearch.Service + const entries = yield* search.find({ query: "target" }) + expect(entries.every((entry) => !entry.path.startsWith("rust/target/"))).toBe(true) + }).pipe(Effect.provide(layer)) + }), + ) - expect(entries.every((entry) => !entry.path.startsWith("rust/target/"))).toBe(true) - } finally { - await rm(directory, { recursive: true, force: true }) - } - }) - - test("selects the ripgrep layer for workspace-backed locations even when vcs would pick fff", async () => { - const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-search-workspace-")) - try { + it.live("selects the ripgrep layer for workspace-backed locations even when vcs would pick fff", () => + Effect.gen(function* () { + const directory = (yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-search-workspace-")))) + .path // A local file that only an fff index of the server directory could surface. // The fff-vs-ripgrep discrimination only bites where Fff.available() is // true; elsewhere the layer choice already falls back to ripgrep. - await Bun.write(path.join(directory, "server-local.ts"), "server local") + yield* Effect.promise(() => Bun.write(path.join(directory, "server-local.ts"), "server local")) let observed: Ripgrep.FindInput | undefined const ref = Location.Ref.make({ directory: AbsolutePath.make(directory), @@ -92,37 +89,35 @@ describe("FileSystemSearch", () => { [Ripgrep.node, ripgrepStub("remote.ts", (input) => (observed = input))], ]) - await Effect.runPromise( - Effect.gen(function* () { - const search = yield* FileSystemSearch.Service - const entries = yield* search.find({ query: "ts", type: "file" }) - expect(observed?.cwd).toBe(directory) - expect(entries.map((entry) => entry.path)).toEqual([RelativePath.make("remote.ts")]) - }).pipe(Effect.provide(layer), Effect.scoped), - ) - } finally { - await rm(directory, { recursive: true, force: true }) - } - }) + yield* Effect.gen(function* () { + const search = yield* FileSystemSearch.Service + const entries = yield* search.find({ query: "ts", type: "file" }) + expect(observed?.cwd).toBe(directory) + expect(entries.map((entry) => entry.path)).toEqual([RelativePath.make("remote.ts")]) + }).pipe(Effect.provide(layer)) + }), + ) - test("bounds a home scan even when home is detected as a repository", async () => { - let observed: Ripgrep.FindInput | undefined - const home = AbsolutePath.make(os.homedir()) - const layer = AppNodeBuilder.build(FileSystemSearch.node, [ - [ - Location.node, - Layer.succeed( - Location.Service, - Location.Service.of( - location({ directory: home }, { vcs: { type: "git", store: AbsolutePath.make(path.join(home, ".git")) } }), + it.live("bounds a home scan even when home is detected as a repository", () => + Effect.gen(function* () { + let observed: Ripgrep.FindInput | undefined + const home = AbsolutePath.make(os.homedir()) + const layer = AppNodeBuilder.build(FileSystemSearch.node, [ + [ + Location.node, + Layer.succeed( + Location.Service, + Location.Service.of( + location( + { directory: home }, + { vcs: { type: "git", store: AbsolutePath.make(path.join(home, ".git")) } }, + ), + ), ), - ), - ], - [Ripgrep.node, ripgrepStub("src/index.ts", (input) => (observed = input))], - ]) - - await Effect.runPromise( - Effect.gen(function* () { + ], + [Ripgrep.node, ripgrepStub("src/index.ts", (input) => (observed = input))], + ]) + yield* Effect.gen(function* () { const search = yield* FileSystemSearch.Service yield* Effect.sleep("10 millis") expect(observed).toBeUndefined() @@ -132,52 +127,52 @@ describe("FileSystemSearch", () => { expect((yield* search.find({ query: "src", type: "directory" }))[0]?.path).toBe( RelativePath.make(`src${path.sep}`), ) - }).pipe(Effect.provide(layer), Effect.scoped), - ) - }) + }).pipe(Effect.provide(layer)) + }), + ) - test("refreshes a stale ripgrep index atomically without blocking search", async () => { - let scans = 0 - const started = Effect.runSync(Deferred.make()) - const release = Effect.runSync(Deferred.make()) - const layer = AppNodeBuilder.build(FileSystemSearch.node, [ - [ - Location.node, - Layer.succeed( - Location.Service, - Location.Service.of( - location({ directory: AbsolutePath.make(path.join(os.tmpdir(), "opencode-search-atomic")) }), + it.effect("refreshes a stale ripgrep index atomically without blocking search", () => + Effect.gen(function* () { + let scans = 0 + const started = yield* Deferred.make() + const release = yield* Deferred.make() + const layer = AppNodeBuilder.build(FileSystemSearch.node, [ + [ + Location.node, + Layer.succeed( + Location.Service, + Location.Service.of( + location({ directory: AbsolutePath.make(path.join(os.tmpdir(), "opencode-search-atomic")) }), + ), ), - ), - ], - [ - Ripgrep.node, - Layer.succeed( - Ripgrep.Service, - Ripgrep.Service.of({ - find: (input) => - Effect.gen(function* () { - scans++ - if (scans > 1) { - yield* Deferred.succeed(started, undefined) - yield* Deferred.await(release) - } - const entry = FileSystem.Entry.make({ - path: RelativePath.make(scans === 1 ? "src/old.ts" : "src/new.ts"), - type: "file", - }) - if (input.onEntry) yield* input.onEntry(entry) - return [entry] - }), - glob: () => Effect.succeed([]), - grep: () => Effect.succeed([]), - }), - ), - ], - ]) + ], + [ + Ripgrep.node, + Layer.succeed( + Ripgrep.Service, + Ripgrep.Service.of({ + find: (input) => + Effect.gen(function* () { + scans++ + if (scans > 1) { + yield* Deferred.succeed(started, undefined) + yield* Deferred.await(release) + } + const entry = FileSystem.Entry.make({ + path: RelativePath.make(scans === 1 ? "src/old.ts" : "src/new.ts"), + type: "file", + }) + if (input.onEntry) yield* input.onEntry(entry) + return [entry] + }), + glob: () => Effect.succeed([]), + grep: () => Effect.succeed([]), + }), + ), + ], + ]) - await Effect.runPromise( - Effect.gen(function* () { + yield* Effect.gen(function* () { const search = yield* FileSystemSearch.Service yield* search.find({ query: "old", type: "file" }) expect((yield* search.find({ query: "old", type: "file" }))[0]?.path).toBe(RelativePath.make("src/old.ts")) @@ -196,47 +191,53 @@ describe("FileSystemSearch", () => { }).pipe(Effect.repeat({ until: (entries) => entries.length > 0 })) expect(refreshed[0]?.path).toBe(RelativePath.make("src/new.ts")) expect(scans).toBe(2) - }).pipe(Effect.provide(layer), Effect.provide(TestClock.layer()), Effect.scoped), - ) - }) + }).pipe(Effect.provide(layer)) + }), + ) - test("reuses location-owned fuzzy targets across index refreshes", async () => { - let scans = 0 - const second = Effect.runSync(Deferred.make()) - const prepare = spyOn(fuzzysort, "prepare") - const cleanup = spyOn(fuzzysort, "cleanup") - const layer = AppNodeBuilder.build(FileSystemSearch.node, [ - [ - Location.node, - Layer.succeed( - Location.Service, - Location.Service.of( - location({ directory: AbsolutePath.make(path.join(os.tmpdir(), "opencode-search-cache")) }), + it.effect("reuses location-owned fuzzy targets across index refreshes", () => + Effect.gen(function* () { + let scans = 0 + const second = yield* Deferred.make() + const prepare = yield* Effect.acquireRelease( + Effect.sync(() => spyOn(fuzzysort, "prepare")), + (value) => Effect.sync(() => value.mockRestore()), + ) + const cleanup = yield* Effect.acquireRelease( + Effect.sync(() => spyOn(fuzzysort, "cleanup")), + (value) => Effect.sync(() => value.mockRestore()), + ) + const layer = AppNodeBuilder.build(FileSystemSearch.node, [ + [ + Location.node, + Layer.succeed( + Location.Service, + Location.Service.of( + location({ directory: AbsolutePath.make(path.join(os.tmpdir(), "opencode-search-cache")) }), + ), ), - ), - ], - [ - Ripgrep.node, - Layer.succeed( - Ripgrep.Service, - Ripgrep.Service.of({ - find: (input) => - Effect.gen(function* () { - scans++ - const entry = FileSystem.Entry.make({ path: RelativePath.make("src/index.ts"), type: "file" }) - if (input.onEntry) yield* input.onEntry(entry) - if (scans > 1) yield* Deferred.succeed(second, undefined) - return [entry] - }), - glob: () => Effect.succeed([]), - grep: () => Effect.succeed([]), - }), - ), - ], - ]) + ], + [ + Ripgrep.node, + Layer.succeed( + Ripgrep.Service, + Ripgrep.Service.of({ + find: (input) => + Effect.gen(function* () { + scans++ + const entry = FileSystem.Entry.make({ path: RelativePath.make("src/index.ts"), type: "file" }) + if (input.onEntry) yield* input.onEntry(entry) + if (scans > 1) yield* Deferred.succeed(second, undefined) + return [entry] + }), + glob: () => Effect.succeed([]), + grep: () => Effect.succeed([]), + }), + ), + ], + ]) - await Effect.runPromise( - Effect.gen(function* () { + yield* Effect.gen(function* () { const search = yield* FileSystemSearch.Service yield* search.find({ query: "index", type: "file" }) yield* TestClock.adjust("10 seconds") @@ -246,9 +247,7 @@ describe("FileSystemSearch", () => { expect(prepare).toHaveBeenCalledTimes(2) expect(cleanup).toHaveBeenCalledTimes(3) - }).pipe(Effect.provide(layer), Effect.provide(TestClock.layer()), Effect.scoped), - ) - prepare.mockRestore() - cleanup.mockRestore() - }) + }).pipe(Effect.provide(layer)) + }), + ) })