fuel-price/tests/Unit/Services/OilPriceServiceTest.php

<?php

use App\Enums\PredictionSource;
use App\Enums\TrendDirection;
use App\Models\BrentPrice;
use App\Models\PricePrediction;
use App\Services\ApiLogger;
use App\Services\OilPriceService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Http;

uses(RefreshDatabase::class);

beforeEach(function (): void {
    Http::preventStrayRequests();
    $this->service = new OilPriceService(new ApiLogger);
});

// --- fetchBrentPrices ---

it('fetches and stores brent prices from FRED', function (): void {
    Http::fake([
        '*/fred/series/observations*' => Http::response([
            'observations' => [
                ['date' => '2026-03-31', 'value' => '74.50'],
                ['date' => '2026-04-01', 'value' => '75.10'],
                ['date' => '2026-04-02', 'value' => '73.80'],
            ],
        ]),
    ]);

    $this->service->fetchBrentPrices();

    expect(BrentPrice::count())->toBe(3)
        ->and(BrentPrice::find('2026-04-02')->price_usd)->toBe('73.80');
});

it('filters out FRED missing value markers', function (): void {
    Http::fake([
        '*/fred/series/observations*' => Http::response([
            'observations' => [
                ['date' => '2026-04-01', 'value' => '75.10'],
                ['date' => '2026-04-02', 'value' => '.'],
                ['date' => '2026-04-03', 'value' => '74.20'],
            ],
        ]),
    ]);

    $this->service->fetchBrentPrices();

    expect(BrentPrice::count())->toBe(2)
        ->and(BrentPrice::find('2026-04-02'))->toBeNull();
});

it('upserts existing brent price rows on refetch', function (): void {
    Http::fake([
        '*/fred/series/observations*' => Http::sequence()
            ->push(['observations' => [['date' => '2026-04-01', 'value' => '74.00']]])
            ->push(['observations' => [['date' => '2026-04-01', 'value' => '75.50']]]),
    ]);

    $this->service->fetchBrentPrices();
    $this->service->fetchBrentPrices();

    expect(BrentPrice::count())->toBe(1)
        ->and(BrentPrice::find('2026-04-01')->price_usd)->toBe('75.50');
});

// --- generateEwmaPrediction ---

it('detects a rising trend when 3-day EWMA exceeds 7-day EWMA by threshold', function (): void {
    $prices = collect(range(1, 14))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(14 - $i)->toDateString(),
        'price_usd' => 70.0 + ($i * 2.0),
    ]));

    $prediction = $this->service->generateEwmaPrediction($prices);

    expect($prediction->direction)->toBe(TrendDirection::Rising)
        ->and($prediction->source)->toBe(PredictionSource::Ewma)
        ->and($prediction->confidence)->toBeGreaterThan(0)
        ->and($prediction->confidence)->toBeLessThanOrEqual(65);
});

it('detects a falling trend when 3-day EWMA falls below 7-day EWMA by threshold', function (): void {
    $prices = collect(range(1, 14))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(14 - $i)->toDateString(),
        'price_usd' => 85.0 - ($i * 2.0),
    ]));

    $prediction = $this->service->generateEwmaPrediction($prices);

    expect($prediction->direction)->toBe(TrendDirection::Falling)
        ->and($prediction->source)->toBe(PredictionSource::Ewma);
});

it('returns flat when price movement is within threshold', function (): void {
    $prices = collect(range(1, 14))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(14 - $i)->toDateString(),
        'price_usd' => 75.0 + (($i % 2 === 0) ? 0.1 : -0.1),
    ]));

    $prediction = $this->service->generateEwmaPrediction($prices);

    expect($prediction->direction)->toBe(TrendDirection::Flat)
        ->and($prediction->confidence)->toBe(50);
});

it('returns null when fewer than 14 prices are available for EWMA', function (): void {
    $prices = collect(range(1, 10))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(10 - $i)->toDateString(),
        'price_usd' => 75.0,
    ]));

    expect($this->service->generateEwmaPrediction($prices))->toBeNull();
});

