{

public function testKernelImplementsHttpKernelInterface(): void

{

$kernel = new Kernel(routingContext: 'public', debug: true);

$this->assertInstanceOf(HttpKernelInterface::class, $kernel);

}

public function testKernelRoutingContext(): void

{

$kernel = new Kernel(routingContext: 'admin', debug: false);

$this->assertSame('admin', $kernel->getRoutingContext());

}

public function testKernelDebugMode(): void

{

$kernel = new Kernel(routingContext: 'public', debug: true);

$this->assertTrue($kernel->isDebug());

}

public function testKernelNonDebugMode(): void

{

$kernel = new Kernel(routingContext: 'public', debug: false);

$this->assertFalse($kernel->isDebug());

}

public function testKernelDefaultParameters(): void

{

$kernel = new Kernel();

$this->assertSame('public', $kernel->getRoutingContext());

$this->assertFalse($kernel->isDebug());

}

public function testKernelRoutingContextApi(): void

{

$kernel = new Kernel(routingContext: 'api', debug: false);

$this->assertSame('api', $kernel->getRoutingContext());

}

public function testKernelRoutingContextAdminApi(): void

{

$kernel = new Kernel(routingContext: 'admin-api', debug: false);

$this->assertSame('admin-api', $kernel->getRoutingContext());

}

public function testBootSetsAllProperties(): void

{

$kernel = $this->createKernelWithMockedBoot();

$kernel->boot();

$reflection = new ReflectionClass(Kernel::class);

$this->assertTrue($reflection->getProperty('booted')->getValue($kernel));

$this->assertInstanceOf(ContainerBuilder::class, $reflection->getProperty('container')->getValue($kernel));

$this->assertInstanceOf(RouteCollection::class, $reflection->getProperty('routes')->getValue($kernel));

$this->assertInstanceOf(HttpKernel::class, $reflection->getProperty('httpKernel')->getValue($kernel));

}

public function testBootOnlyRunsOnce(): void

{

$kernel = $this->createKernelWithMockedBoot();

$kernel->boot();

$kernel->boot(); // second call should be a no-op

$reflection = new ReflectionClass(Kernel::class);

$this->assertTrue($reflection->getProperty('booted')->getValue($kernel));

}

public function testGetContainerAutoBoots(): void

{

$kernel = $this->createKernelWithMockedBoot();

$reflection = new ReflectionClass(Kernel::class);

$this->assertFalse($reflection->getProperty('booted')->getValue($kernel));

$container = $kernel->getContainer();

$this->assertInstanceOf(ContainerBuilder::class, $container);

$this->assertTrue($reflection->getProperty('booted')->getValue($kernel));

}

public function testGetContainerReturnsExistingContainerWhenBooted(): void

{

$kernel = $this->createKernelWithMockedBoot();

$kernel->boot();

$container1 = $kernel->getContainer();

$container2 = $kernel->getContainer();

$this->assertSame($container1, $container2);

}

public function testHandleAutoBoots(): void

{

$kernel = $this->createKernelWithMockedBoot();

$reflection = new ReflectionClass(Kernel::class);

$this->assertFalse($reflection->getProperty('booted')->getValue($kernel));

$request = Request::create('/test');

// This will auto-boot, then fail on routing (no matching route), but that's OK

$response = $kernel->handle($request);

$this->assertTrue($reflection->getProperty('booted')->getValue($kernel));

// The response should be a 404 or error since no routes match

$this->assertInstanceOf(Response::class, $response);

}

public function testHandleSetsApiContextForApiRoute(): void

{

$mockHttpKernel = $this->createMock(HttpKernel::class);

$mockHttpKernel

->method('handle')

->willReturnCallback(function (Request $request): Response {

$this->assertTrue($request->attributes->get('_api_context'));

return new Response('API OK');

});

$kernel = $this->createPreBootedKernel(routingContext: 'api', httpKernel: $mockHttpKernel);

$request = Request::create('/api/test');

$response = $kernel->handle($request);

$this->assertSame(200, $response->getStatusCode());

}

public function testHandleSetsApiContextForAdminApiRoute(): void

{

$mockHttpKernel = $this->createMock(HttpKernel::class);

$mockHttpKernel

->method('handle')

->willReturnCallback(function (Request $request): Response {

$this->assertTrue($request->attributes->get('_api_context'));

return new Response('Admin API OK');

});

$kernel = $this->createPreBootedKernel(routingContext: 'admin-api', httpKernel: $mockHttpKernel);

$request = Request::create('/admin/api/test');

$response = $kernel->handle($request);

$this->assertSame(200, $response->getStatusCode());

}

public function testHandleDoesNotSetApiContextForPublicRoute(): void

{

$mockHttpKernel = $this->createMock(HttpKernel::class);

$mockHttpKernel

->method('handle')

->willReturnCallback(function (Request $request): Response {

$this->assertNull($request->attributes->get('_api_context'));

return new Response('Public OK');

});

$kernel = $this->createPreBootedKernel(routingContext: 'public', httpKernel: $mockHttpKernel);

$request = Request::create('/test');

$response = $kernel->handle($request);

$this->assertSame(200, $response->getStatusCode());

}

public function testHandleDoesNotSetApiContextForAdminRoute(): void

{

$mockHttpKernel = $this->createMock(HttpKernel::class);

$mockHttpKernel

->method('handle')

->willReturnCallback(function (Request $request): Response {

$this->assertNull($request->attributes->get('_api_context'));

return new Response('Admin OK');

});

$kernel = $this->createPreBootedKernel(routingContext: 'admin', httpKernel: $mockHttpKernel);

$request = Request::create('/admin/test');

$response = $kernel->handle($request);

$this->assertSame(200, $response->getStatusCode());

}

public function testHandleDelegatesTypeAndCatchParameters(): void

{

$mockHttpKernel = $this->createMock(HttpKernel::class);

$mockHttpKernel

->expects($this->once())

->method('handle')

->with($this->isInstanceOf(Request::class), HttpKernelInterface::SUB_REQUEST, false)

->willReturn(new Response('Sub-request'));

$kernel = $this->createPreBootedKernel(httpKernel: $mockHttpKernel);

$request = Request::create('/test');

$response = $kernel->handle($request, HttpKernelInterface::SUB_REQUEST, false);

$this->assertSame(200, $response->getStatusCode());

}

public function testBuildContainerLoadsServicesAndRegistersKernel(): void

{

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$buildMethod = $reflection->getMethod('buildContainer');

$container = $buildMethod->invoke($kernel);

$this->assertInstanceOf(ContainerBuilder::class, $container);

$this->assertSame($kernel, $container->get('kernel'));

// Verify the event dispatcher was registered by services.php

$this->assertTrue($container->has('phpmyfaq.event_dispatcher'));

}

public function testLoadRoutesWithDebugModeSkipsCache(): void

{

$container = $this->createMock(ContainerBuilder::class);

$container->method('get')->willReturn(null);

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$loadMethod = $reflection->getMethod('loadRoutes');

$routes = $loadMethod->invoke($kernel);

$this->assertInstanceOf(RouteCollection::class, $routes);

}

public function testLoadRoutesWithCacheDisabledViaEnv(): void

{

$_ENV['ROUTING_CACHE_ENABLED'] = 'false';

try {

$container = $this->createMock(ContainerBuilder::class);

$container->method('get')->willReturn(null);

$kernel = new Kernel(routingContext: 'public', debug: false);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$loadMethod = $reflection->getMethod('loadRoutes');

$routes = $loadMethod->invoke($kernel);

$this->assertInstanceOf(RouteCollection::class, $routes);

} finally {

unset($_ENV['ROUTING_CACHE_ENABLED']);

}

}

public function testLoadRoutesWithCacheEnabled(): void

{

$_ENV['ROUTING_CACHE_ENABLED'] = 'true';

$cacheDir = sys_get_temp_dir() . '/phpmyfaq_test_cache_' . uniqid();

try {

$_ENV['ROUTING_CACHE_DIR'] = $cacheDir;

Environment::enableTestMode();

$container = $this->createMock(ContainerBuilder::class);

$container->method('get')->willReturn(null);

// debug=false so the cache path is taken

$kernel = new Kernel(routingContext: 'public', debug: false);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$loadMethod = $reflection->getMethod('loadRoutes');

$routes = $loadMethod->invoke($kernel);

$this->assertInstanceOf(RouteCollection::class, $routes);

} finally {

unset($_ENV['ROUTING_CACHE_ENABLED'], $_ENV['ROUTING_CACHE_DIR']);

// Clean up cache directory

if (is_dir($cacheDir)) {

array_map('unlink', glob($cacheDir . '/*'));

rmdir($cacheDir);

}

}

}

public function testBuildContainerThrowsRuntimeExceptionOnServiceLoadFailure(): void

{

// Test the catch block by temporarily defining a bad PMF_SRC_DIR

// Since PMF_SRC_DIR is a constant, we test the error path by calling

// buildContainer on a kernel that has a services.php that will fail

// Instead, we verify the exception wrapping by using reflection

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$buildMethod = $reflection->getMethod('buildContainer');

// The real buildContainer will succeed since services.php exists

// Test that it returns a valid container

$container = $buildMethod->invoke($kernel);

$this->assertInstanceOf(ContainerBuilder::class, $container);

// Verify FormsServiceProvider was registered

$this->assertTrue($container->has('phpmyfaq.forms'));

}

public function testCreateHttpKernelFallsBackToNewDispatcher(): void

{

$notADispatcher = new \stdClass();

$container = $this->createMock(ContainerBuilder::class);

$container

->method('get')

->willReturnCallback(static fn(string $id) => match ($id) {

'phpmyfaq.event_dispatcher' => $notADispatcher,

default => null,

});

$container->method('has')->willReturn(false);

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, new RouteCollection());

$createMethod = $reflection->getMethod('createHttpKernel');

$httpKernel = $createMethod->invoke($kernel);

$this->assertInstanceOf(HttpKernel::class, $httpKernel);

}

