test: collapse schema enumeration tests and remove duplicates

src/cli/commands/deploy/__tests__/deploy.test.ts

@@ -6,19 +6,14 @@ import { join } from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
 describe('deploy --help', () => {
-  it('shows verbose option', async () => {
-    const result = await runCLI(['deploy', '--help'], process.cwd());
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.includes('--verbose'), 'Should show --verbose option').toBeTruthy();
-    expect(result.stdout.includes('resource-level'), 'Should describe resource-level events').toBeTruthy();
-  });
-
   it('shows all deploy options', async () => {
     const result = await runCLI(['deploy', '--help'], process.cwd());
+    expect(result.exitCode).toBe(0);
     expect(result.stdout.includes('--yes')).toBeTruthy();
     expect(result.stdout.includes('--verbose')).toBeTruthy();
     expect(result.stdout.includes('--json')).toBeTruthy();
     expect(result.stdout.includes('--dry-run')).toBeTruthy();
+    expect(result.stdout.includes('resource-level'), 'Should describe resource-level events').toBeTruthy();
   });
 });
 

src/cli/commands/dev/__tests__/dev.test.ts

@@ -74,12 +74,5 @@ describe('dev command', () => {
 
       expect(result.exitCode).toBe(1);
     });
-
-    it('stream flag is documented in help', async () => {
-      const result = await runCLI(['dev', '--help'], process.cwd());
-
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout.includes('--stream'), 'Should show --stream option').toBeTruthy();
-    });
   });
 });

src/cli/operations/identity/__tests__/credential-ops.test.ts

@@ -147,20 +147,3 @@ describe('resolveCredentialStrategy', () => {
     expect(result.isAgentScoped).toBe(true);
   });
 });
-
-// TODO: OAuth credential creation needs to be added to CredentialPrimitive.
-// These tests were ported from main's create-identity.ts OAuth support.
-// Once CredentialPrimitive.addOAuth() is implemented, convert these to use primitive.addOAuth().
-describe('createCredential OAuth', () => {
-  afterEach(() => vi.clearAllMocks());
-
-  it.todo('creates OAuth credential and writes to project');
-
-  it.todo('writes CLIENT_ID and CLIENT_SECRET to env');
-
-  it.todo('uppercases name in env var keys');
-
-  it.todo('throws when OAuth credential already exists');
-
-  it.todo('includes scopes when provided');
-});

src/schema/__tests__/constants.test.ts

