fedi-feed-router/backend/tests/Unit/Modules/Lemmy/LemmyRequestTest.php

<?php

namespace Tests\Unit\Modules\Lemmy;

use App\Modules\Lemmy\LemmyRequest;
use Illuminate\Http\Client\Response;
use Illuminate\Support\Facades\Http;
use Tests\TestCase;

class LemmyRequestTest extends TestCase
{
    public function test_constructor_sets_instance_and_token(): void
    {
        $instance = 'lemmy.test';
        $token = 'test-token';
        
        $request = new LemmyRequest($instance, $token);
        
        $this->assertInstanceOf(LemmyRequest::class, $request);
    }

    public function test_constructor_sets_instance_without_token(): void
    {
        $instance = 'lemmy.test';
        
        $request = new LemmyRequest($instance);
        
        $this->assertInstanceOf(LemmyRequest::class, $request);
    }

    public function test_get_makes_request_without_token(): void
    {
        Http::fake([
            'https://lemmy.test/api/v3/test' => Http::response(['success' => true], 200)
        ]);

        $request = new LemmyRequest('lemmy.test');
        $response = $request->get('test');

        $this->assertInstanceOf(Response::class, $response);
        $this->assertTrue($response->successful());
        
        Http::assertSent(function ($request) {
            return $request->url() === 'https://lemmy.test/api/v3/test' &&
                   !$request->hasHeader('Authorization');
        });
    }

    public function test_get_makes_request_with_token(): void
    {
        Http::fake([
            'https://lemmy.test/api/v3/test' => Http::response(['success' => true], 200)
        ]);

        $request = new LemmyRequest('lemmy.test', 'test-token');
        $response = $request->get('test');

        $this->assertInstanceOf(Response::class, $response);
        $this->assertTrue($response->successful());
        
        Http::assertSent(function ($request) {
            return $request->url() === 'https://lemmy.test/api/v3/test' &&
                   $request->hasHeader('Authorization', 'Bearer test-token');
        });
    }

    public function test_get_includes_parameters(): void
    {
        Http::fake([
            'https://lemmy.test/api/v3/test*' => Http::response(['success' => true], 200)
        ]);

        $request = new LemmyRequest('lemmy.test');
        $params = ['param1' => 'value1', 'param2' => 'value2'];
        $response = $request->get('test', $params);

        $this->assertTrue($response->successful());
        
        Http::assertSent(function ($request) use ($params) {
            $query = parse_url($request->url(), PHP_URL_QUERY);
            parse_str($query, $queryParams);
            return $queryParams === $params;
        });
    }

    public function test_post_makes_request_without_token(): void
    {
        Http::fake([
            'https://lemmy.test/api/v3/test' => Http::response(['success' => true], 200)
        ]);

        $request = new LemmyRequest('lemmy.test');
        $response = $request->post('test');

        $this->assertInstanceOf(Response::class, $response);
        $this->assertTrue($response->successful());
        
        Http::assertSent(function ($request) {
            return $request->url() === 'https://lemmy.test/api/v3/test' &&
                   $request->method() === 'POST' &&
                   !$request->hasHeader('Authorization');
        });
    }

    public function test_post_makes_request_with_token(): void
    {
        Http::fake([
            'https://lemmy.test/api/v3/test' => Http::response(['success' => true], 200)
        ]);

        $request = new LemmyRequest('lemmy.test', 'test-token');
        $response = $request->post('test');

        $this->assertTrue($response->successful());
        
        Http::assertSent(function ($request) {
            return $request->url() === 'https://lemmy.test/api/v3/test' &&
                   $request->method() === 'POST' &&
                   $request->hasHeader('Authorization', 'Bearer test-token');
        });
    }

    public function test_post_includes_data(): void
    {
        Http::fake([
            'https://lemmy.test/api/v3/test' => Http::response(['success' => true], 200)
        ]);

        $request = new LemmyRequest('lemmy.test');
        $data = ['field1' => 'value1', 'field2' => 'value2'];
        $response = $request->post('test', $data);

        $this->assertTrue($response->successful());
        
        Http::assertSent(function ($request) use ($data) {
            return $request->data() === $data;
        });
    }

    public function test_with_token_returns_self_and_updates_token(): void
    {
        $request = new LemmyRequest('lemmy.test');
        $result = $request->withToken('new-token');

        $this->assertSame($request, $result);
        
        // Verify token is used in subsequent requests
        Http::fake([
            'https://lemmy.test/api/v3/test' => Http::response(['success' => true], 200)
        ]);

        $request->get('test');
        
        Http::assertSent(function ($request) {
            return $request->hasHeader('Authorization', 'Bearer new-token');
        });
    }

    public function test_requests_have_timeout(): void
    {
        Http::fake([
            'https://lemmy.test/api/v3/test' => Http::response(['success' => true], 200)
        ]);

        $request = new LemmyRequest('lemmy.test');
        $request->get('test');

        // This tests that timeout is set - actual timeout value is implementation detail
        Http::assertSent(function ($request) {
            return str_contains($request->url(), 'lemmy.test');
        });
    }
}