Add test for XML transformer

src/main/java/net/datafaker/transformations/XmlTransformer.java

@@ -5,6 +5,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.StringJoiner;
 
 import net.datafaker.sequence.FakeSequence;
 
@@ -28,6 +29,46 @@ public CharSequence apply(IN input, Schema<IN, ?> schema) {
         return sb.toString();
     }
 
+    @Override
+    public String generate(FakeSequence<IN> input, Schema<IN, ?> schema) {
+        if (input.isInfinite()) {
+            throw new IllegalArgumentException("The sequence should be finite of size");
+        }
+
+        StringJoiner data = new StringJoiner(LINE_SEPARATOR);
+        for (IN in : input) {
+            data.add(apply(in, schema));
+        }
+
+        return data.toString();
+    }
+
+    @Override
+    public CharSequence generate(Schema<IN, ?> schema, int limit) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < limit; i++) {
+            sb.append(apply(null, schema));
+            if (i < limit - 1) {
+                sb.append(LINE_SEPARATOR);
+            }
+        }
+        return sb.toString();
+    }
+
+    public static class XmlTransformerBuilder<IN> {
+
+        private boolean pretty= false;
+
+        public XmlTransformer.XmlTransformerBuilder<IN> pretty(boolean pretty) {
+            this.pretty = pretty;
+            return this;
+        }
+
+        public XmlTransformer<IN> build() {
+            return new XmlTransformer<>(pretty);
+        }
+    }
+
     private void apply(IN input, StringBuilder sb, Field<IN, ?> xmlNode) {
 
         if (pretty && tagIndex > 0) {
@@ -104,37 +145,6 @@ private void applyValue(StringBuilder sb, String tag, String xmlNodeValue) {
         }
     }
 
-    @Override
-    public CharSequence generate(FakeSequence<IN> input, Schema<IN, ?> schema) {
-        return null;
-    }
-
-    @Override
-    public CharSequence generate(Schema<IN, ?> schema, int limit) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < limit; i++) {
-            sb.append(apply(null, schema));
-            if (i < limit - 1) {
-                sb.append(LINE_SEPARATOR);
-            }
-        }
-        return sb.toString();
-    }
-
-    public static class XmlTransformerBuilder<IN> {
-
-        private boolean pretty= false;
-
-        public XmlTransformer.XmlTransformerBuilder<IN> pretty(boolean pretty) {
-            this.pretty = pretty;
-            return this;
-        }
-
-        public XmlTransformer<IN> build() {
-            return new XmlTransformer<>(pretty);
-        }
-    }
-
     private String offset(int length) {
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < length * INDENTATION_STEP; i++) {

src/test/java/net/datafaker/formats/XmlTest.java

@@ -1,8 +1,11 @@
 package net.datafaker.formats;
 
+import net.datafaker.providers.base.BaseFaker;
+import net.datafaker.providers.base.Name;
 import net.datafaker.transformations.Field;
 import net.datafaker.transformations.Schema;
 import net.datafaker.transformations.XmlTransformer;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -23,8 +26,8 @@ class XmlTest {
     @ParameterizedTest
     @MethodSource("generateTestXmlSchema")
     void xmlSchemaTest(Schema<String, String> schema, String expected) {
-        XmlTransformer<String> xml = new XmlTransformer.XmlTransformerBuilder<String>().build();
-        assertThat(xml.generate(schema, 1)).isEqualTo(expected);
+        XmlTransformer<String> xmlTransformer = new XmlTransformer.XmlTransformerBuilder<String>().build();
+        assertThat(xmlTransformer.generate(schema, 1)).isEqualTo(expected);
     }
 
     private static Stream<Arguments> generateTestXmlSchema() {
@@ -51,8 +54,8 @@ private static Stream<Arguments> generateTestXmlSchema() {
     @ParameterizedTest
     @MethodSource("generateTestXmlPrettySchema")
     void xmlPrettySchemaTest(Schema<String, String> schema, String expected) {
-        XmlTransformer<String> xml = new XmlTransformer.XmlTransformerBuilder<String>().pretty(true).build();
-        assertThat(xml.generate(schema, 1)).isEqualTo(expected);
+        XmlTransformer<String> xmlTransformer = new XmlTransformer.XmlTransformerBuilder<String>().pretty(true).build();
+        assertThat(xmlTransformer.generate(schema, 1)).isEqualTo(expected);
     }
 
     private static Stream<Arguments> generateTestXmlPrettySchema() {
@@ -76,6 +79,27 @@ private static Stream<Arguments> generateTestXmlPrettySchema() {
         );
     }
 
+    @Test
+    void generateFromFakeSequence() {
+        final BaseFaker faker = new BaseFaker();
+        Schema<Name, String> schema = Schema.of(field("firstName", Name::firstName));
+
+        XmlTransformer<Name> transformer = new XmlTransformer.XmlTransformerBuilder<Name>().build();
+
+        String xml = transformer.generate(
+            faker.<Name>collection().suppliers(faker::name).maxLen(3).build(),
+            schema);
+
+        int numberOfLines = 1;
+        for (int i = 0; i < xml.length(); i++) {
+            if (xml.regionMatches(i, System.lineSeparator(), 0, System.lineSeparator().length())) {
+                numberOfLines++;
+            }
+        }
+
+        assertThat(numberOfLines).isEqualTo(3);
+    }
+
     @ParameterizedTest
     @MethodSource("generateTestXmlPretty")
     void xmlPrettyTest(Xml.XmlNode xmlNode, String expected) {