Merge pull request #1453 from apache/revert-1452-assert-j-best-practices

Revert "Refactor: AssertJ best practices by @timtebeek"
apache · May 3, 2024 · b382553 · b382553
2 parents bb0078f + b95f118
commit b382553
Show file tree

Hide file tree

Showing 104 changed files with 1,624 additions and 1,551 deletions.
diff --git a/core/src/test/java/org/apache/shiro/SecurityUtilsUnwrapTest.java b/core/src/test/java/org/apache/shiro/SecurityUtilsUnwrapTest.java
@@ -34,10 +34,9 @@
 import static org.apache.shiro.SecurityUtils.getSecurityManager;
 import static org.apache.shiro.SecurityUtils.isSecurityManagerTypeOf;
 import static org.apache.shiro.SecurityUtils.unwrapSecurityManager;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -79,73 +78,73 @@ public <SM extends SecurityManager> SM unwrap() {
     @Test
     void basicUnwrap() {
         SecurityManager sm = unwrapSecurityManager(securityManager, SecurityManager.class);
-        assertThat(sm).isEqualTo(securityManager);
+        assertEquals(securityManager, sm);
     }
 
     @Test
     void basicTypeCheck() {
-        assertThat(isSecurityManagerTypeOf(securityManager, SecurityManager.class)).isTrue();
+        assertTrue(isSecurityManagerTypeOf(securityManager, SecurityManager.class));
     }
 
     @Test
     void securityManager() {
         try (var threadContext = mockStatic(ThreadContext.class)) {
             threadContext.when(ThreadContext::getSecurityManager).thenReturn(defaultSecurityManager);
             DefaultSecurityManager dsm = getSecurityManager(DefaultSecurityManager.class);
-            assertThat(dsm).isEqualTo(defaultSecurityManager);
+            assertEquals(defaultSecurityManager, dsm);
         }
     }
 
     @Test
     void failedTypeUnwrap() {
-        assertThatExceptionOfType(ClassCastException.class).isThrownBy(() -> {
+        assertThrows(ClassCastException.class, () -> {
             SessionsSecurityManager ssm = unwrapSecurityManager(securityManager, SessionsSecurityManager.class);
         });
     }
 
     @Test
     void defaultSecurityManager() {
         var dsm = unwrapSecurityManager(defaultSecurityManager, DefaultSecurityManager.class);
-        assertThat(dsm).isEqualTo(defaultSecurityManager);
+        assertEquals(defaultSecurityManager, dsm);
         when(defaultSecurityManager.createSubject(subjectContext)).thenReturn(subject);
         Subject subject = dsm.createSubject(subjectContext);
-        assertThat(subject).isEqualTo(this.subject);
+        assertEquals(this.subject, subject);
         verify(defaultSecurityManager).createSubject(subjectContext);
         verifyNoMoreInteractions(defaultSecurityManager, this.subject, subjectContext);
     }
 
     @Test
     void invalidCast() {
         SecurityManager wrapped = new Wrapped(defaultSecurityManager);
-        assertThatExceptionOfType(ClassCastException.class).isThrownBy(() -> {
+        assertThrows(ClassCastException.class, () -> {
             DefaultSecurityManager sm = (DefaultSecurityManager) wrapped;
         });
     }
 
     @Test
     void unwrapOne() {
         SecurityManager wrapped = new Wrapped(defaultSecurityManager);
-        assertThat(unwrapSecurityManager(wrapped, DefaultSecurityManager.class)).isEqualTo(defaultSecurityManager);
+        assertEquals(defaultSecurityManager, unwrapSecurityManager(wrapped, DefaultSecurityManager.class));
     }
 
     @Test
     void unwrapTwo() {
         SecurityManager wrapped = new Wrapped(new Wrapped(defaultSecurityManager));
-        assertThat(unwrapSecurityManager(wrapped, DefaultSecurityManager.class)).isEqualTo(defaultSecurityManager);
+        assertEquals(defaultSecurityManager, unwrapSecurityManager(wrapped, DefaultSecurityManager.class));
     }
 
     @Test
     void invalidWrap() {
         SecurityManager wrapped = new Wrapped(new InvalidWrapped(defaultSecurityManager));
-        assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> {
+        assertThrows(IllegalStateException.class, () -> {
             assertEquals(defaultSecurityManager, unwrapSecurityManager(wrapped, DefaultSecurityManager.class));
         });
     }
 
     @Test
     void invalidWrapInverted() {
         SecurityManager wrapped = new InvalidWrapped(new Wrapped(defaultSecurityManager));
-        assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> {
+        assertThrows(IllegalStateException.class, () -> {
             assertEquals(defaultSecurityManager, unwrapSecurityManager(wrapped, DefaultSecurityManager.class));
         });
     }

diff --git a/core/src/test/java/org/apache/shiro/aop/AnnotationResolverTest.java b/core/src/test/java/org/apache/shiro/aop/AnnotationResolverTest.java
@@ -18,10 +18,11 @@
  */
 package org.apache.shiro.aop;
 
-import static org.assertj.core.api.Assertions.assertThat;
 import static org.easymock.EasyMock.createMock;
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.replay;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import java.lang.reflect.Method;
 
@@ -52,7 +53,7 @@ void testAnnotationFoundFromClass() throws SecurityException, NoSuchMethodExcept
         expect(methodInvocation.getMethod()).andReturn(method);
         expect(methodInvocation.getThis()).andReturn(myFixture);
         replay(methodInvocation);
-        assertThat(annotationResolver.getAnnotation(methodInvocation, RequiresRoles.class)).isNotNull();
+        assertNotNull(annotationResolver.getAnnotation(methodInvocation, RequiresRoles.class));
     }
 
     @Test
@@ -61,7 +62,7 @@ void testAnnotationFoundFromMethod() throws SecurityException, NoSuchMethodExcep
         Method method = MyFixture.class.getDeclaredMethod("operateThat");
         expect(methodInvocation.getMethod()).andReturn(method);
         replay(methodInvocation);
-        assertThat(annotationResolver.getAnnotation(methodInvocation, RequiresUser.class)).isNotNull();
+        assertNotNull(annotationResolver.getAnnotation(methodInvocation, RequiresUser.class));
     }
 
     @Test
@@ -71,7 +72,7 @@ void testNullMethodInvocation() throws SecurityException, NoSuchMethodException
         expect(methodInvocation.getMethod()).andReturn(method);
         expect(methodInvocation.getThis()).andReturn(null);
         replay(methodInvocation);
-        assertThat(annotationResolver.getAnnotation(methodInvocation, RequiresUser.class)).isNull();
+        assertNull(annotationResolver.getAnnotation(methodInvocation, RequiresUser.class));
     }
 }
 
diff --git a/core/src/test/java/org/apache/shiro/authc/AbstractAuthenticatorTest.java b/core/src/test/java/org/apache/shiro/authc/AbstractAuthenticatorTest.java
@@ -28,12 +28,14 @@
 
 import java.net.URI;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
 import static org.easymock.EasyMock.createMock;
 import static org.easymock.EasyMock.replay;
 import static org.easymock.EasyMock.verify;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * @since 0.1
@@ -96,7 +98,7 @@ protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws Au
      */
     @Test
     void authenticateWithNullArgument() {
-        assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> {
+        assertThrows(IllegalArgumentException.class, () -> {
             abstractAuthenticator.authenticate(null);
         });
     }
@@ -107,7 +109,7 @@ void authenticateWithNullArgument() {
      */
     @Test
     void throwAuthenticationExceptionIfDoAuthenticateReturnsNull() {
-        assertThatExceptionOfType(AuthenticationException.class).isThrownBy(() -> {
+        assertThrows(AuthenticationException.class, () -> {
             abstractAuthenticator = createAuthcReturnNull();
             abstractAuthenticator.authenticate(newToken());
         });
@@ -121,7 +123,7 @@ void throwAuthenticationExceptionIfDoAuthenticateReturnsNull() {
     @Test
     void nonNullAuthenticationInfoAfterAuthenticate() {
         AuthenticationInfo authcInfo = abstractAuthenticator.authenticate(newToken());
-        assertThat(authcInfo).isNotNull();
+        assertNotNull(authcInfo);
     }
 
     @Test
@@ -158,7 +160,7 @@ protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws Au
             abstractAuthenticator.authenticate(token);
         } catch (AuthenticationException e) {
             exceptionThrown = true;
-            assertThat(ae).isEqualTo(e);
+            assertEquals(e, ae);
         }
         verify(mockListener);
 
@@ -169,7 +171,7 @@ protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws Au
 
     @Test
     void notifyFailureAfterDoAuthenticateThrowsNonAuthenticationException() {
-        assertThatExceptionOfType(AuthenticationException.class).isThrownBy(() -> {
+        assertThrows(AuthenticationException.class, () -> {
             abstractAuthenticator = new AbstractAuthenticator() {
                 protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws AuthenticationException {
                     throw new IllegalArgumentException("not an AuthenticationException subclass");
@@ -200,8 +202,8 @@ protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws Au
         }
 
         String logMsg = String.join("\n", listAppender.getMessages());
-        assertThat(logMsg).contains("WARN");
-        assertThat(logMsg).contains("java.lang.IllegalArgumentException: " + expectedExceptionMessage);
+        assertTrue(logMsg.contains("WARN"));
+        assertTrue(logMsg.contains("java.lang.IllegalArgumentException: " + expectedExceptionMessage));
     }
 
 }
diff --git a/core/src/test/java/org/apache/shiro/authc/SimpleAuthenticationInfoTest.java b/core/src/test/java/org/apache/shiro/authc/SimpleAuthenticationInfoTest.java
@@ -25,10 +25,10 @@
 import java.util.Set;
 
 import org.apache.shiro.subject.PrincipalCollection;
-
-import static org.assertj.core.api.Assertions.assertThat;
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 
 /**
  * @since 0.9
@@ -106,7 +106,7 @@ public Iterator iterator() {
         aggregate.setPrincipals(principalCollection);
         SimpleAuthenticationInfo local = new SimpleAuthenticationInfo("username", "password", "testRealm");
         aggregate.merge(local);
-        assertThat(aggregate.getPrincipals().asList()).hasSize(2);
+        assertEquals(2, aggregate.getPrincipals().asList().size());
     }
 
 }
diff --git a/...src/test/java/org/apache/shiro/authc/credential/AbstractHashedCredentialsMatcherTest.java b/...src/test/java/org/apache/shiro/authc/credential/AbstractHashedCredentialsMatcherTest.java
@@ -20,15 +20,15 @@
 
 import org.apache.shiro.authc.AuthenticationInfo;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import org.apache.shiro.authc.AuthenticationToken;
 import org.apache.shiro.authc.SimpleAuthenticationInfo;
 import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.crypto.hash.SimpleHash;
 import org.apache.shiro.lang.util.ClassUtils;
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 /**
  * @since Jun 10, 2008 4:47:09 PM
  */
@@ -44,6 +44,6 @@ void testBasic() {
         byte[] hashed = hash("password").getBytes();
         AuthenticationInfo account = new SimpleAuthenticationInfo("username", hashed, "realmName");
         AuthenticationToken token = new UsernamePasswordToken("username", "password");
-        assertThat(matcher.doCredentialsMatch(token, account)).isTrue();
+        assertTrue(matcher.doCredentialsMatch(token, account));
     }
 }
diff --git a/core/src/test/java/org/apache/shiro/authc/credential/AllowAllCredentialsMatcherTest.java b/core/src/test/java/org/apache/shiro/authc/credential/AllowAllCredentialsMatcherTest.java
@@ -20,7 +20,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 
 /**
@@ -30,7 +30,7 @@ public class AllowAllCredentialsMatcherTest {
 
     @Test
     void testBasic() {
-        assertThat(new AllowAllCredentialsMatcher().doCredentialsMatch(null, null)).isTrue();
+        assertTrue(new AllowAllCredentialsMatcher().doCredentialsMatch(null, null));
     }
 
 }
diff --git a/core/src/test/java/org/apache/shiro/authc/credential/HashedCredentialsMatcherTest.java b/core/src/test/java/org/apache/shiro/authc/credential/HashedCredentialsMatcherTest.java
@@ -29,7 +29,7 @@
 import org.apache.shiro.subject.SimplePrincipalCollection;
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Tests for the {@link org.apache.shiro.authc.credential.HashedCredentialsMatcher} class.
@@ -54,7 +54,7 @@ void testSaltedAuthenticationInfo() {
         AuthenticationToken token = new UsernamePasswordToken("username", "password");
 
         //verify the hashed token matches what is in the account:
-        assertThat(matcher.doCredentialsMatch(token, account)).isTrue();
+        assertTrue(matcher.doCredentialsMatch(token, account));
     }
 
     /**
@@ -87,7 +87,7 @@ public Object getCredentials() {
         AuthenticationToken token = new UsernamePasswordToken("username", "password");
 
         //verify the hashed token matches what is in the account:
-        assertThat(matcher.doCredentialsMatch(token, account)).isTrue();
+        assertTrue(matcher.doCredentialsMatch(token, account));
     }
 
     /**
@@ -124,6 +124,6 @@ public Object getCredentials() {
         AuthenticationToken token = new UsernamePasswordToken("username", "password");
 
         //verify the hashed token matches what is in the account:
-        assertThat(matcher.doCredentialsMatch(token, account)).isTrue();
+        assertTrue(matcher.doCredentialsMatch(token, account));
     }
 }
diff --git a/core/src/test/java/org/apache/shiro/authc/pam/AllSuccessfulStrategyTest.java b/core/src/test/java/org/apache/shiro/authc/pam/AllSuccessfulStrategyTest.java
@@ -22,8 +22,8 @@
 import org.junit.jupiter.api.Test;
 import org.apache.shiro.authc.AuthenticationException;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.apache.shiro.authc.AuthenticationInfo;
 import org.apache.shiro.authc.AuthenticationToken;
@@ -46,7 +46,7 @@ public void setUp() {
     @Test
     void beforeAllAttempts() {
         AuthenticationInfo info = strategy.beforeAllAttempts(null, null);
-        assertThat(info).isNotNull();
+        assertNotNull(info);
     }
 
     @Test
@@ -56,7 +56,7 @@ void beforeAttemptSupportingToken() {
 
     @Test
     void beforeAttemptRealmDoesntSupportToken() {
-        assertThatExceptionOfType(UnsupportedTokenException.class).isThrownBy(() -> {
+        assertThrows(UnsupportedTokenException.class, () -> {
             Realm notSupportingRealm = new AuthorizingRealm() {
 
                 public boolean supports(AuthenticationToken token) {