AppTest.php

<?php

declare(strict_types=1);

namespace Tests\Kernel;

use Leevel\Config\IConfig;
use Leevel\Di\Container;
use Leevel\Di\IContainer;
use Leevel\Di\Provider;
use Leevel\Filesystem\Helper\DeleteDirectory;
use Leevel\Http\Request;
use Leevel\Kernel\App as Apps;
use Leevel\Kernel\IApp;
use Leevel\Kernel\Utils\Api;
use PHPUnit\Framework\Attributes\DataProvider;
use Tests\TestCase;

#[Api([
    'zh-CN:title' => '应用',
    'path' => 'architecture/kernel/app',
    'zh-CN:description' => <<<'EOT'
应用是整个系统非常核心的一部分，定义了应用的骨架。
EOT,
    'zh-CN:note' => <<<'EOT'
应用设计为可替代，只需要实现 `\Leevel\Kernel\IApp` 即可，然后在入口文件替换即可。
EOT,
])]
final class AppTest extends TestCase
{
    #[\Override]
    protected function setUp(): void
    {
        $this->tearDown();
    }

    #[\Override]
    protected function tearDown(): void
    {
        Container::singletons()->clear();
    }

    #[Api([
        'zh-CN:title' => '基本使用',
    ])]
    public function testBaseUse(): void
    {
        $appPath = __DIR__.'/app';
        $app = $this->createApp();
        $container = $app->container();

        $this->assertInstanceof(IContainer::class, $container);
        $this->assertInstanceof(Container::class, $container);
        $this->assertInstanceof(IApp::class, $app);
        $this->assertInstanceof(Apps::class, $app);

        self::assertSame($appPath, $app->path());
        self::assertSame($appPath.'/foobar', $app->path('foobar'));
    }

    #[Api([
        'zh-CN:title' => 'version 获取程序版本',
    ])]
    public function testVersion(): void
    {
        $app = $this->createApp();

        self::assertSame(App::VERSION, $app->version());
    }

    #[Api([
        'zh-CN:title' => 'isConsole 是否为 PHP 运行模式命令行',
    ])]
    public function testIsConsole(): void
    {
        $app = $this->createApp();

        self::assertTrue($app->isConsole());
    }

    public function testIsConsole2(): void
    {
        $app = $this->createApp();

        $request = $this->createMock(Request::class);

        $request->method('isConsole')->willReturn(true);
        self::assertTrue($request->isConsole());

        $app->container()->singleton('request', static function () use ($request) {
            return $request;
        });

        self::assertTrue($app->isConsole());
    }

    public function testIsConsole3(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $request = $this->createMock(Request::class);
        $request->method('isConsole')->willReturn(false);
        self::assertFalse($request->isConsole());
        $container->singleton('request', static function () use ($request) {
            return $request;
        });

        self::assertFalse($app->isConsole());
    }

    #[Api([
        'zh-CN:title' => 'setPath 设置基础路径',
    ])]
    public function testSetPath(): void
    {
        $app = $this->createApp();

        $app->setPath(__DIR__.'/foo');

        self::assertSame(__DIR__.'/foo', $app->path());
    }

    #[Api([
        'zh-CN:title' => 'appPath 获取应用路径',
    ])]
    public function testAppPath(): void
    {
        $appPath = __DIR__.'/app';
        $app = $this->createApp();
        $container = $app->container();

        $request = $this->createMock(Request::class);
        $container->singleton('request', static function () use ($request) {
            return $request;
        });

        self::assertSame($appPath, $app->appPath());
        self::assertSame($appPath, $app->appPath(''));
        self::assertSame($appPath.'/foo', $app->appPath('foo'));
        self::assertSame($appPath.'/bar', $app->appPath('bar'));
        self::assertSame($appPath.'/foo/foo/bar', $app->appPath('foo/foo/bar'));
        self::assertSame($appPath.'/bar/foo/bar', $app->appPath('bar/foo/bar'));
    }

    public function testAppPath2(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';
        $container = $app->container();

        $request = $this->createMock(Request::class);
        $container->singleton('request', static function () use ($request) {
            return $request;
        });

        self::assertSame($appPath, $app->appPath());
    }

    #[Api([
        'zh-CN:title' => 'setAppPath 设置应用路径',
    ])]
    public function testSetAppPath(): void
    {
        $appPath = __DIR__.'/app';
        $app = $this->createApp();
        $container = $app->container();

        $request = $this->createMock(Request::class);
        $container->singleton('request', static function () use ($request) {
            return $request;
        });

        self::assertSame($appPath, $app->appPath());
        $app->setAppPath(__DIR__.'/app/foo');
        self::assertSame($appPath.'/foo', $app->appPath());
    }

    #[Api([
        'zh-CN:title' => 'storagePath 获取运行路径',
    ])]
    public function testStoragePath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/storage', $app->storagePath());
        self::assertSame($appPath.'/storage/foobar', $app->storagePath('foobar'));
    }

    #[Api([
        'zh-CN:title' => 'setStoragePath 设置运行时路径',
    ])]
    public function testSetStoragePath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/storage', $app->storagePath());
        self::assertSame($appPath.'/storage/foobar', $app->storagePath('foobar'));

        $app->setStoragePath(__DIR__.'/app/storageFoo');

        self::assertSame($appPath.'/storageFoo', $app->storagePath());
        self::assertSame($appPath.'/storageFoo/foobar', $app->storagePath('foobar'));
    }

    #[Api([
        'zh-CN:title' => 'configPath 获取配置路径',
    ])]
    public function testConfigPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/config', $app->configPath());
        self::assertSame($appPath.'/config/foobar', $app->configPath('foobar'));
    }

    #[Api([
        'zh-CN:title' => 'setConfigPath 设置配置路径',
    ])]
    public function testSetConfigPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/config', $app->configPath());
        self::assertSame($appPath.'/config/foobar', $app->configPath('foobar'));

        $app->setConfigPath(__DIR__.'/app/configFoo');

        self::assertSame($appPath.'/configFoo', $app->configPath());
        self::assertSame($appPath.'/configFoo/foobar', $app->configPath('foobar'));
    }

    #[Api([
        'zh-CN:title' => 'i18nPath 获取语言包路径',
    ])]
    public function testI18nPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/i18n', $app->i18nPath());
        self::assertSame($appPath.'/i18n/foobar', $app->i18nPath('foobar'));
    }

    #[Api([
        'zh-CN:title' => 'setI18nPath 设置语言包路径',
    ])]
    public function testSetI18nPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/i18n', $app->i18nPath());
        self::assertSame($appPath.'/i18n/foobar', $app->i18nPath('foobar'));

        $app->setI18nPath(__DIR__.'/app/i18nFoo');

        self::assertSame($appPath.'/i18nFoo', $app->i18nPath());
        self::assertSame($appPath.'/i18nFoo/foobar', $app->i18nPath('foobar'));
    }

    #[Api([
        'zh-CN:title' => 'envPath 获取环境变量路径',
    ])]
    public function testEnvPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath, $app->envPath());
    }

    #[Api([
        'zh-CN:title' => 'setEnvPath 设置环境变量路径',
    ])]
    public function testSetEnvPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath, $app->envPath());

        $app->setEnvPath(__DIR__.'/appFoo');

        self::assertSame(__DIR__.'/appFoo', $app->envPath());
    }

    #[Api([
        'zh-CN:title' => 'envFile 获取环境变量文件',
    ])]
    public function testEnvFile(): void
    {
        $app = $this->createApp();

        self::assertSame('.env', $app->envFile());
    }

    #[Api([
        'zh-CN:title' => 'setEnvFile 设置环境变量文件',
    ])]
    public function testSetEnvFile(): void
    {
        $app = $this->createApp();

        self::assertSame('.env', $app->envFile());

        $app->setEnvFile('.envfoo');

        self::assertSame('.envfoo', $app->envFile());
    }

    #[Api([
        'zh-CN:title' => 'fullEnvPath 获取环境变量完整路径',
    ])]
    public function testFullEnvPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/.env', $app->fullEnvPath());

        $app->setEnvPath(__DIR__.'/appFoo');

        self::assertSame(__DIR__.'/appFoo/.env', $app->fullEnvPath());

        $app->setEnvFile('.envfoo');

        self::assertSame(__DIR__.'/appFoo/.envfoo', $app->fullEnvPath());
    }

    #[Api([
        'zh-CN:title' => 'i18nCachedPath 获取语言包缓存路径',
    ])]
    public function testSetI18nCachePath(): void
    {
        $app = $this->createApp();
        self::assertSame(__DIR__.'/app/storage/bootstrap/i18n/zh-CN.php', $app->i18nCachedPath('zh-CN'));
        $app->setI18nCachedPath(__DIR__.'/hello');
        self::assertSame(__DIR__.'/hello/zh-CN.php', $app->i18nCachedPath('zh-CN'));
    }

    #[Api([
        'zh-CN:title' => 'i18nCachedPath 获取语言包缓存路径',
    ])]
    public function testI18nCachedPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertSame($appPath.'/storage/bootstrap/i18n/zh-CN.php', $app->i18nCachedPath('zh-CN'));
        self::assertSame($appPath.'/storage/bootstrap/i18n/zh-TW.php', $app->i18nCachedPath('zh-TW'));
        self::assertSame($appPath.'/storage/bootstrap/i18n/en-US.php', $app->i18nCachedPath('en-US'));
    }

    #[Api([
        'zh-CN:title' => 'isCachedI18n 是否存在语言包缓存',
    ])]
    public function testIsCachedI18n(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';

        self::assertFalse($app->isCachedI18n('zh-CN'));

        mkdir($appPath.'/storage/bootstrap/i18n', 0o777, true);
        file_put_contents($appPath.'/storage/bootstrap/i18n/zh-CN.php', 'foo');
        self::assertTrue($app->isCachedI18n('zh-CN'));

        DeleteDirectory::handle($appPath);
    }

    #[Api([
        'zh-CN:title' => 'setConfigCachedPath 设置配置缓存路径',
    ])]
    public function testSetConfigCachePath(): void
    {
        $app = $this->createApp();
        self::assertSame(__DIR__.'/app/storage/bootstrap/config.php', $app->configCachedPath());
        $app->setConfigCachedPath(__DIR__.'/hello');
        self::assertSame(__DIR__.'/hello/config.php', $app->configCachedPath());
    }

    #[Api([
        'zh-CN:title' => 'configCachedPath 获取配置缓存路径',
    ])]
    public function testConfigCachedPath(): void
    {
        $app = $this->createApp();
        $appPath = __DIR__.'/app';
        self::assertSame($appPath.'/storage/bootstrap/config.php', $app->configCachedPath());
    }

    #[Api([
        'zh-CN:title' => 'isCachedConfig 是否存在配置缓存',
    ])]
    public function testIsCachedConfig(): void
    {
        $appPath = __DIR__.'/app';
        $app = $this->createApp();

        self::assertFalse($app->isCachedConfig());
        mkdir($appPath.'/storage/bootstrap', 0o777, true);
        file_put_contents($appPath.'/storage/bootstrap/config.php', 'foo');
        self::assertTrue($app->isCachedConfig());

        DeleteDirectory::handle($appPath);
    }

    #[Api([
        'zh-CN:title' => 'routerCachedPath 获取路由缓存路径',
    ])]
    public function testRouterCachedPath(): void
    {
        $appPath = __DIR__.'/app';
        $app = $this->createApp();

        self::assertSame($appPath.'/storage/bootstrap/router.php', $app->routerCachedPath());
    }

    #[Api([
        'zh-CN:title' => 'isCachedRouter 是否存在路由缓存',
    ])]
    public function testIsCachedRouter(): void
    {
        $appPath = __DIR__.'/app';
        $app = $this->createApp();

        self::assertFalse($app->isCachedRouter());

        mkdir($appPath.'/storage/bootstrap', 0o777, true);

        file_put_contents($routerPath = $appPath.'/storage/bootstrap/router.php', 'foo');

        self::assertTrue($app->isCachedRouter());

        DeleteDirectory::handle($appPath);
    }

    #[Api([
        'zh-CN:title' => 'namespacePath 获取命名空间目录真实路径',
    ])]
    public function testNamespacePath(): void
    {
        $appPath = \dirname(__DIR__, 2);
        $app = $this->createApp($appPath);
        self::assertSame(
            \dirname(__DIR__, 2).'/src/Leevel/Kernel/Console',
            realpath($app->namespacePath('Leevel\\Kernel\\Console'))
        );
    }

    public function testNamespacePathClassNotFound(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage(
            'Namespaces `not_found_class` for was not found.'
        );

        $appPath = \dirname(__DIR__, 2);
        $app = $this->createApp($appPath);
        $app->namespacePath('not_found_class');
    }

    public function testNamespacePathComposerWasNotFound(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage(
            'Composer was not found.'
        );

        $appPath = __DIR__.'/assert/app';
        $app = $this->createApp($appPath);
        $container = $app->container();
        $app->namespacePath('not_found_class');
    }

    public function testNamespacePath1(): void
    {
        $appPath = \dirname(__DIR__, 2);
        $composer = require $appPath.'/vendor/autoload.php';
        $composer->addPsr4('', [
            'Foo\\Bar' => $appPath.'/tests/Kernel/assert',
        ]);
        $app = $this->createApp($appPath);
        self::assertSame(
            $appPath.'/tests/Kernel/assert/Foo/Bar/Hello',
            realpath($app->namespacePath('Foo\\Bar\\Hello'))
        );
        $this->setTestProperty($composer, 'fallbackDirsPsr4', []);
    }

    public function testNamespacePath2(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage(
            'Namespaces `Foo_Bar_Hello` for was not found.'
        );

        $appPath = \dirname(__DIR__, 2);
        $app = $this->createApp($appPath);
        $app->namespacePath('Foo_Bar_Hello');
    }

    public function testNamespacePath3(): void
    {
        $appPath = \dirname(__DIR__, 2);
        $composer = require $appPath.'/vendor/autoload.php';
        $composer->add('F', [
            'Foo_Bar_Hello' => $appPath.'/tests/Kernel/assert',
        ]);
        $app = $this->createApp($appPath);
        self::assertSame(
            $appPath.'/tests/Kernel/assert/Foo/Bar/Hello',
            realpath($app->namespacePath('Foo_Bar_Hello'))
        );
        $this->setTestProperty($composer, 'prefixesPsr0', []);
    }

    public function testNamespacePath4(): void
    {
        $appPath = \dirname(__DIR__, 2);
        $composer = require $appPath.'/vendor/autoload.php';
        $composer->add('F', [
            'Foo_Bar_Hello' => $appPath.'/tests/Kernel/assert',
        ]);
        $app = $this->createApp($appPath);
        self::assertSame(
            $appPath.'/tests/Kernel/assert/Foo/Bar/Hello',
            realpath($app->namespacePath('Foo\\Bar_Hello'))
        );
        $this->setTestProperty($composer, 'prefixesPsr0', []);
    }

    public function testNamespacePath5(): void
    {
        $appPath = \dirname(__DIR__, 2);
        $composer = require $appPath.'/vendor/autoload.php';
        $composer->add('', [
            'Foo_Bar_Hello' => $appPath.'/tests/Kernel/assert',
        ]);
        $app = $this->createApp($appPath);
        self::assertSame(
            $appPath.'/tests/Kernel/assert/Foo/Bar/Hello',
            realpath($app->namespacePath('Foo\\Bar_Hello'))
        );
        $this->setTestProperty($composer, 'fallbackDirsPsr0', []);
    }

    #[Api([
        'zh-CN:title' => 'isDebug 是否开启调试',
    ])]
    public function testIsDebug(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $config = $this->createMock(IConfig::class);

        $config
            ->method('get')
            ->willReturnCallback(static function (string $k) {
                $map = [
                    'debug' => true,
                    'environment' => 'development',
                ];

                return $map[$k];
            })
        ;

        self::assertSame('development', $config->get('environment'));
        self::assertTrue($config->get('debug'));

        $container->singleton('config', static function () use ($config) {
            return $config;
        });

        self::assertTrue($app->isDebug());
    }

    public function testIsDebug2(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $config = $this->createMock(IConfig::class);

        $config
            ->method('get')
            ->willReturnCallback(static function (string $k) {
                $map = [
                    'debug' => false,
                    'environment' => 'development',
                ];

                return $map[$k];
            })
        ;

        self::assertSame('development', $config->get('environment'));
        self::assertFalse($config->get('debug'));

        $container->singleton('config', static function () use ($config) {
            return $config;
        });

        self::assertFalse($app->isDebug());
    }

    public function testIsDebug3(): void
    {
        $app = $this->createApp();
        self::assertTrue($app->isDebug());
    }

    #[Api([
        'zh-CN:title' => 'isDevelopment 是否为开发环境',
    ])]
    public function testIsDevelopment(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $config = $this->createMock(Request::class);

        $config->method('get')->willReturn('development');
        self::assertSame('development', $config->get('development'));

        $container->singleton('config', static function () use ($config) {
            return $config;
        });

        self::assertTrue($app->isDevelopment());
    }

    public function testIsDevelopment2(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $config = $this->createMock(Request::class);

        $config->method('get')->willReturn('foo');
        self::assertSame('foo', $config->get('development'));

        $container->singleton('config', static function () use ($config) {
            return $config;
        });

        self::assertFalse($app->isDevelopment());
    }

    #[Api([
        'zh-CN:title' => 'environment 获取运行环境',
    ])]
    public function testEnvironment(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $config = $this->createMock(Request::class);

        $config->method('get')->willReturn('foo');
        self::assertSame('foo', $config->get('development'));

        $container->singleton('config', static function () use ($config) {
            return $config;
        });

        self::assertSame('foo', $app->environment());
    }

    public function testEnvironment2(): void
    {
        $app = $this->createApp();
        self::assertSame('development', $app->environment());
    }

    #[Api([
        'zh-CN:title' => 'bootstrap 初始化应用',
        'zh-CN:description' => <<<'EOT'