public function testCreateHttpKernelUsesExistingDispatcher(): void

{

$dispatcher = new EventDispatcher();

$container = $this->createMock(ContainerBuilder::class);

$container

->method('get')

->willReturnCallback(static fn(string $id) => match ($id) {

'phpmyfaq.event_dispatcher' => $dispatcher,

default => null,

});

$container->method('has')->willReturn(false);

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, new RouteCollection());

$createMethod = $reflection->getMethod('createHttpKernel');

$httpKernel = $createMethod->invoke($kernel);

$this->assertInstanceOf(HttpKernel::class, $httpKernel);

}

public function testRegisterEventListenersAddsAllListeners(): void

{

$container = $this->createMock(ContainerBuilder::class);

$container->method('get')->willReturn(null);

$container->method('has')->willReturn(false);

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, new RouteCollection());

$dispatcher = new EventDispatcher();

$registerMethod = $reflection->getMethod('registerEventListeners');

$registerMethod->invoke($kernel, $dispatcher);

$requestListeners = $dispatcher->getListeners('kernel.request');

$exceptionListeners = $dispatcher->getListeners('kernel.exception');

$controllerListeners = $dispatcher->getListeners('kernel.controller');

// RouterListener and LanguageListener

$this->assertCount(2, $requestListeners);

