Add assertIsDirectoryRecursivelyContaining file assertion

Fixes assertj#1740

Author: warnerbros-zz

src/main/java/org/assertj/core/api/AbstractFileAssert.java

@@ -939,6 +939,94 @@ public SELF isDirectoryContaining(String syntaxAndPattern) {
     return myself;
   }
 
+  /**
+   * Verify that the actual {@code File} directory or any of its subdirectories (recursively) contains at least one file
+   * matching the given {@code String} interpreted as a path matcher (as per {@link FileSystem#getPathMatcher(String)}).
+   * <p>
+   * That methods performs the same assertion as {@link #isDirectoryContaining(String syntaxAndPattern)}  but recursively.
+   * <p>
+   * Note that the actual {@link File} must exist and be a directory.
+   * <p>
+   * Examples given the following directory structure:
+   * <pre><code class="text"> root
+   * |—— foo
+   * |    |—— foobar
+   * |         |—— foo-file-1.ext
+   * |—— foo-file-2.ext</code>
+   * </pre>
+   *
+   * <pre><code class="java"> File root = new File("root");
+   *
+   * // The following assertions succeed:
+   * assertThat(root).isDirectoryRecursivelyContaining("glob:**foo")
+   *                 .isDirectoryRecursivelyContaining("glob:**ooba*")
+   *                 .isDirectoryRecursivelyContaining("glob:**file-1.ext")
+   *                 .isDirectoryRecursivelyContaining("regex:.*file-2.*")
+   *                 .isDirectoryRecursivelyContaining("glob:**.{ext,dummy}");
+   *
+   * // The following assertions fail:
+   * assertThat(root).isDirectoryRecursivelyContaining("glob:**fooba");
+   * assertThat(root).isDirectoryRecursivelyContaining("glob:**.bin");
+   * assertThat(root).isDirectoryRecursivelyContaining("glob:**.{java,class}"); </code></pre>
+   *
+   * @param syntaxAndPattern the syntax and pattern for {@link java.nio.file.PathMatcher} as described in {@link FileSystem#getPathMatcher(String)}.
+   * @return {@code this} assertion object.
+   * @throws NullPointerException if the given syntaxAndPattern is {@code null}.
+   * @throws AssertionError       if actual is {@code null}.
+   * @throws AssertionError       if actual does not exist.
+   * @throws AssertionError       if actual is not a directory.
+   * @throws AssertionError       if actual does not contain recursively any files matching the given path matcher.
+   * @see FileSystem#getPathMatcher(String)
+   * @since 3.16.0
+   */
+  public SELF isDirectoryRecursivelyContaining(String syntaxAndPattern) {
+    files.assertIsDirectoryRecursivelyContaining(info, actual, syntaxAndPattern);
+    return myself;
+  }
+
+  /**
+   * Verify that the actual {@code File} directory or any of its subdirectories (recursively) contains at least one file
+   * matching the given {@code Predicate<File>}.
+   * <p>
+   * That methods performs the same assertion as {@link #isDirectoryContaining(Predicate filter)}  but recursively.
+   * <p>
+   * Note that the actual {@link File} must exist and be a directory.
+   * <p>
+   * Examples given the following directory structure:
+   * <pre><code class="text"> root
+   * |—— foo
+   * |    |—— foobar
+   * |         |—— foo-file-1.ext
+   * |—— foo-file-2.ext</code>
+   * </pre>
+   *
+   * Here are some assertions examples:
+   * <pre><code class="java"> File root = new File("root");
+   *
+   * // The following assertions succeed:
+   * assertThat(root).isDirectoryRecursivelyContaining(file -&gt; file.getName().startsWith("foo-file-1"))
+   *                 .isDirectoryRecursivelyContaining(file -&gt; file.getName().endsWith("file-2.ext"))
+   *                 .isDirectoryRecursivelyContaining(file -&gt; file.getName().equals("foo"))
+   *                 .isDirectoryRecursivelyContaining(file -&gt; file.getParentFile().getName().equals("foo"))
+   *
+   * // The following assertions fail:
+   * assertThat(root).isDirectoryRecursivelyContaining(file -&gt; file.getName().equals("foo-file-1"))
+   * assertThat(root).isDirectoryRecursivelyContaining(file -&gt; file.getName().equals("foo/foobar")); </code></pre>
+   *
+   * @param filter the filter for files located inside {@code actual}'s directory.
+   * @return {@code this} assertion object.
+   * @throws NullPointerException if the given filter is {@code null}.
+   * @throws AssertionError       if actual is {@code null}.
+   * @throws AssertionError       if actual does not exist.
+   * @throws AssertionError       if actual is not a directory.
+   * @throws AssertionError       if actual does not contain recursively any files matching the given predicate.
+   * @since 3.16.0
+   */
+  public SELF isDirectoryRecursivelyContaining(Predicate<File> filter) {
+    files.assertIsDirectoryRecursivelyContaining(info, actual, filter);
+    return myself;
+  }
+
   /**
    * Verify that the actual {@code File} is a directory that does not contain any files matching the given {@code Predicate<File>}.
    * <p>

src/main/java/org/assertj/core/error/ShouldContainRecursively.java

@@ -0,0 +1,42 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2020 the original author or authors.
+ */
+package org.assertj.core.error;
+
+import static org.assertj.core.util.Strings.escapePercent;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * Creates an error message indicating that an assertion that verifies a group of elements contains recursively a given set of values failed.
+ *
+ * @author David Haccoun
+ * @author Joel Costigliola
+ */
+public class ShouldContainRecursively extends BasicErrorMessageFactory {
+
+  public static ErrorMessageFactory directoryShouldContainRecursively(File actual, List<String> directoryContent,
+                                                                      String filterDescription) {
+    return new ShouldContainRecursively(actual, directoryContent, filterDescription);
+  }
+
+  private ShouldContainRecursively(Object actual, List<String> directoryContent, String filterDescription) {
+    // not passing directoryContent and filterDescription as parameter to avoid AssertJ default String formatting
+    super("%nExpecting directory or any of its subdirectories(recursively):%n" +
+          "  <%s>%n" +
+          "to contain at least one file matching " + escapePercent(filterDescription) + " but there was none.%n" +
+          "The directory content was:%n  " + escapePercent(directoryContent.toString()),
+          actual);
+  }
+
+}

