Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import type { ReactNode } from "react";
import TestRenderer, { act } from "react-test-renderer";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
RecordingUploadProvider,
useRecordingUploadActions,
useRecordingUploadDisplayQueue,
useRecordingUploadLibraryRevision,
useRecordingUploads,
} from "./recording-upload-provider";
import type { RecordingUploadJob } from "./recording-upload-queue";
(
globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;
const fileSystemMock = vi.hoisted(() => ({
documentDirectory: "file:///documents/",
deleteAsync: vi.fn(() => Promise.resolve()),
readAsStringAsync: vi.fn(
(): Promise<string> => Promise.reject(new Error("Not found")),
),
writeAsStringAsync: vi.fn((_uri: string, _value: string) =>
Promise.resolve(),
),
}));
const uploadToTarget = vi.hoisted(() => vi.fn(() => Promise.resolve()));
const screenRecordingState = vi.hoisted(() => ({
cancel: vi.fn(() => Promise.resolve()),
getUpdates: vi.fn(),
}));
const authState = vi.hoisted(() => ({
status: "signedIn" as "loading" | "signedIn" | "signedOut",
createRecording: vi.fn(),
createRecordingUploadTargets: vi.fn(),
completeRecording: vi.fn(() => Promise.resolve({ success: true })),
deleteCap: vi.fn(() => Promise.resolve({ success: true })),
getCapStatuses: vi.fn(),
refresh: vi.fn(() => Promise.resolve()),
updateUploadProgress: vi.fn(() => Promise.resolve({ success: true })),
}));
vi.mock("expo-file-system/legacy", () => fileSystemMock);
vi.mock("react-native", () => ({
AppState: {
addEventListener: vi.fn(() => ({ remove: vi.fn() })),
},
}));
vi.mock("@/api/mobile", () => ({ uploadToTarget }));
vi.mock("../../modules/cap-screen-recorder", () => ({
cancelScreenRecording: screenRecordingState.cancel,
getScreenRecordingUpdates: screenRecordingState.getUpdates,
}));
vi.mock("@/auth/AuthContext", () => ({
useAuth: () => ({
status: authState.status,
bootstrap: { activeOrganizationId: "org_123" },
client: authState,
refresh: authState.refresh,
}),
}));
let recordingUploads: ReturnType<typeof useRecordingUploads> | null = null;
let recordingUploadActions: ReturnType<
typeof useRecordingUploadActions
> | null = null;
let displayQueue: ReturnType<typeof useRecordingUploadDisplayQueue> | null =
null;
let libraryRevision: number | null = null;
let actionRenderCount = 0;
let displayQueueRenderCount = 0;
let libraryRevisionRenderCount = 0;
function Harness({ children }: { children?: ReactNode }) {
recordingUploads = useRecordingUploads();
return children;
}
function SubscriptionHarness() {
recordingUploadActions = useRecordingUploadActions();
actionRenderCount += 1;
displayQueue = useRecordingUploadDisplayQueue();
displayQueueRenderCount += 1;
libraryRevision = useRecordingUploadLibraryRevision();
libraryRevisionRenderCount += 1;
return null;
}
const flushQueue = async () => {
for (let index = 0; index < 12; index += 1) {
await act(async () => {
await Promise.resolve();
});
}
};
const uploadedRecording: RecordingUploadJob = {
id: "cap_123",
shareUrl: "https://cap.so/s/cap_123",
createdAt: "2026-07-23T08:00:00.000Z",
status: "processing",
durationSeconds: 2,
totalBytes: 626_000,
uploadedBytes: 626_000,
uploadOwner: "app",
serverPhase: null,
processingProgress: 0,
processingMessage: null,
error: null,
retryCount: 0,
segments: [
{
track: "video",
type: "initialization",
index: 0,
uri: "file:///recording/video_init.mp4",
durationSeconds: 0,
byteLength: 1_000,
uploaded: true,
},
{
track: "video",
type: "media",
index: 1,
uri: "file:///recording/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
uploaded: true,
},
],
};
describe("RecordingUploadProvider", () => {
let recoveryRenderer: ReturnType<typeof TestRenderer.create> | null = null;
const mountRecoveryProvider = async () => {
await act(async () => {
recoveryRenderer = TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
};
afterEach(async () => {
await act(async () => {
recoveryRenderer?.unmount();
recoveryRenderer = null;
});
vi.useRealTimers();
});
beforeEach(() => {
recordingUploads = null;
recordingUploadActions = null;
displayQueue = null;
libraryRevision = null;
actionRenderCount = 0;
displayQueueRenderCount = 0;
libraryRevisionRenderCount = 0;
fileSystemMock.deleteAsync.mockClear();
fileSystemMock.readAsStringAsync.mockReset();
fileSystemMock.readAsStringAsync.mockRejectedValue(new Error("Not found"));
fileSystemMock.writeAsStringAsync.mockReset();
fileSystemMock.writeAsStringAsync.mockResolvedValue(undefined);
uploadToTarget.mockClear();
screenRecordingState.cancel.mockClear();
screenRecordingState.getUpdates.mockReset();
authState.createRecording.mockReset();
authState.createRecording.mockResolvedValue({
id: "cap_123",
shareUrl: "https://cap.so/s/cap_123",
});
authState.createRecordingUploadTargets.mockReset();
authState.createRecordingUploadTargets.mockImplementation(
(_id: string, subpaths: string[]) =>
Promise.resolve({
uploads: Object.fromEntries(
subpaths.map((subpath) => [
subpath,
{
type: "put",
url: `https://uploads.example/${subpath}`,
headers: { "Content-Type": "video/mp4" },
},
]),
),
}),
);
authState.status = "signedIn";
authState.completeRecording.mockReset();
authState.completeRecording.mockResolvedValue({ success: true });
authState.deleteCap.mockClear();
authState.getCapStatuses.mockReset();
authState.getCapStatuses.mockImplementation((ids: readonly string[]) =>
Promise.resolve({
caps: ids.map((id) => ({ id, upload: null })),
}),
);
authState.refresh.mockClear();
authState.updateUploadProgress.mockClear();
});
it.each([false, true])(
"resumes interrupted completion after restart when the server accepted it: %s",
async (acceptedBeforeRestart) => {
vi.useFakeTimers();
let persisted = "";
fileSystemMock.writeAsStringAsync.mockImplementation(
(_uri: string, value: string) => {
persisted = value;
return Promise.resolve();
},
);
let accepted = false;
authState.getCapStatuses.mockImplementation(async () => ({
caps: [
{
id: "cap_123",
upload: {
uploaded: 626_000,
total: 626_000,
phase: accepted ? "processing" : "uploading",
processingProgress: 0,
processingMessage: null,
processingError: null,
},
},
],
}));
authState.completeRecording.mockImplementationOnce(() => {
accepted = acceptedBeforeRestart;
return new Promise<never>(() => {});
});
await mountRecoveryProvider();
await act(async () => {
await recordingUploads?.beginRecording({
fileName: "Cap Recording.mp4",
width: 720,
height: 1280,
fps: 30,
});
for (const segment of uploadedRecording.segments) {
recordingUploads?.addSegment("cap_123", segment);
}
recordingUploads?.finishRecording("cap_123", {
durationSeconds: 2,
totalBytes: 626_000,
});
});
await flushQueue();
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
expect(uploadToTarget).toHaveBeenCalledTimes(2);
expect(fileSystemMock.deleteAsync).not.toHaveBeenCalled();
const persistedBeforeRestart = persisted;
const firstRequest = authState.completeRecording.mock.calls[0];
await act(async () => recoveryRenderer?.unmount());
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(persisted);
authState.completeRecording.mockImplementation(async () => {
accepted = true;
return { success: true };
});
await mountRecoveryProvider();
expect(authState.completeRecording).toHaveBeenCalledTimes(2);
expect(authState.completeRecording.mock.calls[1]).toEqual(firstRequest);
expect(JSON.parse(persistedBeforeRestart)).toMatchObject({
jobs: [
{
status: "uploading",
serverPhase: null,
segments: [{ uploaded: true }, { uploaded: true }],
},
],
});
expect(uploadToTarget).toHaveBeenCalledTimes(2);
expect(recordingUploads?.queue.jobs[0]?.status).toBe("processing");
expect(fileSystemMock.deleteAsync).toHaveBeenCalledWith(
"file:///recording",
{ idempotent: true },
);
await act(async () => {
await vi.advanceTimersByTimeAsync(30_000);
});
expect(authState.completeRecording).toHaveBeenCalledTimes(2);
authState.getCapStatuses.mockResolvedValue({
caps: [{ id: "cap_123", upload: null }],
});
await act(async () => {
await vi.advanceTimersByTimeAsync(3000);
});
expect(recordingUploads?.queue.jobs[0]?.status).toBe("complete");
await act(async () => {
await vi.advanceTimersByTimeAsync(4000);
});
expect(recordingUploads?.queue.jobs).toEqual([]);
},
);
it.each([
{ serverPhase: null, durationSeconds: 2 },
{ serverPhase: "uploading", durationSeconds: 2 },
{ serverPhase: null, durationSeconds: null },
{ serverPhase: "uploading", durationSeconds: null },
] as const)(
"recovers uploaded recording media with saved state %j once per launch",
async ({ serverPhase, durationSeconds }) => {
vi.useFakeTimers();
let persisted = "";
fileSystemMock.writeAsStringAsync.mockImplementation(
(_uri: string, value: string) => {
persisted = value;
return Promise.resolve();
},
);
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
JSON.stringify({
jobs: [
{
...uploadedRecording,
status: serverPhase === null ? "processing" : "uploading",
serverPhase,
durationSeconds,
},
],
}),
);
authState.getCapStatuses.mockResolvedValue({
caps: [
{
id: "cap_123",
upload: {
uploaded: 626_000,
total: 626_000,
phase: "uploading",
processingProgress: 0,
processingMessage: null,
processingError: null,
},
},
],
});
await mountRecoveryProvider();
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
expect(authState.completeRecording).toHaveBeenCalledWith(
"cap_123",
expect.objectContaining({ durationSeconds: 2 }),
);
expect(uploadToTarget).not.toHaveBeenCalled();
await act(async () => {
await vi.advanceTimersByTimeAsync(30_000);
});
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
await act(async () => recoveryRenderer?.unmount());
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(persisted);
await mountRecoveryProvider();
expect(authState.completeRecording).toHaveBeenCalledTimes(2);
expect(authState.completeRecording.mock.calls[1]).toEqual(
authState.completeRecording.mock.calls[0],
);
expect(uploadToTarget).not.toHaveBeenCalled();
},
);
it.each([
{ uploadOwner: "external", serverPhase: null },
{ serverPhase: "processing" },
{ serverPhase: "generating_thumbnail" },
{ status: "complete" },
{ segments: [] },
{
segments: uploadedRecording.segments.map((segment) => ({
...segment,
uploaded: false,
})),
},
] satisfies Partial<RecordingUploadJob>[])(
"preserves startup upload ownership and processing: %j",
async (overrides) => {
vi.useFakeTimers();
const job = { ...uploadedRecording, ...overrides };
authState.getCapStatuses.mockImplementation(
() => new Promise<never>(() => {}),
);
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
JSON.stringify({ jobs: [job] }),
);
screenRecordingState.getUpdates.mockResolvedValue({
status: "uploading",
durationSeconds: 2,
totalBytes: 626_000,
segments: [],
});
await mountRecoveryProvider();
expect(recordingUploads?.queue.jobs[0]).toMatchObject({
status: job.status,
serverPhase: job.serverPhase,
uploadOwner: job.uploadOwner,
});
expect(authState.completeRecording).not.toHaveBeenCalled();
expect(uploadToTarget).not.toHaveBeenCalled();
},
);
it.each(["loading", "signedOut"] as const)(
"does not recover a camera completion while auth is %s",
async (status) => {
vi.useFakeTimers();
authState.status = status;
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
JSON.stringify({ jobs: [uploadedRecording] }),
);
await mountRecoveryProvider();
expect(authState.completeRecording).not.toHaveBeenCalled();
expect(uploadToTarget).not.toHaveBeenCalled();
if (status === "signedOut") {
expect(recordingUploads?.queue.jobs).toEqual([]);
return;
}
expect(recordingUploads?.queue.jobs[0]?.status).toBe("uploading");
authState.status = "signedIn";
await act(async () => {
recoveryRenderer?.update(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
},
);
it("does not restore a discarded recovery when completion responds late", async () => {
vi.useFakeTimers();
let acknowledge: (() => void) | undefined;
authState.completeRecording.mockImplementationOnce(
() =>
new Promise((resolve) => {
acknowledge = () => resolve({ success: true });
}),
);
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
JSON.stringify({ jobs: [uploadedRecording] }),
);
await mountRecoveryProvider();
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
expect(fileSystemMock.deleteAsync).not.toHaveBeenCalled();
await act(async () => recordingUploads?.discardRecording("cap_123"));
expect(authState.deleteCap).toHaveBeenCalledWith("cap_123");
await act(async () => acknowledge?.());
await flushQueue();
await act(async () => {
await vi.advanceTimersByTimeAsync(30_000);
});
expect(recordingUploads?.queue.jobs).toEqual([]);
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
});
it("keeps high-frequency segment progress out of unrelated subscriptions", async () => {
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<SubscriptionHarness />
</RecordingUploadProvider>,
);
});
await flushQueue();
await act(async () => {
await recordingUploadActions?.beginRecording({
fileName: "Cap Recording.mp4",
width: 720,
height: 1280,
fps: 30,
});
});
const rendersAfterBegin = {
actions: actionRenderCount,
displayQueue: displayQueueRenderCount,
libraryRevision: libraryRevisionRenderCount,
};
await act(async () => {
recordingUploadActions?.addSegment("cap_123", {
track: "video",
type: "initialization",
index: 0,
uri: "file:///recording/video_init.mp4",
durationSeconds: 0,
byteLength: 1_000,
});
recordingUploadActions?.addSegment("cap_123", {
track: "video",
type: "media",
index: 1,
uri: "file:///recording/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
});
});
await flushQueue();
expect(uploadToTarget).toHaveBeenCalledTimes(2);
expect(displayQueue?.jobs).toEqual([]);
expect(libraryRevision).toBe(1);
expect(actionRenderCount).toBe(rendersAfterBegin.actions);
expect(displayQueueRenderCount).toBe(rendersAfterBegin.displayQueue);
expect(libraryRevisionRenderCount).toBe(rendersAfterBegin.libraryRevision);
});
it("uploads separate camera and microphone fragments before recording finishes", async () => {
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
await act(async () => {
await recordingUploads?.beginRecording({
fileName: "Cap Recording.mp4",
width: 720,
height: 1280,
fps: 30,
});
});
expect(recordingUploads?.libraryRevision).toBe(1);
await act(async () => {
recordingUploads?.addSegment("cap_123", {
track: "video",
type: "initialization",
index: 0,
uri: "file:///recording/video_init.mp4",
durationSeconds: 0,
byteLength: 1_000,
});
recordingUploads?.addSegment("cap_123", {
track: "video",
type: "media",
index: 1,
uri: "file:///recording/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
});
recordingUploads?.addSegment("cap_123", {
track: "audio",
type: "initialization",
index: 0,
uri: "file:///recording/audio_init.mp4",
durationSeconds: 0,
byteLength: 500,
});
recordingUploads?.addSegment("cap_123", {
track: "audio",
type: "media",
index: 1,
uri: "file:///recording/audio_segment_001.m4s",
durationSeconds: 2,
byteLength: 24_000,
});
});
await flushQueue();
expect(uploadToTarget).toHaveBeenCalledTimes(4);
expect(authState.completeRecording).not.toHaveBeenCalled();
act(() => {
recordingUploads?.finishRecording("cap_123", {
durationSeconds: 2,
totalBytes: 650_500,
});
});
await flushQueue();
expect(authState.completeRecording).toHaveBeenCalledWith("cap_123", {
durationSeconds: 2,
totalBytes: 650_500,
videoSegments: [{ index: 1, duration: 2 }],
audioSegments: [{ index: 1, duration: 2 }],
});
expect(fileSystemMock.deleteAsync).toHaveBeenCalledWith(
"file:///recording",
{ idempotent: true },
);
expect(recordingUploads?.libraryRevision).toBe(3);
});
it("does not resubmit a recording while the server is still processing it", async () => {
vi.useFakeTimers();
let renderer: ReturnType<typeof TestRenderer.create> | null = null;
try {
authState.getCapStatuses.mockResolvedValue({
caps: [
{
id: "cap_123",
upload: {
uploaded: 626_000,
total: 626_000,
phase: "uploading",
processingProgress: 0,
processingMessage: null,
processingError: null,
},
},
],
});
await act(async () => {
renderer = TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
await act(async () => {
await recordingUploads?.beginRecording({
fileName: "Cap Recording.mp4",
width: 720,
height: 1280,
fps: 30,
});
recordingUploads?.addSegment("cap_123", {
track: "video",
type: "initialization",
index: 0,
uri: "file:///recording/video_init.mp4",
durationSeconds: 0,
byteLength: 1_000,
});
recordingUploads?.addSegment("cap_123", {
track: "video",
type: "media",
index: 1,
uri: "file:///recording/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
});
});
await flushQueue();
act(() => {
recordingUploads?.finishRecording("cap_123", {
durationSeconds: 2,
totalBytes: 626_000,
});
});
await flushQueue();
expect(recordingUploads?.queue.jobs[0]).toMatchObject({
status: "uploading",
serverPhase: "uploading",
});
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
authState.getCapStatuses.mockResolvedValue({
caps: [{ id: "cap_123", upload: null }],
});
await act(async () => {
await vi.advanceTimersByTimeAsync(3000);
await flushQueue();
});
expect(recordingUploads?.queue.jobs[0]?.status).toBe("complete");
expect(authState.completeRecording).toHaveBeenCalledTimes(1);
} finally {
await act(async () => {
renderer?.unmount();
});
vi.useRealTimers();
}
});
it("does not start app uploads for externally owned screen fragments", async () => {
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
await act(async () => {
await recordingUploads?.beginRecording({
fileName: "Cap Screen Recording.mp4",
width: 720,
height: 1280,
fps: 30,
uploadOwner: "external",
});
recordingUploads?.addSegment("cap_123", {
track: "video",
type: "media",
index: 1,
uri: "file:///private/app/CapScreenRecordings/cap_123/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
});
});
await flushQueue();
expect(authState.createRecordingUploadTargets).not.toHaveBeenCalled();
expect(uploadToTarget).not.toHaveBeenCalled();
expect(recordingUploads?.queue.jobs[0]?.uploadOwner).toBe("external");
});
it("keeps native screen uploads visible until server processing finishes", async () => {
vi.useFakeTimers();
let renderer: ReturnType<typeof TestRenderer.create> | null = null;
try {
screenRecordingState.getUpdates.mockResolvedValue({
status: "uploading",
segments: [],
durationSeconds: 8,
totalBytes: 1_900_000,
error: null,
});
authState.getCapStatuses.mockResolvedValue({
caps: [
{
id: "cap_123",
upload: {
uploaded: 1_900_000,
total: 1_900_000,
phase: "processing",
processingProgress: 42,
processingMessage: "Muxing segments into MP4...",
processingError: null,
},
},
],
});
await act(async () => {
renderer = TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
await act(async () => {
await recordingUploads?.beginRecording({
fileName: "Cap Screen Recording.mp4",
width: 720,
height: 1280,
fps: 30,
uploadOwner: "external",
});
});
await flushQueue();
expect(recordingUploads?.queue.jobs[0]).toMatchObject({
status: "processing",
serverPhase: "processing",
processingProgress: 42,
processingMessage: "Muxing segments into MP4...",
});
authState.getCapStatuses.mockResolvedValue({
caps: [{ id: "cap_123", upload: null }],
});
await act(async () => {
await vi.advanceTimersByTimeAsync(3000);
await flushQueue();
});
expect(recordingUploads?.queue.jobs[0]?.status).toBe("complete");
expect(screenRecordingState.cancel).toHaveBeenCalledWith("cap_123");
} finally {
await act(async () => {
renderer?.unmount();
});
vi.useRealTimers();
}
});
it("restores a completed legacy screen upload as ready", async () => {
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
JSON.stringify({
jobs: [
{
id: "cap_screen",
shareUrl: "https://cap.so/s/cap_screen",
createdAt: "2026-07-23T08:00:00.000Z",
status: "uploading",
durationSeconds: 8,
totalBytes: 1_900_000,
retryCount: 0,
segments: [
{
track: "video",
type: "media",
index: 1,
uri: "file:///private/app/CapScreenRecordings/cap_screen/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
uploaded: false,
},
],
},
],
}),
);
screenRecordingState.getUpdates.mockResolvedValueOnce({
status: "uploaded",
segments: [],
durationSeconds: 8,
totalBytes: 1_900_000,
error: null,
});
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
expect(screenRecordingState.getUpdates).toHaveBeenCalledWith("cap_screen");
expect(recordingUploads?.queue.jobs[0]).toMatchObject({
id: "cap_screen",
status: "complete",
});
expect(authState.createRecordingUploadTargets).not.toHaveBeenCalled();
expect(uploadToTarget).not.toHaveBeenCalled();
expect(fileSystemMock.writeAsStringAsync).toHaveBeenCalledWith(
"file:///documents/recording-upload-queue.json",
expect.stringContaining('"status":"complete"'),
);
expect(screenRecordingState.cancel).toHaveBeenCalledWith("cap_screen");
});
it("takes over a screen upload only after native capture gives it back", async () => {
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
JSON.stringify({
jobs: [
{
id: "cap_screen",
shareUrl: "https://cap.so/s/cap_screen",
createdAt: "2026-07-23T08:00:00.000Z",
status: "recording",
durationSeconds: null,
totalBytes: 0,
retryCount: 0,
segments: [],
uploadOwner: "external",
},
],
}),
);
screenRecordingState.getUpdates.mockResolvedValueOnce({
status: "finished",
segments: [
{
track: "video",
type: "initialization",
index: 0,
uri: "file:///private/app/CapScreenRecordings/cap_screen/video_init.mp4",
durationSeconds: 0,
byteLength: 1_000,
},
{
track: "video",
type: "media",
index: 1,
uri: "file:///private/app/CapScreenRecordings/cap_screen/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
},
],
durationSeconds: 2,
totalBytes: 626_000,
error: "The screen upload server was unavailable.",
});
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
expect(uploadToTarget).toHaveBeenCalledTimes(2);
expect(authState.completeRecording).toHaveBeenCalledWith("cap_screen", {
durationSeconds: 2,
totalBytes: 626_000,
videoSegments: [{ index: 1, duration: 2 }],
audioSegments: [],
});
expect(recordingUploads?.queue.jobs[0]).toMatchObject({
status: "complete",
uploadOwner: "app",
});
});
it("shows active native screen capture on Home without exposing camera recording", async () => {
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<SubscriptionHarness />
</RecordingUploadProvider>,
);
});
await flushQueue();
await act(async () => {
await recordingUploadActions?.beginRecording({
fileName: "Cap Recording.mp4",
width: 720,
height: 1280,
fps: 30,
uploadOwner: "external",
});
});
expect(displayQueue?.jobs).toHaveLength(1);
expect(displayQueue?.jobs[0]).toMatchObject({
id: "cap_123",
status: "recording",
uploadOwner: "external",
});
});
it("cleans up a screen recording cancelled in the system picker", async () => {
fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
JSON.stringify({
jobs: [
{
id: "cap_screen",
shareUrl: "https://cap.so/s/cap_screen",
createdAt: "2026-07-23T08:00:00.000Z",
status: "recording",
durationSeconds: null,
totalBytes: 0,
retryCount: 0,
segments: [],
uploadOwner: "external",
},
],
}),
);
screenRecordingState.getUpdates.mockResolvedValueOnce({
status: "cancelled",
segments: [],
durationSeconds: null,
totalBytes: 0,
error: null,
});
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
expect(recordingUploads?.queue.jobs).toEqual([]);
expect(screenRecordingState.cancel).toHaveBeenCalledWith("cap_screen");
expect(authState.deleteCap).toHaveBeenCalledWith("cap_screen");
});
it("dismisses a completed recording without deleting the cap", async () => {
await act(async () => {
TestRenderer.create(
<RecordingUploadProvider>
<Harness />
</RecordingUploadProvider>,
);
});
await flushQueue();
await act(async () => {
await recordingUploads?.beginRecording({
fileName: "Cap Recording.mp4",
width: 720,
height: 1280,
fps: 30,
});
});
await act(async () => {
recordingUploads?.addSegment("cap_123", {
track: "video",
type: "initialization",
index: 0,
uri: "file:///recording/video_init.mp4",
durationSeconds: 0,
byteLength: 1_000,
});
recordingUploads?.addSegment("cap_123", {
track: "video",
type: "media",
index: 1,
uri: "file:///recording/video_segment_001.m4s",
durationSeconds: 2,
byteLength: 625_000,
});
});
await flushQueue();
act(() => {
recordingUploads?.finishRecording("cap_123", {
durationSeconds: 2,
totalBytes: 626_000,
});
});
await flushQueue();
expect(
recordingUploads?.queue.jobs.find((job) => job.id === "cap_123")?.status,
).toBe("complete");
act(() => {
recordingUploads?.dismissRecording("cap_123");
});
await flushQueue();
expect(
recordingUploads?.queue.jobs.some((job) => job.id === "cap_123"),
).toBe(false);
expect(authState.deleteCap).not.toHaveBeenCalled();
});
});