@cvr/repo 1.0.0

package/src/test-utils/index.ts

@@ -0,0 +1,109 @@
+import { Layer, Ref } from "effect"
+
+import type { CacheService } from "../services/cache.js"
+import type { GitService } from "../services/git.js"
+import type { MetadataService } from "../services/metadata.js"
+import type { RegistryService } from "../services/registry.js"
+import {
+  createMockCacheService,
+  createMockGitService,
+  createMockMetadataService,
+  createMockRegistryService,
+  type MockCacheState,
+  type MockGitState,
+  type MockMetadataState,
+  type MockRegistryState,
+} from "./layers/index.js"
+import { createSequenceRef, type RecordedCall } from "./sequence.js"
+
+// ─── Re-exports ────────────────────────────────────────────────────────────────
+
+export * from "./layers/index.js"
+export * from "./sequence.js"
+export * from "./run-cli.js"
+
+// ─── Test Layer Types ──────────────────────────────────────────────────────────
+
+/** All services provided by the test layer */
+export type TestServices = GitService | CacheService | MetadataService | RegistryService
+
+// ─── Test Layer Composition ────────────────────────────────────────────────────
+
+export interface CreateTestLayerOptions {
+  /** Initial git state */
+  git?: Partial<MockGitState>
+  /** Initial cache state */
+  cache?: Partial<MockCacheState>
+  /** Initial metadata state */
+  metadata?: Partial<MockMetadataState>
+  /** Initial registry state */
+  registry?: Partial<MockRegistryState>
+}
+
+export interface TestLayerResult {
+  /** Combined layer providing all test services */
+  layer: Layer.Layer<TestServices>
+  /** Git mock utilities for state inspection */
+  git: ReturnType<typeof createMockGitService>
+  /** Cache mock utilities for state inspection */
+  cache: ReturnType<typeof createMockCacheService>
+  /** Metadata mock utilities for state inspection */
+  metadata: ReturnType<typeof createMockMetadataService>
+  /** Registry mock utilities for state inspection */
+  registry: ReturnType<typeof createMockRegistryService>
+  /** Sequence ref for recording all service calls in order */
+  sequenceRef: Ref.Ref<RecordedCall[]>
+}
+
+/**
+ * Creates a complete test layer with all mock services.
+ *
+ * @example
+ * ```ts
+ * const { layer, git, cache, sequenceRef } = createTestLayer({
+ *   git: { defaultBranch: 'main' },
+ *   cache: { cacheDir: '/custom/cache' },
+ * });
+ *
+ * const result = yield* someCommand.pipe(Effect.provide(layer));
+ *
+ * // Verify git state
+ * const gitState = yield* git.getState();
+ * expect(gitState.clonedRepos.size).toBe(1);
+ *
+ * // Verify call sequence
+ * const calls = yield* Ref.get(sequenceRef);
+ * expect(calls[0].service).toBe('registry');
+ * ```
+ */
+export function createTestLayer(options: CreateTestLayerOptions = {}): TestLayerResult {
+  const sequenceRef = createSequenceRef()
+
+  const git = createMockGitService({
+    ...(options.git && { initialState: options.git }),
+    sequenceRef,
+  })
+  const cache = createMockCacheService({
+    ...(options.cache && { initialState: options.cache }),
+    sequenceRef,
+  })
+  const metadata = createMockMetadataService({
+    ...(options.metadata && { initialState: options.metadata }),
+    sequenceRef,
+  })
+  const registry = createMockRegistryService({
+    ...(options.registry && { initialState: options.registry }),
+    sequenceRef,
+  })
+
+  const layer = Layer.mergeAll(git.layer, cache.layer, metadata.layer, registry.layer)
+
+  return {
+    layer,
+    git,
+    cache,
+    metadata,
+    registry,
+    sequenceRef,
+  }
+}

package/src/test-utils/layers/cache.ts

