@odvi/create-dtt-framework 0.1.3 → 0.1.6

package/template/src/config/__tests__/env.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { z } from 'zod';
+
+// Mock process.env
+const originalEnv = process.env;
+
+describe('env configuration', () => {
+  beforeEach(() => {
+    // Reset process.env before each test
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should have valid environment schema structure', () => {
+    // Import after setting up env
+    const envSchema = z.object({
+      NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
+      NEXT_PUBLIC_APP_URL: z.string().url().default('http://localhost:3000'),
+      NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: z.string().startsWith('pk_').default('pk_test_placeholder'),
+      CLERK_SECRET_KEY: z.string().startsWith('sk_').default('sk_test_placeholder'),
+      CLERK_WEBHOOK_SECRET: z.string().optional(),
+      NEXT_PUBLIC_SUPABASE_URL: z.string().url().default('https://placeholder.supabase.co'),
+      NEXT_PUBLIC_SUPABASE_ANON_KEY: z.string().default('placeholder'),
+      SUPABASE_SERVICE_ROLE_KEY: z.string().default('placeholder'),
+      DATABASE_URL: z.string().default('postgresql://postgres:password@localhost:5432/postgres'),
+      SNOWFLAKE_ACCOUNT: z.string().default('placeholder'),
+      SNOWFLAKE_USERNAME: z.string().default('placeholder'),
+      SNOWFLAKE_PASSWORD: z.string().default('placeholder'),
+      SNOWFLAKE_WAREHOUSE: z.string().default('COMPUTE_WH'),
+      SNOWFLAKE_DATABASE: z.string().default('ANALYTICS'),
+      SNOWFLAKE_SCHEMA: z.string().default('PUBLIC'),
+      SNOWFLAKE_ROLE: z.string().default('ANALYST'),
+      NEXTBANK_API: z.string().url().optional(),
+      NEXTBANK_API_USERNAME: z.string().optional(),
+      NEXTBANK_API_PASSWORD: z.string().optional(),
+    });
+
+    const result = envSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate NODE_ENV enum values', () => {
+    const validEnvs = ['development', 'test', 'production'] as const;
+    const envSchema = z.object({
+      NODE_ENV: z.enum(validEnvs).default('development'),
+    });
+
+    validEnvs.forEach((env) => {
+      const result = envSchema.safeParse({ NODE_ENV: env });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  it('should reject invalid NODE_ENV values', () => {
+    const envSchema = z.object({
+      NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
+    });
+
+    const result = envSchema.safeParse({ NODE_ENV: 'invalid' });
+    expect(result.success).toBe(false);
+  });
+
+  it('should validate URL fields', () => {
+    const urlSchema = z.object({
+      NEXT_PUBLIC_APP_URL: z.string().url(),
+      NEXT_PUBLIC_SUPABASE_URL: z.string().url(),
+    });
+
+    const validResult = urlSchema.safeParse({
+      NEXT_PUBLIC_APP_URL: 'https://example.com',
+      NEXT_PUBLIC_SUPABASE_URL: 'https://supabase.example.com',
+    });
+    expect(validResult.success).toBe(true);
+
+    const invalidResult = urlSchema.safeParse({
+      NEXT_PUBLIC_APP_URL: 'not-a-url',
+      NEXT_PUBLIC_SUPABASE_URL: 'also-not-a-url',
+    });
+    expect(invalidResult.success).toBe(false);
+  });
+
+  it('should validate Clerk key prefixes', () => {
+    const clerkSchema = z.object({
+      NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: z.string().startsWith('pk_'),
+      CLERK_SECRET_KEY: z.string().startsWith('sk_'),
+    });
+
+    const validResult = clerkSchema.safeParse({
+      NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: 'pk_test_123',
+      CLERK_SECRET_KEY: 'sk_test_456',
+    });
+    expect(validResult.success).toBe(true);
+
+    const invalidResult = clerkSchema.safeParse({
+      NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: 'invalid_key',
+      CLERK_SECRET_KEY: 'invalid_secret',
+    });
+    expect(invalidResult.success).toBe(false);
+  });
+
+  it('should allow optional NextBank fields', () => {
+    const nextbankSchema = z.object({
+      NEXTBANK_API: z.string().url().optional(),
+      NEXTBANK_API_USERNAME: z.string().optional(),
+      NEXTBANK_API_PASSWORD: z.string().optional(),
+    });
+
+    const result = nextbankSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate Snowflake configuration fields', () => {
+    const snowflakeSchema = z.object({
+      SNOWFLAKE_ACCOUNT: z.string(),
+      SNOWFLAKE_USERNAME: z.string(),
+      SNOWFLAKE_PASSWORD: z.string(),
+      SNOWFLAKE_WAREHOUSE: z.string(),
+      SNOWFLAKE_DATABASE: z.string(),
+      SNOWFLAKE_SCHEMA: z.string(),
+      SNOWFLAKE_ROLE: z.string(),
+    });
+
+    const result = snowflakeSchema.safeParse({
+      SNOWFLAKE_ACCOUNT: 'account',
+      SNOWFLAKE_USERNAME: 'user',
+      SNOWFLAKE_PASSWORD: 'pass',
+      SNOWFLAKE_WAREHOUSE: 'WH',
+      SNOWFLAKE_DATABASE: 'DB',
+      SNOWFLAKE_SCHEMA: 'SCHEMA',
+      SNOWFLAKE_ROLE: 'ROLE',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should use default values when environment variables are not set', () => {
+    const envSchema = z.object({
+      NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
+      NEXT_PUBLIC_APP_URL: z.string().url().default('http://localhost:3000'),
+    });
+
+    const result = envSchema.parse({});
+    expect(result.NODE_ENV).toBe('development');
+    expect(result.NEXT_PUBLIC_APP_URL).toBe('http://localhost:3000');
+  });
+
+  it('should override defaults with environment variables', () => {
+    const testEnv = {
+      NODE_ENV: 'production',
+      NEXT_PUBLIC_APP_URL: 'https://production.example.com',
+    };
+
+    const envSchema = z.object({
+      NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
+      NEXT_PUBLIC_APP_URL: z.string().url().default('http://localhost:3000'),
+    });
+
+    const result = envSchema.parse(testEnv);
+    expect(result.NODE_ENV).toBe('production');
+    expect(result.NEXT_PUBLIC_APP_URL).toBe('https://production.example.com');
+  });
+});

package/template/src/config/__tests__/site.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+
+describe('siteConfig', () => {
+  it('should have a name property', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.name).toBe('DTT Framework');
+  });
+
+  it('should have a description property', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.description).toBe('Production-ready Next.js boilerplate with integrated services');
+  });
+
+  it('should have a url property', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.url).toBeDefined();
+    expect(typeof siteConfig.url).toBe('string');
+  });
+
+  it('should have a links object', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.links).toBeDefined();
+    expect(typeof siteConfig.links).toBe('object');
+  });
+
+  it('should have a twitter link', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.links.twitter).toBe('https://twitter.com/odvi');
+  });
+
+  it('should have a github link', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.links.github).toBe('https://github.com/odvi');
+  });
+
+  it('should have a valid URL format for url property', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.url).toMatch(/^https?:\/\/.+/);
+  });
+
+  it('should have valid URL formats for all links', () => {
+    const { siteConfig } = require('../site.ts');
+    expect(siteConfig.links.twitter).toMatch(/^https?:\/\/.+/);
+    expect(siteConfig.links.github).toMatch(/^https?:\/\/.+/);
+  });
+});