src/main/java/org/assertj/core/internal/Files.java

@@ -14,6 +14,7 @@
 
 import static java.lang.String.format;
 import static java.nio.file.Files.readAllBytes;
+import static java.util.Comparator.comparing;
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.toList;
 import static org.assertj.core.error.ShouldBeAbsolutePath.shouldBeAbsolutePath;
@@ -25,6 +26,7 @@
 import static org.assertj.core.error.ShouldBeRelativePath.shouldBeRelativePath;
 import static org.assertj.core.error.ShouldBeWritable.shouldBeWritable;
 import static org.assertj.core.error.ShouldContain.directoryShouldContain;
+import static org.assertj.core.error.ShouldContainRecursively.directoryShouldContainRecursively;
 import static org.assertj.core.error.ShouldExist.shouldExist;
 import static org.assertj.core.error.ShouldHaveBinaryContent.shouldHaveBinaryContent;
 import static org.assertj.core.error.ShouldHaveContent.shouldHaveContent;
@@ -48,11 +50,13 @@
 import java.io.UncheckedIOException;
 import java.nio.charset.Charset;
 import java.nio.charset.MalformedInputException;
+import java.nio.file.Path;
 import java.nio.file.PathMatcher;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.List;
 import java.util.function.Predicate;
+import java.util.stream.Stream;
 
 import org.assertj.core.api.AssertionInfo;
 import org.assertj.core.util.VisibleForTesting;