**fixture 定义**

**Tests\Kernel\BootstrapTest1**

``` php
{[\Leevel\Kernel\Utils\Doc::getClassBody(\Tests\Kernel\BootstrapTest1::class)]}
```

**Tests\Kernel\BootstrapTest2**

``` php
{[\Leevel\Kernel\Utils\Doc::getClassBody(\Tests\Kernel\BootstrapTest2::class)]}
```

**Tests\Console\Load1\Test1**

``` php
{[\Leevel\Kernel\Utils\Doc::getClassBody(\Tests\Console\Load1\Test1::class)]}
```
EOT,
    ])]
    public function testBootstrap(): void
    {
        $app = $this->createApp();

        $app->bootstrap([BootstrapTest1::class, BootstrapTest2::class]);

        self::assertSame(1, $_SERVER['bootstrapTest1']);
        self::assertSame(1, $_SERVER['bootstrapTest2']);

        unset($_SERVER['bootstrapTest1'], $_SERVER['bootstrapTest2']);
    }

    public function testBootstrap2(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $app->bootstrap([BootstrapTest1::class, BootstrapTest2::class]);

        self::assertFalse($container->isBootstrap());

        self::assertSame(1, $_SERVER['bootstrapTest1']);
        self::assertSame(1, $_SERVER['bootstrapTest2']);

        unset($_SERVER['bootstrapTest1'], $_SERVER['bootstrapTest2']);

        $container->registerProviders([], [], []);

        self::assertTrue($container->isBootstrap());

        $app->bootstrap([BootstrapTest1::class, BootstrapTest2::class]);

        self::assertArrayNotHasKey('bootstrapTest1', $_SERVER);
        self::assertArrayNotHasKey('bootstrapTest2', $_SERVER);
    }

    #[Api([
        'zh-CN:title' => 'registerAppProviders 注册应用服务提供者',
        'zh-CN:description' => <<<'EOT'
