Skip to content

Commit

Permalink
Path and File assertions refactoring
Browse files Browse the repository at this point in the history 
* Pull up `DirectoryStream.Filter` parameter
* Pull up `FileFilter` parameter
* Move file name string conversion to `File` error messages
* Move path string conversion to `Path` error messages
  • Loading branch information
@scordio
scordio committed Sep 14, 2021
1 parent 87eecea commit 48ed152
Show file tree
Hide file tree
Showing 15 changed files with 109 additions and 107 deletions.
28 changes: 21 additions & 7 deletions src/main/java/org/assertj/core/error/ShouldContain.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,19 +12,21 @@
*/
package org.assertj.core.error;

import static java.util.stream.Collectors.toList;
import static org.assertj.core.error.GroupTypeDescription.getGroupTypeDescription;
import static org.assertj.core.util.Strings.escapePercent;

import java.io.File;
import java.nio.file.Path;
import java.util.List;

import org.assertj.core.internal.ComparisonStrategy;
import org.assertj.core.internal.StandardComparisonStrategy;
import static org.assertj.core.error.GroupTypeDescription.getGroupTypeDescription;
import static org.assertj.core.util.Strings.escapePercent;

/**
* Creates an error message indicating that an assertion that verifies a group of elements contains a given set of values failed.
* A group of elements can be a collection, an array or a {@code String}.<br>
* It also mention the {@link ComparisonStrategy} used.
* It also mentions the {@link ComparisonStrategy} used.
*
* @author Alex Ruiz
* @author Joel Costigliola
Expand Down Expand Up @@ -70,12 +72,24 @@ public static ErrorMessageFactory shouldContain(Object actual, Object expected,
return shouldContain(actual, expected, notFound, StandardComparisonStrategy.instance());
}

public static ErrorMessageFactory directoryShouldContain(File actual, List<String> directoryContent, String filterDescription) {
return new ShouldContain(actual, directoryContent, filterDescription);
public static ErrorMessageFactory directoryShouldContain(File actual, List<File> directoryContent, String filterDescription) {
return new ShouldContain(actual, toFileNames(directoryContent), filterDescription);
}

private static List<String> toFileNames(List<File> files) {
return files.stream()
.map(File::getName)
.collect(toList());
}

public static ErrorMessageFactory directoryShouldContain(Path actual, List<Path> directoryContent, String filterDescription) {
return new ShouldContain(actual, toPathNames(directoryContent), filterDescription);
}

public static ErrorMessageFactory directoryShouldContain(Path actual, List<String> directoryContent, String filterDescription) {
return new ShouldContain(actual, directoryContent, filterDescription);
private static List<String> toPathNames(List<Path> files) {
return files.stream()
.map(Path::toString)
.collect(toList());
}

private ShouldContain(Object actual, Object expected, Object notFound, ComparisonStrategy comparisonStrategy,
Expand Down
24 changes: 18 additions & 6 deletions src/main/java/org/assertj/core/error/ShouldNotContain.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,8 @@
*/
package org.assertj.core.error;

import static java.util.stream.Collectors.toList;

import java.io.File;
import java.nio.file.Path;
import java.util.List;
Expand Down Expand Up @@ -56,14 +58,24 @@ private ShouldNotContain(Object actual, Object expected, Object found, Compariso
super("%nExpecting%n %s%nnot to contain%n %s%nbut found%n %s%n%s", actual, expected, found, comparisonStrategy);
}