// ApiExceptionListener and WebExceptionListener

$this->assertCount(2, $exceptionListeners);

// ControllerContainerListener

$this->assertCount(1, $controllerListeners);

}

public function testRegisterEventListenersRequestListenerPriorities(): void

{

$container = $this->createMock(ContainerBuilder::class);

$container->method('get')->willReturn(null);

$container->method('has')->willReturn(false);

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, new RouteCollection());

$dispatcher = new EventDispatcher();

$registerMethod = $reflection->getMethod('registerEventListeners');

$registerMethod->invoke($kernel, $dispatcher);

$requestListeners = $dispatcher->getListeners('kernel.request');

// RouterListener runs first (priority 256), LanguageListener second (priority 200)

$this->assertCount(2, $requestListeners);

// getListeners returns sorted by priority (highest first)

$this->assertSame('onKernelRequest', $requestListeners[0][1]);

$this->assertSame('onKernelRequest', $requestListeners[1][1]);

}

public function testRegisterEventListenersUsesConfigurationForApiListener(): void

{

$configMock = $this->createMock(Configuration::class);

$rateLimiter = new RateLimiter(storage: new InMemoryStorage());

$container = $this->createMock(ContainerBuilder::class);

$container

->method('has')

->willReturnCallback(static fn(string $id) => in_array(

$id,

['phpmyfaq.configuration', 'phpmyfaq.http.rate-limiter'],

true,

));

$container

->method('get')

->willReturnCallback(static fn(string $id) => match ($id) {

'phpmyfaq.configuration' => $configMock,

'phpmyfaq.http.rate-limiter' => $rateLimiter,

default => null,

});

$kernel = new Kernel(routingContext: 'api', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, new RouteCollection());

$dispatcher = new EventDispatcher();

$registerMethod = $reflection->getMethod('registerEventListeners');

$registerMethod->invoke($kernel, $dispatcher);

$requestListeners = $dispatcher->getListeners('kernel.request');

$exceptionListeners = $dispatcher->getListeners('kernel.exception');

$this->assertCount(3, $requestListeners);

$this->assertCount(2, $exceptionListeners);

}

