class InfoParserUnitTest

Same name and namespace in other branches

9 core/tests/Drupal/Tests/Core/Extension/InfoParserUnitTest.php \Drupal\Tests\Core\Extension\InfoParserUnitTest
10 core/tests/Drupal/Tests/Core/Extension/InfoParserUnitTest.php \Drupal\Tests\Core\Extension\InfoParserUnitTest
11.x core/tests/Drupal/Tests/Core/Extension/InfoParserUnitTest.php \Drupal\Tests\Core\Extension\InfoParserUnitTest

Tests InfoParser class and exception.

Files for this test are stored in core/modules/system/tests/fixtures and end with .info.txt instead of info.yml in order not to be considered as real extensions.

@coversDefaultClass \Drupal\Core\Extension\InfoParser

@group Extension

Hierarchy

class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses \Drupal\Tests\PhpunitCompatibilityTrait
- class \Drupal\Tests\Core\Extension\InfoParserUnitTest extends \Drupal\Tests\UnitTestCase

Expanded class hierarchy of InfoParserUnitTest

File

core/tests/Drupal/Tests/Core/Extension/InfoParserUnitTest.php, line 21

Namespace

Drupal\Tests\Core\Extension

View source

class InfoParserUnitTest extends UnitTestCase {
    
    /**
     * The InfoParser object.
     *
     * @var \Drupal\Core\Extension\InfoParser
     */
    protected $infoParser;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() {
        parent::setUp();
        // Use a fake DRUPAL_ROOT.
        $this->infoParser = new InfoParser('vfs:/');
    }
    
    /**
     * Tests the functionality of the infoParser object.
     *
     * @covers ::parse
     */
    public function testInfoParserNonExisting() {
        vfsStream::setup('modules');
        $info = $this->infoParser
            ->parse(vfsStream::url('modules') . '/does_not_exist.info.txt');
        $this->assertTrue(empty($info), 'Non existing info.yml returns empty array.');
    }
    
