TestCaseAbstract.php

<?php

declare(strict_types=1);

namespace MagicPush\CliToolkit\Tests\Tests;

use FilesystemIterator;
use LogicException;
use MagicPush\CliToolkit\Parametizer\Exception\ConfigException;
use MagicPush\CliToolkit\Parametizer\Parametizer;
use MagicPush\CliToolkit\Tests\Utils\CliProcess;
use PHPUnit\Framework\TestCase;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;

use function PHPUnit\Framework\assertNotFalse;
use function PHPUnit\Framework\assertSame;
use function PHPUnit\Framework\assertStringContainsString;
use function PHPUnit\Framework\assertTrue;

abstract class TestCaseAbstract extends TestCase {
    protected static function removeDirectoryRecursively(string $directoryPath): void {
        if (!file_exists($directoryPath)) {
            return;
        }

        $directoryIterator = new RecursiveDirectoryIterator(
            $directoryPath,
            FilesystemIterator::CURRENT_AS_FILEINFO | FilesystemIterator::SKIP_DOTS,
        );
        $filesRecursiveIterator = new RecursiveIteratorIterator(
            $directoryIterator,
            RecursiveIteratorIterator::CHILD_FIRST,
        );
        foreach ($filesRecursiveIterator as $item) {
            /** @var SplFileInfo $item */
            $itemRealPath = $item->getRealPath();
            assertNotFalse($itemRealPath);
            if ($item->isDir()) {
                assertTrue(rmdir($itemRealPath));
            } else {
                assertTrue(unlink($itemRealPath));
            }
        }
        assertTrue(rmdir($directoryPath));
    }

    /**
     * @param string[] $stdinLines {@see CliProcess::__construct()}
     */
    protected static function assertNoErrorsOutput(
        string $scriptPath,
        string $parametersString = '',
        array $stdinLines = [],
        int $expectedExitCode = 0,
    ): CliProcess {
        $command = 'php ' . escapeshellarg($scriptPath);
        if ('' !== $parametersString) {
            $command .= " {$parametersString}";
        }
        $result = new CliProcess($command, $stdinLines);

        // The heading space before a script name is needed for a script being clickable in PhpStorm console log
        // as a script file link.
        $failedAssertMessage = " {$scriptPath}" . PHP_EOL
            . "COMMAND: {$command}" . PHP_EOL
            . "Unexpected error output: {$result->getStdErr()}";
        assertSame($expectedExitCode, $result->getExitCode(), $failedAssertMessage);
        assertSame('', $result->getStdErr(), $failedAssertMessage);

        return $result;
    }

    /**
     * Asserts that an error message was printed in {@see STDERR} (without a stack trace) during a script execution.
     */
    protected static function assertExecutionErrorOutput(
        string $scriptPath,
        string $expectedErrorOutputSubstring,
        string $parametersString = '',
    ): CliProcess {
        return static::assertAnyErrorOutput(
            $scriptPath,
            $expectedErrorOutputSubstring,
            $parametersString,
            shouldAssertExitCode: true,
            shouldAssertStdErr: true,
        );
    }

    /**
     * Asserts that a {@see ConfigException} exception was printed out during a script configuration.
     * Exit code may vary thus is not asserted.
     */
    protected static function assertConfigExceptionOutput(
        string $scriptPath,
        string $expectedErrorOutputSubstring,
        string $parametersString = '',
    ): CliProcess {
        return static::assertAnyErrorOutput(
            $scriptPath,
            $expectedErrorOutputSubstring,
            $parametersString,
            exceptionHeaderSubstring: ConfigException::class . ': ',
            // Config exceptions happen before a specific error code is set for the exception handler:
            shouldAssertExitCode: false,
            shouldAssertStdErr: false,
        );
    }

    /**
     * Asserts that a {@see LogicException} exception was printed in {@see STDERR} (without a stack trace)
     * during a script execution.
     */
    protected static function assertExecutionLogicExceptionOutput(
        string $scriptPath,
        string $expectedErrorOutputSubstring,
        string $parametersString = '',
    ): void {
        static::assertAnyErrorOutput(
            $scriptPath,
            $expectedErrorOutputSubstring,
            $parametersString,
            exceptionHeaderSubstring: LogicException::class . ': ',
            shouldAssertExitCode: true,
            shouldAssertStdErr: true,
        );
    }

