Add tests for kernel Zod schemas: context, feature, package-registry, plugin-structure

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/spec/src/kernel/context.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import {
+  RuntimeMode,
+  KernelContextSchema,
+  type KernelContext,
+} from './context.zod';
+
+describe('RuntimeMode', () => {
+  it('should accept valid runtime modes', () => {
+    expect(() => RuntimeMode.parse('development')).not.toThrow();
+    expect(() => RuntimeMode.parse('production')).not.toThrow();
+    expect(() => RuntimeMode.parse('test')).not.toThrow();
+    expect(() => RuntimeMode.parse('provisioning')).not.toThrow();
+  });
+
+  it('should reject invalid runtime modes', () => {
+    expect(() => RuntimeMode.parse('staging')).toThrow();
+    expect(() => RuntimeMode.parse('debug')).toThrow();
+    expect(() => RuntimeMode.parse('')).toThrow();
+  });
+});
+
+describe('KernelContextSchema', () => {
+  const validContext: KernelContext = {
+    instanceId: '550e8400-e29b-41d4-a716-446655440000',
+    mode: 'production',
+    version: '1.0.0',
+    cwd: '/app',
+    startTime: Date.now(),
+    features: {},
+  };
+
+  it('should accept valid minimal context', () => {
+    expect(() => KernelContextSchema.parse(validContext)).not.toThrow();
+  });
+
+  it('should accept context with all optional fields', () => {
+    const full = {
+      ...validContext,
+      appName: 'My App',
+      workspaceRoot: '/workspace',
+    };
+    const parsed = KernelContextSchema.parse(full);
+    expect(parsed.appName).toBe('My App');
+    expect(parsed.workspaceRoot).toBe('/workspace');
+  });
+
+  it('should apply default mode to production', () => {
+    const { mode: _, ...withoutMode } = validContext;
+    const parsed = KernelContextSchema.parse(withoutMode);
+    expect(parsed.mode).toBe('production');
+  });
+
+  it('should apply default features to empty record', () => {
+    const { features: _, ...withoutFeatures } = validContext;
+    const parsed = KernelContextSchema.parse(withoutFeatures);
+    expect(parsed.features).toEqual({});
+  });
+
+  it('should accept feature flags', () => {
+    const ctx = {
+      ...validContext,
+      features: { darkMode: true, beta: false },
+    };
+    const parsed = KernelContextSchema.parse(ctx);
+    expect(parsed.features.darkMode).toBe(true);
+    expect(parsed.features.beta).toBe(false);
+  });
+
+  it('should reject invalid instanceId (not UUID)', () => {
+    expect(() => KernelContextSchema.parse({
+      ...validContext,
+      instanceId: 'not-a-uuid',
+    })).toThrow();
+  });
+
+  it('should reject missing required fields', () => {
+    expect(() => KernelContextSchema.parse({})).toThrow();
+    expect(() => KernelContextSchema.parse({ instanceId: '550e8400-e29b-41d4-a716-446655440000' })).toThrow();
+  });
+
+  it('should reject non-integer startTime', () => {
+    expect(() => KernelContextSchema.parse({
+      ...validContext,
+      startTime: 1.5,
+    })).toThrow();
+  });
+
+  it('should accept all runtime modes in context', () => {
+    const modes = ['development', 'production', 'test', 'provisioning'] as const;
+    modes.forEach(mode => {
+      const parsed = KernelContextSchema.parse({ ...validContext, mode });
+      expect(parsed.mode).toBe(mode);
+    });
+  });
+});

