Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { beforeEach, describe, expect, it, vi } from "vitest";
import {
checkHasAudioTrackViaMediaServer,
extractAudioViaMediaServer,
fetchConvertedVideoViaMediaServer,
isMediaServerConfigured,
probeVideoViaMediaServer,
} from "@/lib/media-client";
vi.mock("@cap/env", () => ({
serverEnv: vi.fn(),
}));
const mockFetch = vi.fn();
global.fetch = mockFetch;
const mediaServerEnv = {
MEDIA_SERVER_URL: "http://localhost:3456",
MEDIA_SERVER_WEBHOOK_SECRET: "test-secret",
};
const mediaServerHeaders = {
"Content-Type": "application/json",
"x-media-server-secret": "test-secret",
};
describe("media-client", () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe("isMediaServerConfigured", () => {
it("returns true when MEDIA_SERVER_URL is set", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue(
mediaServerEnv as ReturnType<typeof serverEnv>,
);
expect(isMediaServerConfigured()).toBe(true);
});
it("returns false when MEDIA_SERVER_URL is not set", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue({
MEDIA_SERVER_URL: undefined,
} as unknown as ReturnType<typeof serverEnv>);
expect(isMediaServerConfigured()).toBe(false);
});
it("returns false when MEDIA_SERVER_URL is empty string", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue({
MEDIA_SERVER_URL: "",
MEDIA_SERVER_WEBHOOK_SECRET: "test-secret",
} as unknown as ReturnType<typeof serverEnv>);
expect(isMediaServerConfigured()).toBe(false);
});
it("returns false when MEDIA_SERVER_WEBHOOK_SECRET is missing", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue({
MEDIA_SERVER_URL: "http://localhost:3456",
MEDIA_SERVER_WEBHOOK_SECRET: undefined,
} as unknown as ReturnType<typeof serverEnv>);
expect(isMediaServerConfigured()).toBe(false);
});
});
describe("checkHasAudioTrackViaMediaServer", () => {
beforeEach(async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue(
mediaServerEnv as ReturnType<typeof serverEnv>,
);
});
it("throws error when MEDIA_SERVER_URL is not configured", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue({
MEDIA_SERVER_URL: undefined,
} as unknown as ReturnType<typeof serverEnv>);
await expect(
checkHasAudioTrackViaMediaServer("https://example.com/video.mp4"),
).rejects.toThrow("MEDIA_SERVER_URL is not configured");
});
it("throws error when MEDIA_SERVER_WEBHOOK_SECRET is not configured", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue({
MEDIA_SERVER_URL: "http://localhost:3456",
MEDIA_SERVER_WEBHOOK_SECRET: undefined,
} as unknown as ReturnType<typeof serverEnv>);
await expect(
checkHasAudioTrackViaMediaServer("https://example.com/video.mp4"),
).rejects.toThrow("MEDIA_SERVER_WEBHOOK_SECRET is not configured");
});
it("returns true when video has audio track", async () => {
mockFetch.mockResolvedValueOnce({
ok: true,
json: async () => ({ hasAudio: true }),
});
const result = await checkHasAudioTrackViaMediaServer(
"https://example.com/video.mp4",
);
expect(result).toBe(true);
expect(mockFetch).toHaveBeenCalledWith(
"http://localhost:3456/audio/check",
{
method: "POST",
headers: mediaServerHeaders,
body: JSON.stringify({ videoUrl: "https://example.com/video.mp4" }),
},
);
});
it("returns false when video has no audio track", async () => {
mockFetch.mockResolvedValueOnce({
ok: true,
json: async () => ({ hasAudio: false }),
});
const result = await checkHasAudioTrackViaMediaServer(
"https://example.com/video.mp4",
);
expect(result).toBe(false);
});
it("throws error when media server returns error", async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
json: async () => ({
error: "FFMPEG_ERROR",
code: "FFMPEG_ERROR",
details: "FFmpeg process failed",
}),
});
await expect(
checkHasAudioTrackViaMediaServer("https://example.com/video.mp4"),
).rejects.toThrow("FFMPEG_ERROR");
});
});
describe("extractAudioViaMediaServer", () => {
beforeEach(async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue(
mediaServerEnv as ReturnType<typeof serverEnv>,
);
});
it("throws error when MEDIA_SERVER_URL is not configured", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue({
MEDIA_SERVER_URL: undefined,
} as unknown as ReturnType<typeof serverEnv>);
await expect(
extractAudioViaMediaServer("https://example.com/video.mp4"),
).rejects.toThrow("MEDIA_SERVER_URL is not configured");
});
it("returns audio buffer when extraction succeeds", async () => {
const mockAudioData = new Uint8Array([0x00, 0x00, 0x00, 0x1c, 0x66]);
mockFetch.mockResolvedValueOnce({
ok: true,
arrayBuffer: async () => mockAudioData.buffer,
});
const result = await extractAudioViaMediaServer(
"https://example.com/video.mp4",
);
expect(result).toBeInstanceOf(Buffer);
expect(result.length).toBe(mockAudioData.length);
expect(mockFetch).toHaveBeenCalledWith(
"http://localhost:3456/audio/extract",
{
method: "POST",
headers: mediaServerHeaders,
body: JSON.stringify({
videoUrl: "https://example.com/video.mp4",
stream: true,
}),
},
);
});
it("throws NO_AUDIO_TRACK error when video has no audio", async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
json: async () => ({
error: "Video has no audio track",
code: "NO_AUDIO_TRACK",
}),
});
await expect(
extractAudioViaMediaServer("https://example.com/video.mp4"),
).rejects.toThrow("NO_AUDIO_TRACK");
});
it("throws error when extraction fails", async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
json: async () => ({
error: "Failed to extract audio",
code: "FFMPEG_ERROR",
details: "FFmpeg process exited with code 1",
}),
});
await expect(
extractAudioViaMediaServer("https://example.com/video.mp4"),
).rejects.toThrow("FFmpeg process exited with code 1");
});
});
describe("probeVideoViaMediaServer", () => {
beforeEach(async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue(
mediaServerEnv as ReturnType<typeof serverEnv>,
);
});
it("returns authoritative media metadata", async () => {
const metadata = {
duration: 42,
width: 1920,
height: 1080,
fps: 30,
videoCodec: "h264",
audioCodec: "aac",
audioChannels: 2,
sampleRate: 48_000,
bitrate: 1_000_000,
fileSize: 5_000_000,
};
mockFetch.mockResolvedValueOnce({
ok: true,
json: async () => ({ metadata }),
});
await expect(
probeVideoViaMediaServer("https://example.com/video.mp4"),
).resolves.toEqual(metadata);
});
it("can disable request retries for synchronous entitlement checks", async () => {
mockFetch.mockResolvedValue({
ok: false,
status: 503,
json: async () => ({
error: "Server is busy",
code: "SERVER_BUSY",
}),
});
await expect(
probeVideoViaMediaServer("https://example.com/video.mp4", {
maxRetries: 0,
}),
).rejects.toThrow("Server is busy");
expect(mockFetch).toHaveBeenCalledTimes(1);
});
});
describe("fetchConvertedVideoViaMediaServer", () => {
beforeEach(async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue(
mediaServerEnv as ReturnType<typeof serverEnv>,
);
});
it("throws error when MEDIA_SERVER_URL is not configured", async () => {
const { serverEnv } = await import("@cap/env");
vi.mocked(serverEnv).mockReturnValue({
MEDIA_SERVER_URL: undefined,
} as unknown as ReturnType<typeof serverEnv>);
await expect(
fetchConvertedVideoViaMediaServer("https://example.com/video.m3u8"),
).rejects.toThrow("MEDIA_SERVER_URL is not configured");
});
it("posts conversion request to the media server", async () => {
const mockResponse = {
ok: true,
status: 200,
} as Response;
mockFetch.mockResolvedValueOnce(mockResponse);
const result = await fetchConvertedVideoViaMediaServer(
"https://example.com/video.m3u8",
".m3u8",
);
expect(result).toBe(mockResponse);
expect(mockFetch).toHaveBeenCalledWith(
"http://localhost:3456/video/convert",
{
method: "POST",
headers: mediaServerHeaders,
body: JSON.stringify({
videoUrl: "https://example.com/video.m3u8",
inputExtension: ".m3u8",
}),
},
);
});
it("does not retry conversion failures that would repeat heavyweight work", async () => {
const mockResponse = {
ok: false,
status: 502,
} as Response;
mockFetch.mockResolvedValueOnce(mockResponse);
const result = await fetchConvertedVideoViaMediaServer(
"https://example.com/video.m3u8",
".m3u8",
);
expect(result).toBe(mockResponse);
expect(mockFetch).toHaveBeenCalledTimes(1);
});
});
});