MonitorServiceProviderTest.php

<?php

declare(strict_types=1);

namespace Tests\Feature;

use Kirschbaum\Monitor\LogTimer;
use Kirschbaum\Monitor\Monitor;
use Kirschbaum\Monitor\MonitorServiceProvider;
use Kirschbaum\Monitor\Trace;
use Tests\TestCase;

class MonitorServiceProviderTest extends TestCase
{
    public function test_registers_services_as_singletons()
    {
        // Test that services are registered
        expect($this->app->bound(Monitor::class))->toBeTrue()
            ->and($this->app->bound(Trace::class))->toBeTrue()
            ->and($this->app->bound(LogTimer::class))->toBeTrue();

        // Test singleton behavior - same instance returned
        $monitor1 = $this->app->make(Monitor::class);
        $monitor2 = $this->app->make(Monitor::class);
        expect($monitor1)->toBe($monitor2);

        $trace1 = $this->app->make(Trace::class);
        $trace2 = $this->app->make(Trace::class);
        expect($trace1)->toBe($trace2);

        $timer1 = $this->app->make(LogTimer::class);
        $timer2 = $this->app->make(LogTimer::class);
        expect($timer1)->toBe($timer2);
    }

    public function test_services_return_correct_types()
    {
        expect($this->app->make(Monitor::class))->toBeInstanceOf(Monitor::class)
            ->and($this->app->make(Trace::class))->toBeInstanceOf(Trace::class)
            ->and($this->app->make(LogTimer::class))->toBeInstanceOf(LogTimer::class);
    }

    public function test_publishes_config_files()
    {
        // Test that publishing is registered
        $provider = new MonitorServiceProvider($this->app);
        $provider->boot();

        $publishGroups = $provider::$publishGroups ?? [];

        // Laravel 11 changed how this works, so let's test the files exist
        $monitorConfigPath = __DIR__.'/../../config/monitor.php';
        $loggingConfigPath = __DIR__.'/../../config/logging-monitor.php';

        expect(file_exists($monitorConfigPath))->toBeTrue('monitor.php config file should exist')
            ->and(file_exists($loggingConfigPath))->toBeTrue('logging-monitor.php config file should exist');
    }

    public function test_console_auto_trace_logic_with_started_trace()
    {
        // Create a trace that has already started
        $trace = new Trace;
        $trace->start();
        $originalId = $trace->id();

        // Bind to container
        $this->app->instance(Trace::class, $trace);

        // Create a custom service provider to test console logic
        $provider = new class($this->app) extends MonitorServiceProvider
        {
            public function test_boot_console_logic(): void
            {
                // Simulate the console condition manually (console=true, testing=false, already started)
                if (true && ! false && ! app(Trace::class)->hasStarted()) {
                    app(Trace::class)->start();
                }
            }
        };

        $provider->test_boot_console_logic();

        // Trace should remain unchanged (already started)
        expect($trace->hasStarted())->toBeTrue()
            ->and($trace->id())->toBe($originalId);
    }

    public function test_console_auto_trace_logic_with_unstarted_trace()
    {
        // Create a fresh trace that hasn't started
        $trace = new Trace;
        expect($trace->hasNotStarted())->toBeTrue();

        // Bind to container
        $this->app->instance(Trace::class, $trace);

        // Create a custom service provider to test console logic
        $provider = new class($this->app) extends MonitorServiceProvider
        {
            public function test_boot_console_logic(): void
            {
                // Simulate the console condition manually (console=true, testing=false, not started)
                if (true && ! false && ! app(Trace::class)->hasStarted()) {
                    app(Trace::class)->start();
                }
            }
        };

        $provider->test_boot_console_logic();

        // Trace should now be started
        expect($trace->hasStarted())->toBeTrue();
    }

    public function test_console_auto_trace_respects_testing_environment()
    {
        // Create a fresh trace
        $trace = new Trace;
        expect($trace->hasNotStarted())->toBeTrue();

        $this->app->instance(Trace::class, $trace);

        // Create a custom service provider to test testing environment logic
        $provider = new class($this->app) extends MonitorServiceProvider
        {
            public function test_boot_console_logic(): void
            {
                // Simulate console=true, testing=true condition
                if (true && ! true && ! app(Trace::class)->hasStarted()) {
                    app(Trace::class)->start();
                }
            }
        };

        $provider->test_boot_console_logic();

        // Trace should NOT be started in testing environment
        expect($trace->hasNotStarted())->toBeTrue();
    }

    public function test_console_auto_trace_respects_web_environment()
    {
        // Create a fresh trace
        $trace = new Trace;
        expect($trace->hasNotStarted())->toBeTrue();

        $this->app->instance(Trace::class, $trace);

        // Create a custom service provider to test web environment logic
        $provider = new class($this->app) extends MonitorServiceProvider
        {
            public function test_boot_console_logic(): void
            {
                // Simulate console=false (web environment)
                if (false && ! false && ! app(Trace::class)->hasStarted()) {
                    app(Trace::class)->start();
                }
            }
        };

        $provider->test_boot_console_logic();

        // Trace should NOT be started in web environment
        expect($trace->hasNotStarted())->toBeTrue();
    }

    public function test_app_binding_works_through_helper()
    {
        // Test that app() helper works with our registered services
        expect(app(Monitor::class))->toBeInstanceOf(Monitor::class)
            ->and(app(Trace::class))->toBeInstanceOf(Trace::class)
            ->and(app(LogTimer::class))->toBeInstanceOf(LogTimer::class);

        // Test singleton behavior through app() helper
        expect(app(Monitor::class))->toBe(app(Monitor::class))
            ->and(app(Trace::class))->toBe(app(Trace::class))
            ->and(app(LogTimer::class))->toBe(app(LogTimer::class));
    }

    public function test_boot_method_integration()
    {
        // Test that boot() doesn't throw errors and performs expected operations
        $provider = new MonitorServiceProvider($this->app);

        // Test that boot can be called without throwing any exception
        $exception = null;
        try {
            $provider->boot();
        } catch (\Exception $e) {
            $exception = $e;
        }

        expect($exception)->toBeNull();
    }

    public function test_service_provider_properties()
    {
        $provider = new MonitorServiceProvider($this->app);

        // Test that service provider is properly configured
        expect($provider)->toBeInstanceOf(MonitorServiceProvider::class)
            ->and(get_class($provider))->toBe(MonitorServiceProvider::class);
    }

    public function test_register_is_complete()
    {
        // Test the registration process itself by checking that register() method works
        $provider = new MonitorServiceProvider($this->app);

        // The services should already be bound by the test setup, so let's test that they are singletons
        $monitor1 = $this->app->make(Monitor::class);
        $monitor2 = $this->app->make(Monitor::class);
        $trace1 = $this->app->make(Trace::class);
        $trace2 = $this->app->make(Trace::class);
        $timer1 = $this->app->make(LogTimer::class);
        $timer2 = $this->app->make(LogTimer::class);

        // Verify they are the same instances (singleton behavior)
        expect($monitor1)->toBe($monitor2)
            ->and($trace1)->toBe($trace2)
            ->and($timer1)->toBe($timer2);
    }
}