feat: test feature groups

Author: gregnr

packages/mcp-server-supabase/src/server.test.ts

@@ -24,7 +24,7 @@ import {
 } from '../test/mocks.js';
 import { createSupabaseApiPlatform } from './platform/api-platform.js';
 import { BRANCH_COST_HOURLY, PROJECT_COST_MONTHLY } from './pricing.js';
-import { createSupabaseMcpServer } from './server.js';
+import { createSupabaseMcpServer, type FeatureGroup } from './server.js';
 
 beforeEach(async () => {
   mockOrgs.clear();
@@ -39,7 +39,7 @@ type SetupOptions = {
   accessToken?: string;
   projectId?: string;
   readOnly?: boolean;
-  features?: string[];
+  features?: FeatureGroup[];
 };
 
 /**
@@ -497,7 +497,7 @@ describe('tools', () => {
   });
 
   test('get project url', async () => {
-    const { callTool } = await setup({ features: ['development'] });
+    const { callTool } = await setup();
 
     const org = await createOrganization({
       name: 'My Org',
@@ -522,7 +522,7 @@ describe('tools', () => {
   });
 
   test('get anon key', async () => {
-    const { callTool } = await setup({ features: ['development'] });
+    const { callTool } = await setup();
     const org = await createOrganization({
       name: 'My Org',
       plan: 'free',
@@ -1568,7 +1568,7 @@ describe('tools', () => {
 
   test('create branch', async () => {
     const { callTool } = await setup({
-      features: ['account', 'branching', 'database'],
+      features: ['account', 'branching'],
     });
 
     const org = await createOrganization({
@@ -1652,7 +1652,7 @@ describe('tools', () => {
 
   test('delete branch', async () => {
     const { callTool } = await setup({
-      features: ['account', 'branching', 'database'],
+      features: ['account', 'branching'],
     });
 
     const org = await createOrganization({
@@ -2096,6 +2096,159 @@ describe('tools', () => {
   });
 });
 
+describe('feature groups', () => {
+  test('account tools', async () => {
+    const { client: accountClient } = await setup({
+      features: ['account'],
+    });
+
+    const { tools: accountTools } = await accountClient.listTools();
+    const accountToolNames = accountTools.map((tool) => tool.name);
+
+    expect(accountToolNames).toEqual([
+      'list_organizations',
+      'get_organization',
+      'list_projects',
+      'get_project',
+      'get_cost',
+      'confirm_cost',
+      'create_project',
+      'pause_project',
+      'restore_project',
+    ]);
+  });
+
+  test('database tools', async () => {
+    const { client: databaseClient } = await setup({
+      features: ['database'],
+    });
+
+    const { tools: databaseTools } = await databaseClient.listTools();
+    const databaseToolNames = databaseTools.map((tool) => tool.name);
+
+    expect(databaseToolNames).toEqual([
+      'list_tables',
+      'list_extensions',
+      'list_migrations',
+      'apply_migration',
+      'execute_sql',
+    ]);
+  });
+
+  test('debug tools', async () => {
+    const { client: debugClient } = await setup({
+      features: ['debug'],
+    });
+
+    const { tools: debugTools } = await debugClient.listTools();
+    const debugToolNames = debugTools.map((tool) => tool.name);
+
+    expect(debugToolNames).toEqual(['get_logs', 'get_advisors']);
+  });
+
+  test('development tools', async () => {
+    const { client: developmentClient } = await setup({
+      features: ['development'],
+    });
+
+    const { tools: developmentTools } = await developmentClient.listTools();
+    const developmentToolNames = developmentTools.map((tool) => tool.name);
+
+    expect(developmentToolNames).toEqual([
+      'get_project_url',
+      'get_anon_key',
+      'generate_typescript_types',
+    ]);
+  });
+
+  test('docs tools', async () => {
+    const { client: docsClient } = await setup({
+      features: ['docs'],
+    });
+
+    const { tools: docsTools } = await docsClient.listTools();
+    const docsToolNames = docsTools.map((tool) => tool.name);
+
+    expect(docsToolNames).toEqual(['search_docs']);
+  });
+
+  test('functions tools', async () => {
+    const { client: functionsClient } = await setup({
+      features: ['functions'],
+    });
+
+    const { tools: functionsTools } = await functionsClient.listTools();
+    const functionsToolNames = functionsTools.map((tool) => tool.name);
+
+    expect(functionsToolNames).toEqual([
+      'list_edge_functions',
+      'deploy_edge_function',
+    ]);
+  });
+
+  test('branching tools', async () => {
+    const { client: branchingClient } = await setup({
+      features: ['branching'],
+    });
+
+    const { tools: branchingTools } = await branchingClient.listTools();
+    const branchingToolNames = branchingTools.map((tool) => tool.name);
+
+    expect(branchingToolNames).toEqual([
+      'create_branch',
+      'list_branches',
+      'delete_branch',
+      'merge_branch',
+      'reset_branch',
+      'rebase_branch',
+    ]);
+  });
+
+  test('storage tools', async () => {
+    const { client: storageClient } = await setup({
+      features: ['storage'],
+    });
+
+    const { tools: storageTools } = await storageClient.listTools();
+    const storageToolNames = storageTools.map((tool) => tool.name);
+
+    expect(storageToolNames).toEqual([
+      'list_storage_buckets',
+      'get_storage_config',
+      'update_storage_config',
+    ]);
+  });
+
+  test('invalid group fails', async () => {
+    const setupPromise = setup({
+      features: ['my-invalid-group' as FeatureGroup],
+    });
+
+    await expect(setupPromise).rejects.toThrow('Invalid enum value');
+  });
+
+  test('duplicate group behaves like single group', async () => {
+    const { client: duplicateClient } = await setup({
+      features: ['account', 'account'],
+    });
+
+    const { tools: duplicateTools } = await duplicateClient.listTools();
+    const duplicateToolNames = duplicateTools.map((tool) => tool.name);
+
+    expect(duplicateToolNames).toEqual([
+      'list_organizations',
+      'get_organization',
+      'list_projects',
+      'get_project',
+      'get_cost',
+      'confirm_cost',
+      'create_project',
+      'pause_project',
+      'restore_project',
+    ]);
+  });
+});
+
 describe('project scoped tools', () => {
   test('no account level tools should exist', async () => {
     const org = await createOrganization({