**fixture 定义**

**Tests\Kernel\ConfigTest**

``` php
{[\Leevel\Kernel\Utils\Doc::getClassBody(\Tests\Kernel\ConfigTest::class)]}
```

**Tests\Kernel\ProviderTest3**

``` php
{[\Leevel\Kernel\Utils\Doc::getClassBody(\Tests\Kernel\ProviderTest3::class)]}
```

**Tests\Kernel\ProviderDeferTest1**

``` php
{[\Leevel\Kernel\Utils\Doc::getClassBody(\Tests\Kernel\ProviderDeferTest1::class)]}
```
EOT,
    ])]
    public function testRegisterProviders(): void
    {
        $app = $this->createApp();
        $container = $app->container();

        $config = new ConfigTest();
        $container->singleton('config', static function () use ($config) {
            return $config;
        });

        $app->registerAppProviders();

        // for deferredAlias
        self::assertArrayNotHasKey('providerDeferTest1', $_SERVER);
        self::assertSame('bar', $container->make('foo'));
        self::assertSame('bar', $container->make(ProviderDeferTest1::class));
        self::assertSame(1, $_SERVER['providerDeferTest1']);

        // for providers
        self::assertSame(1, $_SERVER['testRegisterProvidersRegister']);
        self::assertArrayHasKey('testRegisterProvidersBootstrap', $_SERVER);

        unset(
            $_SERVER['providerDeferTest1'],
            $_SERVER['testRegisterProvidersRegister']
        );

        // bootstrap
        self::assertTrue($container->isBootstrap());
        self::assertSame(1, $_SERVER['testRegisterProvidersBootstrap']);
        unset($_SERVER['testRegisterProvidersBootstrap']);
        self::assertTrue($container->isBootstrap());

        // again but already bootstrap
        $app->registerAppProviders();
        self::assertArrayNotHasKey('testRegisterProvidersBootstrap', $_SERVER);
        self::assertArrayNotHasKey('testRegisterProvidersRegister', $_SERVER);
    }

    #[Api([
        'zh-CN:title' => 'setThemesPath 设置主题路径',
    ])]
    public function testSetThemesPath(): void
    {
        $app = $this->createApp();
        self::assertSame(__DIR__.'/app/themes', $app->themesPath());
        $app->setThemesPath(__DIR__.'/hello');
        self::assertSame(__DIR__.'/hello', $app->themesPath());
    }

    #[DataProvider('envProvider')]
    #[Api([
        'zh-CN:title' => 'env 获取应用的环境变量',
        'zh-CN:description' => <<<'EOT'
