<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Illuminate\Support\Facades\Http;
use Tests\TestCase;

class UserDataFetcherTest extends TestCase
{
    /**
     * Ensure a user's data can be fetched from an external API.
     */
    public function test_user_data_can_be_fetched_from_external_api(): void
    {
        // Stage 1: Activate the HTTP faker to intercept all outgoing requests.
        Http::fake();

        // Stage 2: Execute the code that makes an HTTP request.
        // Assume 'fetchUserData' internally uses Http::get('https://api.example.com/users/1')
        // We're not defining a specific fake response yet, so by default, Http::fake() returns empty 200 responses.
        $response = $this->get('/users/1'); // Or call a service method directly.

        // Stage 3: Assert that an HTTP request was sent.
        Http::assertSent(function ($request) {
            return $request->url() === 'https://api.example.com/users/1';
        });

        // Stage 4: Assert the application's response (assuming it depends on the external API).
        // If Http::fake() was called without a specific response, the application might receive a default 200 OK.
        // For a more meaningful test, we need to define the fake response payload.
        $response->assertStatus(200);
    }

    /**
     * Demonstrate faking a specific response for an external API.
     */
    public function test_user_data_is_correctly_processed_from_mocked_api(): void
    {
        // Forge a specific JSON response for the external API call.
        Http::fake([
            'https://api.example.com/users/*' => Http::response([
                'id' => 1,
                'name' => 'John Doe',
                'email' => 'john.doe@example.com'
            ], 200, ['Headers' => 'Value']),
        ]);

        // Execute the SUT (System Under Test) that makes the HTTP request.
        $response = $this->get('/fetch-user-data/1'); // Assuming this route triggers the API call.

        // Validate the application's behavior based on the mocked response.
        $response->assertStatus(200)
                 ->assertJson([
                    'id' => 1,
                    'name' => 'John Doe',
                    'email' => 'john.doe@example.com'
                 ]);

        // Verify that the correct request was sent.
        Http::assertSent(function ($request) {
            return $request->url() === 'https://api.example.com/users/1' &&
                   $request->method() === 'GET';
        });
    }
}

<?php

namespace Tests\Feature;

use Illuminate\Support\Facades\Http;
use Tests\TestCase;

class AdvancedApiIntegrationTest extends TestCase
{
    /**
     * Test an API interaction that involves a sequence of different responses.
     */
    public function test_api_call_with_response_sequence(): void
    {
        // Engineer a sequence of fake responses for the same endpoint.
        Http::fakeSequence()
            ->push(Http::response(['status' => 'pending'], 202)) // First call
            ->push(Http::response(['status' => 'processing'], 202)) // Second call
            ->push(Http::response(['status' => 'completed', 'data' => 'result'], 200)); // Third call

        // Simulate three sequential calls to the external API.
        // Assume our service polls an API until it's 'completed'.
        $response1 = Http::get('https://api.example.com/process/123');
        $response2 = Http::get('https://api.example.com/process/123');
        $response3 = Http::get('https://api.example.com/process/123');

        // Verify each response in the sequence.
        $response1->assertStatus(202)->assertJson(['status' => 'pending']);
        $response2->assertStatus(202)->assertJson(['status' => 'processing']);
        $response3->assertStatus(200)->assertJson(['status' => 'completed', 'data' => 'result']);
    }

    /**
     * Test an API call where the response depends on the incoming request parameters.
     */
    public function test_api_call_with_dynamic_response_via_callback(): void
    {
        // Forge a dynamic response using a callback function.
        Http::fake(function ($request) {
            if ($request->url() === 'https://api.example.com/search' && $request->input('query') === 'laravel') {
                return Http::response(['results' => ['Laravel framework']], 200);
            }
            if ($request->url() === 'https://api.example.com/search' && $request->input('query') === 'php') {
                return Http::response(['results' => ['PHP language']], 200);
            }
            return Http::response([], 404); // Default for other queries
        });

        // Test with different query parameters.
        $laravelResponse = Http::get('https://api.example.com/search', ['query' => 'laravel']);
        $phpResponse = Http::get('https://api.example.com/search', ['query' => 'php']);
        $unknownResponse = Http::get('https://api.example.com/search', ['query' => 'python']);

        $laravelResponse->assertStatus(200)->assertJson(['results' => ['Laravel framework']]);
        $phpResponse->assertStatus(200)->assertJson(['results' => ['PHP language']]);
        $unknownResponse->assertStatus(404);
    }

    /**
     * Test handling of API error responses.
     */
    public function test_api_call_handles_error_response(): void
    {
        // Simulate an internal server error from the API.
        Http::fake([
            'https://api.example.com/data' => Http::response('Server Error', 500)
        ]);

        // Execute code that calls the API.
        $response = Http::get('https://api.example.com/data');

        // Verify that our application correctly handles the 500 error.
        $response->assertStatus(500);
        // Additional application-level assertions can go here, e.g., if our code logs the error.
    }