    /**
     * Test if correct exception is thrown for a broken info file.
     *
     * @covers ::parse
     */
    public function testInfoParserBroken() {
        $broken_info = <<<BROKEN_INFO
# info.yml for testing broken YAML parsing exception handling.
name: File
type: module
description: 'Defines a file field type.'
package: Core
version: VERSION
core: 8.x
dependencies::;;
  - field
BROKEN_INFO;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'broken.info.txt' => $broken_info,
            ],
        ]);
        $filename = vfsStream::url('modules/fixtures/broken.info.txt');
        $this->expectException('\\Drupal\\Core\\Extension\\InfoParserException');
        $this->expectExceptionMessage('broken.info.txt');
        $this->infoParser
            ->parse($filename);
    }
    
    /**
     * Tests that missing required keys are detected.
     *
     * @covers ::parse
     */
    public function testInfoParserMissingKeys() {
        $missing_keys = <<<MISSINGKEYS
# info.yml for testing missing name, description, and type keys.
package: Core
version: VERSION
dependencies:
  - field
MISSINGKEYS;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'missing_keys.info.txt' => $missing_keys,
            ],
        ]);
        $filename = vfsStream::url('modules/fixtures/missing_keys.info.txt');
        $this->expectException('\\Drupal\\Core\\Extension\\InfoParserException');
        $this->expectExceptionMessage('Missing required keys (type, name) in vfs://modules/fixtures/missing_keys.info.txt');
        $this->infoParser
            ->parse($filename);
    }
    
    /**
     * Tests that missing 'core' and 'core_version_requirement' keys are detected.
     *
     * @covers ::parse
     */
    public function testMissingCoreCoreVersionRequirement() {
        $missing_core_and_core_version_requirement = <<<MISSING_CORE_AND_CORE_VERSION_REQUIREMENT
# info.yml for testing core and core_version_requirement.
version: VERSION
type: module
name: Skynet
dependencies:
  - self_awareness
MISSING_CORE_AND_CORE_VERSION_REQUIREMENT;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'missing_core_and_core_version_requirement.info.txt' => $missing_core_and_core_version_requirement,
                'missing_core_and_core_version_requirement-duplicate.info.txt' => $missing_core_and_core_version_requirement,
            ],
        ]);
        $exception_message = "The 'core' or the 'core_version_requirement' key must be present in vfs://modules/fixtures/missing_core_and_core_version_requirement";
        // Set the expected exception for the 2nd call to parse().
        $this->expectException('\\Drupal\\Core\\Extension\\InfoParserException');
        $this->expectExceptionMessage("{$exception_message}-duplicate.info.txt");
        try {
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/missing_core_and_core_version_requirement.info.txt'));
        } catch (InfoParserException $exception) {
            $this->assertSame("{$exception_message}.info.txt", $exception->getMessage());
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/missing_core_and_core_version_requirement-duplicate.info.txt'));
        }
    }
    
    /**
     * Tests that Testing package modules use a default core_version_requirement.
     *
     * @covers ::parse
     */
    public function testTestingPackageMissingCoreCoreVersionRequirement() {
        $missing_core_and_core_version_requirement = <<<MISSING_CORE_AND_CORE_VERSION_REQUIREMENT
# info.yml for testing core and core_version_requirement.
package: Testing
version: VERSION
type: module
name: Skynet
MISSING_CORE_AND_CORE_VERSION_REQUIREMENT;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'missing_core_and_core_version_requirement.info.txt' => $missing_core_and_core_version_requirement,
            ],
        ]);
        $info_values = $this->infoParser
            ->parse(vfsStream::url('modules/fixtures/missing_core_and_core_version_requirement.info.txt'));
        $this->assertSame($info_values['core_version_requirement'], \Drupal::VERSION);
    }
    
    /**
     * Tests that 'core_version_requirement: ^8.8' is valid with no 'core' key.
     *
     * @covers ::parse
     */
    public function testCoreVersionRequirement88() {
        $core_version_requirement = <<<BOTH_CORE_VERSION_REQUIREMENT
# info.yml for testing core and core_version_requirement keys.
package: Core
core_version_requirement: ^8.8
version: VERSION
type: module
name: Module for That
dependencies:
  - field
BOTH_CORE_VERSION_REQUIREMENT;
        vfsStream::setup('modules');
        foreach ([
            '1',
            '2',
        ] as $file_delta) {
            $filename = "core_version_requirement-{$file_delta}.info.txt";
            vfsStream::create([
                'fixtures' => [
                    $filename => $core_version_requirement,
                ],
            ]);
            $info_values = $this->infoParser
                ->parse(vfsStream::url("modules/fixtures/{$filename}"));
            $this->assertSame($info_values['core_version_requirement'], '^8.8', "Expected core_version_requirement for file: {$filename}");
        }
    }
    
    /**
     * Tests that 'core_version_requirement: ^8.8' is invalid with a 'core' key.
     *
     * @covers ::parse
     */
    public function testCoreCoreVersionRequirement88() {
        $core_and_core_version_requirement_88 = <<<BOTH_CORE_CORE_VERSION_REQUIREMENT_88
# info.yml for testing core and core_version_requirement keys.
package: Core
core: 8.x
core_version_requirement: ^8.8
version: VERSION
type: module
name: Form auto submitter
dependencies:
  - field
BOTH_CORE_CORE_VERSION_REQUIREMENT_88;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'core_and_core_version_requirement_88.info.txt' => $core_and_core_version_requirement_88,
                'core_and_core_version_requirement_88-duplicate.info.txt' => $core_and_core_version_requirement_88,
            ],
        ]);
        $exception_message = "The 'core_version_requirement' constraint (^8.8) requires the 'core' key not be set in vfs://modules/fixtures/core_and_core_version_requirement_88";
        // Set the expected exception for the 2nd call to parse().
        $this->expectException('\\Drupal\\Core\\Extension\\InfoParserException');
        $this->expectExceptionMessage("{$exception_message}-duplicate.info.txt");
        try {
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/core_and_core_version_requirement_88.info.txt'));
        } catch (InfoParserException $exception) {
            $this->assertSame("{$exception_message}.info.txt", $exception->getMessage());
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/core_and_core_version_requirement_88-duplicate.info.txt'));
        }
    }
    
    /**
     * Tests a invalid 'core' key.
     *
     * @covers ::parse
     */
    public function testInvalidCore() {
        $invalid_core = <<<INVALID_CORE
# info.yml for testing invalid core key.
package: Core
core: ^8
version: VERSION
type: module
name: Llama or Alpaca
description: Tells whether an image is of a Llama or Alpaca
dependencies:
  - llama_detector
  - alpaca_detector
INVALID_CORE;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'invalid_core.info.txt' => $invalid_core,
                'invalid_core-duplicate.info.txt' => $invalid_core,
            ],
        ]);
        $exception_message = "Invalid 'core' value \"^8\" in vfs://modules/fixtures/invalid_core";
        // Set the expected exception for the 2nd call to parse().
        $this->expectException('\\Drupal\\Core\\Extension\\InfoParserException');
        $this->expectExceptionMessage("{$exception_message}-duplicate.info.txt");
        try {
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/invalid_core.info.txt'));
        } catch (InfoParserException $exception) {
            $this->assertSame("{$exception_message}.info.txt", $exception->getMessage());
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/invalid_core-duplicate.info.txt'));
        }
    }
    
    /**
     * Tests a invalid 'core_version_requirement'.
     *
     * @covers ::parse
     *
     * @dataProvider providerCoreVersionRequirementInvalid
     */
    public function testCoreVersionRequirementInvalid($test_case, $constraint) {
        $invalid_core_version_requirement = <<<INVALID_CORE_VERSION_REQUIREMENT
# info.yml for core_version_requirement validation.
name: Gracie Evaluator
description: 'Determines if Gracie is a "Good Dog". The answer is always "Yes".'
package: Core
type: module
version: VERSION
core_version_requirement: '{<span class="php-variable">$constraint</span>}'
dependencies:
  - goodness_api
INVALID_CORE_VERSION_REQUIREMENT;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                "invalid_core_version_requirement-{$test_case}.info.txt" => $invalid_core_version_requirement,
                "invalid_core_version_requirement-{$test_case}-duplicate.info.txt" => $invalid_core_version_requirement,
            ],
        ]);
        $exception_message = "The 'core_version_requirement' can not be used to specify compatibility for a specific version before 8.7.7 in vfs://modules/fixtures/invalid_core_version_requirement-{$test_case}";
        // Set the expected exception for the 2nd call to parse().
        $this->expectException('\\Drupal\\Core\\Extension\\InfoParserException');
        $this->expectExceptionMessage("{$exception_message}-duplicate.info.txt");
        try {
            $this->infoParser
                ->parse(vfsStream::url("modules/fixtures/invalid_core_version_requirement-{$test_case}.info.txt"));
        } catch (InfoParserException $exception) {
            $this->assertSame("{$exception_message}.info.txt", $exception->getMessage());
            $this->infoParser
                ->parse(vfsStream::url("modules/fixtures/invalid_core_version_requirement-{$test_case}-duplicate.info.txt"));
        }
    }
    
    /**
     * Dataprovider for testCoreVersionRequirementInvalid().
     */
    public function providerCoreVersionRequirementInvalid() {
        return [
            '8.0.0-alpha2' => [
                'alpha2',
                '8.0.0-alpha2',
            ],
            '8.6.0-rc1' => [
                'rc1',
                '8.6.0-rc1',
            ],
            '^8.7' => [
                '8_7',
                '^8.7',
            ],
            '>8.6.3' => [
                'gt8_6_3',
                '>8.6.3',
            ],
        ];
    }
    
    /**
     * Tests that missing required key is detected.
     *
     * @covers ::parse
     */
    public function testInfoParserMissingKey() {
        $missing_key = <<<MISSINGKEY
# info.yml for testing missing type key.
name: File
description: 'Defines a file field type.'
package: Core
version: VERSION
core: 8.x
dependencies:
  - field
MISSINGKEY;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'missing_key.info.txt' => $missing_key,
                'missing_key-duplicate.info.txt' => $missing_key,
            ],
        ]);
        // Set the expected exception for the 2nd call to parse().
        $this->expectException(InfoParserException::class);
        $this->expectExceptionMessage('Missing required keys (type) in vfs://modules/fixtures/missing_key-duplicate.info.txt');
        try {
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/missing_key.info.txt'));
        } catch (InfoParserException $exception) {
            $this->assertSame('Missing required keys (type) in vfs://modules/fixtures/missing_key.info.txt', $exception->getMessage());
            $this->infoParser
                ->parse(vfsStream::url('modules/fixtures/missing_key-duplicate.info.txt'));
        }
    }
    
    /**
     * Tests common info file.
     *
     * @covers ::parse
     */
    public function testInfoParserCommonInfo() {
        $common = <<<COMMONTEST
core_version_requirement: '*'
name: common_test
type: module
description: 'testing info file parsing'
simple_string: 'A simple string'
version: "VERSION"
double_colon: dummyClassName::method
COMMONTEST;
        vfsStream::setup('modules');
        foreach ([
            '1',
            '2',
        ] as $file_delta) {
            $filename = "common_test-{$file_delta}.info.txt";
            vfsStream::create([
                'fixtures' => [
                    $filename => $common,
                ],
            ]);
            $info_values = $this->infoParser
                ->parse(vfsStream::url("modules/fixtures/{$filename}"));
            $this->assertEquals($info_values['simple_string'], 'A simple string', 'Simple string value was parsed correctly.');
            $this->assertEquals($info_values['version'], \Drupal::VERSION, 'Constant value was parsed correctly.');
            $this->assertEquals($info_values['double_colon'], 'dummyClassName::method', 'Value containing double-colon was parsed correctly.');
            $this->assertFalse($info_values['core_incompatible']);
        }
    }
    
    /**
     * Tests common info file.
     *
     * @covers ::parse
     */
    public function testInfoParserCoreInfo() {
        $common = <<<CORETEST
name: core_test
type: module
version: "VERSION"
description: 'testing info file parsing'
CORETEST;
        vfsStream::setup('core');
        $filename = "core_test.info.txt";
        vfsStream::create([
            'fixtures' => [
                $filename => $common,
            ],
        ]);
        $info_values = $this->infoParser
            ->parse(vfsStream::url("core/fixtures/{$filename}"));
        $this->assertEquals($info_values['version'], \Drupal::VERSION, 'Constant value was parsed correctly.');
        $this->assertFalse($info_values['core_incompatible']);
        $this->assertEquals(\Drupal::VERSION, $info_values['core_version_requirement']);
    }
    
    /**
     * @covers ::parse
     *
     * @dataProvider providerCoreIncompatibility
     */
    public function testCoreIncompatibility($test_case, $constraint, $expected) {
        $core_incompatibility = <<<CORE_INCOMPATIBILITY
core_version_requirement: {<span class="php-variable">$constraint</span>}
name: common_test
type: module
description: 'testing info file parsing'
simple_string: 'A simple string'
version: "VERSION"
double_colon: dummyClassName::method
CORE_INCOMPATIBILITY;
        vfsStream::setup('modules');
        foreach ([
            '1',
            '2',
        ] as $file_delta) {
            $filename = "core_incompatible-{$test_case}-{$file_delta}.info.txt";
            vfsStream::create([
                'fixtures' => [
                    $filename => $core_incompatibility,
                ],
            ]);
            $info_values = $this->infoParser
                ->parse(vfsStream::url("modules/fixtures/{$filename}"));
            $this->assertSame($expected, $info_values['core_incompatible'], "core_incompatible correct in file: {$filename}");
        }
    }
    
    /**
     * Dataprovider for testCoreIncompatibility().
     */
    public function providerCoreIncompatibility() {
        list($major, $minor) = explode('.', \Drupal::VERSION);
        $next_minor = $minor + 1;
        $next_major = $major + 1;
        return [
            'next_minor' => [
                'next_minor',
                "^{$major}.{$next_minor}",
                TRUE,
            ],
            'current_major_next_major' => [
                'current_major_next_major',
                "^{$major} || ^{$next_major}",
                FALSE,
            ],
            'previous_major_next_major' => [
                'previous_major_next_major',
                "^1 || ^{$next_major}",
                TRUE,
            ],
            'current_minor' => [
                'current_minor',
                "~{$major}.{$minor}",
                FALSE,
            ],
        ];
    }
    
    /**
     * Test a profile info file.
     */
    public function testProfile() {
        $profile = <<<PROFILE_TEST
core_version_requirement: '*'
name: The Perfect Profile
type: profile
description: 'This profile makes Drupal perfect. You should have no complaints.'
PROFILE_TEST;
        vfsStream::setup('profiles');
        vfsStream::create([
            'fixtures' => [
                'invalid_profile.info.txt' => $profile,
            ],
        ]);
        $info = $this->infoParser
            ->parse(vfsStream::url('profiles/fixtures/invalid_profile.info.txt'));
        $this->assertFalse($info['core_incompatible']);
    }
    
    /**
     * Tests the exception for an unparsable 'core_version_requirement' value.
     *
     * @covers ::parse
     */
    public function testUnparsableCoreVersionRequirement() {
        $unparsable_core_version_requirement = <<<UNPARSABLE_CORE_VERSION_REQUIREMENT
# info.yml for testing invalid core_version_requirement value.
name: Not this module
description: 'Not the module you are looking for.'
package: Core
type: module
version: VERSION
core_version_requirement: not-this-version
UNPARSABLE_CORE_VERSION_REQUIREMENT;
        vfsStream::setup('modules');
        vfsStream::create([
            'fixtures' => [
                'unparsable_core_version_requirement.info.txt' => $unparsable_core_version_requirement,
            ],
        ]);
        $this->expectException(InfoParserException::class);
        $this->expectExceptionMessage("The 'core_version_requirement' constraint (not-this-version) is not a valid value in vfs://modules/fixtures/unparsable_core_version_requirement.info.txt");
        $this->infoParser
            ->parse(vfsStream::url('modules/fixtures/unparsable_core_version_requirement.info.txt'));
    }

}