package/template/src/config/env.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod'
+
+const envSchema = z.object({
+  // App
+  NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
+  NEXT_PUBLIC_APP_URL: z.string().url().default('http://localhost:3000'),
+
+  // Clerk
+  NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: z.string().startsWith('pk_').default('pk_test_placeholder'),
+  CLERK_SECRET_KEY: z.string().startsWith('sk_').default('sk_test_placeholder'),
+  CLERK_WEBHOOK_SECRET: z.string().optional(),
+
+  // Supabase
+  NEXT_PUBLIC_SUPABASE_URL: z.string().url().default('https://placeholder.supabase.co'),
+  NEXT_PUBLIC_SUPABASE_ANON_KEY: z.string().default('placeholder'),
+  SUPABASE_SERVICE_ROLE_KEY: z.string().default('placeholder'),
+  DATABASE_URL: z.string().default('postgresql://postgres:password@localhost:5432/postgres'),
+
+  // Snowflake
+  SNOWFLAKE_ACCOUNT: z.string().default('placeholder'),
+  SNOWFLAKE_USERNAME: z.string().default('placeholder'),
+  SNOWFLAKE_AUTHENTICATOR: z.literal('SNOWFLAKE_JWT').default('SNOWFLAKE_JWT'),
+  SNOWFLAKE_PRIVATE_KEY: z.string().default('placeholder'),
+  SNOWFLAKE_PRIVATE_KEY_PASSPHRASE: z.string().optional(),
+  SNOWFLAKE_WAREHOUSE: z.string().default('COMPUTE_WH'),
+  SNOWFLAKE_ROLE: z.string().default('ACCOUNTADMIN'),
+  SNOWFLAKE_LOGGING: z.string().transform((val) => val === 'true').optional(),
+
+  // NextBank (optional)
+  NEXTBANK_API: z.string().url().optional(),
+  NEXTBANK_API_USERNAME: z.string().optional(),
+  NEXTBANK_API_PASSWORD: z.string().optional(),
+})
+
+export const env = envSchema.parse(process.env)
+export type Env = z.infer<typeof envSchema>

