/*
    * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.qulice.maven;
   
   import com.google.common.collect.ImmutableList;
   import java.io.File;
   import java.nio.charset.StandardCharsets;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.util.Collections;
  import org.apache.maven.model.Build;
  import org.apache.maven.model.Resource;
  import org.apache.maven.plugin.testing.stubs.MavenProjectStub;
  import org.hamcrest.MatcherAssert;
  import org.hamcrest.Matchers;
  import org.junit.jupiter.api.Test;
  import org.junit.jupiter.api.io.TempDir;
  
  /**
   * Test case for {@link DefaultMavenEnvironment} class.
   *
   * @since 0.8
   */
  final class DefaultMavenEnvironmentTest {
  
      /**
       * DefaultMavenEnvironment can produce list of excludes.
       */
      @Test
      void excludeAllFiles() {
          final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
          env.setExcludes(Collections.singletonList("codenarc:**/*.groovy"));
          MatcherAssert.assertThat(
              "Excludes should be returned",
              env.excludes("codenarc"),
              Matchers.contains("**/*.groovy")
          );
      }
  
      /**
       * DefaultMavenEnvironment can produce list of excludes from empty source.
       */
      @Test
      void emptyExclude() {
          final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
          env.setExcludes(Collections.<String>emptyList());
          MatcherAssert.assertThat(
              "Empty list should be returned",
              env.excludes("codenarc").iterator().hasNext(),
              Matchers.is(false)
          );
      }
  
      /**
       * DefaultMavenEnvironment can produce list of excludes without excludes.
       */
      @Test
      void noExclude() {
          MatcherAssert.assertThat(
              "Excludes should be empty list by default",
              new DefaultMavenEnvironment().excludes("codenarc")
                  .iterator().hasNext(),
              Matchers.is(false)
          );
      }
  
      /**
       * DefaultMavenEnvironment can produce list of excludes.
       */
      @Test
      void excludeSomeFiles() {
          final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
          env.setExcludes(
              ImmutableList.<String>builder()
                  .add("codenarc:**/src/ex1/Main.groovy")
                  .add("codenarc:**/src/ex2/Main2.groovy")
                  .build()
          );
          MatcherAssert.assertThat(
              "Excludes should be returned as list",
              env.excludes("codenarc"),
              Matchers.containsInAnyOrder(
                  "**/src/ex1/Main.groovy",
                  "**/src/ex2/Main2.groovy"
              )
          );
      }
  
      /**
       * DefaultMavenEnvironment can work with whitespaces in classpath.
       *
       * @throws Exception If something wrong happens inside
       */
      @Test
      void passPathsWithWhitespaces() throws Exception {
          final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
          final MavenProjectStub project = new MavenProjectStub();
         project.setTestClasspathElements(
             Collections.singletonList("/Users/Carlos Miranda/git")
         );
         env.setProject(project);
         MatcherAssert.assertThat(
             "ClassPath should be returned",
             env.classloader(),
             Matchers.notNullValue()
         );
     }
 
     /**
      * DefaultMavenEnvironment.classpath() should return the fully-resolved
      * test classpath (compile + runtime + test scope, transitives included)
      * so that ErrorProne, which compiles test sources too, can access
      * transitive test-scope dependencies such as {@code opentest4j}
      * (see <a href="https://github.com/yegor256/qulice/issues/1691">
      * issue #1691</a>).
      *
      * @throws Exception If something wrong happens inside
      */
     @Test
     void classpathIncludesTransitiveTestDependencies() throws Exception {
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         final MavenProjectStub project = new MavenProjectStub();
         project.setTestClasspathElements(
             ImmutableList.of(
                 "/repo/junit-jupiter-api.jar",
                 "/repo/opentest4j.jar",
                 "/repo/apiguardian-api.jar"
             )
         );
         env.setProject(project);
         MatcherAssert.assertThat(
             "Transitive test dependencies must be on the classpath",
             env.classpath(),
             Matchers.containsInAnyOrder(
                 "/repo/junit-jupiter-api.jar",
                 "/repo/opentest4j.jar",
                 "/repo/apiguardian-api.jar"
             )
         );
     }
 
     /**
      * DefaultMavenEnvironment can produce empty collection when no matches
      * with checker.
      */
     @Test
     void producesEmptyExcludesWhenNoMatches() {
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         env.setExcludes(
             ImmutableList.of(
                 "checkstyle:**/src/ex1/Main.groovy",
                 "pmd:**/src/ex2/Main2.groovy"
             )
         );
         MatcherAssert.assertThat(
             "Exclude dependencies should be empty",
             env.excludes("dependencies"),
             Matchers.empty()
         );
     }
 
     /**
      * DefaultMavenEnvironment.files() should silently drop binary files so
      * that validators never try to read them as text
      * (see <a href="https://github.com/yegor256/qulice/issues/1264">
      * issue #1264</a>).
      *
      * @param basedir Temporary base directory
      * @throws Exception If something wrong happens inside
      */
     @Test
     void skipsBinaryFilesWhenListing(@TempDir final Path basedir)
         throws Exception {
         final Path src = basedir.resolve("src/main/java");
         Files.createDirectories(src);
         final Path source = src.resolve("Foo.java");
         Files.writeString(
             source,
             "class Foo {}".concat(String.valueOf('\n')),
             StandardCharsets.UTF_8
         );
         final Path image = basedir.resolve("src/main/resources/pixel.png");
         Files.createDirectories(image.getParent());
         Files.write(
             image,
             new byte[] {
                 (byte) 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
                 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
             }
         );
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         env.setProject(
             new MavenProjectStub() {
                 @Override
                 public File getBasedir() {
                     return basedir.toFile();
                 }
             }
         );
         MatcherAssert.assertThat(
             "Binary files cannot leak into the list of files to validate",
             env.files("*.*"),
             Matchers.allOf(
                 Matchers.hasItem(source.toFile()),
                 Matchers.not(Matchers.hasItem(image.toFile()))
             )
         );
     }
 
     /**
      * DefaultMavenEnvironment.files() should honor a non-default
      * {@code <sourceDirectory>} declared in the POM
      * (see <a href="https://github.com/yegor256/qulice/issues/382">
      * issue #382</a>).
      *
      * @param basedir Temporary base directory
      * @throws Exception If something wrong happens inside
      */
     @Test
     void respectsCustomSourceDirectory(@TempDir final Path basedir)
         throws Exception {
         final Path sources = basedir.resolve("sources");
         Files.createDirectories(sources);
         final Path source = sources.resolve("Foo.java");
         Files.writeString(
             source,
             "class Foo {}".concat(String.valueOf('\n')),
             StandardCharsets.UTF_8
         );
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         final MavenProjectStub project = new MavenProjectStub() {
             @Override
             public File getBasedir() {
                 return basedir.toFile();
             }
         };
         project.addCompileSourceRoot(sources.toAbsolutePath().toString());
         env.setProject(project);
         MatcherAssert.assertThat(
             "Files under custom sourceDirectory should be found",
             env.files("*.*"),
             Matchers.hasItem(source.toFile())
         );
     }
 
     /**
      * DefaultMavenEnvironment.files() should honor a non-default
      * {@code <testSourceDirectory>} declared in the POM
      * (see <a href="https://github.com/yegor256/qulice/issues/382">
      * issue #382</a>).
      *
      * @param basedir Temporary base directory
      * @throws Exception If something wrong happens inside
      */
     @Test
     void respectsCustomTestSourceDirectory(@TempDir final Path basedir)
         throws Exception {
         final Path tests = basedir.resolve("tests");
         Files.createDirectories(tests);
         final Path test = tests.resolve("FooTest.java");
         Files.writeString(
             test,
             "class FooTest {}".concat(String.valueOf('\n')),
             StandardCharsets.UTF_8
         );
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         final MavenProjectStub project = new MavenProjectStub() {
             @Override
             public File getBasedir() {
                 return basedir.toFile();
             }
         };
         project.addTestCompileSourceRoot(tests.toAbsolutePath().toString());
         env.setProject(project);
         MatcherAssert.assertThat(
             "Files under custom testSourceDirectory should be found",
             env.files("*.*"),
             Matchers.hasItem(test.toFile())
         );
     }
 
     /**
      * DefaultMavenEnvironment.files() should honor directories declared in
      * {@code <resources>} blocks of the POM
      * (see <a href="https://github.com/yegor256/qulice/issues/382">
      * issue #382</a>).
      *
      * @param basedir Temporary base directory
      * @throws Exception If something wrong happens inside
      */
     @Test
     void respectsCustomResourcesDirectory(@TempDir final Path basedir)
         throws Exception {
         final Path assets = basedir.resolve("assets");
         Files.createDirectories(assets);
         final Path asset = assets.resolve("config.xml");
         Files.writeString(
             asset,
             "<config/>".concat(String.valueOf('\n')),
             StandardCharsets.UTF_8
         );
         final Build build = new Build();
         final Resource resource = new Resource();
         resource.setDirectory(assets.toAbsolutePath().toString());
         build.addResource(resource);
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         env.setProject(
             new MavenProjectStub() {
                 @Override
                 public File getBasedir() {
                     return basedir.toFile();
                 }
 
                 @Override
                 public Build getBuild() {
                     return build;
                 }
             }
         );
         MatcherAssert.assertThat(
             "Files under declared resources directory should be found",
             env.files("*.*"),
             Matchers.hasItem(asset.toFile())
         );
     }
 
     /**
      * DefaultMavenEnvironment.testdirs() should report every test source
      * root the project declares, not just {@code src/test/java}, since
      * {@code build-helper-maven-plugin:add-test-source} may add more of
      * them, e.g. {@code src/mock/java}
      * (see <a href="https://github.com/yegor256/qulice/issues/1742">
      * issue #1742</a>).
      *
      * @param basedir Temporary base directory
      */
     @Test
     void reportsEveryTestSourceRoot(@TempDir final Path basedir) {
         final Path tests = basedir.resolve("src/test/java");
         final Path mocks = basedir.resolve("src/mock/java");
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         final MavenProjectStub project = new MavenProjectStub() {
             @Override
             public File getBasedir() {
                 return basedir.toFile();
             }
         };
         project.addTestCompileSourceRoot(
             tests.toAbsolutePath().toString()
         );
         project.addTestCompileSourceRoot(
             mocks.toAbsolutePath().toString()
         );
         env.setProject(project);
         MatcherAssert.assertThat(
             "Every declared test source root must be reported",
             env.testdirs(),
             Matchers.hasItems(tests.toFile(), mocks.toFile())
         );
     }
 
     /**
      * Default source files encoding should be UFT-8.
      */
     @Test
     void defaultEncodingIsUtf() {
         MatcherAssert.assertThat(
             "Default encoding should be UTF-8",
             new DefaultMavenEnvironment().encoding(),
             Matchers.is(StandardCharsets.UTF_8)
         );
     }
 
     /**
      * DefaultMavenEnvironment.files() should ignore source roots that live
      * under the project's build directory, since those are generated build
      * outputs (e.g. target/generated-sources/...) and not user-authored code
      * (see <a href="https://github.com/yegor256/qulice/issues/1560">
      * issue #1560</a>).
      *
      * @param basedir Temporary base directory
      * @throws Exception If something wrong happens inside
      */
     @Test
     void skipsSourcesUnderBuildDirectory(@TempDir final Path basedir)
         throws Exception {
         final Path src = basedir.resolve("src/main/java");
         Files.createDirectories(src);
         final Path source = src.resolve("Foo.java");
         Files.writeString(
             source,
             "class Foo {}".concat(String.valueOf('\n')),
             StandardCharsets.UTF_8
         );
         final Path generated = basedir.resolve(
             "target/generated-sources/plugin/com/example"
         );
         Files.createDirectories(generated);
         final Path help = generated.resolve("HelpMojo.java");
         Files.writeString(
             help,
             "class HelpMojo {}".concat(String.valueOf('\n')),
             StandardCharsets.UTF_8
         );
         final Build build = new Build();
         build.setDirectory(
             basedir.resolve("target").toAbsolutePath().toString()
         );
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         final MavenProjectStub project = new MavenProjectStub() {
             @Override
             public File getBasedir() {
                 return basedir.toFile();
             }
 
             @Override
             public Build getBuild() {
                 return build;
             }
         };
         project.addCompileSourceRoot(src.toAbsolutePath().toString());
         project.addCompileSourceRoot(
             generated.toAbsolutePath().toString()
         );
         env.setProject(project);
         MatcherAssert.assertThat(
             "Generated sources under target/ must not be returned",
             env.files("*.java"),
             Matchers.allOf(
                 Matchers.hasItem(source.toFile()),
                 Matchers.not(Matchers.hasItem(help.toFile()))
             )
         );
     }
 
     /**
      * DefaultMavenEnvironment.tempdir() must not point at the directory
      * with compiled classes, otherwise validators drop their scratch files
      * into {@code target/classes} and they end up in the JAR and confuse
      * {@code jacoco:report}
      * (see <a href="https://github.com/yegor256/qulice/issues/1741">
      * issue #1741</a>).
      *
      * @param basedir Temporary base directory
      */
     @Test
     void keepsTempdirOutsideOutdir(@TempDir final Path basedir) {
         final Path target = basedir.resolve("target");
         final Build build = new Build();
         build.setDirectory(target.toAbsolutePath().toString());
         build.setOutputDirectory(
             target.resolve("classes").toAbsolutePath().toString()
         );
         final DefaultMavenEnvironment env = new DefaultMavenEnvironment();
         env.setProject(
             new MavenProjectStub() {
                 @Override
                 public File getBasedir() {
                     return basedir.toFile();
                 }
 
                 @Override
                 public Build getBuild() {
                     return build;
                 }
             }
         );
         final Path temp = env.tempdir().toPath().toAbsolutePath();
         MatcherAssert.assertThat(
             "Scratch dir must be usable, under target/ and away from classes",
             env.tempdir().isDirectory()
                 && temp.startsWith(target.toAbsolutePath())
                 && !temp.startsWith(env.outdir().toPath().toAbsolutePath()),
             Matchers.is(true)
         );
     }
 }