    /**
     * @param bool $shouldAssertStdErr Otherwise asserts a substring in {@see STDOUT} and {@see STDERR} concatenated.
     *                                 On some configurations unhandled exceptions are shown
     *                                 in {@see STDOUT} instead of {@see STDERR}.
     */
    protected static function assertAnyErrorOutput(
        string $scriptPath,
        string $expectedErrorOutputSubstring,
        string $parametersString = '',
        ?string $exceptionHeaderSubstring = null,
        bool $shouldAssertExitCode = true,
        bool $shouldAssertStdErr = true,
    ): CliProcess {
        $command = 'php ' . escapeshellarg($scriptPath);
        if ('' !== $parametersString) {
            $command .= " {$parametersString}";
        }
        $result = new CliProcess($command);

        // The heading space before a script name is needed for a script being clickable in PhpStorm console log
        // as a script file link.
        $assertOutputPrefix = " {$scriptPath}" . PHP_EOL
            . "COMMAND: {$command}" . PHP_EOL;

        if ($shouldAssertExitCode) {
            assertSame(
                Parametizer::ERROR_EXIT_CODE,
                $result->getExitCode(),
                "{$assertOutputPrefix}Unexpected exit code",
            );
        }

        if ($shouldAssertStdErr) {
            $actualContents = $result->getStdErr();
            $assertOutputMessage = "{$assertOutputPrefix}Unexpected STDERR: {$actualContents}";
        } else {
            $actualContents = $result->getStdAll();
            $assertOutputMessage = "{$assertOutputPrefix}Unexpected output: {$actualContents}";
        }
        assertStringContainsString(
            ($exceptionHeaderSubstring ?? '') . $expectedErrorOutputSubstring,
            $actualContents,
            $assertOutputMessage,
        );

        return $result;
    }

    /**
     * Asserts an exact match of `$expectedErrorOutput` with STDERR.
     */
    protected static function assertFullErrorOutput(
        string $scriptPath,
        string $expectedErrorOutput,
        string $parametersString,
    ): void {
        $command = 'php ' . escapeshellarg($scriptPath);
        if ('' !== $parametersString) {
            $command .= " {$parametersString}";
        }
        $result = new CliProcess($command);
        $stdErr = $result->getStdErr();

        // The heading space before a script name is needed for a script being clickable in PhpStorm console log
        // as a script file link.
        $assertOutputPrefix = " {$scriptPath}" . PHP_EOL
            . "COMMAND: {$command}" . PHP_EOL;

        assertSame(
            Parametizer::ERROR_EXIT_CODE,
            $result->getExitCode(),
            "{$assertOutputPrefix}Unexpected exit code",
        );

        assertSame($expectedErrorOutput, $stdErr, "{$assertOutputPrefix}Unexpected STDERR: {$stdErr}");
    }

    /**
     * Sources a script with alias, then executes an alias-based command in a Bash shell and returns the output.
     */
    protected static function getBashAliasExecutionOutput(string $completionScriptPath, string $command): string {
        /** @noinspection SpellCheckingInspection */
        /**
         * To make aliases actually work in a non-interactive shell these conditions must be made:
         * 1. Do everything in a single execution.
         *  Because each time ({@see exec()}` / {@see shell_exec()} / etc.) a new "environment" is created.
         * 2. Enable aliases support explicitly by starting with `shopt -s expand_aliases`.
         * 3. Launch a command via an alias (with its parameters if needed) strictly on a new line (\n)
         *  within the shell execution.
         *  Dividing an alias and other commands with ';' (like `alias something=date; something`) will not work.
         *  From `man bash`:
         *    > Aliases are expanded when a command is read, not when it is executed. Therefore, an alias definition
         *    > appearing on the same line as another command does not take effect until the next line of input is read.
         */
        $output = shell_exec(
            sprintf(
                "bash -c 'shopt -s expand_aliases; source %s%s%s'",
                $completionScriptPath,
                PHP_EOL,
                $command,
            ),
        );

        return (string) $output;
    }
}