public static ErrorMessageFactory directoryShouldNotContain(File actual, List<String> matchingContent,
String filterDescription) {
return new ShouldNotContain(actual, matchingContent, filterDescription);
public static ErrorMessageFactory directoryShouldNotContain(File actual, List<File> matchingContent, String filterDescription) {
return new ShouldNotContain(actual, toFileNames(matchingContent), filterDescription);
}

private static List<String> toFileNames(List<File> files) {
return files.stream()
.map(File::getName)
.collect(toList());
}

public static ErrorMessageFactory directoryShouldNotContain(Path actual, List<Path> matchingContent, String filterDescription) {
return new ShouldNotContain(actual, toPathNames(matchingContent), filterDescription);
}

public static ErrorMessageFactory directoryShouldNotContain(Path actual, List<String> matchingContent,
String filterDescription) {
return new ShouldNotContain(actual, matchingContent, filterDescription);
private static List<String> toPathNames(List<Path> files) {
return files.stream()
.map(Path::toString)
.collect(toList());
}

private ShouldNotContain(Object actual, List<String> matchingContent, String filterDescription) {
Expand Down
54 changes: 21 additions & 33 deletions src/main/java/org/assertj/core/internal/Files.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,6 +45,7 @@
import static org.assertj.core.util.Preconditions.checkArgument;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
Expand Down Expand Up @@ -75,7 +76,7 @@ public class Files {

private static final String UNABLE_TO_COMPARE_FILE_CONTENTS = "Unable to compare contents of files:<%s> and:<%s>";
private static final Files INSTANCE = new Files();
private static final Predicate<File> ANY = any -> true;
private static final FileFilter ANY = any -> true;

/**
* Returns the singleton instance of this class.
Expand Down Expand Up @@ -475,20 +476,19 @@ public void assertIsNotEmptyDirectory(AssertionInfo info, File actual) {

public void assertIsDirectoryContaining(AssertionInfo info, File actual, Predicate<File> filter) {
requireNonNull(filter, "The files filter should not be null");
assertIsDirectoryContaining(info, actual, filter, "the given filter");
assertIsDirectoryContaining(info, actual, filter::test, "the given filter");
}

public void assertIsDirectoryContaining(AssertionInfo info, File actual, String 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));
FileFilter filter = fileFilter(info, actual, syntaxAndPattern);
assertIsDirectoryContaining(info, actual, filter, 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));
FileFilter filter = fileFilter(info, actual, syntaxAndPattern);
assertIsDirectoryRecursivelyContaining(info, actual, filter::accept, format("the '%s' pattern", syntaxAndPattern));
}

public void assertIsDirectoryRecursivelyContaining(AssertionInfo info, File actual, Predicate<File> filter) {
Expand All @@ -498,27 +498,20 @@ public void assertIsDirectoryRecursivelyContaining(AssertionInfo info, File actu

public void assertIsDirectoryNotContaining(AssertionInfo info, File actual, Predicate<File> filter) {
requireNonNull(filter, "The files filter should not be null");
assertIsDirectoryNotContaining(info, actual, filter, "the given filter");
assertIsDirectoryNotContaining(info, actual, filter::test, "the given filter");
}

public void assertIsDirectoryNotContaining(AssertionInfo info, File actual, String 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));
FileFilter filter = fileFilter(info, actual, syntaxAndPattern);
assertIsDirectoryNotContaining(info, actual, filter, format("the '%s' pattern", syntaxAndPattern));
}

@VisibleForTesting
public static List<String> toFileNames(List<File> files) {
return files.stream()
.map(File::getName)
.collect(toList());
}

// non public section
// non-public section

private List<File> filterDirectory(AssertionInfo info, File actual, Predicate<File> filter) {
private List<File> filterDirectory(AssertionInfo info, File actual, FileFilter filter) {
assertIsDirectory(info, actual);
File[] items = actual.listFiles(filter::test);
File[] items = actual.listFiles(filter);
requireNonNull(items, "Directory listing should not be null");
return list(items);
}
Expand All @@ -527,25 +520,20 @@ private List<File> directoryContent(AssertionInfo info, File actual) {
return filterDirectory(info, actual, ANY);
}

private void assertIsDirectoryContaining(AssertionInfo info, File actual, Predicate<File> filter, String filterPresentation) {
private void assertIsDirectoryContaining(AssertionInfo info, File actual, FileFilter filter, String filterPresentation) {
List<File> matchingFiles = filterDirectory(info, actual, filter);
if (matchingFiles.isEmpty()) {
throw failures.failure(info, directoryShouldContain(actual, directoryContentDescription(info, actual), filterPresentation));
throw failures.failure(info, directoryShouldContain(actual, directoryContent(info, actual), filterPresentation));
}
}

private void assertIsDirectoryNotContaining(AssertionInfo info, File actual, Predicate<File> filter,
String filterPresentation) {
private void assertIsDirectoryNotContaining(AssertionInfo info, File actual, FileFilter filter, String filterPresentation) {
List<File> matchingFiles = filterDirectory(info, actual, filter);
if (matchingFiles.size() > 0) {
throw failures.failure(info, directoryShouldNotContain(actual, toFileNames(matchingFiles), filterPresentation));
if (!matchingFiles.isEmpty()) {
throw failures.failure(info, directoryShouldNotContain(actual, matchingFiles, filterPresentation));
}
}

private List<String> directoryContentDescription(AssertionInfo info, File actual) {
return toFileNames(directoryContent(info, actual));
}

private boolean isDirectoryRecursivelyContaining(AssertionInfo info, File actual, Predicate<File> filter) {
assertIsDirectory(info, actual);
try (Stream<File> actualContent = recursiveContentOf(actual)) {
Expand Down Expand Up @@ -578,10 +566,10 @@ private void assertIsDirectoryRecursivelyContaining(AssertionInfo info, File act
}
}

private static Predicate<File> fileMatcher(AssertionInfo info, File actual, String syntaxAndPattern) {
private static FileFilter fileFilter(AssertionInfo info, File actual, String syntaxAndPattern) {
assertNotNull(info, actual);
PathMatcher pathMatcher = actual.toPath().getFileSystem().getPathMatcher(syntaxAndPattern);
return file -> pathMatcher.matches(file.toPath());
PathMatcher matcher = actual.toPath().getFileSystem().getPathMatcher(syntaxAndPattern);
return file -> matcher.matches(file.toPath());
}

private static void assertNotNull(AssertionInfo info, File actual) {
Expand Down
7 changes: 3 additions & 4 deletions src/main/java/org/assertj/core/internal/NioFilesWrapper.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,11 +15,10 @@
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.DirectoryStream;
import java.nio.file.DirectoryStream.Filter;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.util.function.Predicate;

/**
* Wrapper for <code>{@link java.nio.file.Files}</code> to test methods throwing {@link IOException}.
Expand All @@ -38,8 +37,8 @@ public InputStream newInputStream(Path path, OpenOption... options) throws IOExc
return Files.newInputStream(path, options);
}

public DirectoryStream<Path> newDirectoryStream(Path path, Predicate<Path> matcher) throws IOException {
return Files.newDirectoryStream(path, matcher::test);
public DirectoryStream<Path> newDirectoryStream(Path dir, Filter<? super Path> filter) throws IOException {
return Files.newDirectoryStream(dir, filter);
}

public long size(Path path) throws IOException {
Expand Down
30 changes: 10 additions & 20 deletions src/main/java/org/assertj/core/internal/Paths.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,6 +55,7 @@
import java.io.UncheckedIOException;
import java.nio.charset.Charset;
import java.nio.file.DirectoryStream;
import java.nio.file.DirectoryStream.Filter;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
Expand All @@ -80,7 +81,7 @@ public class Paths {
private static final String UNABLE_TO_COMPARE_PATH_CONTENTS = "Unable to compare contents of paths:<%s> and:<%s>";

private static final Paths INSTANCE = new Paths();
private static final Predicate<Path> ANY = any -> true;
private static final Filter<Path> ANY = any -> true;

@VisibleForTesting
Diff diff = new Diff();
Expand Down Expand Up @@ -314,7 +315,7 @@ public void assertHasDigest(AssertionInfo info, Path actual, String algorithm, S

public void assertIsDirectoryContaining(AssertionInfo info, Path actual, Predicate<Path> filter) {
requireNonNull(filter, "The paths filter should not be null");
assertIsDirectoryContaining(info, actual, filter, "the given filter");
assertIsDirectoryContaining(info, actual, filter::test, "the given filter");
}

public void assertIsDirectoryContaining(AssertionInfo info, Path actual, String syntaxAndPattern) {
Expand All @@ -337,7 +338,7 @@ public void assertIsDirectoryRecursivelyContaining(AssertionInfo info, Path actu

public void assertIsDirectoryNotContaining(AssertionInfo info, Path actual, Predicate<Path> filter) {
requireNonNull(filter, "The paths filter should not be null");
assertIsDirectoryNotContaining(info, actual, filter, "the given filter");
assertIsDirectoryNotContaining(info, actual, filter::test, "the given filter");
}

public void assertIsDirectoryNotContaining(AssertionInfo info, Path actual, String syntaxAndPattern) {
Expand Down Expand Up @@ -374,15 +375,9 @@ public void assertIsNotEmptyFile(AssertionInfo info, Path actual) {
}
}

public static List<String> toPathNames(List<Path> files) {
return files.stream()
.map(Path::toString)
.collect(toList());
}

// non public section
// non-public section

private List<Path> filterDirectory(AssertionInfo info, Path actual, Predicate<Path> filter) {
private List<Path> filterDirectory(AssertionInfo info, Path actual, Filter<Path> filter) {
assertIsDirectory(info, actual);
try (DirectoryStream<Path> stream = nioFilesWrapper.newDirectoryStream(actual, filter)) {
return stream(stream.spliterator(), false).collect(toList());
Expand All @@ -395,10 +390,10 @@ private List<Path> directoryContent(AssertionInfo info, Path actual) {
return filterDirectory(info, actual, ANY);
}

private void assertIsDirectoryContaining(AssertionInfo info, Path actual, Predicate<Path> filter, String filterPresentation) {
private void assertIsDirectoryContaining(AssertionInfo info, Path actual, Filter<Path> filter, String filterPresentation) {
List<Path> matchingFiles = filterDirectory(info, actual, filter);
if (matchingFiles.isEmpty()) {
throw failures.failure(info, directoryShouldContain(actual, directoryContentDescription(info, actual), filterPresentation));
throw failures.failure(info, directoryShouldContain(actual, directoryContent(info, actual), filterPresentation));
}
}

Expand Down Expand Up @@ -430,18 +425,13 @@ private void assertIsDirectoryRecursivelyContaining(AssertionInfo info, Path act
}
}

private void assertIsDirectoryNotContaining(AssertionInfo info, Path actual, Predicate<Path> filter,
String filterPresentation) {
private void assertIsDirectoryNotContaining(AssertionInfo info, Path actual, Filter<Path> filter, String filterPresentation) {
List<Path> matchingPaths = filterDirectory(info, actual, filter);
if (matchingPaths.size() > 0) {
throw failures.failure(info, directoryShouldNotContain(actual, toPathNames(matchingPaths), filterPresentation));
throw failures.failure(info, directoryShouldNotContain(actual, matchingPaths, filterPresentation));
}
}

private List<String> directoryContentDescription(AssertionInfo info, Path actual) {
return toPathNames(directoryContent(info, actual));
}

private PathMatcher pathMatcher(AssertionInfo info, Path actual, String syntaxAndPattern) {
assertNotNull(info, actual);
return actual.getFileSystem().getPathMatcher(syntaxAndPattern);
Expand Down
21 changes: 11 additions & 10 deletions src/test/java/org/assertj/core/error/ShouldContain_create_Test.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,8 @@

import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Map;

import org.assertj.core.data.MapEntry;
Expand All @@ -35,10 +37,6 @@
import org.junit.jupiter.api.Test;

/**
* Tests for
* <code>{@link ShouldContain#create(org.assertj.core.description.Description, org.assertj.core.presentation.Representation)}</code>
* .
*
* @author Alex Ruiz
* @author Yvonne Wang
* @author Joel Costigliola
Expand Down Expand Up @@ -295,7 +293,8 @@ void should_create_error_message_for_file_directory() {
// GIVEN
File directory = mock(File.class);
given(directory.getAbsolutePath()).willReturn("root");
ErrorMessageFactory factory = directoryShouldContain(directory, list("foo.txt", "bar.txt"), "glob:**.java");
List<File> directoryContent = list(new File("root", "foo.txt"), new File("root", "bar.txt"));
ErrorMessageFactory factory = directoryShouldContain(directory, directoryContent, "glob:**.java");
// WHEN
String message = factory.create(new TextDescription("Test"));
// THEN
Expand All @@ -312,7 +311,8 @@ void should_create_error_message_for_file_directory_escaping_percent() {
// GIVEN
File directory = mock(File.class);
given(directory.getAbsolutePath()).willReturn("root%dir");
ErrorMessageFactory factory = directoryShouldContain(directory, list("foo%1.txt", "bar%2.txt"), "glob:**%Test.java");
List<File> directoryContent = list(new File("root%dir", "foo%1.txt"), new File("root%dir", "bar%2.txt"));
ErrorMessageFactory factory = directoryShouldContain(directory, directoryContent, "glob:**%Test.java");
// WHEN
String message = factory.create(new TextDescription("Test"));
// THEN
Expand All @@ -327,9 +327,9 @@ void should_create_error_message_for_file_directory_escaping_percent() {
@Test
void should_create_error_message_for_path_directory() {
// GIVEN
Path directory = mock(Path.class);
given(directory.toString()).willReturn("root");
ErrorMessageFactory factory = directoryShouldContain(directory, list("foo.txt", "bar.txt"), "glob:**.java");
Path directory = Paths.get("root");
List<Path> directoryContent = list(directory.resolve("foo.txt"), directory.resolve("bar.txt"));
ErrorMessageFactory factory = directoryShouldContain(directory, directoryContent, "glob:**.java");
// WHEN
String message = factory.create(new TextDescription("Test"));
// THEN
Expand All @@ -338,7 +338,8 @@ void should_create_error_message_for_path_directory() {
" root%n" +
"to contain at least one file matching glob:**.java but there was none.%n" +
"The directory content was:%n" +
" [foo.txt, bar.txt]"));
" [%s, %s]",
directory.resolve("foo.txt"), directory.resolve("bar.txt")));
}

}
Loading

0 comments on commit 48ed152

Please sign in to comment.