测试数据

``` php
{[\Leevel\Kernel\Utils\Doc::getMethodBody(\Tests\Kernel\AppTest::class, 'envProvider')]}
```
EOT,
    ])]
    public function testEnv(string $name, $value, $envValue): void
    {
        $app = $this->createApp();
        $name = 'test_env_'.$name;
        putenv($name.'='.$value);
        self::assertSame($envValue, $app->env($name));
    }

    public static function envProvider(): array
    {
        return [
            ['bar', 'true', true],
            ['bar', '(true)', true],
            ['bar', 'false', false],
            ['bar', '(false)', false],
            ['bar', 'empty', ''],
            ['bar', '(empty)', ''],
            ['bar', 'null', null],
            ['bar', '(null)', null],
            ['bar', '"hello"', 'hello'],
            ['bar', "'hello'", "'hello'"],
            ['bar', true, '1'],
            ['bar', false, ''],
            ['bar', 1, '1'],
            ['bar', '', ''],
        ];
    }

    public function testEnvFalse(): void
    {
        $app = $this->createApp();
        self::assertSame('default message', $app->env('not_found_env', 'default message'));
        self::assertNull($app->env('not_found_env'));
    }

    protected function createApp(?string $appPath = null): App
    {
        if (null === $appPath) {
            $appPath = __DIR__.'/app';
        }
        $container = Container::singletons();
        $app = new App($container, $appPath);

        $this->assertInstanceof(IContainer::class, $container);
        $this->assertInstanceof(Container::class, $container);
        $this->assertInstanceof(IApp::class, $app);
        $this->assertInstanceof(Apps::class, $app);

        return $app;
    }
}