    /**
     * Demonstrate partial faking where some URLs are faked and others are allowed to hit the network.
     */
    public function test_partial_faking_specific_urls(): void
    {
        // Only fake 'https://api.example.com/users/*' requests.
        // Other requests (e.g., 'https://real-api.com/status') will hit the actual network.
        Http::partialFake([
            'https://api.example.com/users/*' => Http::response([
                'id' => 1,
                'name' => 'Partial Mock User'
            ], 200)
        ]);

        // This request will be faked.
        $fakeUserResponse = Http::get('https://api.example.com/users/10');
        $fakeUserResponse->assertStatus(200)->assertJson(['name' => 'Partial Mock User']);

        // This request, if 'real-api.com' exists and is accessible, will hit the actual network.
        // For production code, ensure this is a controlled scenario or avoid it in unit tests.
        // For demonstration purposes, we assume 'https://real-api.com/status' is a real, accessible endpoint.
        // In a true testing scenario, we'd mock ALL external dependencies.
        // To keep the example runnable without external network access, we'll demonstrate assertNotSent on a faked domain instead
        // Http::get('https://real-api.com/status'); // This would hit a real endpoint
        
        // Let's assert that a specific other URL was NOT faked and therefore would have hit the network (if it existed)
        // This is a more practical demonstration within a controlled test environment.
        $this->expectException("GuzzleHttp\\Exception\\ConnectException"); // Or a more specific exception for network calls
        // For Http::partialFake(), any URL NOT matching the fake patterns will attempt to make a real request.
        // To avoid actual network calls in a test, we usually use a service like `guzzlehttp/guzzle-mock` or mock the underlying Guzzle client itself if partialFake isn't sufficient.
        // For simplicity and to avoid actual network interaction during the test, let's illustrate with another 'faked' domain
        // that we explicitly don't fake with partialFake, to show it would *attempt* a real call.

        // If Http::get('https://another-api.com/status') is called, and it's not in partialFake, it will try to make a real request.
        // In a test environment without network access, this often leads to a connection error.
        // For a more robust test, you'd typically ensure all external calls are mocked in some way.
        // Http::assertNotSent(function ($request) {
        //     return $request->url() === 'https://another-api.com/status';
        // });
        // The above assertion is for full `Http::fake()`. For `partialFake`, any non-matching request WILL attempt a real call.
        // So, we would actually expect a real network call for 'https://another-api.com/status' if it were made.
        // To truly isolate, ensure all necessary calls are covered by the `partialFake` patterns.

        // For example, if we call an API that is NOT covered by partialFake:
        // Http::get('https://unfaked-api.com/data'); // This would attempt a real HTTP request.
        // Since we are in a test and usually don't want real network calls, this often means a test setup error
        // or a deliberate integration test. For a true unit test with Http::partialFake(), we ensure all calls we care about are faked.

        // We can assert that a request that *should* be faked was indeed faked and not sent to the real network.
        Http::assertSent(function ($request) {
            return $request->url() === 'https://api.example.com/users/10';
        });

        // We can also ensure that specific URLs that are *not* intended to be faked (and might hit real network) were not part of our faked scope.
        // This part gets tricky with `partialFake` as it's about what *isn't* faked. The main point is to only fake what's necessary.
        // For a true test of `partialFake`, you'd have a component making calls to both faked and unfaked URLs,
        // and then verify the faked one behaved as expected, and potentially that the unfaked one attempted a real call (if that's part of the test).
    }
}

<?php

namespace Tests\Feature;

use Illuminate\Support\Facades\Http;
use Tests\TestCase;

class DataProcessingIntegrationTest extends TestCase
{
    protected function setUp(): void
    {
        parent::setUp();
        // Global faking for all tests in this class to ensure isolation.
        // Can be refined per test method if needed.
        Http::fake();
    }

    /**
     * Test a component that makes an API call and asserts the request was sent correctly.
     */
    public function test_api_call_sends_correct_data(): void
    {
        // Define the expected response for the API call.
        Http::fake([
            'https://api.example.com/orders' => Http::response(['status' => 'success', 'order_id' => 'XYZ123'], 201)
        ]);

        // Assume a service method `placeOrder` makes an Http::post call.
        $orderData = ['item' => 'Laptop', 'quantity' => 1];
        // Call the service that makes the actual Http request.
        $this->postJson('/api/orders', $orderData); // Or call a specific service method directly.

        // Assert that a request was sent to the correct URL with the correct data.
        Http::assertSent(function ($request) use ($orderData) {
            return $request->url() === 'https://api.example.com/orders' &&
                   $request->method() === 'POST' &&
                   $request->json('item') === $orderData['item'] &&
                   $request->json('quantity') === $orderData['quantity'];
        });

        // We can also assert against the application's response after processing the fake API response.
        $this->assertResponseStatus(201); // Or appropriate assertion for your application's response.
        $this->assertJsonFragment(['order_id' => 'XYZ123']);
    }

    /**
     * Test a scenario where an API call should NOT be made.
     */
    public function test_api_call_is_not_made_under_certain_conditions(): void
    {
        // Ensure the Http client is still faked (from setUp or explicitly here).
        Http::fake();

        // Execute application logic that, under these conditions, should NOT make an API call.
        // E.g., if a cache hit prevents an API call.
        $this->get('/api/cached-data');

        // Assert that NO HTTP requests were sent during this test.
        // Or more granularly, Http::assertNotSent(function ($request) { ... });
        Http::assertNothingSent();

        $this->assertResponseStatus(200); // Assuming the cached data is returned.
    }

    /**
     * Test verifying multiple requests were sent.
     */
    public function test_multiple_api_calls_are_sent_and_verified(): void
    {
        Http::fake([
            'https://api.example.com/resource/A' => Http::response(['data' => 'A'], 200),
            'https://api.example.com/resource/B' => Http::response(['data' => 'B'], 200)
        ]);

        // Assume application makes two distinct API calls.
        $this->post('/process-multiple-resources');

        Http::assertSent(function ($request) {
            return $request->url() === 'https://api.example.com/resource/A';
        });
        Http::assertSent(function ($request) {
            return $request->url() === 'https://api.example.com/resource/B';
        });

        // Assert that exactly two requests were sent total (optional, but good for strict tests).
        Http::assertSentCount(2);
    }
}