michaelschiemer/tests/Unit/Application/Debug/DebugConsoleControllerTest.php

<?php

declare(strict_types=1);

namespace Tests\Unit\Application\Debug;

use App\Application\Debug\DebugCodeEvaluator;
use App\Application\Debug\DebugConsoleController;
use App\Application\Debug\DebugHistoryManager;
use App\Application\Debug\EvaluationResult;
use App\Framework\Config\Environment;
use App\Framework\Http\Method;
use App\Framework\Http\Request;
use App\Framework\Http\ServerEnvironment;
use App\Framework\Router\Result\JsonResult;
use App\Framework\Router\Result\ViewResult;

describe('DebugConsoleController', function () {
    beforeEach(function () {
        // Create test environment with development mode enabled
        $this->environment = new Environment([
            'APP_DEBUG' => true,
        ]);

        // Mock DebugCodeEvaluator
        $this->evaluator = new class extends DebugCodeEvaluator {
            public function evaluate(string $code): EvaluationResult
            {
                // Simulate evaluation
                return new EvaluationResult(
                    output: 'Test output',
                    type: 'string',
                    executionTime: 0.001,
                    rawValue: 'Test output'
                );
            }
        };

        // Mock DebugHistoryManager
        $this->historyManager = new class extends DebugHistoryManager {
            private array $history = [];

            public function __construct()
            {
                // No parent constructor call - avoid cache dependency
            }

            public function addEntry(string $code, EvaluationResult $result): void
            {
                $this->history[] = [
                    'code' => $code,
                    'output' => $result->output,
                    'type' => $result->type,
                    'executionTime' => $result->executionTime,
                    'timestamp' => time(),
                ];
            }

            public function getHistory(int $limit = 50): array
            {
                return array_slice($this->history, 0, $limit);
            }

            public function clearHistory(): void
            {
                $this->history = [];
            }
        };

        // Create mock request
        $this->createRequest = function (string $method = 'GET', array $body = []) {
            $serverEnv = new class extends ServerEnvironment {
                public function __construct()
                {
                    parent::__construct([
                        'HTTPS' => 'on',
                        'HTTP_HOST' => 'localhost',
                        'SERVER_PROTOCOL' => 'HTTP/1.1',
                        'REQUEST_METHOD' => 'GET',
                        'REQUEST_URI' => '/debug/console',
                    ]);
                }
            };

            return new Request(
                method: Method::from($method),
                uri: '/debug/console',
                server: $serverEnv,
                headers: new \App\Framework\Http\Headers([]),
                cookies: new \App\Framework\Http\Cookies([]),
                query: new \App\Framework\Http\QueryParameters([]),
                parsedBody: $body
            );
        };

        $this->controller = new DebugConsoleController(
            $this->environment,
            $this->evaluator,
            $this->historyManager
        );
    });

    it('returns console view in development mode', function () {
        $request = ($this->createRequest)();
        $result = $this->controller->console($request);

        expect($result)->toBeInstanceOf(ViewResult::class);
        expect($result->template)->toBe('debug/console');
        expect($result->data)->toHaveKey('history');
        expect($result->data)->toHaveKey('context');
    });

    it('executes PHP code successfully', function () {
        $request = ($this->createRequest)('POST', ['code' => 'return 2 + 2;']);
        $result = $this->controller->execute($request);

        expect($result)->toBeInstanceOf(JsonResult::class);
        expect($result->data['success'])->toBeTrue();
        expect($result->data['result'])->toBe('Test output');
        expect($result->data['type'])->toBe('string');
    });

    it('returns error when no code provided', function () {
        $request = ($this->createRequest)('POST', []);
        $result = $this->controller->execute($request);

        expect($result)->toBeInstanceOf(JsonResult::class);
        expect($result->data['success'])->toBeFalse();
        expect($result->data['error'])->toBe('No code provided');
    });

    it('returns command history', function () {
        // Add some history
        $this->historyManager->addEntry('test code', new EvaluationResult(
            output: 'output',
            type: 'string',
            executionTime: 0.001
        ));

        $request = ($this->createRequest)();
        $result = $this->controller->history($request);

        expect($result)->toBeInstanceOf(JsonResult::class);
        expect($result->data['history'])->toHaveCount(1);
    });

    it('clears command history', function () {
        // Add history entry
        $this->historyManager->addEntry('test', new EvaluationResult(
            output: 'out',
            type: 'string',
            executionTime: 0.001
        ));

        $request = ($this->createRequest)('POST');
        $result = $this->controller->clearHistory($request);

        expect($result)->toBeInstanceOf(JsonResult::class);
        expect($result->data['success'])->toBeTrue();
        expect($this->historyManager->getHistory())->toHaveCount(0);
    });

    it('throws exception when not in development mode', function () {
        $prodEnvironment = new Environment(['APP_DEBUG' => false]);
        $prodController = new DebugConsoleController(
            $prodEnvironment,
            $this->evaluator,
            $this->historyManager
        );

        $request = ($this->createRequest)();

        expect(fn () => $prodController->console($request))
            ->toThrow(\RuntimeException::class, 'Debug Console is only available in development mode');
    });

    it('includes context information', function () {
        $request = ($this->createRequest)();
        $result = $this->controller->console($request);

        expect($result->data['context'])->toHaveKey('php_version');
        expect($result->data['context'])->toHaveKey('memory_usage');
        expect($result->data['context'])->toHaveKey('loaded_extensions');
    });
});