php-agentic/tests/Unit/ClaudeServiceTest.php

<?php

declare(strict_types=1);

namespace Core\Mod\Agentic\Tests\Unit;

use Core\Mod\Agentic\Services\AgenticResponse;
use Core\Mod\Agentic\Services\ClaudeService;
use Illuminate\Support\Facades\Http;
use RuntimeException;
use Tests\TestCase;

/**
 * Tests for the ClaudeService AI provider.
 *
 * Uses mocked HTTP responses to test the service without real API calls.
 */
class ClaudeServiceTest extends TestCase
{
    private const API_URL = 'https://api.anthropic.com/v1/messages';

    // =========================================================================
    // Service Configuration Tests
    // =========================================================================

    public function test_name_returns_claude(): void
    {
        $service = new ClaudeService('test-api-key');

        $this->assertEquals('claude', $service->name());
    }

    public function test_default_model_returns_configured_model(): void
    {
        $service = new ClaudeService('test-api-key', 'claude-opus-4-20250514');

        $this->assertEquals('claude-opus-4-20250514', $service->defaultModel());
    }

    public function test_default_model_uses_sonnet_when_not_specified(): void
    {
        $service = new ClaudeService('test-api-key');

        $this->assertEquals('claude-sonnet-4-20250514', $service->defaultModel());
    }

    public function test_is_available_returns_true_with_api_key(): void
    {
        $service = new ClaudeService('test-api-key');

        $this->assertTrue($service->isAvailable());
    }

    public function test_is_available_returns_false_without_api_key(): void
    {
        $service = new ClaudeService('');

        $this->assertFalse($service->isAvailable());
    }

    // =========================================================================
    // Generate Tests
    // =========================================================================

    public function test_generate_returns_agentic_response(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'id' => 'msg_123',
                'type' => 'message',
                'role' => 'assistant',
                'model' => 'claude-sonnet-4-20250514',
                'content' => [
                    ['type' => 'text', 'text' => 'Hello, world!'],
                ],
                'stop_reason' => 'end_turn',
                'usage' => [
                    'input_tokens' => 10,
                    'output_tokens' => 5,
                ],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('You are helpful.', 'Say hello');

        $this->assertInstanceOf(AgenticResponse::class, $response);
        $this->assertEquals('Hello, world!', $response->content);
        $this->assertEquals('claude-sonnet-4-20250514', $response->model);
        $this->assertEquals(10, $response->inputTokens);
        $this->assertEquals(5, $response->outputTokens);
        $this->assertEquals('end_turn', $response->stopReason);
    }

    public function test_generate_sends_correct_request_body(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'model' => 'claude-sonnet-4-20250514',
                'content' => [['type' => 'text', 'text' => 'Response']],
                'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $service->generate('System prompt', 'User prompt');

        Http::assertSent(function ($request) {
            $body = $request->data();

            return $body['system'] === 'System prompt'
                && $body['messages'][0]['role'] === 'user'
                && $body['messages'][0]['content'] === 'User prompt'
                && $body['model'] === 'claude-sonnet-4-20250514'
                && $body['max_tokens'] === 4096
                && $body['temperature'] === 1.0;
        });
    }