// --- generateLlmPrediction ---

it('generates an LLM prediction and stores it', function (): void {
    $prices = collect(range(1, 14))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(14 - $i)->toDateString(),
        'price_usd' => 75.0 + $i,
    ]));

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([
            'content' => [
                ['text' => '{"direction":"rising","confidence":72,"reasoning":"Consistent upward trend over 14 days."}'],
            ],
        ]),
    ]);

    $prediction = $this->service->generateLlmPrediction($prices);

    expect($prediction->direction)->toBe(TrendDirection::Rising)
        ->and($prediction->source)->toBe(PredictionSource::Llm)
        ->and($prediction->confidence)->toBe(72)
        ->and($prediction->reasoning)->toBe('Consistent upward trend over 14 days.');
});

it('caps LLM confidence at 85', function (): void {
    $prices = collect(range(1, 14))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(14 - $i)->toDateString(),
        'price_usd' => 75.0,
    ]));

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([
            'content' => [
                ['text' => '{"direction":"falling","confidence":99,"reasoning":"Very confident."}'],
            ],
        ]),
    ]);

    $prediction = $this->service->generateLlmPrediction($prices);

    expect($prediction->confidence)->toBe(85);
});

it('returns null when LLM returns malformed JSON', function (): void {
    $prices = collect(range(1, 14))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(14 - $i)->toDateString(),
        'price_usd' => 75.0,
    ]));

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([
            'content' => [['text' => 'Sorry, I cannot help with that.']],
        ]),
    ]);

    expect($this->service->generateLlmPrediction($prices))->toBeNull();
});

// --- generateLlmPredictionWithContext ---

it('generates LLM prediction with context and returns LlmWithContext source', function (): void {
    config(['services.anthropic.api_key' => 'test-key']);

    $prices = collect(range(1, 20))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(20 - $i)->toDateString(),
        'price_usd' => 80.0 + $i * 0.5,
    ]));

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([
            'content' => [['type' => 'text', 'text' => '{"direction":"rising","confidence":72,"reasoning":"OPEC+ extended cuts while prices trend upward."}']],
            'stop_reason' => 'end_turn',
        ]),
    ]);

    $prediction = $this->service->generateLlmPredictionWithContext($prices);

    expect($prediction)->not->toBeNull()
        ->and($prediction->direction)->toBe(TrendDirection::Rising)
        ->and($prediction->confidence)->toBe(72)
        ->and($prediction->source)->toBe(PredictionSource::LlmWithContext)
        ->and($prediction->reasoning)->toBe('OPEC+ extended cuts while prices trend upward.');

    Http::assertSentCount(1);
});

it('sends web_search tool in the context prediction request', function (): void {
    config(['services.anthropic.api_key' => 'test-key']);

    $prices = collect(range(1, 20))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(20 - $i)->toDateString(),
        'price_usd' => 80.0,
    ]));

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([
            'content' => [['type' => 'text', 'text' => '{"direction":"flat","confidence":50,"reasoning":"No clear trend."}']],
            'stop_reason' => 'end_turn',
        ]),
    ]);

    $this->service->generateLlmPredictionWithContext($prices);

    Http::assertSent(function ($request) {
        $tools = $request->data()['tools'] ?? [];

        return collect($tools)->contains(fn ($t) => $t['type'] === 'web_search_20250305');
    });
});

it('does not include EWMA indicators in the context prediction prompt', function (): void {
    config(['services.anthropic.api_key' => 'test-key']);

    $prices = collect(range(1, 20))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(20 - $i)->toDateString(),
        'price_usd' => 80.0,
    ]));

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([
            'content' => [['type' => 'text', 'text' => '{"direction":"flat","confidence":50,"reasoning":"No clear trend."}']],
            'stop_reason' => 'end_turn',
        ]),
    ]);

    $this->service->generateLlmPredictionWithContext($prices);

    Http::assertSent(function ($request) {
        $content = $request->data()['messages'][0]['content'] ?? '';

        return ! str_contains($content, 'EWMA') && ! str_contains($content, 'Pre-computed');
    });
});

