← back to Designer Wallcoverings

DW-Agents/__tests__/helpers/test-data.ts

204 lines

/**
 * Test Data Generators
 * Factory functions for creating test data
 */

export interface Agent {
  id: string;
  name: string;
  port: number;
  status: 'online' | 'offline' | 'degraded';
  uptime: number;
}

export interface HealthCheckResponse {
  status: 'healthy' | 'degraded' | 'unhealthy';
  timestamp: string;
  uptime?: number;
  service?: {
    name: string;
    version: string;
  };
  agents?: Agent[];
}

/**
 * Generate mock agent data
 */
export function createMockAgent(overrides?: Partial<Agent>): Agent {
  return {
    id: `agent-${Math.random().toString(36).substr(2, 9)}`,
    name: `Test Agent ${Math.floor(Math.random() * 100)}`,
    port: 9800 + Math.floor(Math.random() * 100),
    status: 'online',
    uptime: Math.floor(Math.random() * 86400),
    ...overrides
  };
}

/**
 * Generate multiple mock agents
 */
export function createMockAgents(count: number): Agent[] {
  return Array(count).fill(null).map((_, i) =>
    createMockAgent({ name: `Agent ${i + 1}` })
  );
}

/**
 * Generate mock health check response
 */
export function createMockHealthResponse(overrides?: Partial<HealthCheckResponse>): HealthCheckResponse {
  return {
    status: 'healthy',
    timestamp: new Date().toISOString(),
    uptime: Math.floor(Math.random() * 86400),
    service: {
      name: 'DW-Agents',
      version: '1.0.0'
    },
    agents: createMockAgents(5),
    ...overrides
  };
}

/**
 * Test data factory
 */
export class TestDataFactory {
  private static idCounter = 0;

  /**
   * Generate unique ID
   */
  static generateId(): string {
    return `test-${++this.idCounter}-${Date.now()}`;
  }

  /**
   * Generate random string
   */
  static randomString(length = 10): string {
    return Math.random().toString(36).substring(2, 2 + length);
  }

  /**
   * Generate random number in range
   */
  static randomNumber(min = 0, max = 100): number {
    return Math.floor(Math.random() * (max - min + 1)) + min;
  }

  /**
   * Generate random boolean
   */
  static randomBoolean(): boolean {
    return Math.random() > 0.5;
  }

  /**
   * Generate random date
   */
  static randomDate(start = new Date(2024, 0, 1), end = new Date()): Date {
    return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
  }

  /**
   * Generate random port number
   */
  static randomPort(): number {
    return this.randomNumber(9800, 9999);
  }

  /**
   * Generate random status
   */
  static randomStatus(): 'online' | 'offline' | 'degraded' {
    const statuses: ('online' | 'offline' | 'degraded')[] = ['online', 'offline', 'degraded'];
    return statuses[this.randomNumber(0, statuses.length - 1)];
  }
}

/**
 * Test data builder pattern
 */
export class AgentBuilder {
  private agent: Partial<Agent> = {};

  withId(id: string): this {
    this.agent.id = id;
    return this;
  }

  withName(name: string): this {
    this.agent.name = name;
    return this;
  }

  withPort(port: number): this {
    this.agent.port = port;
    return this;
  }

  withStatus(status: 'online' | 'offline' | 'degraded'): this {
    this.agent.status = status;
    return this;
  }

  withUptime(uptime: number): this {
    this.agent.uptime = uptime;
    return this;
  }

  build(): Agent {
    return {
      id: this.agent.id || TestDataFactory.generateId(),
      name: this.agent.name || `Agent ${TestDataFactory.randomString()}`,
      port: this.agent.port || TestDataFactory.randomPort(),
      status: this.agent.status || 'online',
      uptime: this.agent.uptime || TestDataFactory.randomNumber(0, 86400)
    };
  }
}

/**
 * Assertion helpers
 */
export const assertions = {
  /**
   * Assert health response is valid
   */
  isValidHealthResponse(response: any): boolean {
    return (
      response &&
      typeof response === 'object' &&
      ['healthy', 'degraded', 'unhealthy'].includes(response.status) &&
      typeof response.timestamp === 'string' &&
      !isNaN(Date.parse(response.timestamp))
    );
  },

  /**
   * Assert agent is valid
   */
  isValidAgent(agent: any): boolean {
    return (
      agent &&
      typeof agent === 'object' &&
      typeof agent.id === 'string' &&
      typeof agent.name === 'string' &&
      typeof agent.port === 'number' &&
      ['online', 'offline', 'degraded'].includes(agent.status)
    );
  },

  /**
   * Assert timestamp is recent
   */
  isRecentTimestamp(timestamp: string, maxAgeMs = 5000): boolean {
    const date = new Date(timestamp);
    const now = new Date();
    return now.getTime() - date.getTime() < maxAgeMs;
  }
};