    public function test_generate_uses_custom_config(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'model' => 'claude-opus-4-20250514',
                'content' => [['type' => 'text', 'text' => 'Response']],
                'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $service->generate('System', 'User', [
            'model' => 'claude-opus-4-20250514',
            'max_tokens' => 8192,
            'temperature' => 0.5,
        ]);

        Http::assertSent(function ($request) {
            $body = $request->data();

            return $body['model'] === 'claude-opus-4-20250514'
                && $body['max_tokens'] === 8192
                && $body['temperature'] === 0.5;
        });
    }

    public function test_generate_sends_correct_headers(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'model' => 'claude-sonnet-4-20250514',
                'content' => [['type' => 'text', 'text' => 'Response']],
                'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key-123');
        $service->generate('System', 'User');

        Http::assertSent(function ($request) {
            return $request->hasHeader('x-api-key', 'test-api-key-123')
                && $request->hasHeader('anthropic-version', '2023-06-01')
                && $request->hasHeader('content-type', 'application/json');
        });
    }

    public function test_generate_tracks_duration(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'model' => 'claude-sonnet-4-20250514',
                'content' => [['type' => 'text', 'text' => 'Response']],
                'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('System', 'User');

        $this->assertIsInt($response->durationMs);
        $this->assertGreaterThanOrEqual(0, $response->durationMs);
    }

    public function test_generate_includes_raw_response(): void
    {
        $rawResponse = [
            'id' => 'msg_123',
            'model' => 'claude-sonnet-4-20250514',
            'content' => [['type' => 'text', 'text' => 'Response']],
            'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
        ];

        Http::fake([
            self::API_URL => Http::response($rawResponse, 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('System', 'User');

        $this->assertEquals('msg_123', $response->raw['id']);
    }

    // =========================================================================
    // Error Handling Tests
    // =========================================================================

    public function test_generate_throws_on_client_error(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'error' => ['message' => 'Invalid API key'],
            ], 401),
        ]);

        $service = new ClaudeService('invalid-key');

        $this->expectException(RuntimeException::class);
        $this->expectExceptionMessage('Claude API error');

        $service->generate('System', 'User');
    }

    public function test_generate_retries_on_rate_limit(): void
    {
        Http::fake([
            self::API_URL => Http::sequence()
                ->push(['error' => ['message' => 'Rate limited']], 429)
                ->push([
                    'model' => 'claude-sonnet-4-20250514',
                    'content' => [['type' => 'text', 'text' => 'Success after retry']],
                    'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
                ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('System', 'User');

        $this->assertEquals('Success after retry', $response->content);
    }

    public function test_generate_retries_on_server_error(): void
    {
        Http::fake([
            self::API_URL => Http::sequence()
                ->push(['error' => ['message' => 'Server error']], 500)
                ->push([
                    'model' => 'claude-sonnet-4-20250514',
                    'content' => [['type' => 'text', 'text' => 'Success after retry']],
                    'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
                ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('System', 'User');

        $this->assertEquals('Success after retry', $response->content);
    }

    public function test_generate_throws_after_max_retries(): void
    {
        Http::fake([
            self::API_URL => Http::response(['error' => ['message' => 'Server error']], 500),
        ]);

        $service = new ClaudeService('test-api-key');

        $this->expectException(RuntimeException::class);

        $service->generate('System', 'User');
    }

    // =========================================================================
    // Stream Tests
    // =========================================================================

    public function test_stream_is_generator(): void
    {
        // Create a simple SSE stream response
        $stream = "data: {\"type\": \"content_block_delta\", \"delta\": {\"text\": \"Hello\"}}\n\n";
        $stream .= "data: {\"type\": \"content_block_delta\", \"delta\": {\"text\": \" world\"}}\n\n";
        $stream .= "data: [DONE]\n\n";

        Http::fake([
            self::API_URL => Http::response($stream, 200, ['Content-Type' => 'text/event-stream']),
        ]);

        $service = new ClaudeService('test-api-key');
        $generator = $service->stream('System', 'User');

        $this->assertInstanceOf(\Generator::class, $generator);
    }

    public function test_stream_sends_stream_flag(): void
    {
        Http::fake([
            self::API_URL => Http::response('', 200),
        ]);

        $service = new ClaudeService('test-api-key');
        iterator_to_array($service->stream('System', 'User'));

        Http::assertSent(function ($request) {
            return $request->data()['stream'] === true;
        });
    }

    // =========================================================================
    // Response Handling Edge Cases
    // =========================================================================

    public function test_handles_empty_content(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'model' => 'claude-sonnet-4-20250514',
                'content' => [],
                'usage' => ['input_tokens' => 10, 'output_tokens' => 0],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('System', 'User');

        $this->assertEquals('', $response->content);
    }

    public function test_handles_missing_usage_data(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'model' => 'claude-sonnet-4-20250514',
                'content' => [['type' => 'text', 'text' => 'Response']],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('System', 'User');

        $this->assertEquals(0, $response->inputTokens);
        $this->assertEquals(0, $response->outputTokens);
    }

    public function test_handles_missing_stop_reason(): void
    {
        Http::fake([
            self::API_URL => Http::response([
                'model' => 'claude-sonnet-4-20250514',
                'content' => [['type' => 'text', 'text' => 'Response']],
                'usage' => ['input_tokens' => 10, 'output_tokens' => 5],
            ], 200),
        ]);

        $service = new ClaudeService('test-api-key');
        $response = $service->generate('System', 'User');

        $this->assertNull($response->stopReason);
    }
}