Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

24.0 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from "vitest";

vi.mock("@cap/database", () => {
	const mockDb = {
		select: vi.fn(() => mockDb),
		insert: vi.fn(() => mockDb),
		update: vi.fn(() => mockDb),
		delete: vi.fn(() => mockDb),
		from: vi.fn(() => mockDb),
		set: vi.fn(() => mockDb),
		where: vi.fn(() => mockDb),
		limit: vi.fn(() => Promise.resolve([])),
		values: vi.fn(() => Promise.resolve()),
		transaction: vi.fn((fn) => fn(mockDb)),
		leftJoin: vi.fn(() => mockDb),
		orderBy: vi.fn(() => mockDb),
		offset: vi.fn(() => mockDb),
	};
	return {
		db: () => mockDb,
		__mockDb: mockDb,
	};
});

vi.mock("@cap/database/auth/session", () => ({
	getCurrentUser: vi.fn(),
}));

vi.mock("@cap/database/helpers", () => ({
	nanoId: vi.fn(() => "test-nano-id"),
	nanoIdLong: vi.fn(() => "test-nano-id-long-value"),
}));

vi.mock("@cap/database/crypto", () => ({
	encrypt: vi.fn(async (value: string) => `encrypted:${value}`),
}));

vi.mock("@cap/database/schema", () => ({
	developerApps: {
		id: "id",
		ownerId: "ownerId",
		deletedAt: "deletedAt",
	},
	developerApiKeys: {
		id: "id",
		appId: "appId",
		keyType: "keyType",
		keyPrefix: "keyPrefix",
		keyHash: "keyHash",
		encryptedKey: "encryptedKey",
		revokedAt: "revokedAt",
	},
	developerAppDomains: {
		id: "id",
		appId: "appId",
		domain: "domain",
	},
	developerVideos: {
		id: "id",
		appId: "appId",
		deletedAt: "deletedAt",
	},
	developerCreditAccounts: {
		id: "id",
		appId: "appId",
		balanceMicroCredits: "balanceMicroCredits",
		autoTopUpEnabled: "autoTopUpEnabled",
		autoTopUpThresholdMicroCredits: "autoTopUpThresholdMicroCredits",
		autoTopUpAmountCents: "autoTopUpAmountCents",
	},
	developerCreditTransactions: {},
}));

vi.mock("@/lib/developer-key-hash", () => ({
	hashKey: vi.fn(() => Promise.resolve("mocked-hash-value")),
}));

vi.mock("next/cache", () => ({
	revalidatePath: vi.fn(),
}));

vi.mock("drizzle-orm", () => ({
	and: vi.fn((...args: unknown[]) => args),
	eq: vi.fn((field: unknown, value: unknown) => ({ field, value })),
	isNull: vi.fn((field: unknown) => ({ isNull: field })),
	sql: vi.fn(),
}));

import * as capDatabase from "@cap/database";
import { getCurrentUser } from "@cap/database/auth/session";

const mockGetCurrentUser = getCurrentUser as ReturnType<typeof vi.fn>;

type MockFn = ReturnType<typeof vi.fn>;
interface MockDb {
	select: MockFn;
	insert: MockFn;
	update: MockFn;
	delete: MockFn;
	from: MockFn;
	set: MockFn;
	where: MockFn;
	limit: MockFn;
	values: MockFn;
	transaction: MockFn;
	leftJoin: MockFn;
	orderBy: MockFn;
	offset: MockFn;
	[key: string]: MockFn | undefined;
}

const mockDb = (capDatabase as unknown as { __mockDb: MockDb }).__mockDb;

const mockUser = { id: "user-123", email: "[email protected]" };
const mockApp = {
	id: "app-456",
	ownerId: "user-123",
	name: "Test App",
	environment: "development",
	deletedAt: null,
};

