FixtureManipulatorTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\package_manager\Kernel;

use Drupal\fixture_manipulator\ActiveFixtureManipulator;
use Drupal\fixture_manipulator\FixtureManipulator;
use Drupal\package_manager\ComposerInspector;
use Drupal\package_manager\InstalledPackagesList;
use Drupal\Tests\package_manager\Traits\InstalledPackagesListTrait;
use Drupal\package_manager\PathLocator;

/**
 * @coversDefaultClass \Drupal\fixture_manipulator\FixtureManipulator
 *
 * @group package_manager
 */
class FixtureManipulatorTest extends PackageManagerKernelTestBase {
    use InstalledPackagesListTrait;
    
    /**
     * The root directory of the test project.
     *
     * @var string
     */
    private string $dir;
    
    /**
     * The exception expected in ::tearDown() of this test.
     *
     * @var \Exception
     */
    private \Exception $expectedTearDownException;
    
    /**
     * The Composer inspector service.
     *
     * @var \Drupal\package_manager\ComposerInspector
     */
    private ComposerInspector $inspector;
    
    /**
     * The original fixture package list at the start of the test.
     *
     * @var \Drupal\package_manager\InstalledPackagesList
     */
    private InstalledPackagesList $originalFixturePackages;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $this->dir = $this->container
            ->get(PathLocator::class)
            ->getProjectRoot();
        $this->inspector = $this->container
            ->get(ComposerInspector::class);
        $manipulator = new ActiveFixtureManipulator();
        $manipulator->addPackage([
            'name' => 'my/package',
            'type' => 'library',
            'version' => '1.2.3',
        ])
            ->addPackage([
            'name' => 'my/dev-package',
            'version' => '2.1.0',
            'type' => 'library',
        ], TRUE)
            ->commitChanges();
        $this->originalFixturePackages = $this->inspector
            ->getInstalledPackagesList($this->dir);
    }
    
    /**
     * @covers ::addPackage
     */
    public function testAddPackage() : void {
        // Packages cannot be added without a name.
        foreach ([
            'name',
            'type',
        ] as $require_key) {
            // Make a package that is missing the required key.
            $package = array_diff_key([
                'name' => 'Any old name',
                'type' => 'Any old type',
            ], [
                $require_key => '',
            ]);
            try {
                $manipulator = new ActiveFixtureManipulator();
                $manipulator->addPackage($package)
                    ->commitChanges();
                $this->fail("Adding a package without the '{$require_key}' should raise an error.");
            } catch (\UnexpectedValueException $e) {
                $this->assertSame("The '{$require_key}' is required when calling ::addPackage().", $e->getMessage());
            }
        }
        // We should get a helpful error if the name is not a valid package name.
        try {
            $manipulator = new ActiveFixtureManipulator();
            $manipulator->addPackage([
                'name' => 'my_drupal_module',
                'type' => 'drupal-module',
            ])
                ->commitChanges();
            $this->fail('Trying to add a package with an invalid name should raise an error.');
        } catch (\UnexpectedValueException $e) {
            $this->assertSame("'my_drupal_module' is not a valid package name.", $e->getMessage());
        }
        // We should not be able to add an existing package.
        try {
            $manipulator = new ActiveFixtureManipulator();
            $manipulator->addPackage([
                'name' => 'my/package',
                'type' => 'library',
            ])
                ->commitChanges();
            $this->fail('Trying to add an existing package should raise an error.');
        } catch (\LogicException $e) {
            $this->assertStringContainsString("Expected package 'my/package' to not be installed, but it was.", $e->getMessage());
        }
        // Ensure that none of the failed calls to ::addPackage() changed the installed
        // packages.
        $this->assertPackageListsEqual($this->originalFixturePackages, $this->inspector
            ->getInstalledPackagesList($this->dir));
        $root_info = $this->inspector
            ->getRootPackageInfo($this->dir);
        $this->assertSame([
            'drupal/core-dev',
            'my/dev-package',
        ], array_keys($root_info['devRequires']));
    }
    
    /**
     * @covers ::modifyPackageConfig
     */
    public function testModifyPackageConfig() : void {
        // Assert ::modifyPackage() works with a package in an existing fixture not
        // created by ::addPackage().
        $decode_packages_json = function () : array {
            return json_decode(file_get_contents($this->dir . "/packages.json"), TRUE, flags: JSON_THROW_ON_ERROR);
        };
        $original_packages_json = $decode_packages_json();
        (new ActiveFixtureManipulator())->modifyPackageConfig('my/dev-package', '2.1.0', [
            'description' => 'something else',
        ], TRUE)
            ->commitChanges();
        // Verify that the package is indeed properly installed.
        $this->assertSame('2.1.0', $this->inspector
            ->getInstalledPackagesList($this->dir)['my/dev-package']?->version);
        // Verify that the original exists, but has no description.
        $this->assertSame('my/dev-package', $original_packages_json['packages']['my/dev-package']['2.1.0']['name']);
        $this->assertArrayNotHasKey('description', $original_packages_json);
        // Verify that the description was updated.
        $this->assertSame('something else', $decode_packages_json()['packages']['my/dev-package']['2.1.0']['description']);
        (new ActiveFixtureManipulator())->modifyPackageConfig('my/package', '1.2.3', [
            'extra' => [
                'foo' => 'bar',
            ],
        ])
            ->setVersion('my/dev-package', '3.2.1', TRUE)
            ->commitChanges();
        $this->assertSame([
            'foo' => 'bar',
        ], $decode_packages_json()['packages']['my/package']['1.2.3']['extra']);
        $this->assertSame('3.2.1', $this->inspector
            ->getInstalledPackagesList($this->dir)['my/dev-package']?->version);
    }
    
    /**
     * @covers ::removePackage
     */
    public function testRemovePackage() : void {
        // We should not be able to remove a package that's not installed.
        try {
            (new ActiveFixtureManipulator())->removePackage('junk/drawer')
                ->commitChanges();
            $this->fail('Removing a non-existent package should raise an error.');
        } catch (\LogicException $e) {
            $this->assertStringContainsString('junk/drawer is not required in your composer.json and has not been remove', $e->getMessage());
        }
        // Remove the 2 packages that were added in ::setUp().
        (new ActiveFixtureManipulator())->removePackage('my/package')
            ->removePackage('my/dev-package', TRUE)
            ->commitChanges();
        $expected_packages = $this->originalFixturePackages
            ->getArrayCopy();
        unset($expected_packages['my/package'], $expected_packages['my/dev-package']);
        $expected_list = new InstalledPackagesList($expected_packages);
        $this->assertPackageListsEqual($expected_list, $this->inspector
            ->getInstalledPackagesList($this->dir));
        $root_info = $this->inspector
            ->getRootPackageInfo($this->dir);
        $this->assertSame([
            'drupal/core-dev',
        ], array_keys($root_info['devRequires']));
    }
    
    /**
     * Test that an exception is thrown if ::commitChanges() is not called.
     */
    public function testActiveManipulatorNoCommitError() : void {
        $this->expectException(\LogicException::class);
        $this->expectExceptionMessage('commitChanges() must be called.');
        (new ActiveFixtureManipulator())->setVersion('drupal/core', '1.2.3');
    }
    
    /**
     * @covers ::addDotGitFolder
     */
    public function testAddDotGitFolder() : void {
        $path_locator = $this->container
            ->get(PathLocator::class);
        $project_root = $path_locator->getProjectRoot();
        $this->assertFalse(is_dir($project_root . "/relative/path/.git"));
        // We should not be able to add a git folder to a non-existing directory.
        try {
            (new FixtureManipulator())->addDotGitFolder($project_root . "/relative/path")
                ->commitChanges($project_root);
            $this->fail('Trying to create a .git directory that already exists should raise an error.');
        } catch (\LogicException $e) {
            $this->assertSame('No directory exists at ' . $project_root . '/relative/path.', $e->getMessage());
        }
        mkdir($project_root . "/relative/path", 0777, TRUE);
        $fixture_manipulator = (new FixtureManipulator())->addPackage([
            'name' => 'relative/project_path',
            'type' => 'drupal-module',
        ])
            ->addDotGitFolder($path_locator->getVendorDirectory() . "/relative/project_path")
            ->addDotGitFolder($project_root . "/relative/path");
        $this->assertTrue(!is_dir($project_root . "/relative/project_path/.git"));
        $fixture_manipulator->commitChanges($project_root);
        $this->assertTrue(is_dir($project_root . "/relative/path/.git"));
        // We should not be able to create already existing directory.
        try {
            (new FixtureManipulator())->addDotGitFolder($project_root . "/relative/path")
                ->commitChanges($project_root);
            $this->fail('Trying to create a .git directory that already exists should raise an error.');
        } catch (\LogicException $e) {
            $this->assertStringContainsString("A .git directory already exists at " . $project_root, $e->getMessage());
        }
    }
    
    /**
     * Tests that the stage manipulator throws an exception if not committed.
     */
    public function testStagedFixtureNotCommitted() : void {
        $this->expectedTearDownException = new \LogicException('The StageFixtureManipulator has arguments that were not cleared. This likely means that the PostCreateEvent was never fired.');
        $this->getStageFixtureManipulator()
            ->setVersion('any-org/any-package', '3.2.1');
    }
    
    /**
     * {@inheritdoc}
     *
     * @todo Remove the line below when https://github.com/phpstan/phpstan-phpunit/issues/187 is fixed.
     * @phpstan-ignore-next-line
     */
    protected function tearDown() : void {
        try {
            parent::tearDown();
        } catch (\Exception $exception) {
            if (!(get_class($exception) === get_class($this->expectedTearDownException) && $exception->getMessage() === $this->expectedTearDownException
                ->getMessage())) {
                throw $exception;
            }
        }
    }

}