it('continues on pause_turn and returns final answer', function (): void {
    config(['services.anthropic.api_key' => 'test-key']);

    $prices = collect(range(1, 20))->map(fn (int $i) => new BrentPrice([
        'date' => now()->subDays(20 - $i)->toDateString(),
        'price_usd' => 80.0,
    ]));

    Http::fake([
        'https://api.anthropic.com/*' => Http::sequence()
            ->push([
                'content' => [['type' => 'server_tool_use', 'id' => 'sttool_1', 'name' => 'web_search', 'input' => ['query' => 'Brent crude news']]],
                'stop_reason' => 'pause_turn',
            ])
            ->push([
                'content' => [['type' => 'text', 'text' => '{"direction":"falling","confidence":60,"reasoning":"Demand fears weigh on prices."}']],
                'stop_reason' => 'end_turn',
            ]),
    ]);

    $prediction = $this->service->generateLlmPredictionWithContext($prices);

    expect($prediction)->not->toBeNull()
        ->and($prediction->direction)->toBe(TrendDirection::Falling);

    Http::assertSentCount(2);
});

// --- generatePrediction (orchestrator) ---

it('uses LLM with context when API key is configured', function (): void {
    config(['services.anthropic.api_key' => 'test-key']);

    BrentPrice::insert(
        collect(range(1, 20))->map(fn (int $i) => [
            'date' => now()->subDays(20 - $i)->toDateString(),
            'price_usd' => 75.0 + $i,
        ])->all()
    );

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([
            'content' => [['type' => 'text', 'text' => '{"direction":"rising","confidence":70,"reasoning":"Trend is up."}']],
            'stop_reason' => 'end_turn',
        ]),
    ]);

    $prediction = $this->service->generatePrediction();

    expect($prediction->source)->toBe(PredictionSource::LlmWithContext)
        ->and(PricePrediction::count())->toBe(2);
});

it('falls back to plain LLM when context method fails', function (): void {
    config(['services.anthropic.api_key' => 'test-key']);

    BrentPrice::insert(
        collect(range(1, 20))->map(fn (int $i) => [
            'date' => now()->subDays(20 - $i)->toDateString(),
            'price_usd' => 75.0 + ($i * 0.8),
        ])->all()
    );

    Http::fake([
        'https://api.anthropic.com/*' => Http::sequence()
            ->push([], 500)
            ->push([
                'content' => [['text' => '{"direction":"rising","confidence":70,"reasoning":"Trend up."}']],
            ]),
    ]);

    $prediction = $this->service->generatePrediction();

    expect($prediction->source)->toBe(PredictionSource::Llm)
        ->and(PricePrediction::count())->toBe(2);
});

it('falls back to EWMA when both LLM methods fail', function (): void {
    config(['services.anthropic.api_key' => 'test-key']);

    BrentPrice::insert(
        collect(range(1, 20))->map(fn (int $i) => [
            'date' => now()->subDays(20 - $i)->toDateString(),
            'price_usd' => 75.0 + ($i * 0.8),
        ])->all()
    );

    Http::fake([
        'https://api.anthropic.com/*' => Http::response([], 500),
    ]);

    $prediction = $this->service->generatePrediction();

    expect($prediction->source)->toBe(PredictionSource::Ewma)
        ->and(PricePrediction::count())->toBe(1);
});

it('returns null when there is insufficient price data', function (): void {
    BrentPrice::insert([
        ['date' => now()->subDays(2)->toDateString(), 'price_usd' => 75.0],
        ['date' => now()->subDay()->toDateString(), 'price_usd' => 76.0],
    ]);

    expect($this->service->generatePrediction())->toBeNull()
        ->and(PricePrediction::count())->toBe(0);
});