CollectionProviders tests; added log config to tests.

api/src/main/groovy/com/jessebrault/ssg/provider/FileBasedCollectionProvider.groovy

@@ -36,7 +36,7 @@ final class FileBasedCollectionProvider<T> extends AbstractCollectionProvider<T>
             final Collection<T> ts = []
             this.baseDirectory.eachFileRecurse(FileType.FILES) {
                 def t = this.elementFunction.apply(it, PathUtil.relative(this.baseDirectory.path, it.path)) as T
-                if (t) {
+                if (t != null) {
                     ts << t
                 }
             }

api/src/test/groovy/com/jessebrault/ssg/provider/FileBasedCollectionProviderTests.groovy

@@ -0,0 +1,21 @@
+package com.jessebrault.ssg.provider
+
+final class FileBasedCollectionProviderTests extends AbstractCollectionProviderTests {
+
+    @Override
+    protected CollectionProvider<Integer> getCollectionProvider(Collection<Integer> ts) {
+        def baseDir = File.createTempDir()
+        new FileTreeBuilder(baseDir).tap {
+            ts.each {
+                file(it.toString(), '')
+            }
+        }
+        new FileBasedCollectionProvider<>(baseDir, { File file, String relativePath ->
+            logger.debug('file: {}, relativePath: {}', file, relativePath)
+            def r = Integer.valueOf(relativePath)
+            logger.debug('r: {}', r)
+            r
+        })
+    }
+
+}

api/src/test/groovy/com/jessebrault/ssg/provider/SimpleCollectionProviderTests.groovy

@@ -0,0 +1,10 @@
+package com.jessebrault.ssg.provider
+
+final class SimpleCollectionProviderTests extends AbstractCollectionProviderTests {
+
+    @Override
+    protected CollectionProvider<Integer> getCollectionProvider(Collection<Integer> ts) {
+        new SimpleCollectionProvider<>(ts)
+    }
+
+}

api/src/test/groovy/com/jessebrault/ssg/provider/SupplierBaseCollectionProviderTests.groovy

@@ -0,0 +1,10 @@
+package com.jessebrault.ssg.provider
+
+final class SupplierBaseCollectionProviderTests extends AbstractCollectionProviderTests {
+
+    @Override
+    protected CollectionProvider<Integer> getCollectionProvider(Collection<Integer> ts) {
+        new SupplierBasedCollectionProvider<Integer>({ ts })
+    }
+
+}

api/src/test/resources/log4j2.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<Configuration name="ssg" status="WARN">
+    <Appenders>
+        <Console name="standard" target="SYSTEM_OUT">
+            <PatternLayout>
+                <MarkerPatternSelector defaultPattern="%highlight{%-5level} %logger{1}: %msg%n%ex">
+                    <PatternMatch key="FLOW" pattern="%highlight{%-5level} %logger{1}: %markerSimpleName %msg%n%ex" />
+                </MarkerPatternSelector>
+            </PatternLayout>
+        </Console>
+    </Appenders>
+    <Loggers>
+        <Root level="debug">
+            <AppenderRef ref="standard" />
+        </Root>
+    </Loggers>
+</Configuration>

api/src/testFixtures/groovy/com/jessebrault/ssg/provider/AbstractCollectionProviderTests.groovy

@@ -0,0 +1,86 @@
+package com.jessebrault.ssg.provider
+
+import org.junit.jupiter.api.DynamicTest
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestFactory
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+import java.util.function.Consumer
+
+import static org.junit.jupiter.api.Assertions.assertTrue
+
+abstract class AbstractCollectionProviderTests {
+
+    protected static final Logger logger = LoggerFactory.getLogger(AbstractCollectionProviderTests)
+
+    protected abstract CollectionProvider<Integer> getCollectionProvider(Collection<Integer> ts)
+
+    @Test
+    void providesTs() {
+        def ts = [0, 1]
+        def result = this.getCollectionProvider(ts).provide()
+        logger.debug('result: {}', result)
+        assertTrue(result.size() == 2)
+        assertTrue(result.inject(true) { acc, val ->
+            acc && ts.contains(val)
+        })
+    }
+
+    @Test
+    void collectionsAdded() {
+        def ts0 = [0, 1]
+        def ts1 = [2, 3]
+        def allTs = ts0 + ts1
+        def p0 = this.getCollectionProvider(ts0)
+        def p1 = this.getCollectionProvider(ts1)
+        def sum = p0 + p1
+        def result = sum.provide()
+        logger.debug('result: {}', result)
+        assertTrue(result.size() == 4)
+        assertTrue(result.inject(true) { acc, val ->
+            acc && allTs.contains(val)
+        })
+    }
+
+    @SuppressWarnings('GrMethodMayBeStatic')
+    @TestFactory
+    Collection<DynamicTest> containsAndIsCaseCollectionProviderChildren() {
+        def p0 = this.getCollectionProvider([])
+        def p1 = this.getCollectionProvider([])
+        def sum = p0 + p1
+        ([
+                contains: { CollectionProvider<Integer> p ->
+                    assertTrue(p.contains(p0))
+                    assertTrue(p.contains(p1))
+                } as Consumer<CollectionProvider<Integer>>,
+                in: { CollectionProvider<Integer> p ->
+                    assertTrue(p0 in p)
+                    assertTrue(p1 in p)
+                } as Consumer<CollectionProvider<Integer>>
+        ]).collect { entry ->
+            DynamicTest.dynamicTest(entry.key, { entry.value.accept(sum) })
+        }
+    }
+
+    @SuppressWarnings('GrMethodMayBeStatic')
+    @TestFactory
+    Collection<DynamicTest> containsAndIsCaseProviderChildren() {
+        def p0 = this.getCollectionProvider([])
+        def p1 = this.getCollectionProvider([])
+        def sum = p0 + p1
+        ([
+                contains: { CollectionProvider<Integer> p ->
+                    assertTrue(p.contains(p0))
+                    assertTrue(p.contains(p1))
+                } as Consumer<CollectionProvider<Integer>>,
+                in: { CollectionProvider<Integer> p ->
+                    assertTrue(p0 in p)
+                    assertTrue(p1 in p)
+                } as Consumer<CollectionProvider<Integer>>
+        ]).collect { entry ->
+            DynamicTest.dynamicTest(entry.key, { entry.value.accept(sum) })
+        }
+    }
+
+}