import { TestConductor } from '@ensemble/conductor/testing';

const conductor = await TestConductor.create(options?: TestConductorOptions);

interface TestConductorOptions {
  projectPath?: string;        // Path to Conductor project
  env?: Record<string, any>;   // Mock environment
  mocks?: MockConfig;          // Mock configuration
  enableLogging?: boolean;     // Enable test logging
}

const conductor = await TestConductor.create({
  projectPath: './conductor',
  env: {
    OPENAI_API_KEY: 'test-key',
    DATABASE_URL: 'mock'
  },
  mocks: {
    ai: {
      'think-operation': { result: 'Mocked AI response' }
    },
    http: {
      'https://api.example.com': { status: 200, body: { data: 'mock' } }
    }
  }
});

async executeEnsemble(
  name: string,
  inputs: Record<string, any>
): Promise<TestExecutionResult>

interface TestExecutionResult {
  success: boolean;
  output?: Record<string, any>;
  error?: ExecutionError;
  duration: number;
  agents: AgentExecution[];
  operations: OperationExecution[];
  logs: LogEntry[];
}

const result = await conductor.executeEnsemble('user-onboarding', {
  email: 'test@example.com',
  name: 'Test User'
});

expect(result.success).toBe(true);
expect(result.output).toHaveProperty('userId');

mock(target: string, response: any): void

// Mock agent
conductor.mock('company-enricher', {
  company_data: {
    name: 'Anthropic',
    industry: 'AI'
  }
});

// Mock operation
conductor.mock('openai.chat', {
  message: 'Mocked response'
});

// Mock HTTP
conductor.mock('https://api.example.com/data', {
  status: 200,
  body: { result: 'mocked' }
});

spy(target: string): SpyInstance

const enricherSpy = conductor.spy('company-enricher');

await conductor.executeEnsemble('workflow', input);

expect(enricherSpy).toHaveBeenCalled();
expect(enricherSpy).toHaveBeenCalledWith({
  company_name: 'Anthropic'
});
expect(enricherSpy.callCount).toBe(1);

clearMocks(): void

reset(): void

import { registerMatchers } from '@ensemble/conductor/testing';
import { expect } from 'vitest';

registerMatchers(expect);

expect(result).toBeSuccessful();

expect(result).toHaveFailed();

expect(result).toHaveOutput('userId', expect.any(String));
expect(result).toHaveOutput('created', true);

expect(result).toHaveExecutedAgent('company-enricher');

expect(result).toHaveExecutedOperation('think', 'analyze');

expect(result).toHaveDuration({ lessThan: 1000 }); // < 1 second
expect(result).toHaveDuration({ greaterThan: 100, lessThan: 5000 });

expect(result).toMatchState({
  counter: 5,
  processed: true
});

import { MockAIProvider } from '@ensemble/conductor/testing';

const provider = new MockAIProvider({
  responses: {
    'analyze-text': 'This is a positive review',
    'summarize': 'Summary of the text'
  }
});

import { MockDatabase } from '@ensemble/conductor/testing';

const db = new MockDatabase({
  tables: {
    users: [
      { id: 1, email: 'test@example.com', name: 'Test' }
    ],
    posts: [
      { id: 1, user_id: 1, title: 'Test Post' }
    ]
  }
});

import { MockKV } from '@ensemble/conductor/testing';

const kv = new MockKV({
  'user-123': { name: 'Test User', premium: true },
  'cache-key': 'cached-value'
});

import { MockVectorize } from '@ensemble/conductor/testing';

const vectorize = new MockVectorize({
  documents: [
    {
      id: 'doc-1',
      text: 'Document about AI',
      embedding: [0.1, 0.2, ...],
      metadata: { category: 'tech' }
    }
  ]
});

import { describe, it, expect } from 'vitest';
import { TestConductor } from '@ensemble/conductor/testing';

describe('company-enricher', () => {
  it('should enrich company data', async () => {
    const conductor = await TestConductor.create();
    
    const result = await conductor.executeAgent('company-enricher', {
      company_name: 'Anthropic'
    });
    
    expect(result).toBeDefined();
    expect(result.output).toHaveProperty('name');
    expect(result.output).toHaveProperty('industry');
  });
});

describe('user-onboarding', () => {
  it('should onboard new user', async () => {
    const conductor = await TestConductor.create();
    
    const result = await conductor.executeEnsemble('user-onboarding', {
      email: 'new@example.com',
      name: 'New User'
    });
    
    expect(result).toBeSuccessful();
    expect(result.output.userId).toBeDefined();
    expect(result).toHaveExecutedAgent('create-account');
    expect(result).toHaveExecutedAgent('send-welcome-email');
  });
});

describe('fetch-and-analyze', () => {
  it('should analyze fetched data', async () => {
    const conductor = await TestConductor.create();
    
    // Mock HTTP
    conductor.mock('https://api.example.com/data', {
      status: 200,
      body: { items: [1, 2, 3] }
    });
    
    // Mock AI
    conductor.mock('openai.chat', {
      analysis: 'The data shows an upward trend'
    });
    
    const result = await conductor.executeEnsemble('fetch-and-analyze', {
      url: 'https://api.example.com/data'
    });
    
    expect(result).toBeSuccessful();
    expect(result.output.analysis).toContain('upward trend');
  });
});

describe('stateful-counter', () => {
  it('should maintain counter state', async () => {
    const conductor = await TestConductor.create();
    
    // First execution
    const result1 = await conductor.executeEnsemble('counter', {});
    expect(result1).toMatchState({ count: 1 });
    
    // Second execution
    const result2 = await conductor.executeEnsemble('counter', {});
    expect(result2).toMatchState({ count: 2 });
  });
});

describe('error-handling', () => {
  it('should handle API failure gracefully', async () => {
    const conductor = await TestConductor.create();
    
    // Mock failure
    conductor.mock('https://api.example.com/data', {
      status: 500,
      error: 'Internal Server Error'
    });
    
    const result = await conductor.executeEnsemble('resilient-fetch', {
      url: 'https://api.example.com/data'
    });
    
    expect(result).toBeSuccessful(); // Should use fallback
    expect(result.output.usedFallback).toBe(true);
  });
});

it('should enrich company data with industry and description', async () => {
  // ...
});

describe('user-validation', () => {
  it('should accept valid user data', async () => { ... });
  it('should reject invalid email', async () => { ... });
  it('should reject missing fields', async () => { ... });
});

conductor.mock('external-api', mockResponse);

expect(result).toBeSuccessful();
expect(result).toHaveDuration({ lessThan: 1000 });
expect(result).toHaveExecutedAgent('validator');
expect(result.output).toMatchObject({ ... });

const spy = conductor.spy('expensive-operation');
// ... execute
expect(spy.callCount).toBe(1); // Verify caching worked