|
| 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, |
| 6 | + SourceControlProviderKind, |
4 | 7 | RunId, |
5 | 8 | ThreadId, |
6 | 9 | type OrchestrationV2ThreadShell, |
7 | 10 | } from "@t3tools/contracts"; |
8 | 11 | import * as Deferred from "effect/Deferred"; |
9 | 12 | import * as Effect from "effect/Effect"; |
10 | 13 | import * as Fiber from "effect/Fiber"; |
| 14 | +import * as FileSystem from "effect/FileSystem"; |
| 15 | +import * as PubSub from "effect/PubSub"; |
11 | 16 | import * as Layer from "effect/Layer"; |
12 | 17 | import * as Option from "effect/Option"; |
13 | 18 | import * as TestClock from "effect/testing/TestClock"; |
14 | 19 |
|
| 20 | +import * as ProcessRunner from "../processRunner.ts"; |
| 21 | +import * as ProjectEnrichment from "../project/ProjectEnrichmentService.ts"; |
| 22 | +import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts"; |
| 23 | +import * as ProjectService from "../project/ProjectService.ts"; |
| 24 | +import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts"; |
15 | 25 | import * as PullRequestService from "../pullRequest/PullRequestService.ts"; |
16 | 26 | import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts"; |
17 | 27 | import * as WorkspaceEntries from "../workspace/WorkspaceEntries.ts"; |
@@ -103,6 +113,9 @@ it.effect.each( |
103 | 113 | const layer = RunFinalization.layerObserver.pipe( |
104 | 114 | Layer.provide( |
105 | 115 | Layer.mergeAll( |
| 116 | + Layer.mock(ProjectService.ProjectService)({}), |
| 117 | + Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}), |
| 118 | + Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}), |
106 | 119 | Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
107 | 120 | Layer.mock(PullRequestService.PullRequestService)({ |
108 | 121 | refreshAfterTurn: () => Effect.void, |
@@ -150,6 +163,9 @@ it.effect("returns from the post-turn refresh without waiting for the PR lookup" |
150 | 163 | const layer = RunFinalization.layerObserver.pipe( |
151 | 164 | Layer.provide( |
152 | 165 | Layer.mergeAll( |
| 166 | + Layer.mock(ProjectService.ProjectService)({}), |
| 167 | + Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}), |
| 168 | + Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}), |
153 | 169 | Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
154 | 170 | Layer.mock(PullRequestService.PullRequestService)({ |
155 | 171 | refreshAfterTurn: () => Effect.void, |
@@ -200,6 +216,9 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () => |
200 | 216 | const layer = RunFinalization.layerObserver.pipe( |
201 | 217 | Layer.provide( |
202 | 218 | Layer.mergeAll( |
| 219 | + Layer.mock(ProjectService.ProjectService)({}), |
| 220 | + Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}), |
| 221 | + Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}), |
203 | 222 | Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
204 | 223 | Layer.mock(PullRequestService.PullRequestService)({ |
205 | 224 | refreshAfterTurn: () => Effect.void, |
@@ -241,3 +260,208 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () => |
241 | 260 | assert.strictEqual(lookups, 2); |
242 | 261 | }).pipe(Effect.provide(layer)); |
243 | 262 | }); |
| 263 | + |
| 264 | +it.live( |
| 265 | + "publishes a shell-added remote after a default-branch turn without waiting for the identity TTL", |
| 266 | + () => |
| 267 | + Effect.gen(function* () { |
| 268 | + const fs = yield* FileSystem.FileSystem; |
| 269 | + const runner = yield* ProcessRunner.ProcessRunner; |
| 270 | + const cwd = yield* fs.makeTempDirectoryScoped({ prefix: "t3-turn-remote-" }); |
| 271 | + const git = (args: ReadonlyArray<string>) => |
| 272 | + runner.run({ command: "git", args: ["-C", cwd, ...args] }); |
| 273 | + yield* git(["init", "--initial-branch=main"]); |
| 274 | + const threadId = ThreadId.make("thread-publish-remote"); |
| 275 | + const projectId = ProjectId.make("project-publish-remote"); |
| 276 | + const runId = RunId.make("run-publish-remote"); |
| 277 | + let hasRemote = false; |
| 278 | + const metadata = ProjectEnrichment.layer.pipe( |
| 279 | + Layer.provideMerge(RepositoryIdentityResolver.layer), |
| 280 | + Layer.provide( |
| 281 | + Layer.mock(ProjectFaviconResolver.ProjectFaviconResolver)({ |
| 282 | + resolvePath: () => Effect.succeed(null), |
| 283 | + invalidate: () => Effect.void, |
| 284 | + }), |
| 285 | + ), |
| 286 | + ); |
| 287 | + const layer = RunFinalization.layerObserver.pipe( |
| 288 | + Layer.provideMerge(metadata), |
| 289 | + Layer.provide( |
| 290 | + Layer.mergeAll( |
| 291 | + Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
| 292 | + Layer.mock(PullRequestService.PullRequestService)({ |
| 293 | + refreshAfterTurn: () => Effect.void, |
| 294 | + }), |
| 295 | + Layer.unwrap( |
| 296 | + Effect.gen(function* () { |
| 297 | + const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService; |
| 298 | + return Layer.mock(ProjectService.ProjectService)({ |
| 299 | + getById: () => |
| 300 | + enrichment.peek(cwd).pipe( |
| 301 | + Effect.map((value) => |
| 302 | + Option.some({ |
| 303 | + id: projectId, |
| 304 | + title: "Published project", |
| 305 | + workspaceRoot: cwd, |
| 306 | + repositoryIdentity: value.repositoryIdentity, |
| 307 | + defaultModelSelection: null, |
| 308 | + scripts: [], |
| 309 | + createdAt: "2026-01-01T00:00:00.000Z", |
| 310 | + updatedAt: "2026-01-01T00:00:00.000Z", |
| 311 | + deletedAt: null, |
| 312 | + }), |
| 313 | + ), |
| 314 | + ), |
| 315 | + }); |
| 316 | + }), |
| 317 | + ).pipe(Layer.provide(metadata)), |
| 318 | + Layer.mock(ProjectionStore.ProjectionStoreV2)({ |
| 319 | + getThreadShell: () => |
| 320 | + Effect.succeed({ |
| 321 | + id: threadId, |
| 322 | + projectId, |
| 323 | + branch: "main", |
| 324 | + activeRunId: null, |
| 325 | + } as OrchestrationV2ThreadShell), |
| 326 | + }), |
| 327 | + Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({ |
| 328 | + refreshLocalStatus: () => |
| 329 | + Effect.succeed({ |
| 330 | + isRepo: true, |
| 331 | + hasPrimaryRemote: false, |
| 332 | + isDefaultRef: true, |
| 333 | + refName: "main", |
| 334 | + hasWorkingTreeChanges: false, |
| 335 | + workingTree: { files: [], insertions: 0, deletions: 0 }, |
| 336 | + ...(hasRemote |
| 337 | + ? { |
| 338 | + sourceControlProvider: { |
| 339 | + kind: SourceControlProviderKind.make("github"), |
| 340 | + name: "GitHub", |
| 341 | + baseUrl: "https://github.com", |
| 342 | + }, |
| 343 | + } |
| 344 | + : {}), |
| 345 | + }), |
| 346 | + }), |
| 347 | + ), |
| 348 | + ), |
| 349 | + ); |
| 350 | + yield* Effect.gen(function* () { |
| 351 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 352 | + const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService; |
| 353 | + const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver; |
| 354 | + const changes = yield* enrichment.subscribeChanges; |
| 355 | + yield* enrichment.request(cwd); |
| 356 | + assert.isNull((yield* PubSub.take(changes)).enrichment.repositoryIdentity); |
| 357 | + yield* observer.refresh({ cwd, threadId, runId }); |
| 358 | + yield* git(["remote", "add", "origin", "https://github.com/t3tools/turn-remote.git"]); |
| 359 | + hasRemote = true; |
| 360 | + assert.isNull(yield* resolver.resolve(cwd)); |
| 361 | + assert.isNull((yield* enrichment.peek(cwd)).repositoryIdentity); |
| 362 | + yield* observer.refresh({ cwd, threadId, runId }); |
| 363 | + const refreshed = yield* PubSub.take(changes); |
| 364 | + assert.equal(refreshed.workspaceRoot, cwd); |
| 365 | + assert.equal( |
| 366 | + refreshed.enrichment.repositoryIdentity?.canonicalKey, |
| 367 | + "github.com/t3tools/turn-remote", |
| 368 | + ); |
| 369 | + assert.equal( |
| 370 | + (yield* enrichment.peek(cwd)).repositoryIdentity?.locator.remoteUrl, |
| 371 | + "https://github.com/t3tools/turn-remote.git", |
| 372 | + ); |
| 373 | + }).pipe(Effect.provide(layer)); |
| 374 | + }).pipe( |
| 375 | + Effect.provide(ProcessRunner.layer.pipe(Layer.provideMerge(NodeServices.layer))), |
| 376 | + Effect.scoped, |
| 377 | + ), |
| 378 | +); |
| 379 | + |
| 380 | +it.effect("does not force a known identity when only the enrichment cache has expired", () => |
| 381 | + Effect.gen(function* () { |
| 382 | + const threadId = ThreadId.make("thread-known-identity"); |
| 383 | + const projectId = ProjectId.make("project-known-identity"); |
| 384 | + const runId = RunId.make("run-known-identity"); |
| 385 | + const checked = yield* Deferred.make<boolean>(); |
| 386 | + let afterExpiry = false; |
| 387 | + const resolverLayer = Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, { |
| 388 | + resolve: (_cwd, options) => |
| 389 | + Effect.gen(function* () { |
| 390 | + if (afterExpiry) yield* Deferred.succeed(checked, options?.refresh === true); |
| 391 | + return { |
| 392 | + canonicalKey: "github.com/t3tools/known", |
| 393 | + rootPath: "/repo", |
| 394 | + locator: { |
| 395 | + source: "git-remote" as const, |
| 396 | + remoteName: "origin", |
| 397 | + remoteUrl: "https://github.com/t3tools/known.git", |
| 398 | + }, |
| 399 | + }; |
| 400 | + }), |
| 401 | + }); |
| 402 | + const metadata = ProjectEnrichment.layer.pipe( |
| 403 | + Layer.provideMerge(resolverLayer), |
| 404 | + Layer.provide( |
| 405 | + Layer.mock(ProjectFaviconResolver.ProjectFaviconResolver)({ |
| 406 | + resolvePath: () => Effect.succeed(null), |
| 407 | + invalidate: () => Effect.void, |
| 408 | + }), |
| 409 | + ), |
| 410 | + ); |
| 411 | + const layer = RunFinalization.layerObserver.pipe( |
| 412 | + Layer.provideMerge(metadata), |
| 413 | + Layer.provide( |
| 414 | + Layer.mergeAll( |
| 415 | + Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }), |
| 416 | + Layer.mock(PullRequestService.PullRequestService)({ |
| 417 | + refreshAfterTurn: () => Effect.void, |
| 418 | + }), |
| 419 | + Layer.mock(ProjectService.ProjectService)({ |
| 420 | + getById: () => |
| 421 | + Effect.succeedSome({ |
| 422 | + id: projectId, |
| 423 | + title: "Known project", |
| 424 | + workspaceRoot: "/repo", |
| 425 | + repositoryIdentity: null, |
| 426 | + defaultModelSelection: null, |
| 427 | + scripts: [], |
| 428 | + createdAt: "2026-01-01T00:00:00.000Z", |
| 429 | + updatedAt: "2026-01-01T00:00:00.000Z", |
| 430 | + deletedAt: null, |
| 431 | + }), |
| 432 | + }), |
| 433 | + Layer.mock(ProjectionStore.ProjectionStoreV2)({ |
| 434 | + getThreadShell: () => |
| 435 | + Effect.succeed({ id: threadId, projectId } as OrchestrationV2ThreadShell), |
| 436 | + }), |
| 437 | + Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({ |
| 438 | + refreshLocalStatus: () => |
| 439 | + Effect.succeed({ |
| 440 | + isRepo: true, |
| 441 | + hasPrimaryRemote: true, |
| 442 | + isDefaultRef: true, |
| 443 | + refName: "main", |
| 444 | + hasWorkingTreeChanges: false, |
| 445 | + workingTree: { files: [], insertions: 0, deletions: 0 }, |
| 446 | + sourceControlProvider: { |
| 447 | + kind: SourceControlProviderKind.make("github"), |
| 448 | + name: "GitHub", |
| 449 | + baseUrl: "https://github.com", |
| 450 | + }, |
| 451 | + }), |
| 452 | + }), |
| 453 | + ), |
| 454 | + ), |
| 455 | + ); |
| 456 | + yield* Effect.gen(function* () { |
| 457 | + const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService; |
| 458 | + const observer = yield* RunFinalization.RunFinalizationObserver; |
| 459 | + assert.isNotNull(yield* enrichment.readRepositoryIdentity("/repo")); |
| 460 | + yield* TestClock.adjust("1 minute"); |
| 461 | + assert.isNull((yield* enrichment.peek("/repo")).repositoryIdentity); |
| 462 | + afterExpiry = true; |
| 463 | + yield* observer.refresh({ cwd: "/repo", threadId, runId }); |
| 464 | + assert.isFalse(yield* Deferred.await(checked)); |
| 465 | + }).pipe(Effect.provide(layer)); |
| 466 | + }), |
| 467 | +); |
0 commit comments