Tests

build.gradle

@@ -30,6 +30,13 @@ dependencies {
 
 	compileOnly("org.projectlombok:lombok:${project.lombok_version}")
 	annotationProcessor("org.projectlombok:lombok:${project.lombok_version}")
+
+	testImplementation("org.junit.jupiter:junit-jupiter:${project.junit_version}")
+	testImplementation("org.assertj:assertj-core:${project.assertj_version}")
+	testImplementation("org.mockito:mockito-inline:${project.mockito_version}")
+	testImplementation("org.mockito:mockito-junit-jupiter:${project.mockito_junit_version}")
+	testImplementation("io.github.hakky54:logcaptor:${project.logcaptor_version}")
+	testImplementation("com.google.jimfs:jimfs:${project.jimfs_version}")
 }
 
 processResources {
@@ -67,6 +74,10 @@ remapJar {
 	input.set(shadowJar.archiveFile)
 }
 
+test {
+	useJUnitPlatform()
+}
+
 javadoc {
 	options {
 		source = "8"

gradle.properties

@@ -14,4 +14,10 @@ org.gradle.jvmargs=-Xmx1G
 # Dependencies
 	cloth_config_version=4.8.3
 	lombok_version=1.18.16
-	configurate_version=4.0.0
+	configurate_version=4.0.0
+	junit_version=5.7.0
+	mockito_version=3.7.7
+	logcaptor_version=2.3.2
+	assertj_version=3.19.0
+	mockito_junit_version=3.7.7
+	jimfs_version=1.2	

src/test/java/me/lortseam/completeconfig/ConfigTest.java

@@ -0,0 +1,130 @@
+package me.lortseam.completeconfig;
+
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+import me.lortseam.completeconfig.containers.*;
+import me.lortseam.completeconfig.data.Config;
+import me.lortseam.completeconfig.data.Entry;
+import me.lortseam.completeconfig.data.EntryBase;
+import me.lortseam.completeconfig.data.EntryMap;
+import me.lortseam.completeconfig.io.ConfigSource;
+import nl.altindag.log.LogCaptor;
+import org.apache.logging.log4j.core.util.ReflectionUtil;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ConfigTest {
+
+    @Test
+    public void builder_throwExceptionIfModIDIsNull() {
+        NullPointerException exception = assertThrows(NullPointerException.class, () -> Config.builder(null));
+        assertEquals("modID is marked non-null but is null", exception.getMessage());
+    }
+
+    @Nested
+    public class Builder {
+
+        private static final String MOD_ID = "test";
+
+        private Config.Builder builder;
+
+        @BeforeEach
+        public void createBuilder() {
+            builder = Config.builder(MOD_ID);
+        }
+
+        @AfterEach
+        public void cleanUp() throws NoSuchFieldException {
+            builder = null;
+            ((Set<Config>) ReflectionUtil.getStaticFieldValue(Config.class.getDeclaredField("configs"))).clear();
+            ((Set<ConfigSource>) ReflectionUtil.getStaticFieldValue(ConfigSource.class.getDeclaredField("sources"))).clear();
+            ((Map<?, EntryBase>) ReflectionUtil.getStaticFieldValue(Entry.class.getDeclaredField("entries"))).clear();
+        }
+
+        @Test
+        public void setBranch_throwIfBranchNull() {
+            NullPointerException exception = assertThrows(NullPointerException.class, () -> builder.setBranch(null));
+            assertEquals("branch is marked non-null but is null", exception.getMessage());
+        }
+
+        @Test
+        public void setBranch_throwIfBranchContainsNullElement() {
+            assertThrows(NullPointerException.class, () -> builder.setBranch(new String[]{null}));
+        }
+
+        @Test
+        public void add_throwIfContainersNull() {
+            NullPointerException exception = assertThrows(NullPointerException.class, () -> builder.add((ConfigEntryContainer[]) null));
+            assertEquals("containers is marked non-null but is null", exception.getMessage());
+        }
+
+        @Test
+        public void add_throwIfContainersContainNullElement() {
+            assertThrows(NullPointerException.class, () -> builder.add((ConfigEntryContainer) null));
+        }
+
+        @Test
+        public void build_logWarningAndReturnNullIfChildrenEmpty() {
+            LogCaptor logCaptor = LogCaptor.forRoot();
+            assertNull(builder.build());
+            assertThat(logCaptor.getWarnLogs()).containsExactly("[CompleteConfig] Mod " + MOD_ID + " tried to create an empty config!");
+        }
+
+        @Nested
+        public class Resolving {
+
+            @Test
+            public void logWarningIfEmpty() {
+                LogCaptor logCaptor = LogCaptor.forRoot();
+                builder.add(new EmptyContainer()).build();
+                assertThat(logCaptor.getWarnLogs()).containsExactly("[CompleteConfig] Config of ConfigSource(modID=" + MOD_ID + ", branch=[]) is empty!");
+            }
+
+            @Nested
+            public class Entry {
+
+                @Test
+                public void includeAnnotatedFieldOnlyIfNonPOJO() throws NoSuchFieldException {
+                    EntryMap entries = builder.add(new ContainerWithSingleEntry()).build().getEntries();
+                    assertEquals(1, entries.size());
+                    assertEquals(entries.values().iterator().next().getField(), ContainerWithSingleEntry.class.getDeclaredField("entry"));
+                }
+
+                @Test
+                public void includeFieldIfPOJO() {
+                    EntryMap entries = builder.add(new POJOContainerWithSingleEntry()).build().getEntries();
+                    assertEquals(1, entries.size());
+                }
+
+                @Test
+                public void ignoreFieldIfAnnotatedWithIgnore() {
+                    EntryMap entries = builder.add(new POJOContainerWithSingleIgnoredField()).build().getEntries();
+                    assertEquals(0, entries.size());
+                }
+
+                @Test
+                public void includeSuperclassField() {
+                    EntryMap entries = builder.add(new SubclassOfContainerWithSingleEntry()).build().getEntries();
+                    assertEquals(1, entries.size());
+                }
+
+                @Test
+                public void excludeStaticSuperclassField() {
+                    EntryMap entries = builder.add(new SubclassOfContainerWithSingleStaticEntry()).build().getEntries();
+                    assertEquals(0, entries.size());
+                }
+
+            }
+
+        }
+
+    }
+
+}

src/test/java/me/lortseam/completeconfig/containers/ContainerWithSingleEntry.java

@@ -0,0 +1,12 @@
+package me.lortseam.completeconfig.containers;
+
+import me.lortseam.completeconfig.api.ConfigEntry;
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+
+public class ContainerWithSingleEntry implements ConfigEntryContainer {
+
+    @ConfigEntry
+    private boolean entry;
+    private boolean noEntry;
+
+}

src/test/java/me/lortseam/completeconfig/containers/ContainerWithSingleStaticEntry.java

@@ -0,0 +1,11 @@
+package me.lortseam.completeconfig.containers;
+
+import me.lortseam.completeconfig.api.ConfigEntry;
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+
+public class ContainerWithSingleStaticEntry implements ConfigEntryContainer {
+
+    @ConfigEntry
+    private static boolean entry;
+
+}

src/test/java/me/lortseam/completeconfig/containers/EmptyContainer.java

@@ -0,0 +1,7 @@
+package me.lortseam.completeconfig.containers;
+
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+
+public class EmptyContainer implements ConfigEntryContainer {
+
+}

src/test/java/me/lortseam/completeconfig/containers/POJOContainerWithSingleEntry.java

@@ -0,0 +1,14 @@
+package me.lortseam.completeconfig.containers;
+
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+
+public class POJOContainerWithSingleEntry implements ConfigEntryContainer {
+
+    private boolean entry;
+
+    @Override
+    public boolean isConfigPOJO() {
+        return true;
+    }
+
+}

src/test/java/me/lortseam/completeconfig/containers/POJOContainerWithSingleIgnoredField.java

@@ -0,0 +1,16 @@
+package me.lortseam.completeconfig.containers;
+
+import me.lortseam.completeconfig.api.ConfigEntry;
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+
+public class POJOContainerWithSingleIgnoredField implements ConfigEntryContainer {
+
+    @ConfigEntry.Ignore
+    private boolean noEntry;
+
+    @Override
+    public boolean isConfigPOJO() {
+        return true;
+    }
+
+}

src/test/java/me/lortseam/completeconfig/containers/SubclassOfContainerWithSingleEntry.java

@@ -0,0 +1,5 @@
+package me.lortseam.completeconfig.containers;
+
+public class SubclassOfContainerWithSingleEntry extends ContainerWithSingleEntry {
+
+}

src/test/java/me/lortseam/completeconfig/containers/SubclassOfContainerWithSingleStaticEntry.java

@@ -0,0 +1,5 @@
+package me.lortseam.completeconfig.containers;
+
+public class SubclassOfContainerWithSingleStaticEntry extends ContainerWithSingleStaticEntry {
+
+}

src/test/java/me/lortseam/completeconfig/extension/FabricLoaderExtension.java

@@ -0,0 +1,25 @@
+package me.lortseam.completeconfig.extension;
+
+import com.google.common.jimfs.Jimfs;
+import net.fabricmc.loader.api.FabricLoader;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+import static org.mockito.Mockito.*;
+
+public class FabricLoaderExtension implements BeforeAllCallback {
+
+    private static boolean mocked = false;
+
+    @Override
+    public void beforeAll(ExtensionContext context) {
+        if (!mocked) {
+            FabricLoader loader = mock(FabricLoader.class);
+            when(loader.isModLoaded(any(String.class))).thenReturn(true);
+            when(loader.getConfigDir()).thenReturn(Jimfs.newFileSystem().getPath(""));
+            mockStatic(FabricLoader.class).when(FabricLoader::getInstance).thenReturn(loader);
+            mocked = true;
+        }
+    }
+
+}

src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension

@@ -0,0 +1 @@
+me.lortseam.completeconfig.extension.FabricLoaderExtension

src/test/resources/junit-platform.properties

@@ -0,0 +1 @@
+junit.jupiter.extensions.autodetection.enabled=true