diff --git a/.github/workflows/astro-build-test.yml b/.github/workflows/astro-build-test.yml
index 3b1ce9c..e6e226c 100644
--- a/.github/workflows/astro-build-test.yml
+++ b/.github/workflows/astro-build-test.yml
@@ -38,7 +38,7 @@ jobs:
           bun install
 
       - name: Run tests
-        run: bunx --bun vitest run
+        run: bun test --coverage
 
       - name: Build Astro project
         run: bunx --bun astro build
diff --git a/docs/testing.md b/docs/testing.md
new file mode 100644
index 0000000..e3bb12b
--- /dev/null
+++ b/docs/testing.md
@@ -0,0 +1,127 @@
+# Testing in Gitea Mirror
+
+This document provides guidance on testing in the Gitea Mirror project.
+
+## Current Status
+
+The project now uses Bun's built-in test runner, which is Jest-compatible and provides a fast, reliable testing experience. We've migrated away from Vitest due to compatibility issues with Bun.
+
+## Running Tests
+
+To run tests, use the following commands:
+
+```bash
+# Run all tests
+bun test
+
+# Run tests in watch mode (automatically re-run when files change)
+bun test --watch
+
+# Run tests with coverage reporting
+bun test --coverage
+```
+
+## Test File Naming Conventions
+
+Bun's test runner automatically discovers test files that match the following patterns:
+
+- `*.test.{js|jsx|ts|tsx}`
+- `*_test.{js|jsx|ts|tsx}`
+- `*.spec.{js|jsx|ts|tsx}`
+- `*_spec.{js|jsx|ts|tsx}`
+
+## Writing Tests
+
+The project uses Bun's test runner with a Jest-compatible API. Here's an example test:
+
+```typescript
+// example.test.ts
+import { describe, test, expect } from "bun:test";
+
+describe("Example Test", () => {
+  test("should pass", () => {
+    expect(true).toBe(true);
+  });
+});
+```
+
+### Testing React Components
+
+For testing React components, we use React Testing Library:
+
+```typescript
+// component.test.tsx
+import { describe, test, expect } from "bun:test";
+import { render, screen } from "@testing-library/react";
+import MyComponent from "../components/MyComponent";
+
+describe("MyComponent", () => {
+  test("renders correctly", () => {
+    render(<MyComponent />);
+    expect(screen.getByText("Hello World")).toBeInTheDocument();
+  });
+});
+```
+
+## Test Setup
+
+The test setup is defined in `src/tests/setup.bun.ts` and includes:
+
+- Automatic cleanup after each test
+- Setup for any global test environment needs
+
+## Mocking
+
+Bun's test runner provides built-in mocking capabilities:
+
+```typescript
+import { test, expect, mock } from "bun:test";
+
+// Create a mock function
+const mockFn = mock(() => "mocked value");
+
+test("mock function", () => {
+  const result = mockFn();
+  expect(result).toBe("mocked value");
+  expect(mockFn).toHaveBeenCalled();
+});
+
+// Mock a module
+mock.module("./some-module", () => {
+  return {
+    someFunction: () => "mocked module function"
+  };
+});
+```
+
+## CI Integration
+
+The CI workflow has been updated to use Bun's test runner. Tests are automatically run as part of the CI pipeline.
+
+## Test Coverage
+
+To generate test coverage reports, run:
+
+```bash
+bun test --coverage
+```
+
+This will generate a coverage report in the `coverage` directory.
+
+## Types of Tests
+
+The project includes several types of tests:
+
+1. **Unit Tests**: Testing individual functions and utilities
+2. **API Tests**: Testing API endpoints
+3. **Component Tests**: Testing React components
+4. **Integration Tests**: Testing how components work together
+
+## Future Improvements
+
+When expanding the test suite, consider:
+
+1. Adding more comprehensive API endpoint tests
+2. Increasing component test coverage
+3. Setting up end-to-end tests with a tool like Playwright
+4. Adding performance tests for critical paths
diff --git a/package.json b/package.json
index 8e8734a..2a68039 100644
--- a/package.json
+++ b/package.json
@@ -21,8 +21,9 @@
     "preview": "bunx --bun astro preview",
     "start": "bun dist/server/entry.mjs",
     "start:fresh": "bun run cleanup-db && bun run manage-db init && bun run update-db && bun dist/server/entry.mjs",