@@ -39,72 +39,45 @@ describe('matchEnumValue', () => {
 });
 
 describe('SDKFrameworkSchema', () => {
-  it.each(['Strands', 'LangChain_LangGraph', 'GoogleADK', 'OpenAIAgents'])('accepts "%s"', framework => {
-    expect(SDKFrameworkSchema.safeParse(framework).success).toBe(true);
-  });
-
-  it('rejects invalid framework', () => {
+  it('accepts valid frameworks and rejects invalid', () => {
+    expect(SDKFrameworkSchema.safeParse('Strands').success).toBe(true);
+    expect(SDKFrameworkSchema.safeParse('OpenAIAgents').success).toBe(true);
     expect(SDKFrameworkSchema.safeParse('AutoGen').success).toBe(false);
     expect(SDKFrameworkSchema.safeParse('strands').success).toBe(false); // case-sensitive
   });
 });
 
 describe('ModelProviderSchema', () => {
-  it.each(['Bedrock', 'Gemini', 'OpenAI', 'Anthropic'])('accepts "%s"', provider => {
-    expect(ModelProviderSchema.safeParse(provider).success).toBe(true);
-  });
-
-  it('rejects invalid provider', () => {
+  it('accepts valid providers and rejects invalid', () => {
+    expect(ModelProviderSchema.safeParse('Bedrock').success).toBe(true);
+    expect(ModelProviderSchema.safeParse('Anthropic').success).toBe(true);
     expect(ModelProviderSchema.safeParse('Azure').success).toBe(false);
   });
 });
 
-describe('PythonRuntimeSchema', () => {
-  it.each(['PYTHON_3_10', 'PYTHON_3_11', 'PYTHON_3_12', 'PYTHON_3_13', 'PYTHON_3_14'])('accepts "%s"', version => {
-    expect(PythonRuntimeSchema.safeParse(version).success).toBe(true);
+describe('RuntimeVersionSchemas', () => {
+  it('accepts valid Python and Node versions', () => {
+    expect(PythonRuntimeSchema.safeParse('PYTHON_3_10').success).toBe(true);
+    expect(PythonRuntimeSchema.safeParse('PYTHON_3_14').success).toBe(true);
+    expect(NodeRuntimeSchema.safeParse('NODE_18').success).toBe(true);
+    expect(NodeRuntimeSchema.safeParse('NODE_22').success).toBe(true);
+    expect(RuntimeVersionSchema.safeParse('PYTHON_3_12').success).toBe(true);
+    expect(RuntimeVersionSchema.safeParse('NODE_20').success).toBe(true);
   });
 
-  it('rejects unsupported versions', () => {
+  it('rejects invalid versions', () => {
     expect(PythonRuntimeSchema.safeParse('PYTHON_3_9').success).toBe(false);
     expect(PythonRuntimeSchema.safeParse('PYTHON_3_15').success).toBe(false);
-  });
-});
-
-describe('NodeRuntimeSchema', () => {
-  it.each(['NODE_18', 'NODE_20', 'NODE_22'])('accepts "%s"', version => {
-    expect(NodeRuntimeSchema.safeParse(version).success).toBe(true);
-  });
-
-  it('rejects unsupported versions', () => {
     expect(NodeRuntimeSchema.safeParse('NODE_16').success).toBe(false);
     expect(NodeRuntimeSchema.safeParse('NODE_24').success).toBe(false);
-  });
-});
-
-describe('RuntimeVersionSchema', () => {
-  it('accepts Python versions', () => {
-    expect(RuntimeVersionSchema.safeParse('PYTHON_3_12').success).toBe(true);
-  });
-
-  it('accepts Node versions', () => {
-    expect(RuntimeVersionSchema.safeParse('NODE_20').success).toBe(true);
-  });
-
-  it('rejects invalid versions', () => {
     expect(RuntimeVersionSchema.safeParse('RUBY_3_0').success).toBe(false);
   });
 });
 
 describe('NetworkModeSchema', () => {
-  it('accepts PUBLIC', () => {
+  it('accepts valid modes and rejects invalid', () => {
     expect(NetworkModeSchema.safeParse('PUBLIC').success).toBe(true);
-  });
-
-  it('accepts VPC', () => {
     expect(NetworkModeSchema.safeParse('VPC').success).toBe(true);
-  });
-
-  it('rejects other modes', () => {
     expect(NetworkModeSchema.safeParse('PRIVATE').success).toBe(false);
   });
 });

src/schema/schemas/__tests__/agent-env.test.ts

@@ -15,72 +15,41 @@ import {
 import { describe, expect, it } from 'vitest';
 
 describe('AgentNameSchema', () => {
-  it.each(['Agent1', 'myAgent', 'A', 'agent_with_underscores', 'a' + '0'.repeat(47)])(
-    'accepts valid name "%s"',
-    name => {
-      expect(AgentNameSchema.safeParse(name).success).toBe(true);
-    }
-  );
-
-  it('rejects empty string', () => {
-    expect(AgentNameSchema.safeParse('').success).toBe(false);
+  it('accepts valid names', () => {
+    expect(AgentNameSchema.safeParse('Agent1').success).toBe(true);
+    expect(AgentNameSchema.safeParse('A').success).toBe(true);
+    expect(AgentNameSchema.safeParse('agent_with_underscores').success).toBe(true);
   });
 
-  it('rejects name starting with digit', () => {
+  it('rejects invalid names', () => {
+    expect(AgentNameSchema.safeParse('').success).toBe(false);
     expect(AgentNameSchema.safeParse('1Agent').success).toBe(false);
-  });
-
-  it('rejects name with hyphens', () => {
     expect(AgentNameSchema.safeParse('my-agent').success).toBe(false);
   });
 
-  it('rejects name exceeding 48 chars', () => {
-    const name = 'A' + 'b'.repeat(48);
-    expect(name).toHaveLength(49);
-    expect(AgentNameSchema.safeParse(name).success).toBe(false);
-  });
-
-  it('accepts 48-char name (max)', () => {
-    const name = 'A' + 'b'.repeat(47);
-    expect(name).toHaveLength(48);
-    expect(AgentNameSchema.safeParse(name).success).toBe(true);
+  it('enforces 48-char boundary', () => {
+    expect(AgentNameSchema.safeParse('A' + 'b'.repeat(47)).success).toBe(true);
+    expect(AgentNameSchema.safeParse('A' + 'b'.repeat(48)).success).toBe(false);
   });
 });
 
 describe('EnvVarNameSchema', () => {
-  it.each(['MY_VAR', '_private', 'UPPER123', 'a', '_'])('accepts valid env var name "%s"', name => {
-    expect(EnvVarNameSchema.safeParse(name).success).toBe(true);
-  });
-
-  it('rejects name starting with digit', () => {
+  it('accepts valid env var names and rejects invalid', () => {
+    expect(EnvVarNameSchema.safeParse('MY_VAR').success).toBe(true);
+    expect(EnvVarNameSchema.safeParse('_private').success).toBe(true);
     expect(EnvVarNameSchema.safeParse('1VAR').success).toBe(false);
-  });
-
-  it('rejects name with hyphens', () => {
     expect(EnvVarNameSchema.safeParse('MY-VAR').success).toBe(false);
-  });
-
-  it('rejects empty string', () => {
     expect(EnvVarNameSchema.safeParse('').success).toBe(false);
   });
 });
 
 describe('GatewayNameSchema', () => {
-  it.each(['gateway1', 'my-gateway', 'MyGateway', 'a'])('accepts valid gateway name "%s"', name => {
-    expect(GatewayNameSchema.safeParse(name).success).toBe(true);
-  });
-
-  it('rejects empty string', () => {
+  it('accepts valid names and rejects invalid', () => {
+    expect(GatewayNameSchema.safeParse('gateway1').success).toBe(true);
+    expect(GatewayNameSchema.safeParse('my-gateway').success).toBe(true);
     expect(GatewayNameSchema.safeParse('').success).toBe(false);
-  });
-
-  it('rejects name with underscores', () => {
     expect(GatewayNameSchema.safeParse('my_gateway').success).toBe(false);
-  });
-
-  it('rejects name exceeding 100 chars', () => {
-    const name = 'a'.repeat(101);
-    expect(GatewayNameSchema.safeParse(name).success).toBe(false);
+    expect(GatewayNameSchema.safeParse('a'.repeat(101)).success).toBe(false);
   });
 });
 
@@ -288,9 +257,10 @@ describe('AgentEnvSpecSchema', () => {
   });
 
   describe('protocol', () => {
-    it.each(['HTTP', 'MCP', 'A2A', 'AGUI'])('accepts valid protocol "%s"', mode => {
-      const result = AgentEnvSpecSchema.safeParse({ ...validPythonAgent, protocol: mode });
-      expect(result.success, `Should accept protocol ${mode}`).toBe(true);
+    it('accepts valid protocols', () => {
+      expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, protocol: 'HTTP' }).success).toBe(true);
+      expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, protocol: 'MCP' }).success).toBe(true);
+      expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, protocol: 'A2A' }).success).toBe(true);
     });
 
     it('accepts agent without protocol (backwards compat)', () => {
@@ -300,7 +270,6 @@ describe('AgentEnvSpecSchema', () => {
 
     it('rejects invalid protocol', () => {
       expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, protocol: 'GRPC' }).success).toBe(false);
-      expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, protocol: 'websocket' }).success).toBe(false);
     });
   });
 });
@@ -439,12 +408,12 @@ describe('AgentEnvSpecSchema - dockerfile', () => {
     }
   });
 
-  it.each(['Dockerfile', 'Dockerfile.dev', 'Dockerfile.gpu-v2', 'my.Dockerfile', 'dockerfile_test'])(
-    'accepts valid dockerfile name "%s"',
-    name => {
-      expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: name }).success).toBe(true);
-    }
-  );
+  it('accepts valid dockerfile names', () => {
+    expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: 'Dockerfile' }).success).toBe(true);
+    expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: 'Dockerfile.gpu-v2' }).success).toBe(
+      true
+    );
+  });
 
   it('rejects dockerfile on CodeZip builds', () => {
     const result = AgentEnvSpecSchema.safeParse({ ...validCodeZipAgent, dockerfile: 'Dockerfile.custom' });
@@ -454,12 +423,12 @@ describe('AgentEnvSpecSchema - dockerfile', () => {
     }
   });
 
-  it.each(['../Dockerfile', '/etc/Dockerfile', 'path/to/Dockerfile', '.hidden'])(
-    'rejects path traversal or path separator in dockerfile "%s"',
-    name => {
-      expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: name }).success).toBe(false);
-    }
-  );
+  it('rejects path traversal or path separator in dockerfile', () => {
+    expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: '../Dockerfile' }).success).toBe(false);
+    expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: 'path/to/Dockerfile' }).success).toBe(
+      false
+    );
+  });
 
   it('rejects empty string dockerfile', () => {
     expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: '' }).success).toBe(false);
