|
| 1 | +import * as NodeServices from "@effect/platform-node/NodeServices"; |
1 | 2 | import { assert, it } from "@effect/vitest"; |
2 | 3 | import { |
3 | 4 | CheckpointScopeId, |
| 5 | + ProjectId, |
4 | 6 | RunId, |
5 | 7 | ThreadId, |
6 | 8 | type OrchestrationV2ThreadShell, |
| 9 | + type Project, |
| 10 | + type RepositoryIdentity, |
7 | 11 | } from "@t3tools/contracts"; |
8 | 12 | import * as Deferred from "effect/Deferred"; |
9 | 13 | import * as Effect from "effect/Effect"; |
10 | 14 | import * as Fiber from "effect/Fiber"; |
| 15 | +import * as FileSystem from "effect/FileSystem"; |
11 | 16 | import * as Layer from "effect/Layer"; |
12 | 17 | import * as Option from "effect/Option"; |
| 18 | +import * as PubSub from "effect/PubSub"; |
13 | 19 | import * as TestClock from "effect/testing/TestClock"; |
14 | 20 |
|
| 21 | +import * as ProcessRunner from "../processRunner.ts"; |
| 22 | +import * as ProjectEnrichment from "../project/ProjectEnrichmentService.ts"; |
| 23 | +import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts"; |
| 24 | +import * as ProjectService from "../project/ProjectService.ts"; |
| 25 | +import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts"; |
15 | 26 | import * as PullRequestService from "../pullRequest/PullRequestService.ts"; |
16 | 27 | import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts"; |
17 | 28 | import * as WorkspaceEntries from "../workspace/WorkspaceEntries.ts"; |
18 | 29 | import * as CheckpointCapture from "./CheckpointCaptureService.ts"; |
19 | 30 | import * as ProjectionStore from "./ProjectionStore.ts"; |
20 | 31 | import * as RunFinalization from "./RunFinalizationService.ts"; |
21 | 32 |
|
| 33 | +// Without a project the observer never touches enrichment, so its methods stay unimplemented. |
| 34 | +const layerNoProject = Layer.mergeAll( |
| 35 | + Layer.mock(ProjectService.ProjectService)({ getById: () => Effect.succeedNone }), |
| 36 | + Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}), |
| 37 | +); |
| 38 | + |
22 | 39 | it.effect("completes finalization when the post-checkpoint workspace refresh fails", () => { |
23 | 40 | const threadId = ThreadId.make("thread_refresh_failure"); |
24 | 41 | const runId = RunId.make("run_refresh_failure"); |
@@ -103,6 +120,7 @@ it.effect.each( |
103 | 120 | const layer = RunFinalization.layerObserver.pipe( |
104 | 121 | Layer.provide( |
105 | 122 | Layer.mergeAll( |
| 123 | + layerNoProject, |
106 | 124 | Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
107 | 125 | Layer.mock(PullRequestService.PullRequestService)({ |
108 | 126 | refreshAfterTurn: () => Effect.void, |
@@ -150,6 +168,7 @@ it.effect("returns from the post-turn refresh without waiting for the PR lookup" |
150 | 168 | const layer = RunFinalization.layerObserver.pipe( |
151 | 169 | Layer.provide( |
152 | 170 | Layer.mergeAll( |
| 171 | + layerNoProject, |
153 | 172 | Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
154 | 173 | Layer.mock(PullRequestService.PullRequestService)({ |
155 | 174 | refreshAfterTurn: () => Effect.void, |
@@ -200,6 +219,7 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () => |
200 | 219 | const layer = RunFinalization.layerObserver.pipe( |
201 | 220 | Layer.provide( |
202 | 221 | Layer.mergeAll( |
| 222 | + layerNoProject, |
203 | 223 | Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
204 | 224 | Layer.mock(PullRequestService.PullRequestService)({ |
205 | 225 | refreshAfterTurn: () => Effect.void, |
@@ -241,3 +261,138 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () => |
241 | 261 | assert.strictEqual(lookups, 2); |
242 | 262 | }).pipe(Effect.provide(layer)); |
243 | 263 | }); |
| 264 | + |
| 265 | +const identityProjectId = ProjectId.make("project-identity-refresh"); |
| 266 | +const identityThreadId = ThreadId.make("thread-identity-refresh"); |
| 267 | +const identityRunId = RunId.make("completed-run"); |
| 268 | + |
| 269 | +const layerIdentityRefresh = <R>( |
| 270 | + workspaceRoot: string, |
| 271 | + resolver: Layer.Layer<RepositoryIdentityResolver.RepositoryIdentityResolver, never, R>, |
| 272 | +) => |
| 273 | + RunFinalization.layerObserver.pipe( |
| 274 | + Layer.provideMerge( |
| 275 | + Layer.mergeAll( |
| 276 | + Layer.effect(ProjectEnrichment.ProjectEnrichmentService, ProjectEnrichment.make()).pipe( |
| 277 | + Layer.provide( |
| 278 | + Layer.mergeAll( |
| 279 | + resolver, |
| 280 | + Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, { |
| 281 | + invalidate: () => Effect.void, |
| 282 | + resolvePath: () => Effect.succeed(null), |
| 283 | + }), |
| 284 | + ), |
| 285 | + ), |
| 286 | + ), |
| 287 | + Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
| 288 | + Layer.mock(PullRequestService.PullRequestService)({ refreshAfterTurn: () => Effect.void }), |
| 289 | + Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({ |
| 290 | + refreshLocalStatus: () => |
| 291 | + Effect.succeed({ |
| 292 | + isRepo: true, |
| 293 | + hasPrimaryRemote: true, |
| 294 | + isDefaultRef: true, |
| 295 | + refName: "main", |
| 296 | + hasWorkingTreeChanges: false, |
| 297 | + workingTree: { files: [], insertions: 0, deletions: 0 }, |
| 298 | + }), |
| 299 | + }), |
| 300 | + Layer.mock(ProjectionStore.ProjectionStoreV2)({ |
| 301 | + getThreadShell: () => |
| 302 | + Effect.succeed({ |
| 303 | + id: identityThreadId, |
| 304 | + projectId: identityProjectId, |
| 305 | + branch: "main", |
| 306 | + activeRunId: null, |
| 307 | + } as OrchestrationV2ThreadShell), |
| 308 | + }), |
| 309 | + Layer.mock(ProjectService.ProjectService)({ |
| 310 | + getById: () => Effect.succeedSome({ id: identityProjectId, workspaceRoot } as Project), |
| 311 | + }), |
| 312 | + ), |
| 313 | + ), |
| 314 | + ); |
| 315 | + |
| 316 | +it.effect("resolves the identity of a project whose remote was added during the turn", () => |
| 317 | + Effect.gen(function* () { |
| 318 | + const fileSystem = yield* FileSystem.FileSystem; |
| 319 | + const processRunner = yield* ProcessRunner.ProcessRunner; |
| 320 | + const workspaceRoot = yield* fileSystem.makeTempDirectoryScoped({ |
| 321 | + prefix: "t3-run-finalization-identity-test-", |
| 322 | + }); |
| 323 | + const git = (args: ReadonlyArray<string>) => |
| 324 | + processRunner.run({ command: "git", args: ["-C", workspaceRoot, ...args] }); |
| 325 | + yield* git(["init"]); |
| 326 | + |
| 327 | + yield* Effect.gen(function* () { |
| 328 | + const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService; |
| 329 | + // A shell read before the turn caches the folder as having no repository. |
| 330 | + assert.isNull(yield* enrichment.readRepositoryIdentity(workspaceRoot)); |
| 331 | + |
| 332 | + yield* git(["remote", "add", "origin", "https://github.com/t3-triage/example-29929.git"]); |
| 333 | + const changes = yield* enrichment.subscribeChanges; |
| 334 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 335 | + yield* observer.refresh({ |
| 336 | + cwd: workspaceRoot, |
| 337 | + threadId: identityThreadId, |
| 338 | + runId: identityRunId, |
| 339 | + }); |
| 340 | + |
| 341 | + const change = yield* PubSub.take(changes); |
| 342 | + assert.strictEqual( |
| 343 | + change.enrichment.repositoryIdentity?.locator.remoteUrl, |
| 344 | + "https://github.com/t3-triage/example-29929.git", |
| 345 | + "the project's repository identity is still null after the turn added a remote", |
| 346 | + ); |
| 347 | + }).pipe( |
| 348 | + Effect.scoped, |
| 349 | + Effect.provide(layerIdentityRefresh(workspaceRoot, RepositoryIdentityResolver.layer)), |
| 350 | + ); |
| 351 | + }).pipe( |
| 352 | + Effect.scoped, |
| 353 | + Effect.provide(ProcessRunner.layer.pipe(Layer.provideMerge(NodeServices.layer))), |
| 354 | + ), |
| 355 | +); |
| 356 | + |
| 357 | +it.effect("returns from the post-turn refresh while the identity resolver is still running", () => { |
| 358 | + const workspaceRoot = "/repo-stubbed-identity"; |
| 359 | + const identity: RepositoryIdentity = { |
| 360 | + canonicalKey: "example.test/stubbed-identity", |
| 361 | + locator: { |
| 362 | + source: "git-remote", |
| 363 | + remoteName: "origin", |
| 364 | + remoteUrl: "https://example.test/stubbed-identity.git", |
| 365 | + }, |
| 366 | + }; |
| 367 | + const releaseResolver = Deferred.makeUnsafe<void>(); |
| 368 | + let remoteAdded = false; |
| 369 | + const resolver = Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, { |
| 370 | + resolve: (_cwd, options) => |
| 371 | + options?.refresh |
| 372 | + ? Deferred.await(releaseResolver).pipe( |
| 373 | + Effect.map(() => { |
| 374 | + remoteAdded = true; |
| 375 | + return identity; |
| 376 | + }), |
| 377 | + ) |
| 378 | + : Effect.sync(() => (remoteAdded ? identity : null)), |
| 379 | + }); |
| 380 | + return Effect.gen(function* () { |
| 381 | + const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService; |
| 382 | + assert.isNull(yield* enrichment.readRepositoryIdentity(workspaceRoot)); |
| 383 | + const changes = yield* enrichment.subscribeChanges; |
| 384 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 385 | + const refresh = yield* observer |
| 386 | + .refresh({ cwd: workspaceRoot, threadId: identityThreadId, runId: identityRunId }) |
| 387 | + .pipe(Effect.timeoutOption("1 minute"), Effect.forkChild({ startImmediately: true })); |
| 388 | + yield* TestClock.adjust("1 minute"); |
| 389 | + assert.isTrue( |
| 390 | + Option.isSome(yield* Fiber.join(refresh)), |
| 391 | + "turn finalization waited on the identity resolver, blocking the thread's next turn", |
| 392 | + ); |
| 393 | + |
| 394 | + yield* Deferred.succeed(releaseResolver, undefined); |
| 395 | + const change = yield* PubSub.take(changes); |
| 396 | + assert.strictEqual(change.enrichment.repositoryIdentity?.canonicalKey, identity.canonicalKey); |
| 397 | + }).pipe(Effect.scoped, Effect.provide(layerIdentityRefresh(workspaceRoot, resolver))); |
| 398 | +}); |
0 commit comments