class App extends Apps
{
    protected function registerBaseProvider(): void {}
}

class ProviderTest3 extends Provider
{
    public function __construct(IContainer $container) {}

    public function bootstrap(): void
    {
        $_SERVER['testRegisterProvidersBootstrap'] = 1;
    }

    public function register(): void
    {
        $_SERVER['testRegisterProvidersRegister'] = 1;
    }
}

class ProviderDeferTest1 extends Provider
{
    public function register(): void
    {
        $_SERVER['providerDeferTest1'] = 1;

        $this->container->singleton('foo', static function (IContainer $container) {
            return 'bar';
        });
    }

    public static function providers(): array
    {
        return [
            'foo' => [
                'Tests\\Kernel\\ProviderDeferTest1',
            ],
        ];
    }

    public static function isDeferred(): bool
    {
        return true;
    }
}

class BootstrapTest1
{
    public function handle(): void
    {
        $_SERVER['bootstrapTest1'] = 1;
    }
}

class BootstrapTest2
{
    public function handle(): void
    {
        $_SERVER['bootstrapTest2'] = 1;
    }
}

class ConfigTest
{
    public function get(string $name)
    {
        if (':deferred_providers' === $name) {
            return [
                [
                    'foo' => 'Tests\\Kernel\\ProviderDeferTest1',
                ],
                [
                    'Tests\\Kernel\\ProviderDeferTest1' => [
                        'foo' => [
                            'Tests\\Kernel\\ProviderDeferTest1',
                        ],
                    ],
                ],
            ];
        }

        if (':composer.providers' === $name) {
            return [ProviderTest3::class];
        }
    }
}