import { describe, it, expect, beforeAll } from "vitest";
import { SupabaseManagementClient, ApiError } from "../../src/client/index.js";
import { getTestConfig, delay, addCleanupTask } from "./setup.js";
describe("Branching Operations (Integration)", () => {
let client: SupabaseManagementClient;
let projectRef: string;
beforeAll(() => {
const config = getTestConfig();
client = new SupabaseManagementClient(config.accessToken);
projectRef = config.projectRef;
});
describe("list_branches", () => {
it("lists all branches", async () => {
const result = await client.listBranches(projectRef);
expect(result).toBeDefined();
expect(Array.isArray(result)).toBe(true);
});
it("returns empty array when no branches exist", async () => {
const result = await client.listBranches(projectRef) as unknown[];
// May be empty or have branches
expect(Array.isArray(result)).toBe(true);
});
});
describe("create_branch", () => {
it("creates a new branch", async () => {
const branchName = `test-branch-${Date.now()}`;
try {
const result = await client.createBranch(projectRef, branchName) as { id?: string };
expect(result).toBeDefined();
// Add cleanup task
if (result.id) {
addCleanupTask(async () => {
try {
await client.deleteBranch(projectRef, result.id!);
} catch {
// Ignore cleanup errors
}
});
}
// Verify branch appears in list
await delay(2000);
const branches = await client.listBranches(projectRef) as Array<{ name: string }>;
expect(branches).toBeDefined();
} catch (error) {
// Branching may not be available on free tier
if (error instanceof ApiError) {
console.log("Branch creation may require paid plan:", error.message);
expect(error.statusCode).toBeGreaterThanOrEqual(400);
} else {
throw error;
}
}
});
it("handles branch name with special characters", async () => {
const branchName = `feature/test-branch-${Date.now()}`;
try {
const result = await client.createBranch(projectRef, branchName) as { id?: string };
if (result.id) {
addCleanupTask(async () => {
try {
await client.deleteBranch(projectRef, result.id!);
} catch {
// Ignore
}
});
}
expect(result).toBeDefined();
} catch (error) {
// May fail due to invalid characters or paid plan requirement
expect(error).toBeDefined();
}
});
it("handles duplicate branch name", async () => {
const branchName = `duplicate-branch-${Date.now()}`;
try {
// Create first branch
const first = await client.createBranch(projectRef, branchName) as { id?: string };
if (first.id) {
addCleanupTask(async () => {
try {
await client.deleteBranch(projectRef, first.id!);
} catch {
// Ignore
}
});
}
// Try to create duplicate
try {
await client.createBranch(projectRef, branchName);
// If it succeeds, the API allows duplicates
} catch (dupError) {
expect(dupError).toBeInstanceOf(ApiError);
}
} catch (error) {
// Branching may not be available
console.log("Branch test skipped:", (error as Error).message);
}
});
});
describe("delete_branch", () => {
it("deletes an existing branch", async () => {
const branchName = `delete-test-${Date.now()}`;
try {
// Create a branch to delete
const createResult = await client.createBranch(projectRef, branchName) as { id: string };
if (!createResult.id) {
console.log("No branch ID returned, skipping delete test");
return;
}
await delay(2000);
// Delete the branch
const deleteResult = await client.deleteBranch(projectRef, createResult.id);
expect(deleteResult).toBeDefined();
// Verify branch is gone
await delay(1000);
const branches = await client.listBranches(projectRef) as Array<{ id: string }>;
const stillExists = branches.some((b) => b.id === createResult.id);
expect(stillExists).toBe(false);
} catch (error) {
console.log("Branch delete test skipped:", (error as Error).message);
}
});
it("returns error for non-existent branch", async () => {
try {
await client.deleteBranch(projectRef, "non-existent-branch-id-xyz");
// If it doesn't throw, the API may return success anyway
} catch (error) {
expect(error).toBeInstanceOf(ApiError);
// 404 or 400 are acceptable
expect([400, 404]).toContain((error as ApiError).statusCode);
}
});
});
describe("merge_branch", () => {
it("merges a branch to main", async () => {
const branchName = `merge-test-${Date.now()}`;
try {
// Create branch
const createResult = await client.createBranch(projectRef, branchName) as { id: string };
if (!createResult.id) {
console.log("No branch ID returned, skipping merge test");
return;
}
await delay(3000); // Wait for branch to be ready
// Merge the branch
const mergeResult = await client.mergeBranch(projectRef, createResult.id);
expect(mergeResult).toBeDefined();
// Branch should be deleted after merge (depending on API behavior)
await delay(2000);
} catch (error) {
if (error instanceof ApiError && error.statusCode === 400) {
// Branch may not have changes to merge, or requires specific state
console.log("Merge failed (expected for empty branch):", error.message);
} else {
console.log("Merge test skipped:", (error as Error).message);
}
}
});
});
describe("reset_branch", () => {
it("resets a branch to main state", async () => {
const branchName = `reset-test-${Date.now()}`;
try {
// Create branch
const createResult = await client.createBranch(projectRef, branchName) as { id: string };
if (!createResult.id) {
console.log("No branch ID returned, skipping reset test");
return;
}
addCleanupTask(async () => {
try {
await client.deleteBranch(projectRef, createResult.id);
} catch {
// Ignore
}
});
await delay(3000);
// Reset the branch
const resetResult = await client.resetBranch(projectRef, createResult.id);
expect(resetResult).toBeDefined();
} catch (error) {
console.log("Reset test skipped:", (error as Error).message);
}
});
});
describe("rebase_branch", () => {
it("rebases a branch with main changes", async () => {
const branchName = `rebase-test-${Date.now()}`;
try {
// Create branch
const createResult = await client.createBranch(projectRef, branchName) as { id: string };
if (!createResult.id) {
console.log("No branch ID returned, skipping rebase test");
return;
}
addCleanupTask(async () => {
try {
await client.deleteBranch(projectRef, createResult.id);
} catch {
// Ignore
}
});
await delay(3000);
// Rebase the branch
const rebaseResult = await client.rebaseBranch(projectRef, createResult.id);
expect(rebaseResult).toBeDefined();
} catch (error) {
console.log("Rebase test skipped:", (error as Error).message);
}
});
});
describe("Branch workflow scenarios", () => {
it("full branch lifecycle: create -> use -> merge", async () => {
const branchName = `lifecycle-${Date.now()}`;
try {
// 1. Create branch
const createResult = await client.createBranch(projectRef, branchName) as { id: string };
if (!createResult.id) {
console.log("No branch ID returned, skipping lifecycle test");
return;
}
await delay(3000);
// 2. Make some changes on the branch (if we could target it)
// For now, just verify it exists
const branches = await client.listBranches(projectRef) as Array<{ id: string }>;
const branchExists = branches.some((b) => b.id === createResult.id);
expect(branchExists).toBe(true);
// 3. Clean up (delete instead of merge for test isolation)
await client.deleteBranch(projectRef, createResult.id);
} catch (error) {
console.log("Lifecycle test skipped:", (error as Error).message);
}
});
it("handles concurrent branch operations", async () => {
const branchNames = [
`concurrent-a-${Date.now()}`,
`concurrent-b-${Date.now()}`,
];
try {
// Create multiple branches in parallel
const createPromises = branchNames.map((name) =>
client.createBranch(projectRef, name)
);
const results = await Promise.allSettled(createPromises);
// Clean up successful creations
for (const result of results) {
if (result.status === "fulfilled" && (result.value as { id?: string }).id) {
addCleanupTask(async () => {
try {
await client.deleteBranch(projectRef, (result.value as { id: string }).id);
} catch {
// Ignore
}
});
}
}
// At least verify the operations completed
expect(results.length).toBe(2);
} catch (error) {
console.log("Concurrent branch test skipped:", (error as Error).message);
}
});
});
describe("Error scenarios", () => {
it("handles invalid branch ID format", async () => {
try {
await client.deleteBranch(projectRef, "invalid-format-!!!!");
} catch (error) {
expect(error).toBeDefined();
}
});
it("handles operations on deleted branch", async () => {
const branchName = `deleted-ops-${Date.now()}`;
try {
const createResult = await client.createBranch(projectRef, branchName) as { id: string };
if (!createResult.id) return;
await delay(2000);
// Delete the branch
await client.deleteBranch(projectRef, createResult.id);
await delay(1000);
// Try to operate on deleted branch
try {
await client.resetBranch(projectRef, createResult.id);
} catch (opError) {
expect(opError).toBeInstanceOf(ApiError);
}
} catch (error) {
console.log("Deleted branch ops test skipped:", (error as Error).message);
}
});
});
});
