create-berna-stencil 2.0.9 → 2.0.11

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Parser/EntryParserTest.php

@@ -0,0 +1,234 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Parser;
+
+use Dotenv\Parser\Entry;
+use Dotenv\Parser\EntryParser;
+use Dotenv\Parser\Value;
+use GrahamCampbell\ResultType\Result;
+use PHPUnit\Framework\TestCase;
+
+final class EntryParserTest extends TestCase
+{
+    public function testBasicParse()
+    {
+        $result = EntryParser::parse('FOO=BAR');
+        $this->checkPositiveResult($result, 'FOO', 'BAR');
+    }
+
+    public function testNullParse()
+    {
+        $result = EntryParser::parse('FOO');
+        $this->checkEmptyResult($result, 'FOO');
+    }
+
+    public function testUnicodeNameParse()
+    {
+        $result = EntryParser::parse('FOOƱ=BAZ');
+        $this->checkPositiveResult($result, 'FOOƱ', 'BAZ');
+    }
+
+    public function testQuotesParse()
+    {
+        $result = EntryParser::parse("FOO=\"BAR  \n\"");
+        $this->checkPositiveResult($result, 'FOO', "BAR  \n");
+    }
+
+    public function testNewlineParse()
+    {
+        $result = EntryParser::parse('FOO="\n"');
+        $this->checkPositiveResult($result, 'FOO', "\n");
+    }
+
+    public function testTabParseDouble()
+    {
+        $result = EntryParser::parse('FOO="\t"');
+        $this->checkPositiveResult($result, 'FOO', "\t");
+    }
+
+    public function testTabParseSingle()
+    {
+        $result = EntryParser::parse('FOO=\'\t\'');
+        $this->checkPositiveResult($result, 'FOO', '\t');
+    }
+
+    public function testNonEscapeParse1()
+    {
+        $result = EntryParser::parse('FOO=\n\v');
+        $this->checkPositiveResult($result, 'FOO', '\n\v');
+    }
+
+    public function testNonEscapeParse2()
+    {
+        $result = EntryParser::parse('FOO=\q');
+        $this->checkPositiveResult($result, 'FOO', '\q');
+    }
+
+    public function testBadEscapeParse()
+    {
+        $result = EntryParser::parse('FOO="\q"');
+        $this->checkErrorResult($result, 'Encountered an unexpected escape sequence at ["\q"].');
+    }
+
+    public function testInlineVariable()
+    {
+        $result = EntryParser::parse('FOO=$BAR');
+        $this->checkPositiveResult($result, 'FOO', '$BAR', [0]);
+    }
+
+    public function testInlineVariableOffset()
+    {
+        $result = EntryParser::parse('FOO=AAA$BAR');
+        $this->checkPositiveResult($result, 'FOO', 'AAA$BAR', [3]);
+    }
+
+    public function testInlineVariables()
+    {
+        $result = EntryParser::parse('FOO="TEST $BAR $$BAZ"');
+        $this->checkPositiveResult($result, 'FOO', 'TEST $BAR $$BAZ', [11, 10, 5]);
+    }
+
+    public function testNonInlineVariable()
+    {
+        $result = EntryParser::parse('FOO=\'TEST $BAR $$BAZ\'');
+        $this->checkPositiveResult($result, 'FOO', 'TEST $BAR $$BAZ');
+        self::assertTrue($result->success()->isDefined());
+    }
+
+    public function testWhitespaceParse()
+    {
+        $result = EntryParser::parse("FOO=\"\n\"");
+        $this->checkPositiveResult($result, 'FOO', "\n");
+    }
+
+    public function testExportParse()
+    {
+        $result = EntryParser::parse('export FOO="bar baz"');
+        $this->checkPositiveResult($result, 'FOO', 'bar baz');
+    }
+
+    public function testExportParseTab()
+    {
+        $result = EntryParser::parse("export\t\"FOO\"='bar baz'");
+        $this->checkPositiveResult($result, 'FOO', 'bar baz');
+    }
+
+    public function testExportParseFail()
+    {
+        $result = EntryParser::parse('export "FOO="bar baz"');
+        $this->checkErrorResult($result, 'Encountered an invalid name at ["FOO].');
+    }
+
+    public function testClosingSlashParse()
+    {
+        $result = EntryParser::parse('SPVAR5="test some escaped characters like a quote \\" or maybe a backslash \\\\" # not escaped');
+        $this->checkPositiveResult($result, 'SPVAR5', 'test some escaped characters like a quote " or maybe a backslash \\');
+    }
+
+    public function testParseInvalidSpaces()
+    {
+        $result = EntryParser::parse('FOO=bar baz');
+        $this->checkErrorResult($result, 'Encountered unexpected whitespace at [bar baz].');
+    }
+
+    public function testParseStrayEquals()
+    {
+        $result = EntryParser::parse('=');
+        $this->checkErrorResult($result, 'Encountered an unexpected equals at [=].');
+    }
+
+    public function testParseInvalidName()
+    {
+        $result = EntryParser::parse('FOO_ASD!=BAZ');
+        $this->checkErrorResult($result, 'Encountered an invalid name at [FOO_ASD!].');
+    }
+
+    public function testParserEscapingDouble()
+    {
+        $result = EntryParser::parse('FOO_BAD="iiiiviiiixiiiiviiii\\a"');
+        $this->checkErrorResult($result, 'Encountered an unexpected escape sequence at ["iiiiviiiixiiiiviiii\a"].');
+    }
+
+    public function testParserEscapingSingle()
+    {
+        $result = EntryParser::parse('FOO_BAD=\'iiiiviiiixiiiiviiii\\a\'');
+        $this->checkPositiveResult($result, 'FOO_BAD', 'iiiiviiiixiiiiviiii\\a');
+    }
+
+    public function testParserMissingClosingSingleQuote()
+    {
+        $result = EntryParser::parse('TEST=\'erert');
+        $this->checkErrorResult($result, 'Encountered a missing closing quote at [\'erert].');
+    }
+
+    public function testParserMissingClosingDoubleQuote()
+    {
+        $result = EntryParser::parse('TEST="erert');
+        $this->checkErrorResult($result, 'Encountered a missing closing quote at ["erert].');
+    }
+
+    public function testParserMissingClosingQuotes()
+    {
+        $result = EntryParser::parse("TEST=\"erert\nTEST='erert\n");
+        $this->checkErrorResult($result, 'Encountered a missing closing quote at ["erert].');
+    }
+
+    public function testParserClosingQuoteWithEscape()
+    {
+        $result = EntryParser::parse('TEST="\\');
+        $this->checkErrorResult($result, 'Encountered a missing closing quote at ["\\].');
+    }
+
+    /**
+     * @param \GrahamCampbell\ResultType\Result<\Dotenv\Parser\Entry,string> $result
+     * @param string                                                         $name
+     * @param string                                                         $chars
+     * @param int[]                                                          $vars
+     *
+     * @return void
+     */
+    private function checkPositiveResult(Result $result, string $name, string $chars, array $vars = [])
+    {
+        self::assertTrue($result->success()->isDefined());
+
+        $entry = $result->success()->get();
+        self::assertInstanceOf(Entry::class, $entry);
+        self::assertSame($name, $entry->getName());
+        self::assertTrue($entry->getValue()->isDefined());
+
+        $value = $entry->getValue()->get();
+        self::assertInstanceOf(Value::class, $value);
+        self::assertSame($chars, $value->getChars());
+        self::assertSame($vars, $value->getVars());
+    }
+
+    /**
+     * @param \GrahamCampbell\ResultType\Result<\Dotenv\Parser\Entry,string> $result
+     * @param string                                                         $name
+     *
+     * @return void
+     */
+    private function checkEmptyResult(Result $result, string $name)
+    {
+        self::assertTrue($result->success()->isDefined());
+
+        $entry = $result->success()->get();
+        self::assertInstanceOf(Entry::class, $entry);
+        self::assertSame('FOO', $entry->getName());
+        self::assertFalse($entry->getValue()->isDefined());
+    }
+
+    /**
+     * @param \GrahamCampbell\ResultType\Result<\Dotenv\Parser\Entry,string> $result
+     * @param string                                                         $error
+     *
+     * @return void
+     */
+    private function checkErrorResult(Result $result, string $error)
+    {
+        self::assertTrue($result->error()->isDefined());
+        self::assertSame($error, $result->error()->get());
+    }
+}

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Parser/LexerTest.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Parser;
+
+use Dotenv\Parser\Lexer;
+use PHPUnit\Framework\TestCase;
+
+final class LexerTest extends TestCase
+{
+    /**
+     * @return array{string,string[]}[]
+     */
+    public static function provideLexCases()
+    {
+        return [
+            ['', []],
+            ['FOO', ['FOO']],
+            ['FOO bar', ['FOO', ' ', 'bar']],
+            ['FOO\\n()ab', ['FOO', '\\', 'n()ab']],
+            ["FOO\n\n   A", ['FOO', "\n\n", '   ', 'A']],
+            ['"VA=L"', ['"', 'VA=L', '"']],
+            ['\' \'', ['\'', ' ', '\'']],
+        ];
+    }
+
+    /**
+     * @dataProvider provideLexCases
+     *
+     * @param string   $input
+     * @param string[] $output
+     *
+     * @return void
+     */
+    public function testLex(string $input, array $output)
+    {
+        self::assertSame($output, \iterator_to_array(Lexer::lex($input)));
+    }
+}

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Parser/LinesTest.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Parser;
+
+use Dotenv\Parser\Lines;
+use Dotenv\Util\Regex;
+use PHPUnit\Framework\TestCase;
+
+final class LinesTest extends TestCase
+{
+    public function testProcessBasic()
+    {
+        $content = \file_get_contents(\dirname(\dirname(__DIR__)).'/fixtures/env/assertions.env');
+        self::assertIsString($content);
+        $result = Regex::split("/(\r\n|\n|\r)/", $content);
+        self::assertTrue($result->success()->isDefined());
+
+        $expected = [
+            'ASSERTVAR1=val1',
+            'ASSERTVAR2=""',
+            'ASSERTVAR3="val3   "',
+            'ASSERTVAR4="0" # empty looking value',
+            'ASSERTVAR5="#foo"',
+            "ASSERTVAR6=\"val1\nval2\"",
+            "ASSERTVAR7=\"\nval3\" #",
+            "ASSERTVAR8=\"val3\n\"",
+            "ASSERTVAR9=\"\n\n\"",
+        ];
+
+        self::assertSame($expected, Lines::process($result->success()->get()));
+    }
+
+    public function testProcessQuotes()
+    {
+        $content = \file_get_contents(\dirname(\dirname(__DIR__)).'/fixtures/env/multiline.env');
+        self::assertIsString($content);
+        $result = Regex::split("/(\r\n|\n|\r)/", $content);
+        self::assertTrue($result->success()->isDefined());
+
+        $expected = [
+            "TEST=\"test\n     test\\\"test\\\"\n     test\"",
+            'TEST_ND="test\\ntest"',
+            'TEST_NS=\'test\\ntest\'',
+            'TEST_EQD="https://vision.googleapis.com/v1/images:annotate?key="',
+            'TEST_EQS=\'https://vision.googleapis.com/v1/images:annotate?key=\'',
+            "BASE64_ENCODED_MULTILINE=\"qS1zCzMVVUJWQShokv6YVYi+ruKSC/bHV7GmEiyVkLaBWJHNVHCHsgTksEBsy8wJ\nuwycAvR07ZyOJJed4XTRMKnKp1/v+6UATpWzkIjZXytK+pD+XlZimUHTx3uiDcmU\njhQX1wWSxHDqrSWxeIJiTD+BuUyId8FzmXQ3TcBydJ474tmOU2F492ubk3LAiZ18\nmhiRGoshXAOSbS/P3+RZi4bDeNE/No4=\"",
+        ];
+
+        self::assertSame($expected, Lines::process($result->success()->get()));
+    }
+}

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Parser/ParserTest.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Parser;
+
+use Dotenv\Exception\InvalidFileException;
+use Dotenv\Parser\Entry;
+use Dotenv\Parser\Parser;
+use Dotenv\Parser\ParserInterface;
+use Dotenv\Parser\Value;
+use PHPUnit\Framework\TestCase;
+
+final class ParserTest extends TestCase
+{
+    public function testParserInstanceOf()
+    {
+        self::assertInstanceOf(ParserInterface::class, new Parser());
+    }
+
+    public function testFullParse()
+    {
+        $result = (new Parser())->parse("FOO=BAR\nFOO\nFOO=\"BAR  \n\"\nFOO=\"\\n\"");
+
+        self::assertIsArray($result);
+        self::assertCount(4, $result);
+
+        $this->checkPositiveEntry($result[0], 'FOO', 'BAR');
+        $this->checkEmptyEntry($result[1], 'FOO');
+        $this->checkPositiveEntry($result[2], 'FOO', "BAR  \n");
+        $this->checkPositiveEntry($result[3], 'FOO', "\n");
+    }
+
+    public function testBadEscapeParse()
+    {
+        $this->expectException(InvalidFileException::class);
+        $this->expectExceptionMessage('Failed to parse dotenv file. Encountered an unexpected escape sequence at ["\q"].');
+
+        (new Parser())->parse('FOO="\q"');
+    }
+
+    public function testParseInvalidSpaces()
+    {
+        $this->expectException(InvalidFileException::class);
+        $this->expectExceptionMessage('Failed to parse dotenv file. Encountered unexpected whitespace at [bar baz].');
+
+        (new Parser())->parse("FOO=bar baz\n");
+    }
+
+    public function testParseStrayEquals()
+    {
+        $this->expectException(InvalidFileException::class);
+        $this->expectExceptionMessage('Failed to parse dotenv file. Encountered an unexpected equals at [=].');
+
+        (new Parser())->parse("=\n");
+    }
+
+    public function testParseInvalidName()
+    {
+        $this->expectException(InvalidFileException::class);
+        $this->expectExceptionMessage('Failed to parse dotenv file. Encountered an invalid name at [FOO_ASD!].');
+
+        (new Parser())->parse('FOO_ASD!=BAZ');
+    }
+
+    /**
+     * @param \Dotenv\Parser\Entry $entry
+     * @param string               $name
+     * @param string               $chars
+     * @param int[]                $vars
+     *
+     * @return void
+     */
+    private function checkPositiveEntry(Entry $entry, string $name, string $chars, array $vars = [])
+    {
+        self::assertInstanceOf(Entry::class, $entry);
+        self::assertSame($name, $entry->getName());
+        self::assertTrue($entry->getValue()->isDefined());
+
+        $value = $entry->getValue()->get();
+        self::assertInstanceOf(Value::class, $value);
+        self::assertSame($chars, $value->getChars());
+        self::assertSame($vars, $value->getVars());
+    }
+
+    /**
+     * @param \Dotenv\Parser\Entry $entry
+     * @param string               $name
+     *
+     * @return void
+     */
+    private function checkEmptyEntry(Entry $entry, string $name)
+    {
+        self::assertInstanceOf(Entry::class, $entry);
+        self::assertSame('FOO', $entry->getName());
+        self::assertFalse($entry->getValue()->isDefined());
+    }
+}

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Repository/Adapter/ArrayAdapterTest.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Repository\Adapter;
+
+use Dotenv\Repository\Adapter\ArrayAdapter;
+use PHPUnit\Framework\TestCase;
+
+final class ArrayAdapterTest extends TestCase
+{
+    public function testGoodRead()
+    {
+        $adapter = self::createAdapter();
+        $adapter->write('CONST_TEST', 'foo bar baz');
+        $value = $adapter->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('foo bar baz', $value->get());
+    }
+
+    public function testUndefinedRead()
+    {
+        $adapter = self::createAdapter();
+        unset($_ENV['CONST_TEST']);
+        $value = $adapter->read('CONST_TEST');
+        self::assertFalse($value->isDefined());
+    }
+
+    public function testGoodWrite()
+    {
+        $adapter = self::createAdapter();
+        self::assertTrue($adapter->write('CONST_TEST', 'foo'));
+        self::assertSame('foo', $adapter->read('CONST_TEST')->get());
+    }
+
+    public function testEmptyWrite()
+    {
+        $adapter = self::createAdapter();
+        self::assertTrue($adapter->write('CONST_TEST', ''));
+        self::assertSame('', $adapter->read('CONST_TEST')->get());
+    }
+
+    public function testGoodDelete()
+    {
+        $adapter = self::createAdapter();
+        self::assertTrue($adapter->delete('CONST_TEST'));
+        self::assertFalse($adapter->read('CONST_TEST')->isDefined());
+    }
+
+    /**
+     * @return \Dotenv\Repository\Adapter\AdapterInterface
+     */
+    private static function createAdapter()
+    {
+        return ArrayAdapter::create()->get();
+    }
+}

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Repository/Adapter/EnvConstAdapterTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Repository\Adapter;
+
+use Dotenv\Repository\Adapter\EnvConstAdapter;
+use PHPUnit\Framework\TestCase;
+
+final class EnvConstAdapterTest extends TestCase
+{
+    public function testGoodRead()
+    {
+        $_ENV['CONST_TEST'] = 'foo bar baz';
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('foo bar baz', $value->get());
+    }
+
+    public function testFalseRead()
+    {
+        $_ENV['CONST_TEST'] = false;
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('false', $value->get());
+    }
+
+    public function testTrueRead()
+    {
+        $_ENV['CONST_TEST'] = true;
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('true', $value->get());
+    }
+
+    public function testBadTypeRead()
+    {
+        $_ENV['CONST_TEST'] = [123];
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertFalse($value->isDefined());
+    }
+
+    public function testUndefinedRead()
+    {
+        unset($_ENV['CONST_TEST']);
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertFalse($value->isDefined());
+    }
+
+    public function testGoodWrite()
+    {
+        self::assertTrue(self::createAdapter()->write('CONST_TEST', 'foo'));
+        self::assertSame('foo', $_ENV['CONST_TEST']);
+    }
+
+    public function testEmptyWrite()
+    {
+        self::assertTrue(self::createAdapter()->write('CONST_TEST', ''));
+        self::assertSame('', $_ENV['CONST_TEST']);
+    }
+
+    public function testGoodDelete()
+    {
+        self::assertTrue(self::createAdapter()->delete('CONST_TEST'));
+        self::assertFalse(isset($_ENV['CONST_TEST']));
+    }
+
+    /**
+     * @return \Dotenv\Repository\Adapter\AdapterInterface
+     */
+    private static function createAdapter()
+    {
+        return EnvConstAdapter::create()->get();
+    }
+}

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Repository/Adapter/PutenvAdapterTest.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Repository\Adapter;
+
+use Dotenv\Repository\Adapter\PutenvAdapter;
+use PHPUnit\Framework\TestCase;
+
+final class PutenvAdapterTest extends TestCase
+{
+    public function testGoodRead()
+    {
+        \putenv('CONST_TEST=foo bar baz');
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('foo bar baz', $value->get());
+    }
+
+    public function testUndefinedRead()
+    {
+        \putenv('CONST_TEST');
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertFalse($value->isDefined());
+    }
+
+    public function testGoodWrite()
+    {
+        self::assertTrue(self::createAdapter()->write('CONST_TEST', 'foo'));
+        self::assertSame('foo', \getenv('CONST_TEST'));
+    }
+
+    public function testEmptyWrite()
+    {
+        self::assertTrue(self::createAdapter()->write('CONST_TEST', ''));
+        self::assertSame('', \getenv('CONST_TEST'));
+    }
+
+    public function testGoodDelete()
+    {
+        self::assertTrue(self::createAdapter()->delete('CONST_TEST'));
+        self::assertFalse(\getenv('CONST_TEST'));
+    }
+
+    /**
+     * @return \Dotenv\Repository\Adapter\AdapterInterface
+     */
+    private static function createAdapter()
+    {
+        return PutenvAdapter::create()->get();
+    }
+}