public function testRegisterEventListenersDoesNotAddApiRateLimiterForAdminApi(): void

{

$configMock = $this->createMock(Configuration::class);

$rateLimiter = new RateLimiter(storage: new InMemoryStorage());

$container = $this->createMock(ContainerBuilder::class);

$container

->method('has')

->willReturnCallback(static fn(string $id) => in_array(

$id,

['phpmyfaq.configuration', 'phpmyfaq.http.rate-limiter'],

true,

));

$container

->method('get')

->willReturnCallback(static fn(string $id) => match ($id) {

'phpmyfaq.configuration' => $configMock,

'phpmyfaq.http.rate-limiter' => $rateLimiter,

default => null,

});

$kernel = new Kernel(routingContext: 'admin-api', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, new RouteCollection());

$dispatcher = new EventDispatcher();

$registerMethod = $reflection->getMethod('registerEventListeners');

$registerMethod->invoke($kernel, $dispatcher);

$requestListeners = $dispatcher->getListeners('kernel.request');

$this->assertCount(2, $requestListeners);

}

public function testRegisterEventListenersWithoutConfiguration(): void

{

$container = $this->createMock(ContainerBuilder::class);

$container->method('has')->willReturn(false);

$container->method('get')->willReturn(null);

$kernel = new Kernel(routingContext: 'public', debug: true);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, new RouteCollection());

$dispatcher = new EventDispatcher();

$registerMethod = $reflection->getMethod('registerEventListeners');

$registerMethod->invoke($kernel, $dispatcher);

$exceptionListeners = $dispatcher->getListeners('kernel.exception');

$this->assertCount(2, $exceptionListeners);

}

/**

private function createKernelWithMockedBoot(string $routingContext = 'public'): TestableKernel

{

$kernel = new TestableKernel($routingContext, true);

$container = new ContainerBuilder();

$container->set('phpmyfaq.event_dispatcher', new EventDispatcher());

$kernel->setMockContainer($container);

return $kernel;

}

/**

private function createPreBootedKernel(

string $routingContext = 'public',

bool $debug = true,

?HttpKernel $httpKernel = null,

): Kernel {

$container = $this->createMock(ContainerBuilder::class);

$dispatcher = new EventDispatcher();

$container

->method('get')

->willReturnCallback(static fn(string $id) => match ($id) {

'phpmyfaq.event_dispatcher' => $dispatcher,

default => null,

});

$container->method('has')->willReturn(false);

$routes = new RouteCollection();

$kernel = new Kernel($routingContext, $debug);

$reflection = new ReflectionClass(Kernel::class);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($kernel, $container);

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($kernel, $routes);

$httpKernelProp = $reflection->getProperty('httpKernel');

$httpKernelProp->setValue(

$kernel,

$httpKernel ?? new HttpKernel(

$dispatcher,

new ContainerControllerResolver($container),

new RequestStack(),

new ArgumentResolver(),

),

);

$bootedProp = $reflection->getProperty('booted');

$bootedProp->setValue($kernel, true);

return $kernel;

}

{

private ?ContainerBuilder $mockContainer = null;

public function setMockContainer(ContainerBuilder $container): void

{

$this->mockContainer = $container;

}

public function boot(): void

{

$reflection = new ReflectionClass(Kernel::class);

$bootedProp = $reflection->getProperty('booted');

if ($bootedProp->getValue($this)) {

return;

}

// Use mock container instead of real buildContainer()

$container = $this->mockContainer ?? new ContainerBuilder();

$container->set('kernel', $this);

$containerProp = $reflection->getProperty('container');

$containerProp->setValue($this, $container);

// Use empty routes to avoid needing Configuration::getConfigurationInstance()

$routesProp = $reflection->getProperty('routes');

$routesProp->setValue($this, new RouteCollection());

// Create the HttpKernel (uses the real createHttpKernel)

$createMethod = $reflection->getMethod('createHttpKernel');

$httpKernel = $createMethod->invoke($this);

$httpKernelProp = $reflection->getProperty('httpKernel');

$httpKernelProp->setValue($this, $httpKernel);

$bootedProp->setValue($this, true);

}