improve image asserts

in addition to just "data:*base64" prefix, also

1. check image size
2. verify that the base64 part is a valid parseable  image data
3. validate XML format in case of SVG images

Author: asolntsev

src/main/java/net/datafaker/providers/base/Image.java

@@ -2,14 +2,15 @@
 
 
 import javax.imageio.ImageIO;
-import java.awt.Color;
 import java.awt.*;
+import java.awt.Color;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.Base64;
 
 import static java.awt.Color.WHITE;
+import static java.util.Objects.requireNonNull;
 import static net.datafaker.providers.base.Image.ImageType.BMP;
 import static net.datafaker.providers.base.Image.ImageType.GIF;
 import static net.datafaker.providers.base.Image.ImageType.JPEG;
@@ -106,11 +107,7 @@ public Base64ImageRuleConfig build() {
         }
 
         public ImageBuilder type(ImageType imageType) {
-            if(imageType == null) {
-                throw new IllegalArgumentException("Type cannot be null");
-            }
-
-            this.imageType = imageType;
+            this.imageType = requireNonNull(imageType, "Image type cannot be null");
             return this;
         }
 

src/test/java/net/datafaker/assertions/ImageAssert.java

@@ -0,0 +1,87 @@
+package net.datafaker.assertions;
+
+import net.datafaker.providers.base.Image.ImageType;
+import org.assertj.core.api.AbstractAssert;
+import org.opentest4j.AssertionFailedError;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import javax.imageio.ImageIO;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Base64;
+import java.util.regex.Pattern;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ImageAssert extends AbstractAssert<ImageAssert, ImageData> {
+    private static final Pattern RE = Pattern.compile("data:image/.+;base64,(.+)");
+
+    ImageAssert(ImageData actual) {
+        super(actual, ImageAssert.class);
+    }
+
+    public ImageAssert is(ImageType type, int width, int height) {
+        assertImageDataUrl(type);
+        return switch (type) {
+            case SVG -> verifySvg(actual, width, height);
+            case BMP, GIF, JPEG, PNG, TIFF -> verifyImage(actual, width, height);
+        };
+    }
+
+    private void assertImageDataUrl(ImageType type) {
+        String prefix = "data:%s;base64,".formatted(type.getMimeType());
+
+        if (!actual.url().startsWith(prefix)) {
+            String message = "Expected image data URL starting with \"%s\", but received: \"%s\"".formatted(prefix, actual.url());
+            throw new AssertionFailedError(message, prefix, actual.url());
+        }
+
+        assertThat(actual.url().substring(actual.url().indexOf(",") + 1))
+            .isNotBlank()
+            .isBase64();
+    }
+
+    private ImageAssert verifyImage(ImageData image, int width, int height) {
+        String content = RE.matcher(image.url()).replaceFirst("$1");
+        byte[] bytes = Base64.getDecoder().decode(content);
+        try (InputStream in = new ByteArrayInputStream(bytes)) {
+            BufferedImage i = ImageIO.read(in);
+            assertThat(i.getWidth()).isEqualTo(width);
+            assertThat(i.getHeight()).isEqualTo(height);
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to parse image " + image.url(), e);
+        }
+        return this;
+    }
+
+    private ImageAssert verifySvg(ImageData image, int width, int height) {
+        String content = RE.matcher(image.url()).replaceFirst("$1");
+        byte[] bytes = Base64.getDecoder().decode(content);
+        try {
+            String xml = new String(bytes);
+            assertThat(xml).matches("<svg xmlns=\".+\" width=\"256\" height=\"256\">.*");
+
+            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+            Document doc = builder.parse(new ByteArrayInputStream(bytes));
+            NodeList childNodes = doc.getChildNodes();
+            assertThat(childNodes.getLength()).isEqualTo(1);
+
+            Node svg = childNodes.item(0);
+            assertThat(svg.getNodeName()).isEqualTo("svg");
+
+            int boxSize = width / 8;
+            int rectCount = (width / boxSize) * (height / boxSize);
+            assertThat(svg.getChildNodes().getLength()).isEqualTo(rectCount);
+            assertThat(svg.getChildNodes().item(0).getNodeName()).isEqualTo("rect");
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to parse image " + image.url(), e);
+        }
+        return this;
+    }
+}

src/test/java/net/datafaker/assertions/ImageAssertions.java

@@ -0,0 +1,14 @@
+package net.datafaker.assertions;
+
+import org.assertj.core.api.Assertions;
+
+public class ImageAssertions extends Assertions {
+    public static ImageAssert assertThatImage(String imageDataUrl) {
+        return assertThat(new ImageData(imageDataUrl));
+    }
+
+    public static ImageAssert assertThat(ImageData actual) {
+        return new ImageAssert(actual);
+    }
+}
+