packages/spec/src/kernel/feature.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import {
+  FeatureStrategy,
+  FeatureFlagSchema,
+  FeatureFlag,
+  type FeatureFlag as FeatureFlagType,
+} from './feature.zod';
+
+describe('FeatureStrategy', () => {
+  it('should accept valid strategies', () => {
+    expect(() => FeatureStrategy.parse('boolean')).not.toThrow();
+    expect(() => FeatureStrategy.parse('percentage')).not.toThrow();
+    expect(() => FeatureStrategy.parse('user_list')).not.toThrow();
+    expect(() => FeatureStrategy.parse('group')).not.toThrow();
+    expect(() => FeatureStrategy.parse('custom')).not.toThrow();
+  });
+
+  it('should reject invalid strategies', () => {
+    expect(() => FeatureStrategy.parse('random')).toThrow();
+    expect(() => FeatureStrategy.parse('')).toThrow();
+  });
+});
+
+describe('FeatureFlagSchema', () => {
+  const minimalFlag = {
+    name: 'dark_mode',
+  };
+
+  it('should accept minimal feature flag', () => {
+    expect(() => FeatureFlagSchema.parse(minimalFlag)).not.toThrow();
+  });
+
+  it('should apply default values', () => {
+    const parsed = FeatureFlagSchema.parse(minimalFlag);
+    expect(parsed.enabled).toBe(false);
+    expect(parsed.strategy).toBe('boolean');
+    expect(parsed.environment).toBe('all');
+  });
+
+  it('should accept feature flag with all fields', () => {
+    const full: FeatureFlagType = {
+      name: 'new_dashboard',
+      label: 'New Dashboard',
+      description: 'Enables the new dashboard UI',
+      enabled: true,
+      strategy: 'percentage',
+      conditions: {
+        percentage: 50,
+        users: ['user_1', 'user_2'],
+        groups: ['beta_testers'],
+        expression: 'user.plan == "pro"',
+      },
+      environment: 'staging',
+      expiresAt: '2025-12-31T23:59:59Z',
+    };
+
+    const parsed = FeatureFlagSchema.parse(full);
+    expect(parsed.label).toBe('New Dashboard');
+    expect(parsed.conditions?.percentage).toBe(50);
+    expect(parsed.conditions?.users).toHaveLength(2);
+    expect(parsed.environment).toBe('staging');
+  });
+
+  it('should reject invalid name (not snake_case)', () => {
+    expect(() => FeatureFlagSchema.parse({ name: 'DarkMode' })).toThrow();
+    expect(() => FeatureFlagSchema.parse({ name: 'dark-mode' })).toThrow();
+    expect(() => FeatureFlagSchema.parse({ name: '1invalid' })).toThrow();
+  });
+
+  it('should reject name that is too short', () => {
+    expect(() => FeatureFlagSchema.parse({ name: 'a' })).toThrow();
+  });
+
+  it('should accept all environment values', () => {
+    const envs = ['dev', 'staging', 'prod', 'all'] as const;
+    envs.forEach(environment => {
+      const parsed = FeatureFlagSchema.parse({ name: 'test_flag', environment });
+      expect(parsed.environment).toBe(environment);
+    });
+  });
+
+  it('should reject invalid environment', () => {
+    expect(() => FeatureFlagSchema.parse({
+      name: 'test_flag',
+      environment: 'local',
+    })).toThrow();
+  });
+
+  it('should reject percentage out of range', () => {
+    expect(() => FeatureFlagSchema.parse({
+      name: 'test_flag',
+      conditions: { percentage: 101 },
+    })).toThrow();
+
+    expect(() => FeatureFlagSchema.parse({
+      name: 'test_flag',
+      conditions: { percentage: -1 },
+    })).toThrow();
+  });
+
+  it('should accept percentage at boundaries', () => {
+    const zero = FeatureFlagSchema.parse({
+      name: 'test_flag',
+      conditions: { percentage: 0 },
+    });
+    expect(zero.conditions?.percentage).toBe(0);
+
+    const hundred = FeatureFlagSchema.parse({
+      name: 'test_flag',
+      conditions: { percentage: 100 },
+    });
+    expect(hundred.conditions?.percentage).toBe(100);
+  });
+
+  it('should validate expiresAt as ISO datetime', () => {
+    expect(() => FeatureFlagSchema.parse({
+      name: 'test_flag',
+      expiresAt: 'not-a-date',
+    })).toThrow();
+
+    expect(() => FeatureFlagSchema.parse({
+      name: 'test_flag',
+      expiresAt: '2025-06-15T10:00:00Z',
+    })).not.toThrow();
+  });
+});
+
+describe('FeatureFlag.create', () => {
+  it('should return the config object as-is', () => {
+    const config = { name: 'my_feature', enabled: true };
+    const result = FeatureFlag.create(config);
+    expect(result).toEqual(config);
+  });
+});