|
7 | 7 | ThreadId, |
8 | 8 | type OrchestrationV2ThreadShell, |
9 | 9 | type Project, |
| 10 | + type RepositoryIdentity, |
10 | 11 | } from "@t3tools/contracts"; |
11 | 12 | import * as Deferred from "effect/Deferred"; |
12 | 13 | import * as Effect from "effect/Effect"; |
@@ -335,16 +336,156 @@ it.effect("resolves the identity of a project whose remote was added during the |
335 | 336 | const observer = yield* RunFinalization.RunFinalizationObserver; |
336 | 337 | yield* observer.refresh({ cwd: workspaceRoot, threadId, runId }); |
337 | 338 |
|
338 | | - let available = yield* enrichment.getAvailable(workspaceRoot); |
339 | | - while (!available.repositoryIdentityResolved) { |
340 | | - yield* PubSub.take(changes); |
341 | | - available = yield* enrichment.getAvailable(workspaceRoot); |
342 | | - } |
| 339 | + // The refresh runs in the background; until it publishes, the cached null still reads as resolved. |
| 340 | + const change = yield* PubSub.take(changes); |
343 | 341 | assert.strictEqual( |
344 | | - available.repositoryIdentity?.locator.remoteUrl, |
| 342 | + change.enrichment.repositoryIdentity?.locator.remoteUrl, |
345 | 343 | "https://github.com/t3-triage/example-29929.git", |
346 | 344 | "the project's repository identity is still null after the turn added a remote", |
347 | 345 | ); |
348 | 346 | }).pipe(Effect.scoped, Effect.provide(layer)); |
349 | 347 | }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), |
350 | 348 | ); |
| 349 | + |
| 350 | +const stubbedIdentityProject = { |
| 351 | + projectId: ProjectId.make("project-stubbed-identity"), |
| 352 | + threadId: ThreadId.make("thread-stubbed-identity"), |
| 353 | + runId: RunId.make("completed-run"), |
| 354 | + workspaceRoot: "/repo-stubbed-identity", |
| 355 | +}; |
| 356 | +const stubbedIdentity: RepositoryIdentity = { |
| 357 | + canonicalKey: "example.test/stubbed-identity", |
| 358 | + locator: { |
| 359 | + source: "git-remote", |
| 360 | + remoteName: "origin", |
| 361 | + remoteUrl: "https://example.test/stubbed-identity.git", |
| 362 | + }, |
| 363 | +}; |
| 364 | + |
| 365 | +const layerStubbedIdentityResolver = ( |
| 366 | + resolve: RepositoryIdentityResolver.RepositoryIdentityResolver["Service"]["resolve"], |
| 367 | +) => |
| 368 | + RunFinalization.layerObserver.pipe( |
| 369 | + Layer.provideMerge( |
| 370 | + Layer.mergeAll( |
| 371 | + Layer.effect(ProjectEnrichment.ProjectEnrichmentService, ProjectEnrichment.make()).pipe( |
| 372 | + Layer.provide( |
| 373 | + Layer.mergeAll( |
| 374 | + Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, { resolve }), |
| 375 | + Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, { |
| 376 | + invalidate: () => Effect.void, |
| 377 | + resolvePath: () => Effect.succeed(null), |
| 378 | + }), |
| 379 | + ), |
| 380 | + ), |
| 381 | + ), |
| 382 | + Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
| 383 | + Layer.mock(PullRequestService.PullRequestService)({ refreshAfterTurn: () => Effect.void }), |
| 384 | + Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({ |
| 385 | + refreshLocalStatus: () => |
| 386 | + Effect.succeed({ |
| 387 | + isRepo: true, |
| 388 | + hasPrimaryRemote: true, |
| 389 | + isDefaultRef: true, |
| 390 | + refName: "main", |
| 391 | + hasWorkingTreeChanges: false, |
| 392 | + workingTree: { files: [], insertions: 0, deletions: 0 }, |
| 393 | + }), |
| 394 | + }), |
| 395 | + Layer.mock(ProjectionStore.ProjectionStoreV2)({ |
| 396 | + getThreadShell: () => |
| 397 | + Effect.succeed({ |
| 398 | + id: stubbedIdentityProject.threadId, |
| 399 | + projectId: stubbedIdentityProject.projectId, |
| 400 | + branch: "main", |
| 401 | + activeRunId: null, |
| 402 | + } as OrchestrationV2ThreadShell), |
| 403 | + }), |
| 404 | + Layer.mock(ProjectService.ProjectService)({ |
| 405 | + getById: () => |
| 406 | + Effect.succeedSome({ |
| 407 | + id: stubbedIdentityProject.projectId, |
| 408 | + workspaceRoot: stubbedIdentityProject.workspaceRoot, |
| 409 | + } as Project), |
| 410 | + }), |
| 411 | + ), |
| 412 | + ), |
| 413 | + ); |
| 414 | + |
| 415 | +it.effect( |
| 416 | + "keeps a known identity's resolver caches when a turn outlasts the enrichment TTL", |
| 417 | + () => { |
| 418 | + const { workspaceRoot, threadId, runId } = stubbedIdentityProject; |
| 419 | + const refreshFlags: boolean[] = []; |
| 420 | + const resolvedAfterTurn = Deferred.makeUnsafe<void>(); |
| 421 | + return Effect.gen(function* () { |
| 422 | + const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService; |
| 423 | + assert.isNotNull(yield* enrichment.readRepositoryIdentity(workspaceRoot)); |
| 424 | + yield* TestClock.adjust("61 seconds"); |
| 425 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 426 | + yield* observer.refresh({ cwd: workspaceRoot, threadId, runId }); |
| 427 | + yield* Deferred.await(resolvedAfterTurn); |
| 428 | + assert.deepEqual( |
| 429 | + refreshFlags, |
| 430 | + [false, false], |
| 431 | + "a project with a known identity had its resolver caches forced after the turn", |
| 432 | + ); |
| 433 | + }).pipe( |
| 434 | + Effect.provide( |
| 435 | + layerStubbedIdentityResolver((_cwd, options) => |
| 436 | + Effect.sync(() => { |
| 437 | + refreshFlags.push(options?.refresh === true); |
| 438 | + return stubbedIdentity; |
| 439 | + }).pipe( |
| 440 | + Effect.tap(() => |
| 441 | + refreshFlags.length > 1 |
| 442 | + ? Deferred.succeed(resolvedAfterTurn, undefined) |
| 443 | + : Effect.void, |
| 444 | + ), |
| 445 | + ), |
| 446 | + ), |
| 447 | + ), |
| 448 | + ); |
| 449 | + }, |
| 450 | +); |
| 451 | + |
| 452 | +it.effect("returns from the post-turn refresh while the identity resolver is still running", () => { |
| 453 | + const { workspaceRoot, threadId, runId } = stubbedIdentityProject; |
| 454 | + const releaseResolver = Deferred.makeUnsafe<void>(); |
| 455 | + let remoteAdded = false; |
| 456 | + return Effect.gen(function* () { |
| 457 | + const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService; |
| 458 | + assert.isNull(yield* enrichment.readRepositoryIdentity(workspaceRoot)); |
| 459 | + const changes = yield* enrichment.subscribeChanges; |
| 460 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 461 | + const refresh = yield* observer |
| 462 | + .refresh({ cwd: workspaceRoot, threadId, runId }) |
| 463 | + .pipe(Effect.timeoutOption("1 minute"), Effect.forkChild({ startImmediately: true })); |
| 464 | + yield* TestClock.adjust("1 minute"); |
| 465 | + assert.isTrue( |
| 466 | + Option.isSome(yield* Fiber.join(refresh)), |
| 467 | + "turn finalization waited on the identity resolver, blocking the thread's next turn", |
| 468 | + ); |
| 469 | + |
| 470 | + yield* Deferred.succeed(releaseResolver, undefined); |
| 471 | + const change = yield* PubSub.take(changes); |
| 472 | + assert.strictEqual( |
| 473 | + change.enrichment.repositoryIdentity?.canonicalKey, |
| 474 | + stubbedIdentity.canonicalKey, |
| 475 | + ); |
| 476 | + }).pipe( |
| 477 | + Effect.scoped, |
| 478 | + Effect.provide( |
| 479 | + layerStubbedIdentityResolver((_cwd, options) => |
| 480 | + options?.refresh |
| 481 | + ? Deferred.await(releaseResolver).pipe( |
| 482 | + Effect.map(() => { |
| 483 | + remoteAdded = true; |
| 484 | + return stubbedIdentity; |
| 485 | + }), |
| 486 | + ) |
| 487 | + : Effect.sync(() => (remoteAdded ? stubbedIdentity : null)), |
| 488 | + ), |
| 489 | + ), |
| 490 | + ); |
| 491 | +}); |
0 commit comments