server/tests/php/Unit/Module/CoreModuleTest.php

<?php

declare(strict_types=1);

namespace KTXT\Unit\Module;

use KTXC\Console\Firewall\FirewallMaintenanceCommand;
use KTXC\Console\Firewall\FirewallSetupCommand;
use KTXC\Console\Event\EventsDebugCommand;
use KTXC\Module\Module;
use KTXC\Module\Configuration\BrowserModuleContext;
use KTXC\Module\Configuration\ConsoleModuleContext;
use KTXC\Preview\PreviewManager;
use KTXC\Resource\ProviderManager;
use KTXC\Service\FirewallService;
use KTXC\Service\SystemFirewallRuleService;
use KTXC\Service\SystemFirewallLogService;
use KTXC\Service\TenantFirewallLogService;
use KTXC\Service\TenantFirewallStatusService;
use KTXC\Service\SystemFirewallStatusService;
use KTXC\Service\TenantFirewallRuleService;
use KTXC\Service\TenantService;
use KTXC\SystemStore\SystemStoreManager;
use KTXC\Event\EventListenerRegistry;
use KTXC\Security\Event\AccessDeniedEvent;
use KTXC\Security\Event\AuthenticationFailedEvent;
use KTXC\Security\Event\AuthenticationSucceededEvent;
use KTXC\Security\Event\BruteForceDetectedEvent;
use KTXC\Security\Event\FirewallRuleCreatedEvent;
use KTXC\Security\Event\FirewallRuleDisabledEvent;
use KTXC\Security\Event\FirewallRuleEnabledEvent;
use KTXC\Security\Event\FirewallRuleExtendedEvent;
use KTXC\Security\Event\FirewallRuleRemovedEvent;
use KTXC\Security\Event\FirewallSettingsUpdatedEvent;
use KTXC\Security\Event\RateLimitExceededEvent;
use KTXC\Security\Event\SuspiciousActivityEvent;
use KTXF\Event\DeliveryMode;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;

final class CoreModuleTest extends TestCase
{
    #[Test]
    #[TestDox('Core boot registers owned listeners without resolving services')]
    public function registersListeners(): void
    {
        $registry = new EventListenerRegistry();
        $module = $this->module($registry);

        $module->boot();
        $definitions = $registry->definitions();

        self::assertCount(12, $definitions);
        self::assertSame(['core'], array_values(array_unique(array_column($definitions, 'module'))));
        self::assertSame(
            FirewallService::class,
            $registry->listeners(AuthenticationFailedEvent::class, DeliveryMode::Immediate)[0]->service,
        );
        self::assertSame([], $registry->listeners(AuthenticationFailedEvent::class, DeliveryMode::Deferred));
        $successListeners = $registry->listeners(
            AuthenticationSucceededEvent::class,
            DeliveryMode::Deferred,
        );
        self::assertCount(1, $successListeners);
        self::assertSame(FirewallService::class, $successListeners[0]->service);
        self::assertSame('logAuthenticationSuccess', $successListeners[0]->method);
        foreach ([
            AccessDeniedEvent::class,
            BruteForceDetectedEvent::class,
            RateLimitExceededEvent::class,
            SuspiciousActivityEvent::class,
            FirewallRuleCreatedEvent::class,
            FirewallRuleExtendedEvent::class,
            FirewallRuleDisabledEvent::class,
            FirewallRuleEnabledEvent::class,
            FirewallRuleRemovedEvent::class,
            FirewallSettingsUpdatedEvent::class,
        ] as $event) {
            $listeners = $registry->listeners($event, DeliveryMode::Deferred);
            self::assertCount(1, $listeners);
            self::assertSame(FirewallService::class, $listeners[0]->service);
            self::assertSame('logSecurityEvent', $listeners[0]->method);
        }
        self::assertFalse($registry->frozen());
    }

    #[Test]
    #[TestDox('Core exposes the event registry debug command')]
    public function exposesDebugCommand(): void
    {
        $module = $this->module();
        $context = new ConsoleModuleContext();
        $module->configure($context);
        $commands = $context->commands();

        self::assertContains(EventsDebugCommand::class, $commands);
        self::assertContains(FirewallSetupCommand::class, $commands);
        self::assertContains(FirewallMaintenanceCommand::class, $commands);
    }

    #[Test]
    #[TestDox('Core registers dedicated system firewall permissions')]
    public function registersSystemFirewallPermissions(): void
    {
        $permissions = $this->module()->permissions();

        self::assertArrayHasKey(SystemFirewallRuleService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(SystemFirewallRuleService::PERMISSION_MANAGE, $permissions);
        self::assertArrayHasKey(TenantFirewallRuleService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(TenantFirewallRuleService::PERMISSION_MANAGE, $permissions);
        self::assertArrayHasKey(TenantFirewallLogService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(SystemFirewallLogService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(TenantFirewallStatusService::PERMISSION_SETTINGS_READ, $permissions);
        self::assertArrayHasKey(TenantFirewallStatusService::PERMISSION_SETTINGS_MANAGE, $permissions);
        self::assertArrayHasKey(SystemFirewallStatusService::PERMISSION_MAINTENANCE_READ, $permissions);
        self::assertArrayHasKey(SystemFirewallStatusService::PERMISSION_SETTINGS_MANAGE, $permissions);
    }

    #[Test]
    #[TestDox('Core resolves preview browser configuration')]
    public function resolvesPreviewBrowserConfiguration(): void
    {
        $module = $this->module();
        $context = new BrowserModuleContext('tenant-id', 'identity-id');
        $module->configure($context);

        self::assertSame([
            'preview' => [
                'enabled' => false,
                'storage' => false,
                'generation' => false,
            ],
        ], $context->configuration());
    }

    private function module(?EventListenerRegistry $registry = null): Module
    {
        $tenants = $this->createStub(TenantService::class);
        $providers = new ProviderManager($this->createStub(ContainerInterface::class));
        $previews = new PreviewManager(
            $tenants,
            $providers,
            new SystemStoreManager($tenants, $providers),
            $this->createStub(LoggerInterface::class),
        );

        return new Module($registry ?? new EventListenerRegistry(), $previews);
    }
}