package/template/src/config/site.ts

@@ -0,0 +1,10 @@
+// Site configuration placeholder
+export const siteConfig = {
+  name: 'DTT Framework',
+  description: 'Production-ready Next.js boilerplate with integrated services',
+  url: process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000',
+  links: {
+    twitter: 'https://twitter.com/odvi',
+    github: 'https://github.com/odvi',
+  },
+}

package/template/src/env.js

@@ -0,0 +1,44 @@
+import { createEnv } from "@t3-oss/env-nextjs";
+import { z } from "zod";
+
+export const env = createEnv({
+  /**
+   * Specify your server-side environment variables schema here. This way you can ensure the app
+   * isn't built with invalid env vars.
+   */
+  server: {
+    DATABASE_URL: z.string().url(),
+    NODE_ENV: z
+      .enum(["development", "test", "production"])
+      .default("development"),
+  },
+
+  /**
+   * Specify your client-side environment variables schema here. This way you can ensure the app
+   * isn't built with invalid env vars. To expose them to the client, prefix them with
+   * `NEXT_PUBLIC_`.
+   */
+  client: {
+    // NEXT_PUBLIC_CLIENTVAR: z.string(),
+  },
+
+  /**
+   * You can't destruct `process.env` as a regular object in the Next.js edge runtimes (e.g.
+   * middlewares) or client-side so we need to destruct manually.
+   */
+  runtimeEnv: {
+    DATABASE_URL: process.env.DATABASE_URL,
+    NODE_ENV: process.env.NODE_ENV,
+    // NEXT_PUBLIC_CLIENTVAR: process.env.NEXT_PUBLIC_CLIENTVAR,
+  },
+  /**
+   * Run `build` or `dev` with `SKIP_ENV_VALIDATION` to skip env validation. This is especially
+   * useful for Docker builds.
+   */
+  skipValidation: !!process.env.SKIP_ENV_VALIDATION,
+  /**
+   * Makes it so that empty strings are treated as undefined. `SOME_VAR: z.string()` and
+   * `SOME_VAR=''` will throw an error.
+   */
+  emptyStringAsUndefined: true,
+});