function resetMockDb() {
	for (const key of Object.keys(mockDb)) {
		const fn = mockDb[key];
		if (fn && typeof fn.mockClear === "function") {
			fn.mockClear();
		}
	}
	mockDb.select.mockReturnValue(mockDb);
	mockDb.insert.mockReturnValue(mockDb);
	mockDb.update.mockReturnValue(mockDb);
	mockDb.delete.mockReturnValue(mockDb);
	mockDb.from.mockReturnValue(mockDb);
	mockDb.set.mockReturnValue(mockDb);
	mockDb.where.mockReturnValue(mockDb);
	mockDb.limit.mockReturnValue(Promise.resolve([]));
	mockDb.values.mockReturnValue(Promise.resolve());
	mockDb.leftJoin.mockReturnValue(mockDb);
	mockDb.orderBy.mockReturnValue(mockDb);
	mockDb.offset.mockReturnValue(mockDb);
	mockDb.transaction.mockImplementation((fn) => fn(mockDb));
}

describe("createDeveloperApp", () => {
	let createDeveloperApp: typeof import("@/actions/developers/create-app").createDeveloperApp;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/create-app");
		createDeveloperApp = mod.createDeveloperApp;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(
			createDeveloperApp({ name: "Test", environment: "development" }),
		).rejects.toThrow("Unauthorized");
	});

	it("throws App name is required when empty name", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await expect(
			createDeveloperApp({ name: "", environment: "development" }),
		).rejects.toThrow("App name is required");
	});

	it("throws App name is required when whitespace-only name", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await expect(
			createDeveloperApp({ name: "   ", environment: "development" }),
		).rejects.toThrow("App name is required");
	});

	it("creates app with trimmed name", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await createDeveloperApp({
			name: "  My App  ",
			environment: "production",
		});

		expect(mockDb.insert).toHaveBeenCalled();
		const firstValuesCall = mockDb.values.mock.calls[0]?.[0];
		expect(firstValuesCall).toMatchObject({
			name: "My App",
			environment: "production",
			ownerId: "user-123",
		});
	});

	it("creates public key with cpk_ prefix", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		const result = await createDeveloperApp({
			name: "Test",
			environment: "development",
		});
		expect(result.publicKey).toMatch(/^cpk_/);
	});

	it("creates secret key with csk_ prefix", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		const result = await createDeveloperApp({
			name: "Test",
			environment: "development",
		});
		expect(result.secretKey).toMatch(/^csk_/);
	});

	it("creates credit account alongside app", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await createDeveloperApp({
			name: "Test",
			environment: "development",
		});

		expect(mockDb.insert).toHaveBeenCalledTimes(3);
	});

	it("returns appId, publicKey, secretKey", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		const result = await createDeveloperApp({
			name: "Test",
			environment: "development",
		});

		expect(result).toHaveProperty("appId");
		expect(result).toHaveProperty("publicKey");
		expect(result).toHaveProperty("secretKey");
		expect(result.appId).toBe("test-nano-id");
	});

	it("public key prefix is first 12 chars", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		const result = await createDeveloperApp({
			name: "Test",
			environment: "development",
		});

		const expectedPrefix = result.publicKey.slice(0, 12);
		const keysValuesCall = mockDb.values.mock.calls[1]?.[0];
		const publicKeyEntry = keysValuesCall.find(
			(entry: Record<string, unknown>) => entry.keyType === "public",
		);
		expect(publicKeyEntry.keyPrefix).toBe(expectedPrefix);
	});
});

describe("deleteDeveloperApp", () => {
	let deleteDeveloperApp: typeof import("@/actions/developers/delete-app").deleteDeveloperApp;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/delete-app");
		deleteDeveloperApp = mod.deleteDeveloperApp;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(deleteDeveloperApp("app-456")).rejects.toThrow("Unauthorized");
	});

	it("throws App not found when app does not exist", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValue([]);
		await expect(deleteDeveloperApp("app-456")).rejects.toThrow(
			"App not found",
		);
	});

	it("soft deletes by setting deletedAt", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await deleteDeveloperApp("app-456");

		expect(mockDb.update).toHaveBeenCalled();
		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ deletedAt: expect.any(Date) }),
		);
	});

	it("returns success true", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await deleteDeveloperApp("app-456");
		expect(result).toEqual({ success: true });
	});
});