@@ -0,0 +1,137 @@
+import { Effect, Layer, Option, Ref } from "effect"
+import { CacheService } from "../../services/cache.js"
+import type { PackageSpec } from "../../types.js"
+import { recordCall, type SequenceRef } from "../sequence.js"
+
+// ─── Mock State ───────────────────────────────────────────────────────────────
+
+export interface MockCacheState {
+  store: Map<string, { content: string; size: number }>
+  cacheDir: string
+}
+
+export const defaultMockCacheState: MockCacheState = {
+  store: new Map(),
+  cacheDir: "/tmp/test-repo-cache",
+}
+
+// ─── Mock Implementation ──────────────────────────────────────────────────────
+
+export interface CreateMockCacheServiceOptions {
+  initialState?: Partial<MockCacheState>
+  sequenceRef?: SequenceRef
+}
+
+export function createMockCacheService(options: CreateMockCacheServiceOptions = {}): {
+  layer: Layer.Layer<CacheService>
+  stateRef: Ref.Ref<MockCacheState>
+  getState: () => Effect.Effect<MockCacheState>
+  /** Add a file to the mock cache (for test setup) */
+  addFile: (path: string, size: number) => Effect.Effect<void>
+} {
+  const initialState = options.initialState ?? {}
+  const sequenceRef = options.sequenceRef
+
+  const state: MockCacheState = {
+    ...defaultMockCacheState,
+    ...initialState,
+    store: new Map(initialState.store ?? []),
+  }
+  const stateRef = Ref.unsafeMake(state)
+
+  const record = (method: string, args: unknown, result?: unknown): Effect.Effect<void> =>
+    sequenceRef ? recordCall(sequenceRef, { service: "cache", method, args, result }) : Effect.void
+
+  const getPath = (spec: PackageSpec) =>
+    Effect.gen(function* () {
+      const s = yield* Ref.get(stateRef)
+      const version = Option.getOrElse(spec.version, () => "default")
+      let result: string
+      switch (spec.registry) {
+        case "github":
+          result = `${s.cacheDir}/${spec.name}`
+          break
+        case "npm":
+        case "pypi":
+        case "crates":
+          result = `${s.cacheDir}/${spec.name}/${version}`
+          break
+      }
+      yield* record("getPath", { spec }, result)
+      return result
+    })
+
+  const layer = Layer.succeed(
+    CacheService,
+    CacheService.of({
+      cacheDir: state.cacheDir,
+
+      getPath,
+
+      exists: (spec) =>
+        Effect.gen(function* () {
+          const path = yield* getPath(spec)
+          const s = yield* Ref.get(stateRef)
+          const result = s.store.has(path)
+          yield* record("exists", { spec }, result)
+          return result
+        }),
+
+      remove: (path) =>
+        Effect.gen(function* () {
+          yield* record("remove", { path })
+          yield* Ref.update(stateRef, (s) => {
+            const newStore = new Map(s.store)
+            for (const key of newStore.keys()) {
+              if (key.startsWith(path)) {
+                newStore.delete(key)
+              }
+            }
+            return { ...s, store: newStore }
+          })
+        }),
+
+      removeAll: () =>
+        Effect.gen(function* () {
+          yield* record("removeAll", {})
+          yield* Ref.update(stateRef, (s) => ({ ...s, store: new Map() }))
+        }),
+
+      getSize: (path) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          let total = 0
+          for (const [key, value] of s.store.entries()) {
+            if (key.startsWith(path)) {
+              total += value.size
+            }
+          }
+          yield* record("getSize", { path }, total)
+          return total
+        }),
+
+      ensureDir: (path) =>
+        Effect.gen(function* () {
+          yield* record("ensureDir", { path })
+        }),
+    })
+  )
+
+  const addFile = (path: string, size: number) =>
+    Ref.update(stateRef, (s) => {
+      const newStore = new Map(s.store)
+      newStore.set(path, { content: "", size })
+      return { ...s, store: newStore }
+    })
+
+  return {
+    layer,
+    stateRef,
+    getState: () => Ref.get(stateRef),
+    addFile,
+  }
+}
+
+// ─── Preset Configurations ────────────────────────────────────────────────────
+
+export const MockCacheServiceDefault = createMockCacheService()

package/src/test-utils/layers/git.ts