Members

Title Sort descending	Deprecated	Modifiers	Object type	Summary	Overriden Title	Overrides
InfoParserUnitTest::$infoParser		protected	property	The InfoParser object.
InfoParserUnitTest::providerCoreIncompatibility		public	function	Dataprovider for testCoreIncompatibility().
InfoParserUnitTest::providerCoreVersionRequirementInvalid		public	function	Dataprovider for testCoreVersionRequirementInvalid().
InfoParserUnitTest::setUp		protected	function		Overrides UnitTestCase::setUp
InfoParserUnitTest::testCoreCoreVersionRequirement88		public	function	Tests that 'core_version_requirement: ^8.8' is invalid with a 'core' key.
InfoParserUnitTest::testCoreIncompatibility		public	function	@covers ::parse
InfoParserUnitTest::testCoreVersionRequirement88		public	function	Tests that 'core_version_requirement: ^8.8' is valid with no 'core' key.
InfoParserUnitTest::testCoreVersionRequirementInvalid		public	function	Tests a invalid 'core_version_requirement'.
InfoParserUnitTest::testInfoParserBroken		public	function	Test if correct exception is thrown for a broken info file.
InfoParserUnitTest::testInfoParserCommonInfo		public	function	Tests common info file.
InfoParserUnitTest::testInfoParserCoreInfo		public	function	Tests common info file.
InfoParserUnitTest::testInfoParserMissingKey		public	function	Tests that missing required key is detected.
InfoParserUnitTest::testInfoParserMissingKeys		public	function	Tests that missing required keys are detected.
InfoParserUnitTest::testInfoParserNonExisting		public	function	Tests the functionality of the infoParser object.
InfoParserUnitTest::testInvalidCore		public	function	Tests a invalid 'core' key.
InfoParserUnitTest::testMissingCoreCoreVersionRequirement		public	function	Tests that missing 'core' and 'core_version_requirement' keys are detected.
InfoParserUnitTest::testProfile		public	function	Test a profile info file.
InfoParserUnitTest::testTestingPackageMissingCoreCoreVersionRequirement		public	function	Tests that Testing package modules use a default core_version_requirement.
InfoParserUnitTest::testUnparsableCoreVersionRequirement		public	function	Tests the exception for an unparsable 'core_version_requirement' value.
PhpunitCompatibilityTrait::getMock	Deprecated	public	function	Returns a mock object for the specified class using the available method.
PhpunitCompatibilityTrait::setExpectedException	Deprecated	public	function	Compatibility layer for PHPUnit 6 to support PHPUnit 4 code.
UnitTestCase::$randomGenerator		protected	property	The random generator.
UnitTestCase::$root		protected	property	The app root.		1
UnitTestCase::assertArrayEquals		protected	function	Asserts if two arrays are equal by sorting them first.
UnitTestCase::getBlockMockWithMachineName	Deprecated	protected	function	Mocks a block with a block plugin.		1
UnitTestCase::getClassResolverStub		protected	function	Returns a stub class resolver.
UnitTestCase::getConfigFactoryStub		public	function	Returns a stub config factory that behaves according to the passed array.
UnitTestCase::getConfigStorageStub		public	function	Returns a stub config storage that returns the supplied configuration.
UnitTestCase::getContainerWithCacheTagsInvalidator		protected	function	Sets up a container with a cache tags invalidator.
UnitTestCase::getRandomGenerator		protected	function	Gets the random generator for the utility methods.
UnitTestCase::getStringTranslationStub		public	function	Returns a stub translation manager that just returns the passed string.
UnitTestCase::randomMachineName		public	function	Generates a unique random string containing letters and numbers.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.

class InfoParserUnitTest

Hierarchy

File

Namespace

Members

Search drupal 8.9.x

API Navigation

Breadcrumb

class InfoParserUnitTest

Hierarchy

File

Namespace

Members

Search drupal 8.9.x

API Navigation