describe("updateDeveloperApp", () => {
	let updateDeveloperApp: typeof import("@/actions/developers/update-app").updateDeveloperApp;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/update-app");
		updateDeveloperApp = mod.updateDeveloperApp;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(
			updateDeveloperApp({ appId: "app-456", name: "New" }),
		).rejects.toThrow("Unauthorized");
	});

	it("throws App not found when app does not exist", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValue([]);
		await expect(
			updateDeveloperApp({ appId: "app-456", name: "New" }),
		).rejects.toThrow("App not found");
	});

	it("updates name when provided", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await updateDeveloperApp({ appId: "app-456", name: "Updated Name" });

		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ name: "Updated Name" }),
		);
	});

	it("updates environment when provided", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await updateDeveloperApp({
			appId: "app-456",
			environment: "production",
		});

		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ environment: "production" }),
		);
	});

	it("trims name before saving", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await updateDeveloperApp({ appId: "app-456", name: "  Trimmed  " });

		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ name: "Trimmed" }),
		);
	});

	it("skips update when no fields provided", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await updateDeveloperApp({ appId: "app-456" });

		expect(mockDb.update).not.toHaveBeenCalled();
	});

	it("returns success true", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await updateDeveloperApp({
			appId: "app-456",
			name: "New",
		});
		expect(result).toEqual({ success: true });
	});
});

describe("addDeveloperDomain", () => {
	let addDeveloperDomain: typeof import("@/actions/developers/add-domain").addDeveloperDomain;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/add-domain");
		addDeveloperDomain = mod.addDeveloperDomain;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(
			addDeveloperDomain("app-456", "https://example.com"),
		).rejects.toThrow("Unauthorized");
	});

	it("throws Domain is required when empty", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await expect(addDeveloperDomain("app-456", "")).rejects.toThrow(
			"Domain is required",
		);
	});

	it("throws Domain is required when whitespace only", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await expect(addDeveloperDomain("app-456", "   ")).rejects.toThrow(
			"Domain is required",
		);
	});

	it("validates domain format with regex", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await expect(addDeveloperDomain("app-456", "not-a-url")).rejects.toThrow(
			"Domain must be a valid origin (e.g. https://myapp.com)",
		);
	});

	it("accepts https://example.com", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await addDeveloperDomain("app-456", "https://example.com");
		expect(result).toEqual({ success: true });
	});

	it("accepts http://localhost:3000", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await addDeveloperDomain("app-456", "http://localhost:3000");
		expect(result).toEqual({ success: true });
	});

	it("rejects invalid domains without protocol", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await expect(addDeveloperDomain("app-456", "example.com")).rejects.toThrow(
			"Domain must be a valid origin (e.g. https://myapp.com)",
		);
	});

	it("rejects bare hostnames", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		await expect(
			addDeveloperDomain("app-456", "just-hostname"),
		).rejects.toThrow("Domain must be a valid origin (e.g. https://myapp.com)");
	});

	it("normalizes to lowercase", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await addDeveloperDomain("app-456", "HTTPS://EXAMPLE.COM");

		expect(mockDb.values).toHaveBeenCalledWith(
			expect.objectContaining({ domain: "https://example.com" }),
		);
	});

	it("returns success true", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await addDeveloperDomain("app-456", "https://example.com");
		expect(result).toEqual({ success: true });
	});
});