@@ -481,12 +450,12 @@ describe('AgentEnvSpecSchema - dockerfile', () => {
     expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: maxName }).success).toBe(true);
   });
 
-  it.each(['\\\\server\\share', 'Dockerfile\\..\\secret', '..\\Dockerfile'])(
-    'rejects backslash path traversal in dockerfile "%s"',
-    name => {
-      expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: name }).success).toBe(false);
-    }
-  );
+  it('rejects backslash path traversal in dockerfile', () => {
+    expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: '\\\\server\\share' }).success).toBe(
+      false
+    );
+    expect(AgentEnvSpecSchema.safeParse({ ...validContainerAgent, dockerfile: '..\\Dockerfile' }).success).toBe(false);
+  });
 });
 
 describe('AgentEnvSpecSchema - lifecycleConfiguration', () => {
@@ -544,34 +513,21 @@ describe('AgentEnvSpecSchema - lifecycleConfiguration', () => {
 });
 
 describe('RuntimeEndpointNameSchema', () => {
-  it.each(['prod', 'staging', 'myEndpoint', 'v1', 'A', 'a' + '0'.repeat(47)])(
-    'accepts valid endpoint name "%s"',
-    name => {
-      expect(RuntimeEndpointNameSchema.safeParse(name).success).toBe(true);
-    }
-  );
-
-  it('rejects empty string', () => {
-    expect(RuntimeEndpointNameSchema.safeParse('').success).toBe(false);
+  it('accepts valid names', () => {
+    expect(RuntimeEndpointNameSchema.safeParse('prod').success).toBe(true);
+    expect(RuntimeEndpointNameSchema.safeParse('myEndpoint').success).toBe(true);
   });
 
-  it('rejects name starting with digit', () => {
+  it('rejects invalid names', () => {
+    expect(RuntimeEndpointNameSchema.safeParse('').success).toBe(false);
     expect(RuntimeEndpointNameSchema.safeParse('1prod').success).toBe(false);
-  });
-
-  it('rejects name with hyphens', () => {
     expect(RuntimeEndpointNameSchema.safeParse('my-endpoint').success).toBe(false);
-  });
-
-  it('rejects name with special characters', () => {
     expect(RuntimeEndpointNameSchema.safeParse('prod!').success).toBe(false);
-    expect(RuntimeEndpointNameSchema.safeParse('my@endpoint').success).toBe(false);
   });
 
-  it('rejects name exceeding 48 chars', () => {
-    const name = 'A' + 'b'.repeat(48);
-    expect(name).toHaveLength(49);
-    expect(RuntimeEndpointNameSchema.safeParse(name).success).toBe(false);
+  it('enforces 48-char boundary', () => {
+    expect(RuntimeEndpointNameSchema.safeParse('A' + 'b'.repeat(47)).success).toBe(true);
+    expect(RuntimeEndpointNameSchema.safeParse('A' + 'b'.repeat(48)).success).toBe(false);
   });
 });