|
1 | 1 | import { assert, it } from "@effect/vitest"; |
2 | 2 | import { |
3 | 3 | CheckpointScopeId, |
| 4 | + GitManagerError, |
4 | 5 | RunId, |
5 | 6 | ThreadId, |
6 | 7 | type OrchestrationV2ThreadShell, |
@@ -310,3 +311,108 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () => |
310 | 311 | assert.strictEqual(lookups, 2); |
311 | 312 | }).pipe(Effect.provide(layer)); |
312 | 313 | }); |
| 314 | + |
| 315 | +it.effect("still looks up a PR when the divergence refresh fails", () => { |
| 316 | + const threadId = ThreadId.make("thread-divergence-fail"); |
| 317 | + const runId = RunId.make("completed-run"); |
| 318 | + const lookedUp = Deferred.makeUnsafe<void>(); |
| 319 | + const layer = RunFinalization.layerObserver.pipe( |
| 320 | + Layer.provide( |
| 321 | + Layer.mergeAll( |
| 322 | + Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
| 323 | + Layer.mock(PullRequestService.PullRequestService)({ |
| 324 | + refreshAfterTurn: () => Effect.void, |
| 325 | + }), |
| 326 | + Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({ |
| 327 | + refreshLocalStatus: () => |
| 328 | + Effect.succeed({ |
| 329 | + isRepo: true, |
| 330 | + hasPrimaryRemote: true, |
| 331 | + isDefaultRef: false, |
| 332 | + refName: "feature", |
| 333 | + hasWorkingTreeChanges: false, |
| 334 | + workingTree: { files: [], insertions: 0, deletions: 0 }, |
| 335 | + }), |
| 336 | + refreshDivergence: () => |
| 337 | + Effect.fail( |
| 338 | + new GitManagerError({ |
| 339 | + operation: "refreshDivergence", |
| 340 | + cwd: "/repo", |
| 341 | + detail: "transient remote read failed", |
| 342 | + }), |
| 343 | + ), |
| 344 | + refreshPullRequestStatus: () => |
| 345 | + Deferred.succeed(lookedUp, undefined).pipe(Effect.as(null)), |
| 346 | + }), |
| 347 | + Layer.mock(ProjectionStore.ProjectionStoreV2)({ |
| 348 | + getThreadShell: () => |
| 349 | + Effect.succeed({ |
| 350 | + id: threadId, |
| 351 | + branch: "feature", |
| 352 | + activeRunId: null, |
| 353 | + } as OrchestrationV2ThreadShell), |
| 354 | + }), |
| 355 | + ), |
| 356 | + ), |
| 357 | + ); |
| 358 | + return Effect.gen(function* () { |
| 359 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 360 | + yield* observer.refresh({ cwd: "/repo", threadId, runId }); |
| 361 | + yield* Deferred.await(lookedUp); |
| 362 | + }).pipe(Effect.provide(layer)); |
| 363 | +}); |
| 364 | + |
| 365 | +it.effect("runs a second divergence-only refresh after an overlapping one finishes", () => { |
| 366 | + const threadId = ThreadId.make("thread-divergence-overlap"); |
| 367 | + const runId = RunId.make("completed-run"); |
| 368 | + const firstStarted = Deferred.makeUnsafe<void>(); |
| 369 | + const releaseFirst = Deferred.makeUnsafe<void>(); |
| 370 | + const secondFinished = Deferred.makeUnsafe<void>(); |
| 371 | + let divergenceRefreshes = 0; |
| 372 | + const layer = RunFinalization.layerObserver.pipe( |
| 373 | + Layer.provide( |
| 374 | + Layer.mergeAll( |
| 375 | + Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
| 376 | + Layer.mock(PullRequestService.PullRequestService)({ |
| 377 | + refreshAfterTurn: () => Effect.void, |
| 378 | + }), |
| 379 | + Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({ |
| 380 | + refreshLocalStatus: () => |
| 381 | + Effect.succeed({ |
| 382 | + isRepo: true, |
| 383 | + hasPrimaryRemote: true, |
| 384 | + isDefaultRef: true, |
| 385 | + refName: "main", |
| 386 | + hasWorkingTreeChanges: false, |
| 387 | + workingTree: { files: [], insertions: 0, deletions: 0 }, |
| 388 | + }), |
| 389 | + refreshDivergence: () => |
| 390 | + Effect.suspend(() => { |
| 391 | + divergenceRefreshes += 1; |
| 392 | + if (divergenceRefreshes === 1) { |
| 393 | + return Deferred.succeed(firstStarted, undefined).pipe( |
| 394 | + Effect.andThen(Deferred.await(releaseFirst)), |
| 395 | + Effect.as(null), |
| 396 | + ); |
| 397 | + } |
| 398 | + return Deferred.succeed(secondFinished, undefined).pipe(Effect.as(null)); |
| 399 | + }), |
| 400 | + refreshPullRequestStatus: () => |
| 401 | + Effect.die("default-branch finalization must not look up a PR"), |
| 402 | + }), |
| 403 | + Layer.mock(ProjectionStore.ProjectionStoreV2)({ |
| 404 | + getThreadShell: () => Effect.die("default branch skips the thread shell"), |
| 405 | + }), |
| 406 | + ), |
| 407 | + ), |
| 408 | + ); |
| 409 | + return Effect.gen(function* () { |
| 410 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 411 | + yield* observer.refresh({ cwd: "/repo", threadId, runId }); |
| 412 | + yield* Deferred.await(firstStarted); |
| 413 | + yield* observer.refresh({ cwd: "/repo", threadId, runId }); |
| 414 | + yield* Deferred.succeed(releaseFirst, undefined); |
| 415 | + yield* Deferred.await(secondFinished); |
| 416 | + assert.strictEqual(divergenceRefreshes, 2); |
| 417 | + }).pipe(Effect.provide(layer)); |
| 418 | +}); |
0 commit comments