Rename isValidBase64 to isBase64

Related to assertj#1805.

Author: scordio

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

@@ -224,22 +224,22 @@ public SELF isStrictlyBetween(String startExclusive, String endExclusive) {
    * <p>
    * Examples:
    * <pre><code class='java'> // assertion succeeds
-   * assertThat(&quot;QXNzZXJ0Sg==&quot;).isValidBase64();
+   * assertThat(&quot;QXNzZXJ0Sg==&quot;).isBase64();
    *
    * // assertion succeeds even without padding as it is optional by specification
-   * assertThat(&quot;QXNzZXJ0Sg&quot;).isValidBase64();
+   * assertThat(&quot;QXNzZXJ0Sg&quot;).isBase64();
    *
    * // assertion fails as it has invalid Base64 characters
-   * assertThat(&quot;inv@lid&quot;).isValidBase64();</code></pre>
+   * assertThat(&quot;inv@lid&quot;).isBase64();</code></pre>
    *
    * @return this assertion object.
    * @throws AssertionError if the actual value is {@code null}.
    * @throws AssertionError if the actual value is not a valid Base64 encoded string.
    *
    * @since 3.16.0
    */
-  public SELF isValidBase64() {
-    strings.assertIsValidBase64(info, actual);
+  public SELF isBase64() {
+    strings.assertIsBase64(info, actual);
     return myself;
   }
 
@@ -264,7 +264,7 @@ public SELF isValidBase64() {
    */
   @CheckReturnValue
   public AbstractByteArrayAssert<?> decodedAsBase64() {
-    strings.assertIsValidBase64(info, actual);
+    strings.assertIsBase64(info, actual);
     return new ByteArrayAssert(Base64.getDecoder().decode(actual)).withAssertionState(myself);
   }
 

src/main/java/org/assertj/core/error/ShouldBeValidBase64.java renamed to src/main/java/org/assertj/core/error/ShouldBeBase64.java

@@ -17,18 +17,18 @@
  * 
  * @author Stefano Cordio
  */
-public class ShouldBeValidBase64 extends BasicErrorMessageFactory {
+public class ShouldBeBase64 extends BasicErrorMessageFactory {
 
   /**
-   * Creates a new <code>{@link ShouldBeValidBase64}</code>.
+   * Creates a new <code>{@link ShouldBeBase64}</code>.
    * @param actual the actual value in the failed assertion.
    * @return the created {@code ErrorMessageFactory}.
    */
-  public static ErrorMessageFactory shouldBeValidBase64(String actual) {
-    return new ShouldBeValidBase64(actual);
+  public static ErrorMessageFactory shouldBeBase64(String actual) {
+    return new ShouldBeBase64(actual);
   }
 
-  private ShouldBeValidBase64(String actual) {
+  private ShouldBeBase64(String actual) {
     super("%nExpecting <%s> to be a valid Base64 encoded string", actual);
   }
 

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

@@ -18,7 +18,7 @@
 import static java.util.Arrays.stream;
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.toCollection;
-import static org.assertj.core.error.ShouldBeValidBase64.shouldBeValidBase64;
+import static org.assertj.core.error.ShouldBeBase64.shouldBeBase64;
 import static org.assertj.core.error.ShouldBeBlank.shouldBeBlank;
 import static org.assertj.core.error.ShouldBeEmpty.shouldBeEmpty;
 import static org.assertj.core.error.ShouldBeEqual.shouldBeEqual;
@@ -1132,12 +1132,12 @@ public void assertUpperCase(AssertionInfo info, CharSequence actual) {
    * @throws AssertionError if {@code actual} is {@code null}.
    * @throws AssertionError if {@code actual} is not a valid Base64 encoded string.
    */
-  public void assertIsValidBase64(AssertionInfo info, String actual) {
+  public void assertIsBase64(AssertionInfo info, String actual) {
     assertNotNull(info, actual);
     try {
       Base64.getDecoder().decode(actual);
     } catch (IllegalArgumentException e) {
-      throw failures.failure(info, shouldBeValidBase64(actual));
+      throw failures.failure(info, shouldBeBase64(actual));
     }
   }
 

src/test/java/org/assertj/core/api/string_/StringAssert_decodedAsBase64_Test.java

@@ -39,7 +39,7 @@ protected StringAssert invoke_api_method() {
 
   @Override
   protected void verify_internal_effects() {
-    verify(strings).assertIsValidBase64(getInfo(assertions), getActual(assertions));
+    verify(strings).assertIsBase64(getInfo(assertions), getActual(assertions));
   }
 
   @Override

src/test/java/org/assertj/core/api/string_/StringAssert_isValidBase64_Test.java renamed to src/test/java/org/assertj/core/api/string_/StringAssert_isBase64_Test.java

@@ -19,21 +19,21 @@
 import org.junit.jupiter.api.DisplayName;
 
 /**
- * Tests for <code>{@link StringAssert#isValidBase64()}</code>.
+ * Tests for <code>{@link StringAssert#isBase64()}</code>.
  *
  * @author Stefano Cordio
  */
-@DisplayName("StringAssert isValidBase64")
-class StringAssert_isValidBase64_Test extends StringAssertBaseTest {
+@DisplayName("StringAssert isBase64")
+class StringAssert_isBase64_Test extends StringAssertBaseTest {
 
   @Override
   protected StringAssert invoke_api_method() {
-    return assertions.isValidBase64();
+    return assertions.isBase64();
   }
 
   @Override
   protected void verify_internal_effects() {
-    verify(strings).assertIsValidBase64(getInfo(assertions), getActual(assertions));
+    verify(strings).assertIsBase64(getInfo(assertions), getActual(assertions));
   }
 
 }

src/test/java/org/assertj/core/error/ShouldBeValidBase64_create_Test.java renamed to src/test/java/org/assertj/core/error/ShouldBeBase64_create_Test.java

@@ -14,7 +14,7 @@
 
 import static java.lang.String.format;
 import static org.assertj.core.api.BDDAssertions.then;
-import static org.assertj.core.error.ShouldBeValidBase64.shouldBeValidBase64;
+import static org.assertj.core.error.ShouldBeBase64.shouldBeBase64;
 import static org.assertj.core.presentation.StandardRepresentation.STANDARD_REPRESENTATION;
 
 import org.assertj.core.description.Description;
@@ -24,17 +24,17 @@
 import org.junit.jupiter.api.Test;
 
 /**
- * Tests for <code>{@link ShouldHaveNoSuperclass#create(Description, Representation)}</code>.
+ * Tests for <code>{@link ShouldBeBase64#create(Description, Representation)}</code>.
  *
  * @author Stefano Cordio
  */
-@DisplayName("ShouldBeValidBase64 create")
-class ShouldBeValidBase64_create_Test {
+@DisplayName("ShouldBeBase64 create")
+class ShouldBeBase64_create_Test {
 
   @Test
   void should_create_error_message() {
     // WHEN
-    String message = shouldBeValidBase64("string %s").create(new TestDescription("TEST"), STANDARD_REPRESENTATION);
+    String message = shouldBeBase64("string %s").create(new TestDescription("TEST"), STANDARD_REPRESENTATION);
     // THEN
     then(message).isEqualTo(format("[TEST] %nExpecting <\"string %%s\"> to be a valid Base64 encoded string"));
   }

src/test/java/org/assertj/core/internal/strings/Strings_assertIsValidBase64_Test.java renamed to src/test/java/org/assertj/core/internal/strings/Strings_assertIsBase64_Test.java

@@ -13,7 +13,7 @@
 package org.assertj.core.internal.strings;
 
 import static org.assertj.core.api.BDDAssertions.then;
-import static org.assertj.core.error.ShouldBeValidBase64.shouldBeValidBase64;
+import static org.assertj.core.error.ShouldBeBase64.shouldBeBase64;
 import static org.assertj.core.test.TestData.someInfo;
 import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
@@ -22,15 +22,15 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-@DisplayName("Strings assertIsValidBase64")
-class Strings_assertIsValidBase64_Test extends StringsBaseTest {
+@DisplayName("Strings assertIsBase64")
+class Strings_assertIsBase64_Test extends StringsBaseTest {
 
   @Test
   void should_fail_if_actual_is_null() {
     // GIVEN
     String actual = null;
     // WHEN
-    AssertionError assertionError = expectAssertionError(() -> strings.assertIsValidBase64(someInfo(), actual));
+    AssertionError assertionError = expectAssertionError(() -> strings.assertIsBase64(someInfo(), actual));
     // THEN
     then(assertionError).hasMessage(actualIsNull());
   }
@@ -40,25 +40,25 @@ void should_fail_if_actual_has_invalid_Base64_characters() {
     // GIVEN
     String actual = "inv@lid";
     // WHEN
-    AssertionError assertionError = expectAssertionError(() -> strings.assertIsValidBase64(someInfo(), actual));
+    AssertionError assertionError = expectAssertionError(() -> strings.assertIsBase64(someInfo(), actual));
     // THEN
-    then(assertionError).hasMessage(shouldBeValidBase64(actual).create());
+    then(assertionError).hasMessage(shouldBeBase64(actual).create());
   }
 
   @Test
   void should_succeeds_if_actual_is_Base64_encoded_with_padding() {
     // GIVEN
     String actual = "QXNzZXJ0Sg==";
     // WHEN/THEN
-    strings.assertIsValidBase64(someInfo(), actual);
+    strings.assertIsBase64(someInfo(), actual);
   }
 
   @Test
   void should_succeeds_if_actual_is_Base64_encoded_without_padding() {
     // GIVEN
     String actual = "QXNzZXJ0Sg";
     // WHEN/THEN
-    strings.assertIsValidBase64(someInfo(), actual);
+    strings.assertIsBase64(someInfo(), actual);
   }
 
 }