describe("removeDeveloperDomain", () => {
	let removeDeveloperDomain: typeof import("@/actions/developers/remove-domain").removeDeveloperDomain;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/remove-domain");
		removeDeveloperDomain = mod.removeDeveloperDomain;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(
			removeDeveloperDomain("app-456", "domain-789"),
		).rejects.toThrow("Unauthorized");
	});

	it("throws App not found when app does not exist", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValue([]);
		await expect(
			removeDeveloperDomain("app-456", "domain-789"),
		).rejects.toThrow("App not found");
	});

	it("deletes domain record", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await removeDeveloperDomain("app-456", "domain-789");

		expect(mockDb.delete).toHaveBeenCalled();
	});

	it("returns success true", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await removeDeveloperDomain("app-456", "domain-789");
		expect(result).toEqual({ success: true });
	});
});

describe("regenerateDeveloperKeys", () => {
	let regenerateDeveloperKeys: typeof import("@/actions/developers/regenerate-keys").regenerateDeveloperKeys;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/regenerate-keys");
		regenerateDeveloperKeys = mod.regenerateDeveloperKeys;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(regenerateDeveloperKeys("app-456")).rejects.toThrow(
			"Unauthorized",
		);
	});

	it("throws App not found when app does not exist", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValue([]);
		await expect(regenerateDeveloperKeys("app-456")).rejects.toThrow(
			"App not found",
		);
	});

	it("revokes all existing active keys", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await regenerateDeveloperKeys("app-456");

		expect(mockDb.update).toHaveBeenCalled();
		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ revokedAt: expect.any(Date) }),
		);
	});

	it("creates new public and secret keys", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await regenerateDeveloperKeys("app-456");

		expect(result.publicKey).toMatch(/^cpk_/);
		expect(result.secretKey).toMatch(/^csk_/);
	});

	it("returns new publicKey and secretKey", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await regenerateDeveloperKeys("app-456");

		expect(result).toHaveProperty("publicKey");
		expect(result).toHaveProperty("secretKey");
		expect(typeof result.publicKey).toBe("string");
		expect(typeof result.secretKey).toBe("string");
	});
});

describe("addCreditsToAccount", () => {
	let addCreditsToAccount: typeof import("@/lib/developer-credits").addCreditsToAccount;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/lib/developer-credits");
		addCreditsToAccount = mod.addCreditsToAccount;
	});

	it("correctly calculates micro-credits from cents", async () => {
		mockDb.transaction.mockImplementation(async (fn) => {
			const txDb = { ...mockDb };
			txDb.select = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.from = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.where = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.update = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.set = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.insert = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.values = vi.fn(() => Promise.resolve()) as unknown as ReturnType<
				typeof vi.fn
			>;
			txDb.limit = vi.fn(() =>
				Promise.resolve([{ balanceMicroCredits: 1000000 }]),
			) as unknown as ReturnType<typeof vi.fn>;
			return fn(txDb);
		});

		const result = await addCreditsToAccount({
			accountId: "account-001",
			amountCents: 1000,
		});
		expect(result).toBe(1000000);
	});

	it("creates topup transaction record with referenceType", async () => {
		let capturedValues: Record<string, unknown> | null = null;
		mockDb.transaction.mockImplementation(async (fn) => {
			const txDb = { ...mockDb };
			txDb.select = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.from = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.where = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.update = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.set = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.insert = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.values = vi.fn((vals: Record<string, unknown>) => {
				capturedValues = vals;
				return Promise.resolve();
			}) as unknown as ReturnType<typeof vi.fn>;
			txDb.limit = vi.fn(() =>
				Promise.resolve([{ balanceMicroCredits: 500000 }]),
			) as unknown as ReturnType<typeof vi.fn>;
			return fn(txDb);
		});

		await addCreditsToAccount({
			accountId: "account-001",
			amountCents: 500,
			referenceId: "pi_test123",
			referenceType: "stripe_payment_intent",
		});
		expect(capturedValues).toMatchObject({
			type: "topup",
			referenceId: "pi_test123",
			referenceType: "stripe_payment_intent",
		});
	});

	it("returns the new balance", async () => {
		mockDb.transaction.mockImplementation(async (fn) => {
			const txDb = { ...mockDb };
			txDb.select = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.from = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.where = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.update = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.set = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.insert = vi.fn(() => txDb) as unknown as ReturnType<typeof vi.fn>;
			txDb.values = vi.fn(() => Promise.resolve()) as unknown as ReturnType<
				typeof vi.fn
			>;
			txDb.limit = vi.fn(() =>
				Promise.resolve([{ balanceMicroCredits: 750000 }]),
			) as unknown as ReturnType<typeof vi.fn>;
			return fn(txDb);
		});

		const result = await addCreditsToAccount({
			accountId: "account-001",
			amountCents: 750,
		});
		expect(result).toBe(750000);
	});
});

