@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/organizations.test.ts

@@ -15,7 +15,15 @@ import {
 	listProjectShares,
 } from './organizations.js';
 import { ValidationError } from '../validators.js';
-import { createMockSupabase, createMockContext, testUUID } from './__test-utils__.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
+const OTHER_UUID = '223e4567-e89b-12d3-a456-426614174001';
 
 // ============================================================================
 // listOrganizations Tests
@@ -25,10 +33,11 @@ describe('listOrganizations', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should return empty array when no organizations', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.listOrganizations.mockResolvedValue({
+			ok: true,
+			data: { organizations: [], count: 0 },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await listOrganizations({}, ctx);
 
@@ -39,44 +48,34 @@ describe('listOrganizations', () => {
 	});
 
 	it('should return organizations with role and joined_at', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: [
-					{
-						role: 'admin',
-						joined_at: '2025-01-14T12:00:00Z',
-						organizations: {
-							id: 'org-1',
-							name: 'Test Org',
-							slug: 'test-org',
-							description: 'A test organization',
-							logo_url: null,
-							owner_id: 'user-123',
-							created_at: '2025-01-01T00:00:00Z',
-						},
-					},
-				],
-				error: null,
+		mockApiClient.listOrganizations.mockResolvedValue({
+			ok: true,
+			data: {
+				organizations: [{
+					id: 'org-1',
+					name: 'Test Org',
+					slug: 'test-org',
+					role: 'admin',
+					joined_at: '2025-01-14T12:00:00Z',
+				}],
+				count: 1,
 			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await listOrganizations({}, ctx);
 
-		expect(result.result).toMatchObject({
-			count: 1,
-		});
+		expect(result.result).toMatchObject({ count: 1 });
 	});
 
 	it('should throw error when query fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Query failed' } },
+		mockApiClient.listOrganizations.mockResolvedValue({
+			ok: false,
+			error: 'Failed to list organizations',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await expect(listOrganizations({}, ctx)).rejects.toThrow(
-			'Failed to list organizations: Query failed'
-		);
+		await expect(listOrganizations({}, ctx)).rejects.toThrow('Failed to list organizations');
 	});
 });
 
