michaelschiemer/tests/Cache/Warming/WarmupMetricsTest.php

<?php

declare(strict_types=1);

use App\Framework\Cache\Warming\ValueObjects\WarmupMetrics;
use App\Framework\Cache\Warming\ValueObjects\WarmupResult;

describe('WarmupMetrics', function () {
    it('creates from single result', function () {
        $result = new WarmupResult(
            strategyName: 'test_strategy',
            itemsWarmed: 10,
            itemsFailed: 2,
            durationSeconds: 1.5,
            memoryUsedBytes: 1024000
        );

        $metrics = WarmupMetrics::fromResults([$result]);

        expect($metrics->totalStrategiesExecuted)->toBe(1);
        expect($metrics->totalItemsWarmed)->toBe(10);
        expect($metrics->totalItemsFailed)->toBe(2);
        expect($metrics->totalDurationSeconds)->toBe(1.5);
        expect($metrics->totalMemoryUsedBytes)->toBe(1024000);
        expect($metrics->strategyResults)->toHaveCount(1);
    });

    it('aggregates multiple results', function () {
        $results = [
            new WarmupResult(
                strategyName: 'strategy1',
                itemsWarmed: 10,
                itemsFailed: 1,
                durationSeconds: 1.0,
                memoryUsedBytes: 1024000
            ),
            new WarmupResult(
                strategyName: 'strategy2',
                itemsWarmed: 20,
                itemsFailed: 2,
                durationSeconds: 2.0,
                memoryUsedBytes: 2048000
            ),
        ];

        $metrics = WarmupMetrics::fromResults($results);

        expect($metrics->totalStrategiesExecuted)->toBe(2);
        expect($metrics->totalItemsWarmed)->toBe(30);
        expect($metrics->totalItemsFailed)->toBe(3);
        expect($metrics->totalDurationSeconds)->toBe(3.0);
        expect($metrics->totalMemoryUsedBytes)->toBe(3072000);
        expect($metrics->strategyResults)->toHaveCount(2);
    });

    it('handles empty results', function () {
        $metrics = WarmupMetrics::fromResults([]);

        expect($metrics->totalStrategiesExecuted)->toBe(0);
        expect($metrics->totalItemsWarmed)->toBe(0);
        expect($metrics->totalItemsFailed)->toBe(0);
        expect($metrics->totalDurationSeconds)->toBe(0.0);
        expect($metrics->totalMemoryUsedBytes)->toBe(0);
        expect($metrics->strategyResults)->toBeEmpty();
    });

    it('calculates overall success rate', function () {
        $results = [
            new WarmupResult(
                strategyName: 'strategy1',
                itemsWarmed: 8,
                itemsFailed: 2,
                durationSeconds: 1.0,
                memoryUsedBytes: 1024
            ),
            new WarmupResult(
                strategyName: 'strategy2',
                itemsWarmed: 18,
                itemsFailed: 2,
                durationSeconds: 1.0,
                memoryUsedBytes: 1024
            ),
        ];

        $metrics = WarmupMetrics::fromResults($results);

        // 26 warmed, 4 failed = 30 total = 26/30 = 0.8666...
        expect($metrics->getOverallSuccessRate())->toBeGreaterThan(0.86);
        expect($metrics->getOverallSuccessRate())->toBeLessThan(0.87);
    });

    it('handles zero items for success rate', function () {
        $metrics = WarmupMetrics::fromResults([]);

        expect($metrics->getOverallSuccessRate())->toBe(0.0);
    });

    it('calculates average items per second', function () {
        $results = [
            new WarmupResult(
                strategyName: 'strategy1',
                itemsWarmed: 100,
                itemsFailed: 0,
                durationSeconds: 2.0,
                memoryUsedBytes: 1024
            ),
            new WarmupResult(
                strategyName: 'strategy2',
                itemsWarmed: 200,
                itemsFailed: 0,
                durationSeconds: 4.0,
                memoryUsedBytes: 1024
            ),
        ];

        $metrics = WarmupMetrics::fromResults($results);

        // 300 total items / 6 total seconds = 50 items/second
        expect($metrics->getAverageItemsPerSecond())->toBe(50.0);
    });

    it('handles zero duration for items per second', function () {
        $result = new WarmupResult(
            strategyName: 'test',
            itemsWarmed: 100,
            itemsFailed: 0,
            durationSeconds: 0.0,
            memoryUsedBytes: 1024
        );

        $metrics = WarmupMetrics::fromResults([$result]);

        expect($metrics->getAverageItemsPerSecond())->toBe(0.0);
    });

    it('calculates total memory in MB', function () {
        $results = [
            new WarmupResult(
                strategyName: 'strategy1',
                itemsWarmed: 10,
                itemsFailed: 0,
                durationSeconds: 1.0,
                memoryUsedBytes: 1048576 // 1MB
            ),
            new WarmupResult(
                strategyName: 'strategy2',
                itemsWarmed: 20,
                itemsFailed: 0,
                durationSeconds: 1.0,
                memoryUsedBytes: 2097152 // 2MB
            ),
        ];

        $metrics = WarmupMetrics::fromResults($results);

        expect($metrics->getTotalMemoryUsedMB())->toBe(3.0);
    });

    it('converts to array', function () {
        $result = new WarmupResult(
            strategyName: 'test_strategy',
            itemsWarmed: 10,
            itemsFailed: 2,
            durationSeconds: 1.5,
            memoryUsedBytes: 1024000
        );

        $metrics = WarmupMetrics::fromResults([$result]);
        $array = $metrics->toArray();

        expect($array)->toBeArray();
        expect($array['total_strategies_executed'])->toBe(1);
        expect($array['total_items_warmed'])->toBe(10);
        expect($array['total_items_failed'])->toBe(2);
        expect($array['total_duration_seconds'])->toBe(1.5);
        expect($array['total_memory_used_bytes'])->toBe(1024000);
        expect($array['strategy_results'])->toHaveCount(1);
    });

    it('includes per-strategy data in array', function () {
        $results = [
            new WarmupResult(
                strategyName: 'strategy1',
                itemsWarmed: 10,
                itemsFailed: 1,
                durationSeconds: 1.0,
                memoryUsedBytes: 1024000
            ),
            new WarmupResult(
                strategyName: 'strategy2',
                itemsWarmed: 20,
                itemsFailed: 0,
                durationSeconds: 2.0,
                memoryUsedBytes: 2048000
            ),
        ];

        $metrics = WarmupMetrics::fromResults($results);
        $array = $metrics->toArray();

        expect($array['strategy_results'])->toHaveCount(2);
        expect($array['strategy_results'][0]['strategy_name'])->toBe('strategy1');
        expect($array['strategy_results'][1]['strategy_name'])->toBe('strategy2');
        expect($array['strategy_results'][0]['items_warmed'])->toBe(10);
        expect($array['strategy_results'][1]['items_warmed'])->toBe(20);
    });
});