You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by sl...@apache.org on 2026/09/20 09:05:09 UTC
(maven-jarsigner-plugin) branch master updated: Drop Hamcrest from tests
This is an automated email from the ASF dual-hosted git repository.
slachiewicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-jarsigner-plugin.git
The following commit(s) were added to refs/heads/master by this push:
new 7964181 Drop Hamcrest from tests
7964181 is described below
commit 7964181d62df0c9c40d917a835d082d663e53a99
Author: Sylwester Lachiewicz <sl...@apache.org>
AuthorDate: Sat Sep 19 23:53:43 2026 +0200
Drop Hamcrest from tests
---
pom.xml | 6 --
.../jarsigner/JarsignerSignMojoParallelTest.java | 4 +-
.../jarsigner/JarsignerSignMojoRetryTest.java | 11 +--
.../plugins/jarsigner/JarsignerSignMojoTest.java | 106 ++++++++++-----------
.../jarsigner/JarsignerSignMojoTsaTest.java | 11 +--
.../plugins/jarsigner/JarsignerVerifyMojoTest.java | 21 ++--
.../maven/plugins/jarsigner/RequestMatchers.java | 65 ++++++-------
7 files changed, 101 insertions(+), 123 deletions(-)
diff --git a/pom.xml b/pom.xml
index 4d9af3b..2eb5337 100644
--- a/pom.xml
+++ b/pom.xml
@@ -136,12 +136,6 @@ under the License.
<artifactId>junit-jupiter</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest</artifactId>
- <version>3.0</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java
index 7ba8c3a..3ca475d 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoParallelTest.java
@@ -45,8 +45,6 @@ import org.junit.jupiter.api.io.TempDir;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -204,7 +202,7 @@ public class JarsignerSignMojoParallelTest {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString(String.valueOf("Failed executing 'jarsigner ")));
+ assertTrue(mojoException.getMessage().contains("Failed executing 'jarsigner "));
Locale.setDefault(orginalLocale);
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java
index f5b2d21..68eb3a9 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoRetryTest.java
@@ -41,11 +41,10 @@ import org.junit.jupiter.api.io.TempDir;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.Mockito.argThat;
@@ -267,7 +266,7 @@ public class JarsignerSignMojoRetryTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.waitAfterFailure(0, Duration.ofSeconds(10), iterruptedSleeper);
});
- assertThat(mojoException.getMessage(), containsString("interrupted while waiting after failure"));
+ assertTrue(mojoException.getMessage().contains("interrupted while waiting after failure"));
}
/** Check that the error returned from a re-try scenario where all execution fails is the "correct" error */
@@ -290,8 +289,8 @@ public class JarsignerSignMojoRetryTest {
});
// Make sure that the last error exit code is present
- assertThat(mojoException.getMessage(), containsString(String.valueOf(42)));
+ assertTrue(mojoException.getMessage().contains(String.valueOf(42)));
// Make sure that the first error exit code is not present
- assertThat(mojoException.getMessage(), not(containsString(String.valueOf(1))));
+ assertFalse(mojoException.getMessage().contains(String.valueOf(1)));
}
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java
index 5a4e796..7dabde7 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTest.java
@@ -40,21 +40,15 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.mockito.ArgumentCaptor;
-import org.mockito.hamcrest.MockitoHamcrest;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.everyItem;
-import static org.hamcrest.CoreMatchers.hasItem;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.mock;
@@ -116,7 +110,7 @@ public class JarsignerSignMojoTest {
assertNull(request.getProviderClass());
assertNull(request.getProviderArg());
assertNull(request.getMaxMemory());
- assertThat(request.getArguments()[0], startsWith("-J-Dfile.encoding="));
+ assertTrue(request.getArguments()[0].startsWith("-J-Dfile.encoding="));
assertEquals(projectDir, request.getWorkingDirectory());
assertEquals(mainArtifact.getFile(), request.getArchive());
assertFalse(request.isProtectedAuthenticationPath());
@@ -140,10 +134,10 @@ public class JarsignerSignMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString(String.valueOf(RESULT_ERROR.getExitCode())));
- assertThat(
- mojoException.getMessage(),
- containsString(RESULT_ERROR.getCommandline().toString()));
+ assertTrue(mojoException.getMessage().contains(String.valueOf(RESULT_ERROR.getExitCode())));
+ assertTrue(mojoException
+ .getMessage()
+ .contains(RESULT_ERROR.getCommandline().toString()));
}
/** When JavaTool throws an exception on execute() (when executing jarsigner). */
@@ -157,7 +151,7 @@ public class JarsignerSignMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString("test failure"));
+ assertTrue(mojoException.getMessage().contains("test failure"));
}
/** Standard POM project with nothing special configured */
@@ -210,8 +204,8 @@ public class JarsignerSignMojoTest {
mojo.execute();
// Make sure only the jar pointed by "archive" has been processed, but not the main artifact
- verify(jarSigner, never()).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project.jar")));
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("archive.jar")));
+ verify(jarSigner, never()).execute(argThat(RequestMatchers.hasFileName("my-project.jar")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasFileName("archive.jar")));
}
/** Test that it is possible to disable processing of attached artifacts */
@@ -231,9 +225,8 @@ public class JarsignerSignMojoTest {
mojo.execute();
// Make sure that only the main artifact has been processed, but not the attached artifact
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project.jar")));
- verify(jarSigner, never())
- .execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project-sources.jar")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasFileName("my-project.jar")));
+ verify(jarSigner, never()).execute(argThat(RequestMatchers.hasFileName("my-project-sources.jar")));
}
/** A Java project with 3 types of artifacts: main, javadoc and sources */
@@ -254,9 +247,9 @@ public class JarsignerSignMojoTest {
verify(jarSigner, times(3)).execute(requestArgument.capture());
List<JarSignerSignRequest> requests = requestArgument.getAllValues();
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-sources.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-javadoc.jar")));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-sources.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-javadoc.jar")::matches));
}
/**
@@ -332,36 +325,43 @@ public class JarsignerSignMojoTest {
verify(jarSigner, times(5)).execute(requestArgument.capture());
List<JarSignerSignRequest> requests = requestArgument.getAllValues();
- assertThat(requests, everyItem(RequestMatchers.hasAlias("myalias")));
-
- assertThat(requests, hasItem(RequestMatchers.hasFileName("archive1.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("previously_signed_archive.jar")));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("archive_to_exclude.jar"))));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("not_this.par"))));
-
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-sources.jar")));
- assertThat(requests, hasItem(RequestMatchers.hasFileName("my-project-javadoc.jar")));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("my-project-included_and_excluded.jar"))));
- assertThat(requests, hasItem(not(RequestMatchers.hasFileName("my-project-excluded_classifier.jar"))));
-
- assertThat(
- requests, everyItem(RequestMatchers.hasArguments(new String[] {"jarsigner-arg1", "jarsigner-arg2"})));
- assertThat(requests, everyItem(RequestMatchers.hasCertchain("mycertchain")));
- assertThat(requests, everyItem(RequestMatchers.hasKeypass("mykeypass")));
- assertThat(requests, everyItem(RequestMatchers.hasKeystore("mykeystore")));
- assertThat(requests, everyItem(RequestMatchers.hasMaxMemory("mymaxmemory")));
- assertThat(requests, everyItem(RequestMatchers.hasProtectedAuthenticationPath(true)));
- assertThat(requests, everyItem(RequestMatchers.hasProviderArg("myproviderarg")));
- assertThat(requests, everyItem(RequestMatchers.hasProviderClass("myproviderclass")));
- assertThat(requests, everyItem(RequestMatchers.hasProviderName("myprovidername")));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasAlias("myalias")::matches));
+
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("archive1.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("previously_signed_archive.jar")::matches));
+ assertTrue(requests.stream()
+ .anyMatch(r ->
+ !RequestMatchers.hasFileName("archive_to_exclude.jar").matches(r)));
+ assertTrue(requests.stream()
+ .anyMatch(r -> !RequestMatchers.hasFileName("not_this.par").matches(r)));
+
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-sources.jar")::matches));
+ assertTrue(requests.stream().anyMatch(RequestMatchers.hasFileName("my-project-javadoc.jar")::matches));
+ assertTrue(requests.stream()
+ .anyMatch(r -> !RequestMatchers.hasFileName("my-project-included_and_excluded.jar")
+ .matches(r)));
+ assertTrue(requests.stream()
+ .anyMatch(r -> !RequestMatchers.hasFileName("my-project-excluded_classifier.jar")
+ .matches(r)));
+
+ assertTrue(requests.stream()
+ .allMatch(RequestMatchers.hasArguments(new String[] {"jarsigner-arg1", "jarsigner-arg2"})::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasCertchain("mycertchain")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasKeypass("mykeypass")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasKeystore("mykeystore")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasMaxMemory("mymaxmemory")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProtectedAuthenticationPath(true)::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProviderArg("myproviderarg")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProviderClass("myproviderclass")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasProviderName("myprovidername")::matches));
assertFalse(JarSignerUtil.isArchiveSigned(previouslySignedArchive)); // Make sure previous signing is gone
- assertThat(requests, everyItem(RequestMatchers.hasSigfile("mysigfile")));
- assertThat(requests, everyItem(RequestMatchers.hasStorepass("mystorepass")));
- assertThat(requests, everyItem(RequestMatchers.hasStoretype("mystoretype")));
- assertThat(requests, everyItem(RequestMatchers.hasTsa("mytsa")));
- assertThat(requests, everyItem(RequestMatchers.hasTsacert("mytsacert")));
- assertThat(requests, everyItem(RequestMatchers.hasVerbose(true)));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasSigfile("mysigfile")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasStorepass("mystorepass")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasStoretype("mystoretype")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsa("mytsa")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsacert("mytsacert")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasVerbose(true)::matches));
}
/** Make sure that if a custom ToolchainManager is set on the Mojo, it is used by jarSigner */
@@ -398,8 +398,8 @@ public class JarsignerSignMojoTest {
mojo.execute();
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasKeypass("mykeypass")));
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasStorepass("mystorepass")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasKeypass("mykeypass")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasStorepass("mystorepass")));
}
/** Make sure that a customer file encoding to jarsigner can be set and that it does not get duplicated */
@@ -414,7 +414,7 @@ public class JarsignerSignMojoTest {
mojo.execute();
verify(jarSigner)
- .execute(MockitoHamcrest.argThat(
+ .execute(argThat(
RequestMatchers.hasArguments(new String[] {"-J-Dfile.encoding=ISO-8859-1", "argument2"})));
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java
index fe79617..aed7843 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerSignMojoTsaTest.java
@@ -39,9 +39,8 @@ import org.mockito.ArgumentCaptor;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.everyItem;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.Mockito.mock;
@@ -97,10 +96,10 @@ public class JarsignerSignMojoTsaTest {
ArgumentCaptor<JarSignerSignRequest> requestArgument = ArgumentCaptor.forClass(JarSignerSignRequest.class);
verify(jarSigner, times(3)).execute(requestArgument.capture());
List<JarSignerSignRequest> requests = requestArgument.getAllValues();
- assertThat(requests, everyItem(RequestMatchers.hasTsa("http://my-timestamp.server.com")));
- assertThat(requests, everyItem(RequestMatchers.hasTsacert("mytsacertalias")));
- assertThat(requests, everyItem(RequestMatchers.hasTsaPolicyid("0.1.2.3.4")));
- assertThat(requests, everyItem(RequestMatchers.hasTsaDigestalg("SHA-384")));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsa("http://my-timestamp.server.com")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsacert("mytsacertalias")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsaPolicyid("0.1.2.3.4")::matches));
+ assertTrue(requests.stream().allMatch(RequestMatchers.hasTsaDigestalg("SHA-384")::matches));
}
@Test
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java
index 15b6497..8a65ffa 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/JarsignerVerifyMojoTest.java
@@ -32,17 +32,14 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.mockito.ArgumentCaptor;
-import org.mockito.hamcrest.MockitoHamcrest;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_ERROR;
import static org.apache.maven.plugins.jarsigner.TestJavaToolResults.RESULT_OK;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
@@ -94,7 +91,7 @@ public class JarsignerVerifyMojoTest {
assertNull(request.getProviderClass());
assertNull(request.getProviderArg());
assertNull(request.getMaxMemory());
- assertThat(request.getArguments()[0], startsWith("-J-Dfile.encoding="));
+ assertTrue(request.getArguments()[0].startsWith("-J-Dfile.encoding="));
assertEquals(dummyMavenProjectDir, request.getWorkingDirectory());
assertEquals(mainArtifact.getFile(), request.getArchive());
assertFalse(request.isProtectedAuthenticationPath());
@@ -127,10 +124,10 @@ public class JarsignerVerifyMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(mojoException.getMessage(), containsString(String.valueOf(RESULT_ERROR.getExitCode())));
- assertThat(
- mojoException.getMessage(),
- containsString(RESULT_ERROR.getCommandline().toString()));
+ assertTrue(mojoException.getMessage().contains(String.valueOf(RESULT_ERROR.getExitCode())));
+ assertTrue(mojoException
+ .getMessage()
+ .contains(RESULT_ERROR.getCommandline().toString()));
}
/** When setting errorWhenNotSigned, for file that has existing signing (should not fail) */
@@ -146,7 +143,7 @@ public class JarsignerVerifyMojoTest {
mojo.execute();
- verify(jarSigner).execute(MockitoHamcrest.argThat(RequestMatchers.hasFileName("my-project.jar")));
+ verify(jarSigner).execute(argThat(RequestMatchers.hasFileName("my-project.jar")));
}
/** When setting errorWhenNotSigned, for file that does not have existing signing (should fail) */
@@ -162,8 +159,6 @@ public class JarsignerVerifyMojoTest {
MojoExecutionException mojoException = assertThrows(MojoExecutionException.class, () -> {
mojo.execute();
});
- assertThat(
- mojoException.getMessage(),
- containsString(mainArtifact.getFile().getPath()));
+ assertTrue(mojoException.getMessage().contains(mainArtifact.getFile().getPath()));
}
}
diff --git a/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java b/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java
index be53d11..6334f9a 100644
--- a/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java
+++ b/src/test/java/org/apache/maven/plugins/jarsigner/RequestMatchers.java
@@ -24,17 +24,16 @@ import java.util.function.Predicate;
import org.apache.maven.shared.jarsigner.AbstractJarSignerRequest;
import org.apache.maven.shared.jarsigner.JarSignerSignRequest;
-import org.hamcrest.Description;
-import org.hamcrest.TypeSafeMatcher;
+import org.mockito.ArgumentMatcher;
/**
- * Hamcrest matcher(s) to match properties on a JarSignerRequest request instances
+ * Mockito {@link ArgumentMatcher} factories to match properties on a JarSignerRequest request instances
*/
class RequestMatchers {
/** Matcher for parameters common for JarSignerRequest instances */
private static class AbstractJarSignerRequestMatcher<T extends AbstractJarSignerRequest>
- extends TypeSafeMatcher<T> {
+ implements ArgumentMatcher<T> {
private final String predicateDescription;
private final Object value;
private final Predicate<AbstractJarSignerRequest> predicate;
@@ -47,21 +46,18 @@ class RequestMatchers {
}
@Override
- protected boolean matchesSafely(AbstractJarSignerRequest request) {
+ public boolean matches(T request) {
return predicate.test(request);
}
@Override
- public void describeTo(Description description) {
- description
- .appendText("request that ")
- .appendText(predicateDescription)
- .appendValue(value);
+ public String toString() {
+ return "request that " + predicateDescription + value;
}
}
/** Matcher for parameters specific to JarSignerSignRequest instances */
- private static class JarSignerSignRequestMatcher extends TypeSafeMatcher<JarSignerSignRequest> {
+ private static class JarSignerSignRequestMatcher implements ArgumentMatcher<JarSignerSignRequest> {
private final String predicateDescription;
private final Object value;
private final Predicate<JarSignerSignRequest> predicate;
@@ -74,33 +70,30 @@ class RequestMatchers {
}
@Override
- protected boolean matchesSafely(JarSignerSignRequest request) {
+ public boolean matches(JarSignerSignRequest request) {
return predicate.test(request);
}
@Override
- public void describeTo(Description description) {
- description
- .appendText("request that ")
- .appendText(predicateDescription)
- .appendValue(value);
+ public String toString() {
+ return "request that " + predicateDescription + value;
}
}
/** Create a matcher that matches when the request is using a specific file name for the archive */
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasFileName(String expectedFileName) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasFileName(String expectedFileName) {
return new AbstractJarSignerRequestMatcher<T>(
"has archive file name ",
expectedFileName,
request -> request.getArchive().getPath().endsWith(expectedFileName));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasAlias(String alias) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasAlias(String alias) {
return new AbstractJarSignerRequestMatcher<T>(
"has alias ", alias, request -> request.getAlias().equals(alias));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasArguments(String[] arguments) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasArguments(String[] arguments) {
return new AbstractJarSignerRequestMatcher<T>("has arguments ", arguments, request -> {
List<String> haystack = Arrays.asList(request.getArguments());
for (String argumentNeedle : arguments) {
@@ -112,17 +105,17 @@ class RequestMatchers {
});
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasKeystore(String keystore) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasKeystore(String keystore) {
return new AbstractJarSignerRequestMatcher<T>(
"has keystore ", keystore, request -> request.getKeystore().equals(keystore));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasMaxMemory(String maxMemory) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasMaxMemory(String maxMemory) {
return new AbstractJarSignerRequestMatcher<T>(
"has maxMemory ", maxMemory, request -> request.getMaxMemory().equals(maxMemory));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProtectedAuthenticationPath(
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProtectedAuthenticationPath(
boolean protectedAuthenticationPath) {
return new AbstractJarSignerRequestMatcher<T>(
"has protectedAuthenticationPath ",
@@ -130,79 +123,79 @@ class RequestMatchers {
request -> request.isProtectedAuthenticationPath() == protectedAuthenticationPath);
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProviderArg(String providerArg) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProviderArg(String providerArg) {
return new AbstractJarSignerRequestMatcher<T>(
"has providerArg ",
providerArg,
request -> request.getProviderArg().equals(providerArg));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProviderClass(String providerClass) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProviderClass(String providerClass) {
return new AbstractJarSignerRequestMatcher<T>(
"has providerClass ",
providerClass,
request -> request.getProviderClass().equals(providerClass));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasProviderName(String providerName) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasProviderName(String providerName) {
return new AbstractJarSignerRequestMatcher<T>(
"has providerName ",
providerName,
request -> request.getProviderName().equals(providerName));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasStorepass(String storepass) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasStorepass(String storepass) {
return new AbstractJarSignerRequestMatcher<T>(
"has storepass ", storepass, request -> request.getStorepass().equals(storepass));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasStoretype(String storetype) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasStoretype(String storetype) {
return new AbstractJarSignerRequestMatcher<T>(
"has storetype ", storetype, request -> request.getStoretype().equals(storetype));
}
- static <T extends AbstractJarSignerRequest> TypeSafeMatcher<T> hasVerbose(boolean verbose) {
+ static <T extends AbstractJarSignerRequest> ArgumentMatcher<T> hasVerbose(boolean verbose) {
return new AbstractJarSignerRequestMatcher<T>(
"has verbose ", verbose, request -> request.isVerbose() == verbose);
}
/* ************************************ JarSignerSignRequest specific matchers ************************************/
- static TypeSafeMatcher<JarSignerSignRequest> hasKeypass(String keypass) {
+ static ArgumentMatcher<JarSignerSignRequest> hasKeypass(String keypass) {
return new JarSignerSignRequestMatcher(
"has keypass ", keypass, request -> request.getKeypass().equals(keypass));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasSigfile(String sigfile) {
+ static ArgumentMatcher<JarSignerSignRequest> hasSigfile(String sigfile) {
return new JarSignerSignRequestMatcher(
"has sigfile ", sigfile, request -> request.getSigfile().equals(sigfile));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsa(String tsa) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsa(String tsa) {
return new JarSignerSignRequestMatcher(
"has tsa ", tsa, request -> request.getTsaLocation().equals(tsa));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsacert(String tsacert) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsacert(String tsacert) {
return new JarSignerSignRequestMatcher(
"has tsacert ", tsacert, request -> request.getTsaAlias().equals(tsacert));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsaPolicyid(String tsapolicyid) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsaPolicyid(String tsapolicyid) {
return new JarSignerSignRequestMatcher(
"has tsapolicyid ",
tsapolicyid,
request -> request.getTsapolicyid().equals(tsapolicyid));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasTsaDigestalg(String tsadigestalg) {
+ static ArgumentMatcher<JarSignerSignRequest> hasTsaDigestalg(String tsadigestalg) {
return new JarSignerSignRequestMatcher(
"has tsadigestalg ",
tsadigestalg,
request -> request.getTsadigestalg().equals(tsadigestalg));
}
- static TypeSafeMatcher<JarSignerSignRequest> hasCertchain(String certchain) {
+ static ArgumentMatcher<JarSignerSignRequest> hasCertchain(String certchain) {
return new JarSignerSignRequestMatcher(
"has certchain ",
certchain,