@@ -88,17 +87,16 @@ describe('createOrganization', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing name', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(createOrganization({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error when slug is taken', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { id: 'existing-org' }, error: null },
+		mockApiClient.createOrganization.mockResolvedValue({
+			ok: false,
+			error: 'Organization slug "test-org" is already taken',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			createOrganization({ name: 'Test Org' }, ctx)
@@ -106,19 +104,16 @@ describe('createOrganization', () => {
 	});
 
 	it('should create organization with auto-generated slug', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null }, // No existing slug
-			insertResult: {
-				data: {
-					id: 'org-1',
-					name: 'Test Org',
-					slug: 'test-org',
-					owner_id: 'user-123',
-				},
-				error: null,
+		mockApiClient.createOrganization.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				organization_id: 'org-1',
+				slug: 'test-org',
+				message: 'Organization "Test Org" created. You are the owner.',
 			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await createOrganization({ name: 'Test Org' }, ctx);
 
@@ -129,40 +124,30 @@ describe('createOrganization', () => {
 	});
 
 	it('should create organization with custom slug', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null },
-			insertResult: {
-				data: {
-					id: 'org-1',
-					name: 'Test Org',
-					slug: 'my-custom-slug',
-					owner_id: 'user-123',
-				},
-				error: null,
-			},
+		mockApiClient.createOrganization.mockResolvedValue({
+			ok: true,
+			data: { success: true, organization_id: 'org-1', slug: 'my-custom-slug' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await createOrganization(
 			{ name: 'Test Org', slug: 'my-custom-slug' },
 			ctx
 		);
 
-		expect(result.result).toMatchObject({
-			success: true,
-		});
+		expect(result.result).toMatchObject({ success: true });
 	});
 
 	it('should throw error when insert fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null },
-			insertResult: { data: null, error: { message: 'Insert failed' } },
+		mockApiClient.createOrganization.mockResolvedValue({
+			ok: false,
+			error: 'Failed to create organization',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			createOrganization({ name: 'Test Org' }, ctx)
-		).rejects.toThrow('Failed to create organization: Insert failed');
+		).rejects.toThrow('Failed to create organization');
 	});
 });
 
@@ -174,64 +159,51 @@ describe('updateOrganization', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			updateOrganization({ name: 'New Name' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid organization_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			updateOrganization({ organization_id: 'invalid', name: 'New Name' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error when no updates provided', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			updateOrganization({ organization_id: testUUID() }, ctx)
+			updateOrganization({ organization_id: VALID_UUID }, ctx)
 		).rejects.toThrow('No updates provided');
 	});
 
 	it('should update organization successfully', async () => {
-		const supabase = createMockSupabase({
-			updateResult: {
-				data: { id: testUUID(), name: 'Updated Org', description: 'New desc' },
-				error: null,
-			},
+		mockApiClient.updateOrganization.mockResolvedValue({
+			ok: true,
+			data: { success: true, organization_id: VALID_UUID },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await updateOrganization(
-			{
-				organization_id: testUUID(),
-				name: 'Updated Org',
-				description: 'New desc',
-			},
+			{ organization_id: VALID_UUID, name: 'Updated Org', description: 'New desc' },
 			ctx
 		);
 
-		expect(result.result).toMatchObject({
-			success: true,
-		});
+		expect(result.result).toMatchObject({ success: true });
 	});
 
 	it('should throw error when update fails', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: { message: 'Update failed' } },
+		mockApiClient.updateOrganization.mockResolvedValue({
+			ok: false,
+			error: 'Failed to update organization',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			updateOrganization({ organization_id: testUUID(), name: 'New Name' }, ctx)
-		).rejects.toThrow('Failed to update organization: Update failed');
+			updateOrganization({ organization_id: VALID_UUID, name: 'New Name' }, ctx)
+		).rejects.toThrow('Failed to update organization');
 	});
 });
 
@@ -243,28 +215,25 @@ describe('deleteOrganization', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(deleteOrganization({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid organization_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			deleteOrganization({ organization_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should delete organization successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		mockApiClient.deleteOrganization.mockResolvedValue({
+			ok: true,
+			data: { success: true, message: 'Organization deleted. All shares have been removed.' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await deleteOrganization({ organization_id: testUUID() }, ctx);
+		const result = await deleteOrganization({ organization_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			success: true,
@@ -273,14 +242,15 @@ describe('deleteOrganization', () => {
 	});
 
 	it('should throw error when delete fails', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: { message: 'Delete failed' } },
+		mockApiClient.deleteOrganization.mockResolvedValue({
+			ok: false,
+			error: 'Failed to delete organization',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			deleteOrganization({ organization_id: testUUID() }, ctx)
-		).rejects.toThrow('Failed to delete organization: Delete failed');
+			deleteOrganization({ organization_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Failed to delete organization');
 	});
 });
 
@@ -292,63 +262,57 @@ describe('listOrgMembers', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(listOrgMembers({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid organization_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			listOrgMembers({ organization_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should return empty array when no members', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.listOrgMembers.mockResolvedValue({
+			ok: true,
+			data: { members: [], count: 0 },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await listOrgMembers({ organization_id: testUUID() }, ctx);
+		const result = await listOrgMembers({ organization_id: VALID_UUID }, ctx);
 
-		expect(result.result).toMatchObject({
-			members: [],
-			count: 0,
-		});
+		expect(result.result).toMatchObject({ members: [], count: 0 });
 	});
 
 	it('should return members list', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: [
-					{ id: 'm-1', user_id: 'u-1', role: 'owner', joined_at: '2025-01-01T00:00:00Z' },
-					{ id: 'm-2', user_id: 'u-2', role: 'member', joined_at: '2025-01-02T00:00:00Z' },
+		mockApiClient.listOrgMembers.mockResolvedValue({
+			ok: true,
+			data: {
+				members: [
+					{ id: 'm-1', user_id: 'u-1', role: 'owner' },
+					{ id: 'm-2', user_id: 'u-2', role: 'member' },
 				],
-				error: null,
+				count: 2,
 			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await listOrgMembers({ organization_id: testUUID() }, ctx);
+		const result = await listOrgMembers({ organization_id: VALID_UUID }, ctx);
 
-		expect(result.result).toMatchObject({
-			count: 2,
-		});
+		expect(result.result).toMatchObject({ count: 2 });
 	});
 
 	it('should throw error when query fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Query failed' } },
+		mockApiClient.listOrgMembers.mockResolvedValue({
+			ok: false,
+			error: 'Failed to list members',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			listOrgMembers({ organization_id: testUUID() }, ctx)
-		).rejects.toThrow('Failed to list members: Query failed');
+			listOrgMembers({ organization_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Failed to list members');
 	});
 });
 
@@ -360,69 +324,44 @@ describe('inviteMember', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			inviteMember({ email: 'test@example.com' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing email', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			inviteMember({ organization_id: testUUID() }, ctx)
+			inviteMember({ organization_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for invalid role', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null }, // No existing invite
-		});
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			inviteMember({
-				organization_id: testUUID(),
-				email: 'test@example.com',
-				role: 'owner', // Invalid - can't invite as owner
-			}, ctx)
-		).rejects.toThrow('Invalid role. Must be admin, member, or viewer.');
-	});
-
 	it('should throw error when invite already exists', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { id: 'existing-invite' }, error: null },
+		mockApiClient.inviteMember.mockResolvedValue({
+			ok: false,
+			error: 'A pending invite already exists for test@example.com',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			inviteMember({
-				organization_id: testUUID(),
-				email: 'test@example.com',
-			}, ctx)
+			inviteMember({ organization_id: VALID_UUID, email: 'test@example.com' }, ctx)
 		).rejects.toThrow('A pending invite already exists for test@example.com');
 	});
 
 	it('should create invite successfully with default role', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null }, // No existing invite
-			insertResult: {
-				data: {
-					id: 'invite-1',
-					email: 'test@example.com',
-					role: 'member',
-					token: 'abc123',
-				},
-				error: null,
+		mockApiClient.inviteMember.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				invite_id: 'invite-1',
+				message: 'Invite sent to test@example.com with role "member"',
 			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await inviteMember({
-			organization_id: testUUID(),
+			organization_id: VALID_UUID,
 			email: 'test@example.com',
 		}, ctx);
 
@@ -433,18 +372,15 @@ describe('inviteMember', () => {
 	});
 
 	it('should throw error when insert fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null },
-			insertResult: { data: null, error: { message: 'Insert failed' } },
+		mockApiClient.inviteMember.mockResolvedValue({
+			ok: false,
+			error: 'Failed to create invite',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			inviteMember({
-				organization_id: testUUID(),
-				email: 'test@example.com',
-			}, ctx)
-		).rejects.toThrow('Failed to create invite: Insert failed');
+			inviteMember({ organization_id: VALID_UUID, email: 'test@example.com' }, ctx)
+		).rejects.toThrow('Failed to create invite');
 	});
 });
 
@@ -456,105 +392,72 @@ describe('updateMemberRole', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			updateMemberRole({ user_id: testUUID(), role: 'admin' }, ctx)
+			updateMemberRole({ user_id: VALID_UUID, role: 'admin' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing user_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			updateMemberRole({ organization_id: testUUID(), role: 'admin' }, ctx)
+			updateMemberRole({ organization_id: VALID_UUID, role: 'admin' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing role', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			updateMemberRole({ organization_id: testUUID(), user_id: testUUID() }, ctx)
+			updateMemberRole({ organization_id: VALID_UUID, user_id: OTHER_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for invalid role', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			updateMemberRole({
-				organization_id: testUUID(),
-				user_id: testUUID(),
-				role: 'superadmin',
-			}, ctx)
-		).rejects.toThrow('Invalid role. Must be one of: viewer, member, admin, owner');
-	});
-
-	it('should throw error when trying to assign owner role', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			updateMemberRole({
-				organization_id: testUUID(),
-				user_id: testUUID(),
-				role: 'owner',
-			}, ctx)
-		).rejects.toThrow('Cannot assign owner role. Use transfer ownership instead.');
-	});
-
 	it('should throw error when changing own role', async () => {
-		const supabase = createMockSupabase();
-		const ownUserId = testUUID(); // Use valid UUID
-		const ctx = createMockContext(supabase, { userId: ownUserId });
+		mockApiClient.updateMemberRole.mockResolvedValue({
+			ok: false,
+			error: 'Cannot change your own role',
+		});
+		const ctx = createMockContext({ userId: VALID_UUID });
 
 		await expect(
 			updateMemberRole({
-				organization_id: testUUID(),
-				user_id: ownUserId,
+				organization_id: OTHER_UUID,
+				user_id: VALID_UUID,
 				role: 'admin',
 			}, ctx)
 		).rejects.toThrow('Cannot change your own role');
 	});
 
 	it('should update member role successfully', async () => {
-		const supabase = createMockSupabase({
-			updateResult: {
-				data: { user_id: testUUID(), role: 'admin' },
-				error: null,
-			},
+		mockApiClient.updateMemberRole.mockResolvedValue({
+			ok: true,
+			data: { success: true, user_id: OTHER_UUID, role: 'admin' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await updateMemberRole({
-			organization_id: testUUID(),
-			user_id: testUUID(),
+			organization_id: VALID_UUID,
+			user_id: OTHER_UUID,
 			role: 'admin',
 		}, ctx);
 
-		expect(result.result).toMatchObject({
-			success: true,
-		});
+		expect(result.result).toMatchObject({ success: true });
 	});
 
 	it('should throw error when update fails', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: { message: 'Update failed' } },
+		mockApiClient.updateMemberRole.mockResolvedValue({
+			ok: false,
+			error: 'Failed to update member role',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			updateMemberRole({
-				organization_id: testUUID(),
-				user_id: testUUID(),
+				organization_id: VALID_UUID,
+				user_id: OTHER_UUID,
 				role: 'admin',
 			}, ctx)
-		).rejects.toThrow('Failed to update member role: Update failed');
+		).rejects.toThrow('Failed to update member role');
 	});
 });
 
@@ -566,32 +469,32 @@ describe('removeMember', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			removeMember({ user_id: testUUID() }, ctx)
+			removeMember({ user_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing user_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			removeMember({ organization_id: testUUID() }, ctx)
+			removeMember({ organization_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should remove member successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		mockApiClient.removeMember.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				message: 'Member removed. Their org-scoped API keys have been invalidated.',
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await removeMember({
-			organization_id: testUUID(),
-			user_id: testUUID(),
+			organization_id: VALID_UUID,
+			user_id: OTHER_UUID,
 		}, ctx);
 
 		expect(result.result).toMatchObject({
@@ -601,17 +504,15 @@ describe('removeMember', () => {
 	});
 
 	it('should throw error when delete fails', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: { message: 'Delete failed' } },
+		mockApiClient.removeMember.mockResolvedValue({
+			ok: false,
+			error: 'Failed to remove member',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			removeMember({
-				organization_id: testUUID(),
-				user_id: testUUID(),
-			}, ctx)
-		).rejects.toThrow('Failed to remove member: Delete failed');
+			removeMember({ organization_id: VALID_UUID, user_id: OTHER_UUID }, ctx)
+		).rejects.toThrow('Failed to remove member');
 	});
 });
 
@@ -623,31 +524,30 @@ describe('leaveOrganization', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(leaveOrganization({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error when user is owner', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { role: 'owner' }, error: null },
+		mockApiClient.leaveOrganization.mockResolvedValue({
+			ok: false,
+			error: 'Owner cannot leave. Transfer ownership first or delete the organization.',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			leaveOrganization({ organization_id: testUUID() }, ctx)
+			leaveOrganization({ organization_id: VALID_UUID }, ctx)
 		).rejects.toThrow('Owner cannot leave. Transfer ownership first or delete the organization.');
 	});
 
 	it('should leave organization successfully', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { role: 'member' }, error: null },
-			deleteResult: { data: null, error: null },
+		mockApiClient.leaveOrganization.mockResolvedValue({
+			ok: true,
+			data: { success: true, message: 'You have left the organization.' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await leaveOrganization({ organization_id: testUUID() }, ctx);
+		const result = await leaveOrganization({ organization_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			success: true,
@@ -656,15 +556,15 @@ describe('leaveOrganization', () => {
 	});
 
 	it('should throw error when delete fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { role: 'member' }, error: null },
-			deleteResult: { data: null, error: { message: 'Delete failed' } },
+		mockApiClient.leaveOrganization.mockResolvedValue({
+			ok: false,
+			error: 'Failed to leave organization',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			leaveOrganization({ organization_id: testUUID() }, ctx)
-		).rejects.toThrow('Failed to leave organization: Delete failed');
+			leaveOrganization({ organization_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Failed to leave organization');
 	});
 });
 
@@ -676,109 +576,55 @@ describe('shareProjectWithOrg', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			shareProjectWithOrg({ organization_id: testUUID() }, ctx)
+			shareProjectWithOrg({ organization_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			shareProjectWithOrg({ project_id: testUUID() }, ctx)
+			shareProjectWithOrg({ project_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for invalid permission', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			shareProjectWithOrg({
-				project_id: testUUID(),
-				organization_id: testUUID(),
-				permission: 'invalid',
-			}, ctx)
-		).rejects.toThrow('Invalid permission. Must be one of: read, write, admin');
-	});
-
 	it('should throw error when project not found or not owned', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null },
+		mockApiClient.shareProjectWithOrg.mockResolvedValue({
+			ok: false,
+			error: 'Project not found or you are not the owner',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			shareProjectWithOrg({
-				project_id: testUUID(),
-				organization_id: testUUID(),
-			}, ctx)
+			shareProjectWithOrg({ project_id: VALID_UUID, organization_id: OTHER_UUID }, ctx)
 		).rejects.toThrow('Project not found or you are not the owner');
 	});
 
 	it('should share project successfully with default permission', async () => {
-		// Need to simulate multiple select calls
-		const supabase = createMockSupabase();
-		let selectCount = 0;
-		supabase.select = vi.fn(() => {
-			selectCount++;
-			return supabase;
-		});
-		supabase.single = vi.fn(() => {
-			if (selectCount === 1) {
-				// First call: get project
-				return Promise.resolve({ data: { id: testUUID(), name: 'Test Project' }, error: null });
-			}
-			// Insert result
-			return Promise.resolve({
-				data: { id: 'share-1', permission: 'read' },
-				error: null,
-			});
-		});
-		supabase.maybeSingle = vi.fn(() => {
-			// Check for existing share
-			return Promise.resolve({ data: null, error: null });
-		});
-
-		const ctx = createMockContext(supabase);
+		mockApiClient.shareProjectWithOrg.mockResolvedValue({
+			ok: true,
+			data: { success: true, share_id: 'share-1', permission: 'read' },
+		});
+		const ctx = createMockContext();
 
 		const result = await shareProjectWithOrg({
-			project_id: testUUID(),
-			organization_id: testUUID(),
+			project_id: VALID_UUID,
+			organization_id: OTHER_UUID,
 		}, ctx);
 
-		expect(result.result).toMatchObject({
-			success: true,
-		});
+		expect(result.result).toMatchObject({ success: true });
 	});
 
 	it('should throw error when share already exists', async () => {
-		const supabase = createMockSupabase();
-		let selectCount = 0;
-		supabase.select = vi.fn(() => {
-			selectCount++;
-			return supabase;
-		});
-		supabase.single = vi.fn(() => {
-			// First call: get project
-			return Promise.resolve({ data: { id: testUUID(), name: 'Test Project' }, error: null });
+		mockApiClient.shareProjectWithOrg.mockResolvedValue({
+			ok: false,
+			error: 'Project is already shared with this organization',
 		});
-		supabase.maybeSingle = vi.fn(() => {
-			// Check for existing share - exists
-			return Promise.resolve({ data: { id: 'existing-share' }, error: null });
-		});
-
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			shareProjectWithOrg({
-				project_id: testUUID(),
-				organization_id: testUUID(),
-			}, ctx)
+			shareProjectWithOrg({ project_id: VALID_UUID, organization_id: OTHER_UUID }, ctx)
 		).rejects.toThrow('Project is already shared with this organization');
 	});
 });
@@ -791,78 +637,56 @@ describe('updateProjectShare', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			updateProjectShare({ organization_id: testUUID(), permission: 'write' }, ctx)
+			updateProjectShare({ organization_id: VALID_UUID, permission: 'write' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			updateProjectShare({ project_id: testUUID(), permission: 'write' }, ctx)
+			updateProjectShare({ project_id: VALID_UUID, permission: 'write' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing permission', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			updateProjectShare({ project_id: testUUID(), organization_id: testUUID() }, ctx)
+			updateProjectShare({ project_id: VALID_UUID, organization_id: OTHER_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for invalid permission', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			updateProjectShare({
-				project_id: testUUID(),
-				organization_id: testUUID(),
-				permission: 'invalid',
-			}, ctx)
-		).rejects.toThrow('Invalid permission. Must be one of: read, write, admin');
-	});
-
 	it('should update share permission successfully', async () => {
-		const supabase = createMockSupabase({
-			updateResult: {
-				data: { id: 'share-1', permission: 'write' },
-				error: null,
-			},
+		mockApiClient.updateProjectShare.mockResolvedValue({
+			ok: true,
+			data: { success: true, share_id: 'share-1', permission: 'write' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await updateProjectShare({
-			project_id: testUUID(),
-			organization_id: testUUID(),
+			project_id: VALID_UUID,
+			organization_id: OTHER_UUID,
 			permission: 'write',
 		}, ctx);
 
-		expect(result.result).toMatchObject({
-			success: true,
-		});
+		expect(result.result).toMatchObject({ success: true });
 	});
 
 	it('should throw error when update fails', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: { message: 'Update failed' } },
+		mockApiClient.updateProjectShare.mockResolvedValue({
+			ok: false,
+			error: 'Failed to update share',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			updateProjectShare({
-				project_id: testUUID(),
-				organization_id: testUUID(),
+				project_id: VALID_UUID,
+				organization_id: OTHER_UUID,
 				permission: 'write',
 			}, ctx)
-		).rejects.toThrow('Failed to update share: Update failed');
+		).rejects.toThrow('Failed to update share');
 	});
 });
 
@@ -874,32 +698,32 @@ describe('unshareProject', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			unshareProject({ organization_id: testUUID() }, ctx)
+			unshareProject({ organization_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing organization_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			unshareProject({ project_id: testUUID() }, ctx)
+			unshareProject({ project_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should unshare project successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		mockApiClient.unshareProject.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				message: 'Project share removed. Org members can no longer access this project.',
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await unshareProject({
-			project_id: testUUID(),
-			organization_id: testUUID(),
+			project_id: VALID_UUID,
+			organization_id: OTHER_UUID,
 		}, ctx);
 
 		expect(result.result).toMatchObject({
@@ -909,17 +733,15 @@ describe('unshareProject', () => {
 	});
 
 	it('should throw error when delete fails', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: { message: 'Delete failed' } },
+		mockApiClient.unshareProject.mockResolvedValue({
+			ok: false,
+			error: 'Failed to unshare project',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			unshareProject({
-				project_id: testUUID(),
-				organization_id: testUUID(),
-			}, ctx)
-		).rejects.toThrow('Failed to unshare project: Delete failed');
+			unshareProject({ project_id: VALID_UUID, organization_id: OTHER_UUID }, ctx)
+		).rejects.toThrow('Failed to unshare project');
 	});
 });
 
@@ -931,67 +753,53 @@ describe('listProjectShares', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(listProjectShares({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			listProjectShares({ project_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should return empty array when no shares', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.listProjectShares.mockResolvedValue({
+			ok: true,
+			data: { shares: [], count: 0 },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await listProjectShares({ project_id: testUUID() }, ctx);
+		const result = await listProjectShares({ project_id: VALID_UUID }, ctx);
 
-		expect(result.result).toMatchObject({
-			shares: [],
-			count: 0,
-		});
+		expect(result.result).toMatchObject({ shares: [], count: 0 });
 	});
 
 	it('should return shares list', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: [
-					{
-						id: 'share-1',
-						permission: 'read',
-						shared_at: '2025-01-14T12:00:00Z',
-						shared_by: 'user-123',
-						organizations: { id: 'org-1', name: 'Test Org', slug: 'test-org' },
-					},
-				],
-				error: null,
+		mockApiClient.listProjectShares.mockResolvedValue({
+			ok: true,
+			data: {
+				shares: [{ id: 'share-1', permission: 'read', organization: { name: 'Test Org' } }],
+				count: 1,
 			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await listProjectShares({ project_id: testUUID() }, ctx);
+		const result = await listProjectShares({ project_id: VALID_UUID }, ctx);
 
-		expect(result.result).toMatchObject({
-			count: 1,
-		});
+		expect(result.result).toMatchObject({ count: 1 });
 	});
 
 	it('should throw error when query fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Query failed' } },
+		mockApiClient.listProjectShares.mockResolvedValue({
+			ok: false,
+			error: 'Failed to list shares',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			listProjectShares({ project_id: testUUID() }, ctx)
-		).rejects.toThrow('Failed to list shares: Query failed');
+			listProjectShares({ project_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Failed to list shares');
 	});
 });