package/src/backend/_core/vendor/vlucas/phpdotenv/tests/Dotenv/Repository/Adapter/ServerConstAdapterTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Tests\Repository\Adapter;
+
+use Dotenv\Repository\Adapter\ServerConstAdapter;
+use PHPUnit\Framework\TestCase;
+
+final class ServerConstAdapterTest extends TestCase
+{
+    public function testGoodRead()
+    {
+        $_SERVER['CONST_TEST'] = 'foo bar baz';
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('foo bar baz', $value->get());
+    }
+
+    public function testFalseRead()
+    {
+        $_SERVER['CONST_TEST'] = false;
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('false', $value->get());
+    }
+
+    public function testTrueRead()
+    {
+        $_SERVER['CONST_TEST'] = true;
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertTrue($value->isDefined());
+        self::assertSame('true', $value->get());
+    }
+
+    public function testBadTypeRead()
+    {
+        $_SERVER['CONST_TEST'] = [123];
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertFalse($value->isDefined());
+    }
+
+    public function testUndefinedRead()
+    {
+        unset($_SERVER['CONST_TEST']);
+        $value = self::createAdapter()->read('CONST_TEST');
+        self::assertFalse($value->isDefined());
+    }
+
+    public function testGoodWrite()
+    {
+        self::assertTrue(self::createAdapter()->write('CONST_TEST', 'foo'));
+        self::assertSame('foo', $_SERVER['CONST_TEST']);
+    }
+
+    public function testEmptyWrite()
+    {
+        self::assertTrue(self::createAdapter()->write('CONST_TEST', ''));
+        self::assertSame('', $_SERVER['CONST_TEST']);
+    }
+
+    public function testGoodDelete()
+    {
+        self::assertTrue(self::createAdapter()->delete('CONST_TEST'));
+        self::assertFalse(isset($_SERVER['CONST_TEST']));
+    }
+
+    /**
+     * @return \Dotenv\Repository\Adapter\AdapterInterface
+     */
+    private static function createAdapter()
+    {
+        return ServerConstAdapter::create()->get();
+    }
+}