# Testing Internal Operations

This guide explains how to test ChronoTrace with internal Laravel operations using the `chronotrace:test-internal` command.

## Overview

The `chronotrace:test-internal` command addresses a common limitation where `chronotrace:record` primarily captures external HTTP events. This command allows you to test ChronoTrace's ability to capture internal Laravel operations like database queries, cache operations, and custom events.

## Why Use `chronotrace:test-internal` vs `chronotrace:record`?

### `chronotrace:record` - Real Application Debugging
- **Purpose**: Records actual HTTP requests to your application
- **Best for**: Debugging real user interactions and API calls
- **Captures**: Complete HTTP request lifecycle
- **Limitation**: Requires external HTTP requests to trigger

### `chronotrace:test-internal` - Internal Operations Testing
- **Purpose**: Tests ChronoTrace functionality without HTTP requests
- **Best for**: Verifying installation, testing event capture, development
- **Captures**: Database, cache, jobs, custom events
- **Advantage**: Works without web server or external requests

---

## Basic Usage

### Simple Internal Test

```bash
# Run basic internal operations test
php artisan chronotrace:test-internal

# Expected output:
🧪 Testing ChronoTrace Internal Operations...

✅ Configuration Check:
   - ChronoTrace enabled: Yes
   - Storage driver: local
   - Event capture: database, cache, http, jobs

✅ Database Operations:
   - Test query executed (5ms)
   - Transaction test passed
   - Query bindings test passed

✅ Cache Operations:
   - Cache set operation (2ms)
   - Cache get operation (1ms)
   - Cache hit test passed

✅ Queue Operations:
   - Test job dispatched
   - Job payload test passed

📊 Test Results:
   - Total operations: 8
   - Total duration: 45ms
   - Events captured: 8
   - Trace ID: chronotrace_test_20240806_143015

🎉 All tests passed! ChronoTrace is working correctly.
```

---

## Advanced Testing Options

### Test Specific Components

```bash
# Test only database operations
php artisan chronotrace:test-internal --component=database

# Test only cache operations
php artisan chronotrace:test-internal --component=cache

# Test only queue operations
php artisan chronotrace:test-internal --component=jobs

# Test multiple components
php artisan chronotrace:test-internal --component=database,cache
```

### Generate Sample Data

```bash
# Generate sample traces for development/demo
php artisan chronotrace:test-internal --generate-samples=10

# Generate with specific event types
php artisan chronotrace:test-internal --generate-samples=5 --events=database,http

# Generate traces with different performance profiles
php artisan chronotrace:test-internal --generate-samples=3 --profile=slow
php artisan chronotrace:test-internal --generate-samples=3 --profile=fast
php artisan chronotrace:test-internal --generate-samples=3 --profile=error
```

### Stress Testing

```bash
# Test with high load simulation
php artisan chronotrace:test-internal --stress-test --operations=100

# Test memory usage with large operations
php artisan chronotrace:test-internal --memory-test --size=large

# Test concurrent operations
php artisan chronotrace:test-internal --concurrent=5
```

---

## Test Categories

### Database Testing

```bash
# Database-specific testing
php artisan chronotrace:test-internal --component=database --verbose

# Expected operations:
✅ Basic Query Test:
   - SELECT * FROM users LIMIT 1 (3ms)
   - Query executed successfully
   - Bindings captured correctly

✅ Transaction Test:
   - BEGIN TRANSACTION
   - INSERT INTO test_table VALUES (?)
   - COMMIT TRANSACTION
   - Transaction boundaries captured

✅ N+1 Query Simulation:
   - Generated 5 related queries
   - N+1 pattern detected and flagged

✅ Slow Query Simulation:
   - Simulated 500ms query
   - Slow query threshold triggered
   - Performance warning generated
```

### Cache Testing

```bash
# Cache-specific testing
php artisan chronotrace:test-internal --component=cache --verbose

# Expected operations:
✅ Cache Write Test:
   - SET test_key_1 = "test_value" (TTL: 3600s)
   - Operation completed in 2ms
   - Cache store: redis/file

✅ Cache Read Test:
   - GET test_key_1 (HIT)
   - Value retrieved in 1ms
   - Cache efficiency: 100%

✅ Cache Miss Test:
   - GET non_existent_key (MISS)
   - Fallback behavior tested
   - Miss properly recorded

✅ Cache Deletion Test:
   - FORGET test_key_1
   - Key removed successfully
   - Cleanup verified
```