src/test/java/net/datafaker/assertions/ImageData.java

@@ -0,0 +1,4 @@
+package net.datafaker.assertions;
+
+public record ImageData(String url) {
+}

src/test/java/net/datafaker/providers/base/ImageTest.java

@@ -6,83 +6,85 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.EnumSource;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static net.datafaker.assertions.ImageAssertions.assertThatImage;
+import static net.datafaker.providers.base.Image.ImageType.BMP;
+import static net.datafaker.providers.base.Image.ImageType.GIF;
+import static net.datafaker.providers.base.Image.ImageType.JPEG;
+import static net.datafaker.providers.base.Image.ImageType.PNG;
+import static net.datafaker.providers.base.Image.ImageType.SVG;
+import static net.datafaker.providers.base.Image.ImageType.TIFF;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 
 class ImageTest {
     private final Faker faker = new Faker();
 
     @Test
     void bmp() {
-        assertThat(faker.image().base64BMP()).startsWith("data:image/bmp;base64,");
+        assertThatImage(faker.image().base64BMP()).is(BMP, 256, 256);
     }
 
     @Test
     void gif() {
-        assertThat(faker.image().base64GIF()).startsWith("data:image/gif;base64,");
+        assertThatImage(faker.image().base64GIF()).is(GIF, 256, 256);
     }
 
     @Test
     void png() {
-        assertThat(faker.image().base64PNG()).startsWith("data:image/png;base64,");
+        assertThatImage(faker.image().base64PNG()).is(PNG, 256, 256);
     }
 
     @Test
     void jpg() {
-        assertThat(faker.image().base64JPG()).startsWith("data:image/jpeg;base64,");
+        assertThatImage(faker.image().base64JPG()).is(JPEG, 256, 256);
     }
 
     @Test
     void jpeg() {
-        assertThat(faker.image().base64JPEG()).startsWith("data:image/jpeg;base64,");
+        assertThatImage(faker.image().base64JPEG()).is(JPEG, 256, 256);
     }
 
     @Test
     void svg() {
-        assertThat(faker.image().base64SVG()).startsWith("data:image/svg+xml;base64,");
+        assertThatImage(faker.image().base64SVG()).is(SVG, 256, 256);
     }
 
     @Test
     void tiff() {
-        assertThat(faker.image().base64TIFF()).startsWith("data:image/tiff;base64,");
+        assertThatImage(faker.image().base64TIFF()).is(TIFF, 256, 256);
     }
 
     @ParameterizedTest
     @EnumSource(ImageType.class)
     void base64(ImageType imageType) {
         String base64Image = faker.image().base64(new Image.Base64ImageRuleConfig(imageType, 1000, 1000));
 
-        assertThat(base64Image)
-            .startsWith("data:" + imageType.getMimeType() + ";base64,");
-        assertThat(base64Image.substring(base64Image.indexOf(",") + 1))
-            .isNotBlank()
-            .isBase64();
+        assertThatImage(base64Image).is(imageType, 1000, 1000);
     }
 
     @Test
-    void defaultBuilder() {
-        String image = faker.image().base64(Image.ImageBuilder.builder()
-            .build());
-        assertThat(image).startsWith("data:image/");
+    void defaultBuilder_generatesPngImage() {
+        String image = faker.image().base64(Image.ImageBuilder.builder().build());
+        assertThatImage(image).is(PNG, 256, 256);
     }
 
     @Test
     void customBase64builder() {
         String gif = faker.image().base64(Image.ImageBuilder.builder()
             .type(ImageType.GIF)
             .build());
-        assertThat(gif).startsWith("data:image/gif;base64,");
+        assertThatImage(gif).is(GIF, 256, 256);
     }
 
     @Test
     void tinyBase64builder() {
         String tiny = faker.image().base64(Image.ImageBuilder.builder()
             .height(1)
             .width(1)
-            .type(ImageType.PNG)
+            .type(PNG)
             .build());
 
-        assertThat(tiny).startsWith("data:image/png;base64,");
+        assertThatImage(tiny).is(PNG, 1, 1);
     }
 
     @Test
@@ -92,12 +94,12 @@ void largeBase64builder() {
             .width(2000)
             .type(ImageType.BMP)
             .build());
-        assertThat(large).startsWith("data:image/bmp;base64,");
+        assertThatImage(large).is(BMP, 2000, 1000);
     }
 
     @Test
     void shouldErrorOnIllegalType() {
-        assertThatIllegalArgumentException().isThrownBy(() -> Image.ImageBuilder.builder().type(null).build());
+        assertThatExceptionOfType(NullPointerException.class).isThrownBy(() -> Image.ImageBuilder.builder().type(null).build());
     }
 
     @Test