GitExcluderTest.php

<?php

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

use Drupal\Core\Serialization\Yaml;
use Drupal\fixture_manipulator\ActiveFixtureManipulator;
use Drupal\package_manager\PathLocator;
use Drupal\Tests\package_manager\Kernel\PackageManagerKernelTestBase;
use Drupal\Tests\package_manager\Traits\ComposerInstallersTrait;
use PhpTuf\ComposerStager\API\Core\BeginnerInterface;
use PhpTuf\ComposerStager\API\Core\CommitterInterface;
use Symfony\Component\Filesystem\Filesystem;

/**
 * @covers \Drupal\package_manager\PathExcluder\GitExcluder
 * @group package_manager
 * @internal
 */
class GitExcluderTest extends PackageManagerKernelTestBase {
  use ComposerInstallersTrait;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $project_root = $this->container
      ->get(PathLocator::class)
      ->getProjectRoot();
    $this->installComposerInstallers($project_root);
    $active_manipulator = new ActiveFixtureManipulator();
    $active_manipulator->addPackage([
      'name' => 'foo/package_known_to_composer_removed_later',
      'type' => 'drupal-module',
      'version' => '1.0.0',
    ], FALSE, TRUE)
      ->addPackage([
      'name' => 'foo/custom_package_known_to_composer',
      'type' => 'drupal-custom-module',
      'version' => '1.0.0',
    ], FALSE, TRUE)
      ->addPackage([
      'name' => 'foo/package_with_different_installer_path_known_to_composer',
      'type' => 'drupal-module',
      'version' => '1.0.0',
    ], FALSE, TRUE);
    // Set the installer path config in the project root where we install the
    // package.
    $installer_paths['different_installer_path/package_known_to_composer'] = [
      'foo/package_with_different_installer_path_known_to_composer',
    ];
    $this->setInstallerPaths($installer_paths, $project_root);
    $active_manipulator->addProjectAtPath("modules/module_not_known_to_composer_in_active")
      ->addDotGitFolder($project_root . "/modules/module_not_known_to_composer_in_active")
      ->addDotGitFolder($project_root . "/modules/contrib/package_known_to_composer_removed_later")
      ->addDotGitFolder($project_root . "/modules/custom/custom_package_known_to_composer")
      ->addDotGitFolder($project_root . "/different_installer_path/package_known_to_composer")
      ->commitChanges();
  }
  
  /**
   * Tests that Git directories are excluded from stage during PreCreate.
   */
  public function testGitDirectoriesExcludedActive() : void {
    // Ensure we have an up-to-date container.
    $this->container = $this->container
      ->get('kernel')
      ->rebuildContainer();
    $stage = $this->createStage();
    $stage->create();
    /** @var \Drupal\package_manager_bypass\LoggingBeginner $beginner */
    $beginner = $this->container
      ->get(BeginnerInterface::class);
    $beginner_args = $beginner->getInvocationArguments();
    $excluded_paths = [
      '.git',
      'modules/module_not_known_to_composer_in_active/.git',
      'modules/example/.git',
    ];
    foreach ($excluded_paths as $excluded_path) {
      $this->assertContains($excluded_path, $beginner_args[0][2]);
    }
    $not_excluded_paths = [
      'modules/contrib/package_known_to_composer_removed_later/.git',
      'modules/custom/custom_package_known_to_composer/.git',
      'different_installer_path/package_known_to_composer/.git',
    ];
    foreach ($not_excluded_paths as $not_excluded_path) {
      $this->assertNotContains($not_excluded_path, $beginner_args[0][2]);
    }
  }
  
  /**
   * Tests that Git directories are excluded from active during PreApply.
   */
  public function testGitDirectoriesExcludedStage() : void {
    // Ensure we have an up-to-date container.
    $this->container = $this->container
      ->get('kernel')
      ->rebuildContainer();
    $this->getStageFixtureManipulator()
      ->removePackage('foo/package_known_to_composer_removed_later');
    $stage = $this->createStage();
    $stage->create();
    $stage->require([
      'ext-json:*',
    ]);
    $stage_dir = $stage->getSandboxDirectory();
    // Adding a module with .git in stage which is unknown to composer, we
    // expect it to not be copied to the active directory.
    $path = "{$stage_dir}/modules/unknown_to_composer_in_stage";
    $fs = new Filesystem();
    $fs->mkdir("{$path}/.git");
    file_put_contents("{$path}/unknown_to_composer.info.yml", Yaml::encode([
      'name' => 'Unknown to composer in stage',
      'type' => 'module',
      'core_version_requirement' => '^9.7 || ^10',
    ]));
    file_put_contents("{$path}/.git/excluded.txt", 'Phoenix!');
    $stage->apply();
    /** @var \Drupal\package_manager_bypass\LoggingCommitter $committer */
    $committer = $this->container
      ->get(CommitterInterface::class);
    $committer_args = $committer->getInvocationArguments();
    $excluded_paths = [
      '.git',
      'modules/module_not_known_to_composer_in_active/.git',
      'modules/example/.git',
    ];
    // We are missing "modules/unknown_to_composer_in_stage/.git" in excluded
    // paths because there is no validation for it as it is assumed about any
    // new .git folder in stage directory that either composer is aware of it or
    // the developer knows what they are doing.
    foreach ($excluded_paths as $excluded_path) {
      $this->assertContains($excluded_path, $committer_args[0][2]);
    }
    $this->assertNotContains('modules/unknown_to_composer_in_stage/.git', $committer_args[0][2]);
  }

}