@@ -475,9 +479,21 @@ public void assertIsDirectoryContaining(AssertionInfo info, File actual, Predica
   }
 
   public void assertIsDirectoryContaining(AssertionInfo info, File actual, String syntaxAndPattern) {
-    requireNonNull(syntaxAndPattern, "The syntax and pattern to build PathMatcher should not be null");
-    Predicate<File> pathMatcher = pathMatcher(info, actual, syntaxAndPattern);
-    assertIsDirectoryContaining(info, actual, pathMatcher, format("the '%s' pattern", syntaxAndPattern));
+    requireNonNull(syntaxAndPattern, "The syntax and pattern should not be null");
+    Predicate<File> fileMatcher = fileMatcher(info, actual, syntaxAndPattern);
+    assertIsDirectoryContaining(info, actual, fileMatcher, format("the '%s' pattern", syntaxAndPattern));
+  }
+
+  public void assertIsDirectoryRecursivelyContaining(AssertionInfo info, File actual, String syntaxAndPattern) {
+    requireNonNull(syntaxAndPattern, "The syntax and pattern should not be null");
+    Predicate<File> fileMatcher = fileMatcher(info, actual, syntaxAndPattern);
+    assertIsDirectoryRecursivelyContaining(info, actual, fileMatcher,
+                                           format("the '%s' pattern", syntaxAndPattern));
+  }
+
+  public void assertIsDirectoryRecursivelyContaining(AssertionInfo info, File actual, Predicate<File> filter) {
+    requireNonNull(filter, "The files filter should not be null");
+    assertIsDirectoryRecursivelyContaining(info, actual, filter, "the given filter");
   }
 
   public void assertIsDirectoryNotContaining(AssertionInfo info, File actual, Predicate<File> filter) {
@@ -486,9 +502,9 @@ public void assertIsDirectoryNotContaining(AssertionInfo info, File actual, Pred
   }
 
   public void assertIsDirectoryNotContaining(AssertionInfo info, File actual, String syntaxAndPattern) {
-    requireNonNull(syntaxAndPattern, "The syntax and pattern to build PathMatcher should not be null");
-    Predicate<File> pathMatcher = pathMatcher(info, actual, syntaxAndPattern);
-    assertIsDirectoryNotContaining(info, actual, pathMatcher, format("the '%s' pattern", syntaxAndPattern));
+    requireNonNull(syntaxAndPattern, "The syntax and pattern should not be null");
+    Predicate<File> fileMatcher = fileMatcher(info, actual, syntaxAndPattern);
+    assertIsDirectoryNotContaining(info, actual, fileMatcher, format("the '%s' pattern", syntaxAndPattern));
   }
 
   public static List<String> toFileNames(List<File> files) {
@@ -497,6 +513,12 @@ public static List<String> toFileNames(List<File> files) {
                 .collect(toList());
   }
 
+  public static List<String> toAbsolutePaths(List<File> files) {
+    return files.stream()
+                .map(File::getAbsolutePath)
+                .collect(toList());
+  }
+
   // non public section
 
   private List<File> filterDirectory(AssertionInfo info, File actual, Predicate<File> filter) {
@@ -529,7 +551,46 @@ private List<String> directoryContentDescription(AssertionInfo info, File actual
     return toFileNames(directoryContent(info, actual));
   }
 
-  private Predicate<File> pathMatcher(AssertionInfo info, File actual, String syntaxAndPattern) {
+  // BEGIN - recursively assertion private methods
+  private boolean isDirectoryRecursivelyContaining(AssertionInfo info, File actual, Predicate<File> filter) {
+    assertIsDirectory(info, actual);
+    try (Stream<File> fileStream = createRecursiveStreamOfFile(actual)) {
+      return fileStream.anyMatch(filter);
+    }
+  }
+
+  private List<File> directoryRecursiveContent(File actual) {
+    try (Stream<File> fileStream = createRecursiveStreamOfFile(actual)) {
+      return fileStream.sorted(comparing(File::getAbsolutePath))
+                       .collect(toList());
+    }
+  }
+
+  private Stream<File> createRecursiveStreamOfFile(File directory) {
+    Path path = directory.toPath();
+    try {
+      return java.nio.file.Files.walk(path)
+                                .filter(p -> !p.equals(path))
+                                .map(Path::toFile);
+    } catch (IOException e) {
+      throw new UncheckedIOException(format("Unable to walk recursively the directory :<%s>", path), e);
+    }
+  }
+
+  private void assertIsDirectoryRecursivelyContaining(AssertionInfo info, File actual, Predicate<File> filter,
+                                                      String filterPresentation) {
+    if (!isDirectoryRecursivelyContaining(info, actual, filter)) {
+      throw failures.failure(info, directoryShouldContainRecursively(actual, directoryRecursiveContentDescription(actual),
+                                                                     filterPresentation));
+    }
+  }
+
+  private List<String> directoryRecursiveContentDescription(File actual) {
+    return toAbsolutePaths(directoryRecursiveContent(actual));
+  }
+  // END - recursively assertion private methods
+
+  private static Predicate<File> fileMatcher(AssertionInfo info, File actual, String syntaxAndPattern) {
     assertNotNull(info, actual);
     PathMatcher pathMatcher = actual.toPath().getFileSystem().getPathMatcher(syntaxAndPattern);
     return file -> pathMatcher.matches(file.toPath());

src/main/java/org/assertj/core/internal/Paths.java

@@ -366,7 +366,7 @@ public void assertIsDirectoryContaining(AssertionInfo info, Path actual, Predica
   }
 
   public void assertIsDirectoryContaining(AssertionInfo info, Path actual, String syntaxAndPattern) {
-    requireNonNull(syntaxAndPattern, "The syntax and pattern to build PathMatcher should not be null");
+    requireNonNull(syntaxAndPattern, "The syntax and pattern should not be null");
     PathMatcher pathMatcher = pathMatcher(info, actual, syntaxAndPattern);
     assertIsDirectoryContaining(info, actual, pathMatcher::matches, format("the '%s' pattern", syntaxAndPattern));
   }
@@ -377,7 +377,7 @@ public void assertIsDirectoryNotContaining(AssertionInfo info, Path actual, Pred
   }
 
   public void assertIsDirectoryNotContaining(AssertionInfo info, Path actual, String syntaxAndPattern) {
-    requireNonNull(syntaxAndPattern, "The syntax and pattern to build PathMatcher should not be null");
+    requireNonNull(syntaxAndPattern, "The syntax and pattern should not be null");
     PathMatcher pathMatcher = pathMatcher(info, actual, syntaxAndPattern);
     assertIsDirectoryNotContaining(info, actual, pathMatcher::matches, format("the '%s' pattern", syntaxAndPattern));
   }

src/test/java/org/assertj/core/api/file/FileAssert_isDirectoryRecursivelyContaining_Predicate_Test.java

@@ -0,0 +1,41 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2020 the original author or authors.
+ */
+package org.assertj.core.api.file;
+
+import static org.mockito.Mockito.verify;
+
+import java.io.File;
+import java.util.function.Predicate;
+
+import org.assertj.core.api.FileAssert;
+import org.assertj.core.api.FileAssertBaseTest;
+
+/**
+ * Tests for <code>{@link FileAssert#isDirectoryRecursivelyContaining(Predicate)}</code>
+ *
+ * @author David Haccoun
+ */
+public class FileAssert_isDirectoryRecursivelyContaining_Predicate_Test extends FileAssertBaseTest {
+
+  private final Predicate<File> anyFilter = path -> true;
+
+  @Override
+  protected FileAssert invoke_api_method() {
+    return assertions.isDirectoryRecursivelyContaining(anyFilter);
+  }
+
+  @Override
+  protected void verify_internal_effects() {
+    verify(files).assertIsDirectoryRecursivelyContaining(getInfo(assertions), getActual(assertions), anyFilter);
+  }
+}

src/test/java/org/assertj/core/api/file/FileAssert_isDirectoryRecursivelyContaining_SyntaxAndPattern_Test.java

@@ -0,0 +1,38 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2020 the original author or authors.
+ */
+package org.assertj.core.api.file;
+
+import static org.mockito.Mockito.verify;
+
+import org.assertj.core.api.FileAssert;
+import org.assertj.core.api.FileAssertBaseTest;
+
+/**
+ * Tests for <code>{@link FileAssert#isDirectoryRecursivelyContaining(String)}</code>
+ *
+ * @author David Haccoun
+ */
+public class FileAssert_isDirectoryRecursivelyContaining_SyntaxAndPattern_Test extends FileAssertBaseTest {
+
+  private final String syntaxAndPattern = "glob:*.java";
+
+  @Override
+  protected FileAssert invoke_api_method() {
+    return assertions.isDirectoryRecursivelyContaining(syntaxAndPattern);
+  }
+
+  @Override
+  protected void verify_internal_effects() {
+    verify(files).assertIsDirectoryRecursivelyContaining(getInfo(assertions), getActual(assertions), syntaxAndPattern);
+  }
+}

src/test/java/org/assertj/core/internal/FilesBaseTest.java

@@ -25,6 +25,7 @@
 import java.io.FileFilter;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.UncheckedIOException;
 import java.nio.file.FileSystem;
 import java.nio.file.Path;
 import java.util.LinkedHashMap;
@@ -106,7 +107,7 @@ protected File mockRegularFile(String... names) {
     try {
       given(nioFilesWrapper.newInputStream(path.toPath())).willReturn(new ByteArrayInputStream(new byte[0]));
     } catch (IOException e) {
-      assertThat(e).describedAs("Should not happen").isNull();
+      throw new UncheckedIOException("error during nioFilesWrapper mock recording", e);
     }
     return path;
   }