@@ -0,0 +1,104 @@
+import { Effect, Layer, Ref } from "effect"
+import { GitService } from "../../services/git.js"
+import { recordCall, type SequenceRef } from "../sequence.js"
+
+// ─── Mock State ───────────────────────────────────────────────────────────────
+
+export interface MockGitState {
+  clonedRepos: Map<string, { url: string; ref?: string; depth?: number }>
+  updatedPaths: string[]
+  defaultBranch: string
+  currentRef: string
+}
+
+export const defaultMockGitState: MockGitState = {
+  clonedRepos: new Map(),
+  updatedPaths: [],
+  defaultBranch: "main",
+  currentRef: "v1.0.0",
+}
+
+// ─── Mock Implementation ──────────────────────────────────────────────────────
+
+export interface CreateMockGitServiceOptions {
+  initialState?: Partial<MockGitState>
+  sequenceRef?: SequenceRef
+}
+
+export function createMockGitService(options: CreateMockGitServiceOptions = {}): {
+  layer: Layer.Layer<GitService>
+  stateRef: Ref.Ref<MockGitState>
+  getState: () => Effect.Effect<MockGitState>
+} {
+  const initialState = options.initialState ?? {}
+  const sequenceRef = options.sequenceRef
+
+  const state: MockGitState = {
+    ...defaultMockGitState,
+    ...initialState,
+    clonedRepos: new Map(initialState.clonedRepos ?? []),
+    updatedPaths: [...(initialState.updatedPaths ?? [])],
+  }
+  const stateRef = Ref.unsafeMake(state)
+
+  const record = (method: string, args: unknown, result?: unknown): Effect.Effect<void> =>
+    sequenceRef ? recordCall(sequenceRef, { service: "git", method, args, result }) : Effect.void
+
+  const layer = Layer.succeed(
+    GitService,
+    GitService.of({
+      clone: (url, dest, options) =>
+        Effect.gen(function* () {
+          yield* record("clone", { url, dest, options })
+          const entry: { url: string; ref?: string; depth?: number } = { url }
+          if (options?.ref) entry.ref = options.ref
+          if (options?.depth) entry.depth = options.depth
+          yield* Ref.update(stateRef, (s) => ({
+            ...s,
+            clonedRepos: new Map(s.clonedRepos).set(dest, entry),
+          }))
+        }),
+
+      update: (path) =>
+        Effect.gen(function* () {
+          yield* record("update", { path })
+          yield* Ref.update(stateRef, (s) => ({
+            ...s,
+            updatedPaths: [...s.updatedPaths, path],
+          }))
+        }),
+
+      isGitRepo: (path) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          const result = s.clonedRepos.has(path)
+          yield* record("isGitRepo", { path }, result)
+          return result
+        }),
+
+      getDefaultBranch: (url) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          yield* record("getDefaultBranch", { url }, s.defaultBranch)
+          return s.defaultBranch
+        }),
+
+      getCurrentRef: (path) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          yield* record("getCurrentRef", { path }, s.currentRef)
+          return s.currentRef
+        }),
+    })
+  )
+
+  return {
+    layer,
+    stateRef,
+    getState: () => Ref.get(stateRef),
+  }
+}
+
+// ─── Preset Configurations ────────────────────────────────────────────────────
+
+export const MockGitServiceDefault = createMockGitService()

package/src/test-utils/layers/index.ts

@@ -0,0 +1,33 @@
+// Re-export all mock service factories and types
+
+export {
+  createMockGitService,
+  defaultMockGitState,
+  MockGitServiceDefault,
+  type CreateMockGitServiceOptions,
+  type MockGitState,
+} from "./git.js"
+
+export {
+  createMockCacheService,
+  defaultMockCacheState,
+  MockCacheServiceDefault,
+  type CreateMockCacheServiceOptions,
+  type MockCacheState,
+} from "./cache.js"
+
+export {
+  createMockMetadataService,
+  defaultMockMetadataState,
+  MockMetadataServiceDefault,
+  type CreateMockMetadataServiceOptions,
+  type MockMetadataState,
+} from "./metadata.js"
+
+export {
+  createMockRegistryService,
+  defaultMockRegistryState,
+  MockRegistryServiceDefault,
+  type CreateMockRegistryServiceOptions,
+  type MockRegistryState,
+} from "./registry.js"

package/src/test-utils/layers/metadata.ts