package/template/src/features/__tests__/health-check-config.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import { SERVICES } from '../health-check/config';
+
+describe('SERVICES configuration', () => {
+  it('should be defined', () => {
+    expect(SERVICES).toBeDefined();
+    expect(Array.isArray(SERVICES)).toBe(true);
+  });
+
+  it('should have 6 services configured', () => {
+    expect(SERVICES).toHaveLength(6);
+  });
+
+  it('should have Clerk Authentication service', () => {
+    const clerkService = SERVICES.find((s) => s.name === 'Clerk Authentication');
+    expect(clerkService).toBeDefined();
+    expect(clerkService?.icon).toBe('key');
+    expect(clerkService?.checks).toHaveLength(3);
+  });
+
+  it('should have Supabase Database service', () => {
+    const dbService = SERVICES.find((s) => s.name === 'Supabase Database');
+    expect(dbService).toBeDefined();
+    expect(dbService?.icon).toBe('database');
+    expect(dbService?.checks).toHaveLength(3);
+  });
+
+  it('should have Supabase Storage service', () => {
+    const storageService = SERVICES.find((s) => s.name === 'Supabase Storage');
+    expect(storageService).toBeDefined();
+    expect(storageService?.icon).toBe('folder');
+    expect(storageService?.checks).toHaveLength(3);
+  });
+
+  it('should have Supabase Edge Functions service', () => {
+    const edgeService = SERVICES.find((s) => s.name === 'Supabase Edge Functions');
+    expect(edgeService).toBeDefined();
+    expect(edgeService?.icon).toBe('zap');
+    expect(edgeService?.checks).toHaveLength(2);
+  });
+
+  it('should have Snowflake service', () => {
+    const snowflakeService = SERVICES.find((s) => s.name === 'Snowflake');
+    expect(snowflakeService).toBeDefined();
+    expect(snowflakeService?.icon).toBe('snowflake');
+    expect(snowflakeService?.checks).toHaveLength(2);
+  });
+
+  it('should have NextBank service', () => {
+    const nextbankService = SERVICES.find((s) => s.name === 'NextBank');
+    expect(nextbankService).toBeDefined();
+    expect(nextbankService?.icon).toBe('building');
+    expect(nextbankService?.checks).toHaveLength(2);
+  });
+
+  it('should have all services with required properties', () => {
+    SERVICES.forEach((service) => {
+      expect(service.name).toBeDefined();
+      expect(typeof service.name).toBe('string');
+      expect(service.name.length).toBeGreaterThan(0);
+
+      expect(service.icon).toBeDefined();
+      expect(typeof service.icon).toBe('string');
+      expect(service.icon.length).toBeGreaterThan(0);
+
+      expect(service.checks).toBeDefined();
+      expect(Array.isArray(service.checks)).toBe(true);
+      expect(service.checks.length).toBeGreaterThan(0);
+    });
+  });
+
+  it('should have all checks with required properties', () => {
+    SERVICES.forEach((service) => {
+      service.checks.forEach((check) => {
+        expect(check.name).toBeDefined();
+        expect(typeof check.name).toBe('string');
+        expect(check.name.length).toBeGreaterThan(0);
+
+        expect(check.endpoint).toBeDefined();
+        expect(typeof check.endpoint).toBe('string');
+        expect(check.endpoint.length).toBeGreaterThan(0);
+        expect(check.endpoint).toMatch(/^\/.+/);
+      });
+    });
+  });
+
+  it('should have unique service names', () => {
+    const serviceNames = SERVICES.map((s) => s.name);
+    const uniqueNames = new Set(serviceNames);
+    expect(uniqueNames.size).toBe(serviceNames.length);
+  });
+
+  it('should have unique icons', () => {
+    const icons = SERVICES.map((s) => s.icon);
+    const uniqueIcons = new Set(icons);
+    expect(uniqueIcons.size).toBe(icons.length);
+  });
+
+  it('should have Clerk Authentication checks with correct endpoints', () => {
+    const clerkService = SERVICES.find((s) => s.name === 'Clerk Authentication');
+    expect(clerkService?.checks[0].endpoint).toBe('/clerk/user');
+    expect(clerkService?.checks[1].endpoint).toBe('/clerk/org');
+    expect(clerkService?.checks[2].endpoint).toBe('/clerk/members');
+  });
+
+  it('should have Supabase Database checks with correct endpoints', () => {
+    const dbService = SERVICES.find((s) => s.name === 'Supabase Database');
+    expect(dbService?.checks[0].endpoint).toBe('/database/write');
+    expect(dbService?.checks[1].endpoint).toBe('/database/read');
+    expect(dbService?.checks[2].endpoint).toBe('/database/delete');
+  });
+
+  it('should have Supabase Storage checks with correct endpoints', () => {
+    const storageService = SERVICES.find((s) => s.name === 'Supabase Storage');
+    expect(storageService?.checks[0].endpoint).toBe('/storage/upload');
+    expect(storageService?.checks[1].endpoint).toBe('/storage/download');
+    expect(storageService?.checks[2].endpoint).toBe('/storage/delete');
+  });
+
+  it('should have Edge Functions checks with correct endpoints', () => {
+    const edgeService = SERVICES.find((s) => s.name === 'Supabase Edge Functions');
+    expect(edgeService?.checks[0].endpoint).toBe('/edge/ping');
+    expect(edgeService?.checks[1].endpoint).toBe('/edge/auth');
+  });
+
+  it('should have Snowflake checks with correct endpoints', () => {
+    const snowflakeService = SERVICES.find((s) => s.name === 'Snowflake');
+    expect(snowflakeService?.checks[0].endpoint).toBe('/snowflake/connect');
+    expect(snowflakeService?.checks[1].endpoint).toBe('/snowflake/query');
+  });
+
+  it('should have NextBank checks with correct endpoints', () => {
+    const nextbankService = SERVICES.find((s) => s.name === 'NextBank');
+    expect(nextbankService?.checks[0].endpoint).toBe('/nextbank/ping');
+    expect(nextbankService?.checks[1].endpoint).toBe('/nextbank/auth');
+  });
+
+  it('should have total of 15 checks across all services', () => {
+    const totalChecks = SERVICES.reduce((sum, service) => sum + service.checks.length, 0);
+    expect(totalChecks).toBe(15);
+  });
+});