### Queue Testing

```bash
# Queue-specific testing
php artisan chronotrace:test-internal --component=jobs --verbose

# Expected operations:
✅ Job Dispatch Test:
   - TestJob dispatched to 'default' queue
   - Payload size: 234 bytes
   - Job ID: job_abc123

✅ Delayed Job Test:
   - DelayedTestJob scheduled (+30s)
   - Delay properly recorded
   - Queue: high-priority

✅ Job Failure Simulation:
   - FailingTestJob dispatched
   - Exception handling tested
   - Failure reason captured
```

---

## Custom Test Scenarios

### E-commerce Simulation

```bash
# Simulate e-commerce operations
php artisan chronotrace:test-internal --scenario=ecommerce

# Simulated operations:
✅ Product Catalog:
   - Product lookup queries
   - Category filtering
   - Price calculations
   - Inventory checks

✅ Shopping Cart:
   - Cart creation
   - Item additions
   - Price updates
   - Session management

✅ Order Processing:
   - Order creation
   - Payment simulation
   - Inventory updates
   - Email notifications
```

### API Integration Simulation

```bash
# Simulate API-heavy operations
php artisan chronotrace:test-internal --scenario=api-integration

# Simulated operations:
✅ External API Calls:
   - Payment gateway simulation
   - Shipping rate calculations
   - Third-party webhooks
   - Authentication tokens

✅ API Response Caching:
   - Response caching logic
   - Cache invalidation
   - Rate limiting simulation
   - Error handling
```

### Performance Testing

```bash
# Test performance characteristics
php artisan chronotrace:test-internal --scenario=performance

# Performance tests:
✅ Memory Usage:
   - Baseline memory: 8MB
   - Peak memory: 15MB
   - Memory growth: 7MB
   - Garbage collection: 3 cycles

✅ Operation Speed:
   - Database queries: avg 5ms
   - Cache operations: avg 1ms
   - Job dispatching: avg 2ms
   - Overall efficiency: 95%
```

---

## Integration with Testing

### PHPUnit Integration

```php
// tests/Feature/ChronoTraceTest.php
use Tests\TestCase;
use Grazulex\LaravelChronotrace\Testing\ChronoTraceAssertions;

class ChronoTraceTest extends TestCase
{
    use ChronoTraceAssertions;
    
    public function test_chronotrace_captures_database_operations()
    {
        // Enable ChronoTrace for test
        $this->enableChronoTrace();
        
        // Perform database operations
        User::factory()->create();
        User::where('email', 'test@example.com')->first();
        
        // Assert trace captured operations
        $this->assertTraceHasDatabaseQueries();
        $this->assertDatabaseQueriesLessThan(5);
        
        $trace = $this->getLastTrace();
        $this->assertArrayHasKey('database_events', $trace['events']);
    }
    
    public function test_chronotrace_captures_cache_operations()
    {
        $this->enableChronoTrace();
        
        // Perform cache operations
        Cache::put('test_key', 'test_value', 3600);
        $value = Cache::get('test_key');
        
        // Assert cache operations captured
        $this->assertTraceHasCacheOperations();
        $this->assertCacheHitRate(greaterThan: 50);
    }
    
    public function test_internal_operations_command()
    {
        // Run internal test command
        $this->artisan('chronotrace:test-internal --component=database')
             ->expectsOutput('✅ Database Operations:')
             ->assertExitCode(0);
             
        // Verify trace was created
        $this->artisan('chronotrace:list --limit=1')
             ->expectsTable(['Trace ID', 'Method', 'Status', 'Duration'], [
                 // Expected trace data
             ]);
    }
}
```

### Test Helpers

```php
// tests/Support/ChronoTraceTestHelpers.php
trait ChronoTraceTestHelpers
{
    protected function generateTestTrace(): string
    {
        return $this->artisan('chronotrace:test-internal --quiet')
                    ->run();
    }
    
    protected function simulateSlowOperation(): void
    {
        $this->artisan('chronotrace:test-internal --component=database --profile=slow')
             ->run();
    }
    
    protected function assertTracePerformance(string $traceId, int $maxDuration): void
    {
        $trace = $this->getTrace($traceId);
        $this->assertLessThan($maxDuration, $trace['performance']['total_duration_ms']);
    }
}
```

---

## Troubleshooting Test Operations

