Skip to content

Commit 05fe05d

Browse files
committed
test(pr): cover cross-client refresh and pending merge notifications
1 parent ec7c2b3 commit 05fe05d

2 files changed

Lines changed: 150 additions & 0 deletions

File tree

‎apps/server/src/pullRequest/PullRequestService.test.ts‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1118,6 +1118,53 @@ it.effect("publishes a merge for immediate settlement only after host confirmati
11181118
),
11191119
);
11201120

1121+
it.effect("refreshes every reader before a queued merge confirmation finishes", () =>
1122+
Effect.scoped(
1123+
Effect.gen(function* () {
1124+
const confirmationStarted = yield* Deferred.make<void>();
1125+
const confirm = yield* Deferred.make<void>();
1126+
const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1127+
const service = yield* makeService({
1128+
projects: [
1129+
project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
1130+
],
1131+
providers: [
1132+
fakeProvider("github", {
1133+
getChangeRequestSummary: () =>
1134+
Effect.gen(function* () {
1135+
yield* Deferred.succeed(confirmationStarted, undefined);
1136+
yield* Deferred.await(confirm);
1137+
return changeRequest(1, "2026-09-16T00:00:00.000Z");
1138+
}),
1139+
}),
1140+
],
1141+
});
1142+
const merges = yield* service.subscribeMerges;
1143+
const observedMerge = yield* Stream.runHead(merges).pipe(
1144+
Effect.forkChild({ startImmediately: true }),
1145+
);
1146+
const readers = yield* Effect.forEach([0, 1], () =>
1147+
Stream.runHead(service.subscribeRefreshes).pipe(
1148+
Effect.forkChild({ startImmediately: true }),
1149+
),
1150+
);
1151+
const action = yield* service
1152+
.runAction({ ...reference, action: "merge" })
1153+
.pipe(Effect.forkChild({ startImmediately: true }));
1154+
yield* Deferred.await(confirmationStarted);
1155+
const revisions = yield* Effect.forEach(readers, (reader) =>
1156+
Fiber.join(reader).pipe(Effect.map(Option.getOrThrow)),
1157+
);
1158+
assert.isAbove(revisions[0]!, 0);
1159+
assert.strictEqual(revisions[0], revisions[1]);
1160+
assert.isUndefined(action.pollUnsafe());
1161+
yield* Deferred.succeed(confirm, undefined);
1162+
yield* Fiber.join(action);
1163+
assert.isUndefined(observedMerge.pollUnsafe());
1164+
}),
1165+
),
1166+
);
1167+
11211168
it.effect("refuses an action this viewer may not take, and says what access it takes", () =>
11221169
Effect.gen(function* () {
11231170
let ran: string | null = null;

‎packages/client-runtime/src/state/pullRequests.test.ts‎

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@ import * as EnvironmentSupervisor from "../connection/supervisor.ts";
3434
import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
3535
import type { RpcSession } from "../rpc/session.ts";
3636
import {
37+
createLinkedPullRequestSummaryAtomFamily,
3738
createPullRequestEnvironmentAtoms,
3839
createPullRequestStackAtomFamily,
3940
} from "./pullRequests.ts";
@@ -808,6 +809,108 @@ it.effect("keeps concurrent diff file reads on different hosts separate", () =>
808809
),
809810
);
810811

812+
it.effect("shares close, reopen, and merge with an untouched client's mounted PR readers", () =>
813+
Effect.scoped(
814+
Effect.gen(function* () {
815+
const revision = yield* SubscriptionRef.make(0);
816+
let state: "open" | "closed" | "merged" = "open";
817+
const client = {
818+
[WS_METHODS.pullRequestsSubscribeRefreshes]: () => SubscriptionRef.changes(revision),
819+
[WS_METHODS.pullRequestsSummary]: () => Effect.sync(() => ({ state })),
820+
[WS_METHODS.pullRequestsDetail]: () => Effect.sync(() => ({ state })),
821+
[WS_METHODS.pullRequestsList]: () =>
822+
Effect.sync(() => ({ entries: [{ number: 1, state }] })),
823+
[WS_METHODS.pullRequestsRunAction]: (input: {
824+
readonly action: "close" | "reopen" | "merge";
825+
}) =>
826+
Effect.gen(function* () {
827+
state =
828+
input.action === "close" ? "closed" : input.action === "merge" ? "merged" : "open";
829+
yield* SubscriptionRef.update(revision, (value) => value + 1);
830+
}),
831+
} as unknown as WsRpcProtocolClient;
832+
const writer = yield* makeTestRuntime(client);
833+
const reader = yield* makeTestRuntime(client);
834+
const target = {
835+
environmentId: TARGET.environmentId,
836+
input: {
837+
projectId: ProjectId.make("project-1"),
838+
host: "github.example.com",
839+
repository: "acme/web",
840+
number: 1,
841+
},
842+
};
843+
const detail = reader.atoms.detail(target);
844+
const summary = createLinkedPullRequestSummaryAtomFamily(
845+
reader.runtime,
846+
reader.atoms.refreshes,
847+
)(target);
848+
const list = reader.atoms.list({
849+
environmentId: TARGET.environmentId,
850+
input: { state: "all" },
851+
});
852+
const unmountDetail = reader.registry.mount(detail);
853+
const unmountSummary = reader.registry.mount(summary);
854+
const unmountList = reader.registry.mount(list);
855+
yield* Effect.addFinalizer(() =>
856+
Effect.sync(() => {
857+
unmountDetail();
858+
unmountSummary();
859+
unmountList();
860+
}),
861+
);
862+
expect((yield* AtomRegistry.getResult(reader.registry, detail)).state).toBe("open");
863+
expect((yield* AtomRegistry.getResult(reader.registry, summary)).state).toBe("open");
864+
expect((yield* AtomRegistry.getResult(reader.registry, list)).entries[0]?.state).toBe("open");
865+
866+
for (const [action, expected] of [
867+
["close", "closed"],
868+
["reopen", "open"],
869+
["merge", "merged"],
870+
] as const) {
871+
const detailChanged = Latch.makeUnsafe();
872+
const summaryChanged = Latch.makeUnsafe();
873+
const listChanged = Latch.makeUnsafe();
874+
const stops = [
875+
reader.registry.subscribe(detail, (result) => {
876+
if (AsyncResult.isSuccess(result) && result.value.state === expected) {
877+
detailChanged.openUnsafe();
878+
}
879+
}),
880+
reader.registry.subscribe(summary, (result) => {
881+
if (AsyncResult.isSuccess(result) && result.value.state === expected) {
882+
summaryChanged.openUnsafe();
883+
}
884+
}),
885+
reader.registry.subscribe(list, (result) => {
886+
if (AsyncResult.isSuccess(result) && result.value.entries[0]?.state === expected) {
887+
listChanged.openUnsafe();
888+
}
889+
}),
890+
];
891+
yield* Effect.addFinalizer(() => Effect.sync(() => stops.forEach((stop) => stop())));
892+
const result = yield* Effect.promise(() =>
893+
writer.atoms.runAction.run(writer.registry, {
894+
...target,
895+
input: { ...target.input, action },
896+
}),
897+
);
898+
expect(AsyncResult.isSuccess(result)).toBe(true);
899+
// The second client receives only the server push: no local refresh or timer tick.
900+
yield* detailChanged.await;
901+
yield* summaryChanged.await;
902+
yield* listChanged.await;
903+
expect((yield* AtomRegistry.getResult(reader.registry, detail)).state).toBe(expected);
904+
expect((yield* AtomRegistry.getResult(reader.registry, summary)).state).toBe(expected);
905+
expect((yield* AtomRegistry.getResult(reader.registry, list)).entries[0]?.state).toBe(
906+
expected,
907+
);
908+
stops.forEach((stop) => stop());
909+
}
910+
}),
911+
),
912+
);
913+
811914
it.effect("refreshes pull request activity after a comment is updated", () =>
812915
Effect.scoped(
813916
Effect.gen(function* () {

0 commit comments

Comments
 (0)