package/template/src/features/__tests__/health-check-types.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest';
+import type { HealthStatus, ServiceCheck, ServiceHealth } from '../health-check/types';
+
+describe('Health check types', () => {
+  describe('HealthStatus type', () => {
+    it('should accept valid health status values', () => {
+      const validStatuses: HealthStatus[] = [
+        'healthy',
+        'unhealthy',
+        'error',
+        'pending',
+        'unconfigured',
+      ];
+
+      validStatuses.forEach((status) => {
+        expect(status).toBeDefined();
+        expect(typeof status).toBe('string');
+      });
+    });
+
+    it('should have exactly 5 valid health status values', () => {
+      const validStatuses: HealthStatus[] = [
+        'healthy',
+        'unhealthy',
+        'error',
+        'pending',
+        'unconfigured',
+      ];
+
+      expect(validStatuses).toHaveLength(5);
+    });
+
+    it('should allow creating objects with HealthStatus', () => {
+      const status: HealthStatus = 'healthy';
+      expect(status).toBe('healthy');
+    });
+  });
+
+  describe('ServiceCheck interface', () => {
+    it('should create a valid ServiceCheck object', () => {
+      const serviceCheck: ServiceCheck = {
+        name: 'Test Check',
+        endpoint: '/test/endpoint',
+        status: 'healthy',
+        responseTimeMs: 100,
+        error: undefined,
+      };
+
+      expect(serviceCheck.name).toBe('Test Check');
+      expect(serviceCheck.endpoint).toBe('/test/endpoint');
+      expect(serviceCheck.status).toBe('healthy');
+      expect(serviceCheck.responseTimeMs).toBe(100);
+      expect(serviceCheck.error).toBeUndefined();
+    });
+
+    it('should create ServiceCheck without optional fields', () => {
+      const serviceCheck: ServiceCheck = {
+        name: 'Test Check',
+        endpoint: '/test/endpoint',
+        status: 'healthy',
+      };
+
+      expect(serviceCheck.name).toBe('Test Check');
+      expect(serviceCheck.endpoint).toBe('/test/endpoint');
+      expect(serviceCheck.status).toBe('healthy');
+      expect(serviceCheck.responseTimeMs).toBeUndefined();
+      expect(serviceCheck.error).toBeUndefined();
+    });
+
+    it('should create ServiceCheck with error field', () => {
+      const serviceCheck: ServiceCheck = {
+        name: 'Test Check',
+        endpoint: '/test/endpoint',
+        status: 'error',
+        error: 'Connection failed',
+      };
+
+      expect(serviceCheck.status).toBe('error');
+      expect(serviceCheck.error).toBe('Connection failed');
+    });
+
+    it('should accept all valid HealthStatus values in ServiceCheck', () => {
+      const validStatuses: HealthStatus[] = [
+        'healthy',
+        'unhealthy',
+        'error',
+        'pending',
+        'unconfigured',
+      ];
+
+      validStatuses.forEach((status) => {
+        const serviceCheck: ServiceCheck = {
+          name: 'Test Check',
+          endpoint: '/test/endpoint',
+          status,
+        };
+        expect(serviceCheck.status).toBe(status);
+      });
+    });
+  });
+
+  describe('ServiceHealth interface', () => {
+    it('should create a valid ServiceHealth object', () => {
+      const checks: ServiceCheck[] = [
+        {
+          name: 'Check 1',
+          endpoint: '/check1',
+          status: 'healthy',
+          responseTimeMs: 50,
+        },
+        {
+          name: 'Check 2',
+          endpoint: '/check2',
+          status: 'healthy',
+          responseTimeMs: 75,
+        },
+      ];
+
+      const serviceHealth: ServiceHealth = {
+        name: 'Test Service',
+        icon: 'test-icon',
+        status: 'healthy',
+        responseTimeMs: 125,
+        checks,
+      };
+
+      expect(serviceHealth.name).toBe('Test Service');
+      expect(serviceHealth.icon).toBe('test-icon');
+      expect(serviceHealth.status).toBe('healthy');
+      expect(serviceHealth.responseTimeMs).toBe(125);
+      expect(serviceHealth.checks).toHaveLength(2);
+    });
+
+    it('should create ServiceHealth with empty checks array', () => {
+      const serviceHealth: ServiceHealth = {
+        name: 'Test Service',
+        icon: 'test-icon',
+        status: 'unconfigured',
+        responseTimeMs: 0,
+        checks: [],
+      };
+
+      expect(serviceHealth.checks).toHaveLength(0);
+    });
+
+    it('should create ServiceHealth with error status', () => {
+      const checks: ServiceCheck[] = [
+        {
+          name: 'Check 1',
+          endpoint: '/check1',
+          status: 'error',
+          error: 'Failed to connect',
+        },
+      ];
+
+      const serviceHealth: ServiceHealth = {
+        name: 'Test Service',
+        icon: 'test-icon',
+        status: 'error',
+        responseTimeMs: 0,
+        checks,
+      };
+
+      expect(serviceHealth.status).toBe('error');
+      expect(serviceHealth.checks[0]?.error).toBe('Failed to connect');
+    });
+
+    it('should allow all valid HealthStatus values in ServiceHealth', () => {
+      const validStatuses: HealthStatus[] = [
+        'healthy',
+        'unhealthy',
+        'error',
+        'pending',
+        'unconfigured',
+      ];
+
+      validStatuses.forEach((status) => {
+        const serviceHealth: ServiceHealth = {
+          name: 'Test Service',
+          icon: 'test-icon',
+          status,
+          responseTimeMs: 0,
+          checks: [],
+        };
+        expect(serviceHealth.status).toBe(status);
+      });
+    });
+
+    it('should have responseTimeMs as required field', () => {
+      const serviceHealth: ServiceHealth = {
+        name: 'Test Service',
+        icon: 'test-icon',
+        status: 'healthy',
+        responseTimeMs: 100,
+        checks: [],
+      };
+
+      expect(typeof serviceHealth.responseTimeMs).toBe('number');
+    });
+  });
+});