### Common Issues

#### No Events Captured

```bash
# Check configuration
php artisan chronotrace:test-internal --diagnose

# Expected output if misconfigured:
❌ Configuration Issues Detected:
   - Database capture disabled
   - Cache capture disabled
   - Storage not writable

# Fix:
CHRONOTRACE_CAPTURE_DATABASE=true
CHRONOTRACE_CAPTURE_CACHE=true
```

#### Storage Permission Issues

```bash
# Test storage permissions
php artisan chronotrace:test-internal --test-storage

# Expected output:
✅ Storage Test:
   - Write test: SUCCESS
   - Read test: SUCCESS
   - Delete test: SUCCESS
   - Storage driver: local (/app/storage/chronotrace)
```

#### Queue Worker Issues

```bash
# Test queue functionality
php artisan chronotrace:test-internal --component=jobs --test-queue

# If queue workers not running:
❌ Queue Test Failed:
   - Job dispatch: SUCCESS
   - Job processing: TIMEOUT
   - Recommendation: Start queue workers

# Solution:
php artisan queue:work --queue=chronotrace
```

---

## Continuous Integration

### CI/CD Pipeline Integration

```yaml
# .github/workflows/chronotrace-tests.yml
name: ChronoTrace Tests

on: [push, pull_request]

jobs:
  chronotrace-tests:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: 8.3
        
    - name: Install dependencies
      run: composer install
      
    - name: Setup test database
      run: |
        php artisan migrate --env=testing
        
    - name: Test ChronoTrace Installation
      run: php artisan chronotrace:test-internal --env=testing
      
    - name: Test Component Functionality
      run: |
        php artisan chronotrace:test-internal --component=database --env=testing
        php artisan chronotrace:test-internal --component=cache --env=testing
        php artisan chronotrace:test-internal --component=jobs --env=testing
        
    - name: Verify Trace Generation
      run: |
        php artisan chronotrace:list --env=testing
        php artisan chronotrace:diagnose --env=testing
```

### Docker Testing

```dockerfile
# Dockerfile.chronotrace-test
FROM php:8.3-cli

RUN apt-get update && apt-get install -y \
    redis-server \
    && docker-php-ext-install pdo_mysql

COPY . /app
WORKDIR /app

RUN composer install --no-dev --optimize-autoloader

# Start Redis for testing
RUN redis-server --daemonize yes

# Test ChronoTrace
CMD ["php", "artisan", "chronotrace:test-internal", "--verbose"]
```

---

## Performance Benchmarking

### Benchmark Tests

```bash
# Run performance benchmarks
php artisan chronotrace:test-internal --benchmark

# Expected output:
📊 ChronoTrace Performance Benchmark:

Database Operations (1000 iterations):
- Average query time: 2.3ms
- ChronoTrace overhead: 0.1ms (4.3%)
- Memory overhead: 0.5MB

Cache Operations (1000 iterations):
- Average cache time: 0.8ms
- ChronoTrace overhead: 0.05ms (6.25%)
- Memory overhead: 0.2MB

Overall Performance Impact:
- CPU overhead: 3.2%
- Memory overhead: 2.1%
- Storage overhead: 1.8MB/hour
- Recommendation: ✅ Acceptable for production
```

### Custom Benchmarks

```php
// Create custom benchmark
php artisan make:command ChronoTrace:CustomBenchmark

class CustomBenchmark extends Command
{
    public function handle()
    {
        $this->benchmark('Database Operations', function () {
            for ($i = 0; $i < 1000; $i++) {
                User::find(1);
            }
        });
        
        $this->benchmark('Cache Operations', function () {
            for ($i = 0; $i < 1000; $i++) {
                Cache::get('test_key_' . $i);
            }
        });
    }
    
    private function benchmark(string $name, callable $operation): void
    {
        $start = microtime(true);
        $operation();
        $duration = microtime(true) - $start;
        
        $this->info("{$name}: {$duration}s");
    }
}
```

---

## 📚 Related Documentation

- **[Commands](Commands.md)** - Complete command reference
- **[Configuration](Configuration.md)** - Configure test behavior
- **[API Reference](API-Reference.md)** - Testing API methods
- **[Troubleshooting](Troubleshooting.md)** - Solve testing issues

---

**Use internal testing to verify ChronoTrace functionality!** The `test-internal` command is essential for validating your installation and testing specific components without external dependencies.