describe("updateDeveloperAutoTopUp", () => {
	let updateDeveloperAutoTopUp: typeof import("@/actions/developers/update-auto-topup").updateDeveloperAutoTopUp;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/update-auto-topup");
		updateDeveloperAutoTopUp = mod.updateDeveloperAutoTopUp;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(
			updateDeveloperAutoTopUp({ appId: "app-456", enabled: true }),
		).rejects.toThrow("Unauthorized");
	});

	it("throws App not found when app does not exist", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValue([]);
		await expect(
			updateDeveloperAutoTopUp({ appId: "app-456", enabled: true }),
		).rejects.toThrow("App not found");
	});

	it("throws Threshold must be non-negative for negative threshold", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await expect(
			updateDeveloperAutoTopUp({
				appId: "app-456",
				enabled: true,
				thresholdMicroCredits: -100,
			}),
		).rejects.toThrow("Threshold must be non-negative");
	});

	it("throws Top-up amount must be positive for zero amount", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await expect(
			updateDeveloperAutoTopUp({
				appId: "app-456",
				enabled: true,
				amountCents: 0,
			}),
		).rejects.toThrow("Top-up amount must be positive");
	});

	it("throws Top-up amount must be positive for negative amount", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await expect(
			updateDeveloperAutoTopUp({
				appId: "app-456",
				enabled: true,
				amountCents: -50,
			}),
		).rejects.toThrow("Top-up amount must be positive");
	});

	it("updates enabled flag", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await updateDeveloperAutoTopUp({ appId: "app-456", enabled: false });

		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ autoTopUpEnabled: false }),
		);
	});

	it("conditionally updates threshold and amount", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await updateDeveloperAutoTopUp({
			appId: "app-456",
			enabled: true,
			thresholdMicroCredits: 50000,
			amountCents: 1000,
		});

		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({
				autoTopUpEnabled: true,
				autoTopUpThresholdMicroCredits: 50000,
				autoTopUpAmountCents: 1000,
			}),
		);
	});

	it("returns success true", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await updateDeveloperAutoTopUp({
			appId: "app-456",
			enabled: true,
		});
		expect(result).toEqual({ success: true });
	});
});

describe("deleteDeveloperVideo", () => {
	let deleteDeveloperVideo: typeof import("@/actions/developers/delete-video").deleteDeveloperVideo;

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		const mod = await import("@/actions/developers/delete-video");
		deleteDeveloperVideo = mod.deleteDeveloperVideo;
	});

	it("throws Unauthorized when no user", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		await expect(deleteDeveloperVideo("app-456", "video-001")).rejects.toThrow(
			"Unauthorized",
		);
	});

	it("throws App not found when app does not exist", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValue([]);
		await expect(deleteDeveloperVideo("app-456", "video-001")).rejects.toThrow(
			"App not found",
		);
	});

	it("soft deletes video", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		await deleteDeveloperVideo("app-456", "video-001");

		expect(mockDb.update).toHaveBeenCalled();
		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ deletedAt: expect.any(Date) }),
		);
	});

	it("returns success true", async () => {
		mockGetCurrentUser.mockResolvedValue(mockUser);
		mockDb.limit.mockResolvedValueOnce([mockApp]);
		const result = await deleteDeveloperVideo("app-456", "video-001");
		expect(result).toEqual({ success: true });
	});
});