@@ -0,0 +1,155 @@
+import { Effect, Layer, Option, Ref } from "effect"
+import { MetadataService } from "../../services/metadata.js"
+import type { MetadataIndex, PackageSpec } from "../../types.js"
+import { recordCall, type SequenceRef } from "../sequence.js"
+
+// ─── Mock State ───────────────────────────────────────────────────────────────
+
+export interface MockMetadataState {
+  index: MetadataIndex
+}
+
+export const defaultMockMetadataState: MockMetadataState = {
+  index: { version: 1, repos: [] },
+}
+
+// ─── Mock Implementation ──────────────────────────────────────────────────────
+
+export interface CreateMockMetadataServiceOptions {
+  initialState?: Partial<MockMetadataState>
+  sequenceRef?: SequenceRef
+}
+
+export function createMockMetadataService(options: CreateMockMetadataServiceOptions = {}): {
+  layer: Layer.Layer<MetadataService>
+  stateRef: Ref.Ref<MockMetadataState>
+  getState: () => Effect.Effect<MockMetadataState>
+} {
+  const initialState = options.initialState ?? {}
+  const sequenceRef = options.sequenceRef
+
+  const state: MockMetadataState = {
+    ...defaultMockMetadataState,
+    ...initialState,
+    index: {
+      version: initialState.index?.version ?? 1,
+      repos: [...(initialState.index?.repos ?? [])],
+    },
+  }
+  const stateRef = Ref.unsafeMake(state)
+
+  const record = (method: string, args: unknown, result?: unknown): Effect.Effect<void> =>
+    sequenceRef ? recordCall(sequenceRef, { service: "metadata", method, args, result }) : Effect.void
+
+  const specMatches = (a: PackageSpec, b: PackageSpec): boolean => {
+    if (a.registry !== b.registry || a.name !== b.name) return false
+    const aVersion = Option.getOrElse(a.version, () => "")
+    const bVersion = Option.getOrElse(b.version, () => "")
+    return aVersion === bVersion
+  }
+
+  const layer = Layer.succeed(
+    MetadataService,
+    MetadataService.of({
+      load: () =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          yield* record("load", {}, s.index)
+          return s.index
+        }),
+
+      save: (newIndex) =>
+        Effect.gen(function* () {
+          yield* record("save", { index: newIndex })
+          yield* Ref.update(stateRef, (s) => ({ ...s, index: newIndex }))
+        }),
+
+      add: (metadata) =>
+        Effect.gen(function* () {
+          yield* record("add", { metadata })
+          yield* Ref.update(stateRef, (s) => {
+            const filtered = s.index.repos.filter((r) => !specMatches(r.spec, metadata.spec))
+            return {
+              ...s,
+              index: { ...s.index, repos: [...filtered, metadata] },
+            }
+          })
+        }),
+
+      remove: (spec) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          const originalLength = s.index.repos.length
+          const filtered = s.index.repos.filter((r) => !specMatches(r.spec, spec))
+          const result = filtered.length < originalLength
+          yield* record("remove", { spec }, result)
+          yield* Ref.set(stateRef, {
+            ...s,
+            index: { ...s.index, repos: filtered },
+          })
+          return result
+        }),
+
+      find: (spec) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          const result = s.index.repos.find((r) => specMatches(r.spec, spec)) ?? null
+          yield* record("find", { spec }, result)
+          return result
+        }),
+
+      updateAccessTime: (spec) =>
+        Effect.gen(function* () {
+          yield* record("updateAccessTime", { spec })
+          yield* Ref.update(stateRef, (s) => ({
+            ...s,
+            index: {
+              ...s.index,
+              repos: s.index.repos.map((r) => {
+                if (specMatches(r.spec, spec)) {
+                  return { ...r, lastAccessedAt: new Date().toISOString() }
+                }
+                return r
+              }),
+            },
+          }))
+        }),
+
+      findOlderThan: (days) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          const cutoff = Date.now() - days * 24 * 60 * 60 * 1000
+          const result = s.index.repos.filter(
+            (r) => new Date(r.lastAccessedAt).getTime() < cutoff
+          )
+          yield* record("findOlderThan", { days }, result)
+          return result
+        }),
+
+      findLargerThan: (bytes) =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          const result = s.index.repos.filter((r) => r.sizeBytes > bytes)
+          yield* record("findLargerThan", { bytes }, result)
+          return result
+        }),
+
+      all: () =>
+        Effect.gen(function* () {
+          const s = yield* Ref.get(stateRef)
+          yield* record("all", {}, s.index.repos)
+          return s.index.repos
+        }),
+    })
+  )
+
+  return {
+    layer,
+    stateRef,
+    getState: () => Ref.get(stateRef),
+  }
+}
+
+// ─── Preset Configurations ────────────────────────────────────────────────────
+
+export const MockMetadataServiceDefault = createMockMetadataService()