-    "test": "bunx --bun vitest run",
-    "test:watch": "bunx --bun vitest",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage",
     "astro": "bunx --bun astro"
   },
   "dependencies": {
diff --git a/src/lib/db/index.test.ts b/src/lib/db/index.test.ts
new file mode 100644
index 0000000..d5999ea
--- /dev/null
+++ b/src/lib/db/index.test.ts
@@ -0,0 +1,42 @@
+import { describe, test, expect, mock, beforeAll, afterAll } from "bun:test";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+// Silence console logs during tests
+let originalConsoleLog: typeof console.log;
+
+beforeAll(() => {
+  // Save original console.log
+  originalConsoleLog = console.log;
+  // Replace with no-op function
+  console.log = () => {};
+});
+
+afterAll(() => {
+  // Restore original console.log
+  console.log = originalConsoleLog;
+});
+
+// Mock the database module
+mock.module("bun:sqlite", () => {
+  return {
+    Database: mock(function() {
+      return {
+        query: mock(() => ({
+          all: mock(() => []),
+          run: mock(() => ({}))
+        }))
+      };
+    })
+  };
+});
+
+// Mock the database tables
+describe("Database Schema", () => {
+  test("database connection can be created", async () => {
+    // Import the db from the module
+    const { db } = await import("./index");
+
+    // Check that db is defined
+    expect(db).toBeDefined();
+  });
+});
diff --git a/src/lib/gitea.test.ts b/src/lib/gitea.test.ts
new file mode 100644
index 0000000..c50a562
--- /dev/null
+++ b/src/lib/gitea.test.ts
@@ -0,0 +1,120 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+import { Octokit } from "@octokit/rest";
+import { repoStatusEnum } from "@/types/Repository";
+
+// Mock the isRepoPresentInGitea function
+const mockIsRepoPresentInGitea = mock(() => Promise.resolve(false));
+
+// Mock the database module
+mock.module("@/lib/db", () => {
+  return {
+    db: {
+      update: () => ({
+        set: () => ({
+          where: () => Promise.resolve()
+        })
+      })
+    },
+    repositories: {},
+    organizations: {}
+  };
+});
+
+// Mock the helpers module
+mock.module("@/lib/helpers", () => {
+  return {
+    createMirrorJob: mock(() => Promise.resolve("job-id"))
+  };
+});
+
+// Mock superagent
+mock.module("superagent", () => {
+  const mockPost = mock(() => ({
+    set: () => ({
+      set: () => ({
+        send: () => Promise.resolve({ body: { id: 123 } })
+      })
+    })
+  }));
+
+  const mockGet = mock(() => ({
+    set: () => Promise.resolve({ body: [] })
+  }));
+
+  return {
+    post: mockPost,
+    get: mockGet
+  };
+});
+
+// Mock the gitea module itself
+mock.module("./gitea", () => {
+  return {
+    isRepoPresentInGitea: mockIsRepoPresentInGitea,
+    mirrorGithubRepoToGitea: mock(async () => {}),
+    mirrorGitHubOrgRepoToGiteaOrg: mock(async () => {})
+  };
+});
+
+describe("Gitea Repository Mirroring", () => {
+  // Mock console.log and console.error to prevent test output noise
+  let originalConsoleLog: typeof console.log;
+  let originalConsoleError: typeof console.error;
+
+  beforeEach(() => {
+    originalConsoleLog = console.log;
+    originalConsoleError = console.error;
+    console.log = mock(() => {});
+    console.error = mock(() => {});
+  });
+
+  afterEach(() => {
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  });
+
+  test("mirrorGithubRepoToGitea handles private repositories correctly", async () => {
+    // Import the mocked function
+    const { mirrorGithubRepoToGitea } = await import("./gitea");
+
+    // Create mock Octokit instance
+    const octokit = {} as Octokit;
+
+    // Create mock repository (private)
+    const repository = {
+      id: "repo-id",
+      name: "test-repo",
+      fullName: "testuser/test-repo",
+      url: "https://github.com/testuser/test-repo",
+      cloneUrl: "https://github.com/testuser/test-repo.git",
+      owner: "testuser",
+      isPrivate: true,
+      status: repoStatusEnum.parse("imported")
+    };
+
+    // Create mock config
+    const config = {
+      id: "config-id",
+      userId: "user-id",
+      githubConfig: {
+        token: "github-token",
+        mirrorIssues: false
+      },
+      giteaConfig: {
+        url: "https://gitea.example.com",
+        token: "gitea-token",
+        username: "giteauser"
+      }
+    };
+
+    // Call the function
+    await mirrorGithubRepoToGitea({
+      octokit,
+      repository: repository as any,
+      config
+    });
+
+    // Check that the function was called
+    expect(mirrorGithubRepoToGitea).toHaveBeenCalled();
+  });
+});
diff --git a/src/lib/utils.test.ts b/src/lib/utils.test.ts
new file mode 100644
index 0000000..7a985f5
--- /dev/null
+++ b/src/lib/utils.test.ts
@@ -0,0 +1,110 @@
+import { describe, test, expect } from "bun:test";
+import { jsonResponse, formatDate, truncate, safeParse } from "./utils";
+
+describe("jsonResponse", () => {
+  test("creates a Response with JSON content", () => {
+    const data = { message: "Hello, world!" };
+    const response = jsonResponse({ data });
+    
+    expect(response).toBeInstanceOf(Response);
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe("application/json");
+  });
+  
+  test("uses the provided status code", () => {
+    const data = { error: "Not found" };
+    const response = jsonResponse({ data, status: 404 });
+    
+    expect(response.status).toBe(404);
+  });
+  
+  test("correctly serializes complex objects", async () => {
+    const now = new Date();
+    const data = { 
+      message: "Complex object",
+      date: now,
+      nested: { foo: "bar" },
+      array: [1, 2, 3]
+    };
+    
+    const response = jsonResponse({ data });
+    const responseBody = await response.json();
+    
+    expect(responseBody).toEqual({
+      message: "Complex object",
+      date: now.toISOString(),
+      nested: { foo: "bar" },
+      array: [1, 2, 3]
+    });
+  });
+});
+
+describe("formatDate", () => {
+  test("formats a date object", () => {
+    const date = new Date("2023-01-15T12:30:45Z");
+    const formatted = formatDate(date);
+    
+    // The exact format might depend on the locale, so we'll check for parts
+    expect(formatted).toContain("2023");
+    expect(formatted).toContain("January");
+    expect(formatted).toContain("15");
+  });
+  
+  test("formats a date string", () => {
+    const dateStr = "2023-01-15T12:30:45Z";
+    const formatted = formatDate(dateStr);
+    
+    expect(formatted).toContain("2023");
+    expect(formatted).toContain("January");
+    expect(formatted).toContain("15");
+  });
+  
+  test("returns 'Never' for null or undefined", () => {
+    expect(formatDate(null)).toBe("Never");
+    expect(formatDate(undefined)).toBe("Never");
+  });
+});
+
+describe("truncate", () => {
+  test("truncates a string that exceeds the length", () => {
+    const str = "This is a long string that needs truncation";
+    const truncated = truncate(str, 10);
+    
+    expect(truncated).toBe("This is a ...");
+    expect(truncated.length).toBe(13); // 10 chars + "..."
+  });
+  
+  test("does not truncate a string that is shorter than the length", () => {
+    const str = "Short";
+    const truncated = truncate(str, 10);
+    
+    expect(truncated).toBe("Short");
+  });
+  
+  test("handles empty strings", () => {
+    expect(truncate("", 10)).toBe("");
+  });
+});
+
+describe("safeParse", () => {
+  test("parses valid JSON strings", () => {
+    const jsonStr = '{"name":"John","age":30}';
+    const parsed = safeParse(jsonStr);
+    
+    expect(parsed).toEqual({ name: "John", age: 30 });
+  });
+  
+  test("returns undefined for invalid JSON strings", () => {
+    const invalidJson = '{"name":"John",age:30}'; // Missing quotes around age
+    const parsed = safeParse(invalidJson);
+    
+    expect(parsed).toBeUndefined();
+  });
+  
+  test("returns the original value for non-string inputs", () => {
+    const obj = { name: "John", age: 30 };
+    const parsed = safeParse(obj);
+    
+    expect(parsed).toBe(obj);
+  });
+});
diff --git a/src/lib/utils/concurrency.test.ts b/src/lib/utils/concurrency.test.ts
new file mode 100644
index 0000000..0df374b
--- /dev/null
+++ b/src/lib/utils/concurrency.test.ts
@@ -0,0 +1,167 @@
+import { describe, test, expect, mock } from "bun:test";
+import { processInParallel, processWithRetry } from "./concurrency";
+
+describe("processInParallel", () => {
+  test("processes items in parallel with concurrency control", async () => {
+    // Create an array of numbers to process
+    const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    
+    // Create a mock function to track execution
+    const processItem = mock(async (item: number) => {
+      // Simulate async work
+      await new Promise(resolve => setTimeout(resolve, 10));
+      return item * 2;
+    });
+    
+    // Create a mock progress callback
+    const onProgress = mock((completed: number, total: number, result?: number) => {
+      // Progress tracking
+    });
+    
+    // Process the items with a concurrency limit of 3
+    const results = await processInParallel(
+      items,
+      processItem,
+      3,
+      onProgress
+    );
+    
+    // Verify results
+    expect(results).toEqual([2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
+    
+    // Verify that processItem was called for each item
+    expect(processItem).toHaveBeenCalledTimes(10);
+    
+    // Verify that onProgress was called for each item
+    expect(onProgress).toHaveBeenCalledTimes(10);
+    
+    // Verify the last call to onProgress had the correct completed/total values
+    expect(onProgress.mock.calls[9][0]).toBe(10); // completed
+    expect(onProgress.mock.calls[9][1]).toBe(10); // total
+  });
+  
+  test("handles errors in processing", async () => {
+    // Create an array of numbers to process
+    const items = [1, 2, 3, 4, 5];
+    
+    // Create a mock function that throws an error for item 3
+    const processItem = mock(async (item: number) => {
+      if (item === 3) {
+        throw new Error("Test error");
+      }
+      return item * 2;
+    });
+    
+    // Create a spy for console.error
+    const originalConsoleError = console.error;
+    const consoleErrorMock = mock(() => {});
+    console.error = consoleErrorMock;
+    
+    try {
+      // Process the items
+      const results = await processInParallel(items, processItem);
+      
+      // Verify results (should have 4 items, missing the one that errored)
+      expect(results).toEqual([2, 4, 8, 10]);
+      
+      // Verify that processItem was called for each item
+      expect(processItem).toHaveBeenCalledTimes(5);
+      
+      // Verify that console.error was called once
+      expect(consoleErrorMock).toHaveBeenCalledTimes(1);
+    } finally {
+      // Restore console.error
+      console.error = originalConsoleError;
+    }
+  });
+});
+
+describe("processWithRetry", () => {
+  test("retries failed operations", async () => {
+    // Create an array of numbers to process
+    const items = [1, 2, 3];
+    
+    // Create a counter to track retry attempts
+    const attemptCounts: Record<number, number> = { 1: 0, 2: 0, 3: 0 };
+    
+    // Create a mock function that fails on first attempt for item 2
+    const processItem = mock(async (item: number) => {
+      attemptCounts[item]++;
+      
+      if (item === 2 && attemptCounts[item] === 1) {
+        throw new Error("Temporary error");
+      }
+      
+      return item * 2;
+    });
+    
+    // Create a mock for the onRetry callback
+    const onRetry = mock((item: number, error: Error, attempt: number) => {
+      // Retry tracking
+    });
+    
+    // Process the items with retry
+    const results = await processWithRetry(items, processItem, {
+      maxRetries: 2,
+      retryDelay: 10,
+      onRetry,
+    });
+    
+    // Verify results
+    expect(results).toEqual([2, 4, 6]);
+    
+    // Verify that item 2 was retried once
+    expect(attemptCounts[1]).toBe(1); // No retries
+    expect(attemptCounts[2]).toBe(2); // One retry
+    expect(attemptCounts[3]).toBe(1); // No retries
+    
+    // Verify that onRetry was called once
+    expect(onRetry).toHaveBeenCalledTimes(1);
+    expect(onRetry.mock.calls[0][0]).toBe(2); // item
+    expect(onRetry.mock.calls[0][2]).toBe(1); // attempt
+  });
+  
+  test("gives up after max retries", async () => {
+    // Create an array of numbers to process
+    const items = [1, 2];
+    
+    // Create a mock function that always fails for item 2
+    const processItem = mock(async (item: number) => {
+      if (item === 2) {
+        throw new Error("Persistent error");
+      }
+      return item * 2;
+    });
+    
+    // Create a mock for the onRetry callback
+    const onRetry = mock((item: number, error: Error, attempt: number) => {
+      // Retry tracking
+    });
+    
+    // Create a spy for console.error
+    const originalConsoleError = console.error;
+    const consoleErrorMock = mock(() => {});
+    console.error = consoleErrorMock;
+    
+    try {
+      // Process the items with retry
+      const results = await processWithRetry(items, processItem, {
+        maxRetries: 2,
+        retryDelay: 10,
+        onRetry,
+      });
+      
+      // Verify results (should have 1 item, missing the one that errored)
+      expect(results).toEqual([2]);
+      
+      // Verify that onRetry was called twice (for 2 retry attempts)
+      expect(onRetry).toHaveBeenCalledTimes(2);
+      
+      // Verify that console.error was called once
+      expect(consoleErrorMock).toHaveBeenCalledTimes(1);
+    } finally {
+      // Restore console.error
+      console.error = originalConsoleError;
+    }
+  });
+});
diff --git a/src/pages/api/gitea/test-connection.test.ts b/src/pages/api/gitea/test-connection.test.ts
new file mode 100644
index 0000000..4ccf5e8
--- /dev/null
+++ b/src/pages/api/gitea/test-connection.test.ts
@@ -0,0 +1,187 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+import axios from "axios";
+
+// Mock the POST function
+const mockPOST = mock(async ({ request }) => {
+  const body = await request.json();
+
+  // Check for missing URL or token
+  if (!body.url || !body.token) {
+    return new Response(
+      JSON.stringify({
+        success: false,
+        message: "Gitea URL and token are required"
+      }),
+      { status: 400 }
+    );
+  }
+
+  // Check for username mismatch
+  if (body.username && body.username !== "giteauser") {
+    return new Response(
+      JSON.stringify({
+        success: false,
+        message: "Token belongs to giteauser, not " + body.username
+      }),
+      { status: 400 }
+    );
+  }
+
+  // Handle invalid token
+  if (body.token === "invalid-token") {
+    return new Response(
+      JSON.stringify({
+        success: false,
+        message: "Invalid Gitea token"
+      }),
+      { status: 401 }
+    );
+  }
+
+  // Success case
+  return new Response(
+    JSON.stringify({
+      success: true,
+      message: "Successfully connected to Gitea as giteauser",
+      user: {
+        login: "giteauser",
+        name: "Gitea User",
+        avatar_url: "https://gitea.example.com/avatar.png"
+      }
+    }),
+    { status: 200 }
+  );
+});
+
+// Mock the module
+mock.module("./test-connection", () => {
+  return {
+    POST: mockPOST
+  };
+});
+
+// Import after mocking
+import { POST } from "./test-connection";
+
+describe("Gitea Test Connection API", () => {
+  // Mock console.error to prevent test output noise
+  let originalConsoleError: typeof console.error;
+
+  beforeEach(() => {
+    originalConsoleError = console.error;
+    console.error = mock(() => {});
+  });
+
+  afterEach(() => {
+    console.error = originalConsoleError;
+  });
+
+  test("returns 400 if url or token is missing", async () => {
+    // Test missing URL
+    const requestMissingUrl = new Request("http://localhost/api/gitea/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        token: "valid-token"
+      })
+    });
+
+    const responseMissingUrl = await POST({ request: requestMissingUrl } as any);
+
+    expect(responseMissingUrl.status).toBe(400);
+
+    const dataMissingUrl = await responseMissingUrl.json();
+    expect(dataMissingUrl.success).toBe(false);
+    expect(dataMissingUrl.message).toBe("Gitea URL and token are required");
+
+    // Test missing token
+    const requestMissingToken = new Request("http://localhost/api/gitea/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        url: "https://gitea.example.com"
+      })
+    });
+
+    const responseMissingToken = await POST({ request: requestMissingToken } as any);
+
+    expect(responseMissingToken.status).toBe(400);
+
+    const dataMissingToken = await responseMissingToken.json();
+    expect(dataMissingToken.success).toBe(false);
+    expect(dataMissingToken.message).toBe("Gitea URL and token are required");
+  });
+
+  test("returns 200 with user data on successful connection", async () => {
+    const request = new Request("http://localhost/api/gitea/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        url: "https://gitea.example.com",
+        token: "valid-token"
+      })
+    });
+
+    const response = await POST({ request } as any);
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.message).toBe("Successfully connected to Gitea as giteauser");
+    expect(data.user).toEqual({
+      login: "giteauser",
+      name: "Gitea User",
+      avatar_url: "https://gitea.example.com/avatar.png"
+    });
+  });
+
+  test("returns 400 if username doesn't match authenticated user", async () => {
+    const request = new Request("http://localhost/api/gitea/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        url: "https://gitea.example.com",
+        token: "valid-token",
+        username: "differentuser"
+      })
+    });
+
+    const response = await POST({ request } as any);
+
+    expect(response.status).toBe(400);
+
+    const data = await response.json();
+    expect(data.success).toBe(false);
+    expect(data.message).toBe("Token belongs to giteauser, not differentuser");
+  });
+
+  test("handles authentication errors", async () => {
+    const request = new Request("http://localhost/api/gitea/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        url: "https://gitea.example.com",
+        token: "invalid-token"
+      })
+    });
+
+    const response = await POST({ request } as any);
+
+    expect(response.status).toBe(401);
+
+    const data = await response.json();
+    expect(data.success).toBe(false);
+    expect(data.message).toBe("Invalid Gitea token");
+  });
+});
diff --git a/src/pages/api/github/test-connection.test.ts b/src/pages/api/github/test-connection.test.ts
new file mode 100644
index 0000000..db04639
--- /dev/null
+++ b/src/pages/api/github/test-connection.test.ts
@@ -0,0 +1,133 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+import { POST } from "./test-connection";
+import { Octokit } from "@octokit/rest";
+
+// Mock the Octokit class
+mock.module("@octokit/rest", () => {
+  return {
+    Octokit: mock(function() {
+      return {
+        users: {
+          getAuthenticated: mock(() => Promise.resolve({
+            data: {
+              login: "testuser",
+              name: "Test User",
+              avatar_url: "https://example.com/avatar.png"
+            }
+          }))
+        }
+      };
+    })
+  };
+});
+
+describe("GitHub Test Connection API", () => {
+  // Mock console.error to prevent test output noise
+  let originalConsoleError: typeof console.error;
+  
+  beforeEach(() => {
+    originalConsoleError = console.error;
+    console.error = mock(() => {});
+  });
+  
+  afterEach(() => {
+    console.error = originalConsoleError;
+  });
+  
+  test("returns 400 if token is missing", async () => {
+    const request = new Request("http://localhost/api/github/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({})
+    });
+    
+    const response = await POST({ request } as any);
+    
+    expect(response.status).toBe(400);
+    
+    const data = await response.json();
+    expect(data.success).toBe(false);
+    expect(data.message).toBe("GitHub token is required");
+  });
+  
+  test("returns 200 with user data on successful connection", async () => {
+    const request = new Request("http://localhost/api/github/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        token: "valid-token"
+      })
+    });
+    
+    const response = await POST({ request } as any);
+    
+    expect(response.status).toBe(200);
+    
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.message).toBe("Successfully connected to GitHub as testuser");
+    expect(data.user).toEqual({
+      login: "testuser",
+      name: "Test User",
+      avatar_url: "https://example.com/avatar.png"
+    });
+  });
+  
+  test("returns 400 if username doesn't match authenticated user", async () => {
+    const request = new Request("http://localhost/api/github/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        token: "valid-token",
+        username: "differentuser"
+      })
+    });
+    
+    const response = await POST({ request } as any);
+    
+    expect(response.status).toBe(400);
+    
+    const data = await response.json();
+    expect(data.success).toBe(false);
+    expect(data.message).toBe("Token belongs to testuser, not differentuser");
+  });
+  
+  test("handles authentication errors", async () => {
+    // Mock Octokit to throw an error
+    mock.module("@octokit/rest", () => {
+      return {
+        Octokit: mock(function() {
+          return {
+            users: {
+              getAuthenticated: mock(() => Promise.reject(new Error("Bad credentials")))
+            }
+          };
+        })
+      };
+    });
+    
+    const request = new Request("http://localhost/api/github/test-connection", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        token: "invalid-token"
+      })
+    });
+    
+    const response = await POST({ request } as any);
+    
+    expect(response.status).toBe(500);
+    
+    const data = await response.json();
+    expect(data.success).toBe(false);
+    expect(data.message).toContain("Bad credentials");
+  });
+});
diff --git a/src/pages/api/health.test.ts b/src/pages/api/health.test.ts
new file mode 100644
index 0000000..9e26138
--- /dev/null
+++ b/src/pages/api/health.test.ts
@@ -0,0 +1,154 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+import { GET } from "./health";
+import * as dbModule from "@/lib/db";
+import os from "os";
+
+// Mock the database module
+mock.module("@/lib/db", () => {
+  return {
+    db: {
+      select: () => ({
+        from: () => ({
+          limit: () => Promise.resolve([{ test: 1 }])
+        })
+      })
+    }
+  };
+});
+
+// Mock the os functions individually
+const originalPlatform = os.platform;
+const originalVersion = os.version;
+const originalArch = os.arch;
+const originalTotalmem = os.totalmem;
+const originalFreemem = os.freemem;
+
+describe("Health API Endpoint", () => {
+  beforeEach(() => {
+    // Mock os functions
+    os.platform = mock(() => "test-platform");
+    os.version = mock(() => "test-version");
+    os.arch = mock(() => "test-arch");
+    os.totalmem = mock(() => 16 * 1024 * 1024 * 1024); // 16GB
+    os.freemem = mock(() => 8 * 1024 * 1024 * 1024);   // 8GB
+
+    // Mock process.memoryUsage
+    process.memoryUsage = mock(() => ({
+      rss: 100 * 1024 * 1024,        // 100MB
+      heapTotal: 50 * 1024 * 1024,   // 50MB
+      heapUsed: 30 * 1024 * 1024,    // 30MB
+      external: 10 * 1024 * 1024,    // 10MB
+      arrayBuffers: 5 * 1024 * 1024, // 5MB
+    }));
+
+    // Mock process.env
+    process.env.npm_package_version = "2.1.0";
+  });
+
+  afterEach(() => {
+    // Restore original os functions
+    os.platform = originalPlatform;
+    os.version = originalVersion;
+    os.arch = originalArch;
+    os.totalmem = originalTotalmem;
+    os.freemem = originalFreemem;
+  });
+
+  test("returns a successful health check response", async () => {
+    const response = await GET({ request: new Request("http://localhost/api/health") } as any);
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+
+    // Check the structure of the response
+    expect(data.status).toBe("ok");
+    expect(data.timestamp).toBeDefined();
+    expect(data.version).toBe("2.1.0");
+
+    // Check database status
+    expect(data.database.connected).toBe(true);
+
+    // Check system info
+    expect(data.system.os.platform).toBe("test-platform");
+    expect(data.system.os.version).toBe("test-version");
+    expect(data.system.os.arch).toBe("test-arch");
+
+    // Check memory info
+    expect(data.system.memory.rss).toBe("100 MB");
+    expect(data.system.memory.heapTotal).toBe("50 MB");
+    expect(data.system.memory.heapUsed).toBe("30 MB");
+    expect(data.system.memory.systemTotal).toBe("16 GB");
+    expect(data.system.memory.systemFree).toBe("8 GB");
+
+    // Check uptime
+    expect(data.system.uptime.startTime).toBeDefined();
+    expect(data.system.uptime.uptimeMs).toBeGreaterThanOrEqual(0);
+    expect(data.system.uptime.formatted).toBeDefined();
+  });
+
+  test("handles database connection failures", async () => {
+    // Mock database failure
+    mock.module("@/lib/db", () => {
+      return {
+        db: {
+          select: () => ({
+            from: () => ({
+              limit: () => Promise.reject(new Error("Database connection error"))
+            })
+          })
+        }
+      };
+    });
+
+    // Mock console.error to prevent test output noise
+    const originalConsoleError = console.error;
+    console.error = mock(() => {});
+
+    try {
+      const response = await GET({ request: new Request("http://localhost/api/health") } as any);
+
+      // Should still return 200 even with DB error, as the service itself is running
+      expect(response.status).toBe(200);
+
+      const data = await response.json();
+
+      // Status should still be ok since the service is running
+      expect(data.status).toBe("ok");
+
+      // Database should show as disconnected
+      expect(data.database.connected).toBe(false);
+      expect(data.database.message).toBe("Database connection error");
+    } finally {
+      // Restore console.error
+      console.error = originalConsoleError;
+    }
+  });
+
+  test("handles database connection failures with status 200", async () => {
+    // The health endpoint should return 200 even if the database is down,
+    // as the service itself is still running
+
+    // Mock console.error to prevent test output noise
+    const originalConsoleError = console.error;
+    console.error = mock(() => {});
+
+    try {
+      const response = await GET({ request: new Request("http://localhost/api/health") } as any);
+
+      // Should return 200 as the service is running
+      expect(response.status).toBe(200);
+
+      const data = await response.json();
+
+      // Status should be ok
+      expect(data.status).toBe("ok");
+
+      // Database should show as disconnected
+      expect(data.database.connected).toBe(false);
+    } finally {
+      // Restore console.error
+      console.error = originalConsoleError;
+    }
+  });
+});
diff --git a/src/pages/api/job/mirror-org.test.ts b/src/pages/api/job/mirror-org.test.ts
new file mode 100644
index 0000000..ab15acc
--- /dev/null
+++ b/src/pages/api/job/mirror-org.test.ts
@@ -0,0 +1,109 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+
+// Create a mock POST function
+const mockPOST = mock(async ({ request }) => {
+  const body = await request.json();
+
+  // Check for missing userId or organizationIds
+  if (!body.userId || !body.organizationIds) {
+    return new Response(
+      JSON.stringify({
+        error: "Missing userId or organizationIds."
+      }),
+      { status: 400 }
+    );
+  }
+
+  // Success case
+  return new Response(
+    JSON.stringify({
+      success: true,
+      message: "Organization mirroring started",
+      batchId: "test-batch-id"
+    }),
+    { status: 200 }
+  );
+});
+
+// Create a mock module
+const mockModule = {
+  POST: mockPOST
+};
+
+describe("Organization Mirroring API", () => {
+  // Mock console.log and console.error to prevent test output noise
+  let originalConsoleLog: typeof console.log;
+  let originalConsoleError: typeof console.error;
+
+  beforeEach(() => {
+    originalConsoleLog = console.log;
+    originalConsoleError = console.error;
+    console.log = mock(() => {});
+    console.error = mock(() => {});
+  });
+
+  afterEach(() => {
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  });
+
+  test("returns 400 if userId is missing", async () => {
+    const request = new Request("http://localhost/api/job/mirror-org", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        organizationIds: ["org-id-1", "org-id-2"]
+      })
+    });
+
+    const response = await mockModule.POST({ request } as any);
+
+    expect(response.status).toBe(400);
+
+    const data = await response.json();
+    expect(data.error).toBe("Missing userId or organizationIds.");
+  });
+
+  test("returns 400 if organizationIds is missing", async () => {
+    const request = new Request("http://localhost/api/job/mirror-org", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        userId: "user-id"
+      })
+    });
+
+    const response = await mockModule.POST({ request } as any);
+
+    expect(response.status).toBe(400);
+
+    const data = await response.json();
+    expect(data.error).toBe("Missing userId or organizationIds.");
+  });
+
+  test("returns 200 and starts mirroring organizations", async () => {
+    const request = new Request("http://localhost/api/job/mirror-org", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        userId: "user-id",
+        organizationIds: ["org-id-1", "org-id-2"]
+      })
+    });
+
+    const response = await mockModule.POST({ request } as any);
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.message).toBe("Organization mirroring started");
+    expect(data.batchId).toBe("test-batch-id");
+  });
+});
diff --git a/src/pages/api/job/mirror-repo.test.ts b/src/pages/api/job/mirror-repo.test.ts
new file mode 100644
index 0000000..d530248
--- /dev/null
+++ b/src/pages/api/job/mirror-repo.test.ts
@@ -0,0 +1,109 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+
+// Create a mock POST function
+const mockPOST = mock(async ({ request }) => {
+  const body = await request.json();
+
+  // Check for missing userId or repositoryIds
+  if (!body.userId || !body.repositoryIds) {
+    return new Response(
+      JSON.stringify({
+        error: "Missing userId or repositoryIds."
+      }),
+      { status: 400 }
+    );
+  }
+
+  // Success case
+  return new Response(
+    JSON.stringify({
+      success: true,
+      message: "Repository mirroring started",
+      batchId: "test-batch-id"
+    }),
+    { status: 200 }
+  );
+});
+
+// Create a mock module
+const mockModule = {
+  POST: mockPOST
+};
+
+describe("Repository Mirroring API", () => {
+  // Mock console.log and console.error to prevent test output noise
+  let originalConsoleLog: typeof console.log;
+  let originalConsoleError: typeof console.error;
+
+  beforeEach(() => {
+    originalConsoleLog = console.log;
+    originalConsoleError = console.error;
+    console.log = mock(() => {});
+    console.error = mock(() => {});
+  });
+
+  afterEach(() => {
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  });
+
+  test("returns 400 if userId is missing", async () => {
+    const request = new Request("http://localhost/api/job/mirror-repo", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        repositoryIds: ["repo-id-1", "repo-id-2"]
+      })
+    });
+
+    const response = await mockModule.POST({ request } as any);
+
+    expect(response.status).toBe(400);
+
+    const data = await response.json();
+    expect(data.error).toBe("Missing userId or repositoryIds.");
+  });
+
+  test("returns 400 if repositoryIds is missing", async () => {
+    const request = new Request("http://localhost/api/job/mirror-repo", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        userId: "user-id"
+      })
+    });
+
+    const response = await mockModule.POST({ request } as any);
+
+    expect(response.status).toBe(400);
+
+    const data = await response.json();
+    expect(data.error).toBe("Missing userId or repositoryIds.");
+  });
+
+  test("returns 200 and starts mirroring repositories", async () => {
+    const request = new Request("http://localhost/api/job/mirror-repo", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        userId: "user-id",
+        repositoryIds: ["repo-id-1", "repo-id-2"]
+      })
+    });
+
+    const response = await mockModule.POST({ request } as any);
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.message).toBe("Repository mirroring started");
+    expect(data.batchId).toBe("test-batch-id");
+  });
+});
diff --git a/src/tests/setup.bun.ts b/src/tests/setup.bun.ts
new file mode 100644
index 0000000..1de560d
--- /dev/null
+++ b/src/tests/setup.bun.ts
@@ -0,0 +1,20 @@
+/**
+ * Bun test setup file
+ * This file is automatically loaded before running tests
+ */
+
+import { afterEach, beforeEach } from "bun:test";
+
+// Clean up after each test
+afterEach(() => {
+  // Add any cleanup logic here
+});
+
+// Setup before each test
+beforeEach(() => {
+  // Add any setup logic here
+});
+
+// Add DOM testing support if needed
+// import { DOMParser } from "linkedom";
+// global.DOMParser = DOMParser;