Update to JUnit 5 and fix tests (#72)

* Update to JUnit 5 and fix tests

- Updated dependency. The version is still managed by the parent.
- Tests no longer extend TestCase
- Annotated test methods with `@Test`.
- Made classes and test methods package-private, as it is recommended.

* Add GitHub Action to run tests automatically

- This excludes master, since the maven_release.yaml workflow already tests master.

Author: Til7701

.github/workflows/maven_test.yml

@@ -0,0 +1,28 @@
+name: Test
+
+on:
+  push:
+    branches-ignore:
+      - master
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Set up JDK 8
+        uses: actions/setup-java@v3
+        with:
+          java-version: 8
+          distribution: 'temurin'
+      - name: Cache Maven packages
+        uses: actions/cache@v3
+        with:
+          path: ~/.m2
+          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+          restore-keys: ${{ runner.os }}-m2
+      - name: Build and Test
+        run: mvn clean verify

pom.xml

@@ -59,8 +59,8 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
             <scope>test</scope>
         </dependency>
     </dependencies>

src/test/java/org/openapitools/jackson/nullable/ContextualJsonNullableTest.java

@@ -3,12 +3,15 @@
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
 
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.TimeZone;
 
-public class ContextualJsonNullableTest extends ModuleTestBase
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class ContextualJsonNullableTest extends ModuleTestBase
 {
     // [datatypes-java8#17]
     @JsonPropertyOrder({ "date", "date1", "date2" })
@@ -29,7 +32,8 @@ static class ContextualJsonNullables
     /**********************************************************
      */
 
-    public void testContextualJsonNullables() throws Exception
+    @Test
+    void testContextualJsonNullables() throws Exception
     {
         final ObjectMapper mapper = mapperWithModule();
         SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd");

src/test/java/org/openapitools/jackson/nullable/CreatorTest.java

@@ -3,11 +3,14 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 // TODO: fix JsonNullable in constructor annotated by JsonCreator
-@Ignore("JsonNullable in a constructor is dederialized to JsonNullable[null] instead of JsonNullable.undefined")
-public class CreatorTest extends ModuleTestBase
+@Disabled("JsonNullable in a constructor is dederialized to JsonNullable[null] instead of JsonNullable.undefined")
+class CreatorTest extends ModuleTestBase
 {
     static class CreatorWithJsonNullableStrings
     {
@@ -35,7 +38,8 @@ public CreatorWithJsonNullableStrings(@JsonProperty("a") JsonNullable<String> a,
      * Test to ensure that creator parameters use defaulting
      * (introduced in Jackson 2.6)
      */
-    public void testCreatorWithJsonNullable() throws Exception
+    @Test
+    void testCreatorWithJsonNullable() throws Exception
     {
         CreatorWithJsonNullableStrings bean = MAPPER.readValue(
                 aposToQuotes("{'a':'foo'}"), CreatorWithJsonNullableStrings.class);

src/test/java/org/openapitools/jackson/nullable/JsonNullJacksonServiceLoadingTest.java

@@ -2,11 +2,14 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
-import junit.framework.TestCase;
+import org.junit.jupiter.api.Test;
 
-public class JsonNullJacksonServiceLoadingTest extends TestCase {
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-    public void testJacksonJsonNullableModuleServiceLoading() {
+class JsonNullJacksonServiceLoadingTest {
+
+    @Test
+    void testJacksonJsonNullableModuleServiceLoading() {
         String foundModuleName = ObjectMapper.findModules().get(0).getModuleName();
         assertEquals(new JsonNullableModule().getModuleName(), foundModuleName);
     }

src/test/java/org/openapitools/jackson/nullable/JsonNullWithEmptyTest.java

@@ -2,8 +2,12 @@
 
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
 
-public class JsonNullWithEmptyTest  extends ModuleTestBase
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class JsonNullWithEmptyTest  extends ModuleTestBase
 {
     private final ObjectMapper MAPPER = mapperWithModule();
 
@@ -16,14 +20,15 @@ public BooleanBean(Boolean b) {
         }
     }
 
-    public void testJsonNullableFromEmpty() throws Exception {
+    @Test
+    void testJsonNullableFromEmpty() throws Exception {
         JsonNullable<?> value = MAPPER.readValue(quote(""), new TypeReference<JsonNullable<Integer>>() {});
         assertFalse(value.isPresent());
     }
 
     // for [datatype-jdk8#23]
-    public void testBooleanWithEmpty() throws Exception
-    {
+    @Test
+    void testBooleanWithEmpty() throws Exception {
         // and looks like a special, somewhat non-conforming case is what a user had
         // issues with
         BooleanBean b = MAPPER.readValue(aposToQuotes("{'value':''}"), BooleanBean.class);

src/test/java/org/openapitools/jackson/nullable/JsonNullableBasicTest.java

@@ -4,11 +4,14 @@
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class JsonNullableBasicTest extends ModuleTestBase {
+import static org.junit.jupiter.api.Assertions.*;
+
+class JsonNullableBasicTest extends ModuleTestBase {
 
     public static final class JsonNullableData {
         public JsonNullable<String> myString;
@@ -58,37 +61,42 @@ public static class ContainedImpl implements Contained { }
 
     private final ObjectMapper MAPPER = mapperWithModule();
 
-    public void testJsonNullableTypeResolution() throws Exception {
+    @Test
+    void testJsonNullableTypeResolution() {
         // With 2.6, we need to recognize it as ReferenceType
         JavaType t = MAPPER.constructType(JsonNullable.class);
         assertNotNull(t);
         assertEquals(JsonNullable.class, t.getRawClass());
         assertTrue(t.isReferenceType());
     }
 
-    public void testDeserAbsent() throws Exception {
+    @Test
+    void testDeserAbsent() throws Exception {
         JsonNullable<?> value = MAPPER.readValue("null",
                 new TypeReference<JsonNullable<String>>() {
                 });
         assertNull(value.get());
     }
 
-    public void testDeserSimpleString() throws Exception {
+    @Test
+    void testDeserSimpleString() throws Exception {
         JsonNullable<?> value = MAPPER.readValue("\"simpleString\"",
                 new TypeReference<JsonNullable<String>>() {
                 });
         assertTrue(value.isPresent());
         assertEquals("simpleString", value.get());
     }
 
-    public void testDeserInsideObject() throws Exception {
+    @Test
+    void testDeserInsideObject() throws Exception {
         JsonNullableData data = MAPPER.readValue("{\"myString\":\"simpleString\"}",
                 JsonNullableData.class);
         assertTrue(data.myString.isPresent());
         assertEquals("simpleString", data.myString.get());
     }
 
-    public void testDeserComplexObject() throws Exception {
+    @Test
+    void testDeserComplexObject() throws Exception {
         TypeReference<JsonNullable<JsonNullableData>> type = new TypeReference<JsonNullable<JsonNullableData>>() {
         };
         JsonNullable<JsonNullableData> data = MAPPER.readValue(
@@ -98,7 +106,8 @@ public void testDeserComplexObject() throws Exception {
         assertEquals("simpleString", data.get().myString.get());
     }
 
-    public void testDeserGeneric() throws Exception {
+    @Test
+    void testDeserGeneric() throws Exception {
         TypeReference<JsonNullable<JsonNullableGenericData<String>>> type = new TypeReference<JsonNullable<JsonNullableGenericData<String>>>() {
         };
         JsonNullable<JsonNullableGenericData<String>> data = MAPPER.readValue(
@@ -108,62 +117,71 @@ public void testDeserGeneric() throws Exception {
         assertEquals("simpleString", data.get().myData.get());
     }
 
-    public void testSerAbsent() throws Exception {
+    @Test
+    void testSerAbsent() throws Exception {
         String value = MAPPER.writeValueAsString(JsonNullable.undefined());
         assertEquals("null", value);
     }
 
-    public void testSerSimpleString() throws Exception {
+    @Test
+    void testSerSimpleString() throws Exception {
         String value = MAPPER.writeValueAsString(JsonNullable.of("simpleString"));
         assertEquals("\"simpleString\"", value);
     }
 
-    public void testSerInsideObject() throws Exception {
+    @Test
+    void testSerInsideObject() throws Exception {
         JsonNullableData data = new JsonNullableData();
         data.myString = JsonNullable.of("simpleString");
         String value = MAPPER.writeValueAsString(data);
         assertEquals("{\"myString\":\"simpleString\"}", value);
     }
 
-    public void testSerComplexObject() throws Exception {
+    @Test
+    void testSerComplexObject() throws Exception {
         JsonNullableData data = new JsonNullableData();
         data.myString = JsonNullable.of("simpleString");
         String value = MAPPER.writeValueAsString(JsonNullable.of(data));
         assertEquals("{\"myString\":\"simpleString\"}", value);
     }
 
-    public void testSerGeneric() throws Exception {
+    @Test
+    void testSerGeneric() throws Exception {
         JsonNullableGenericData<String> data = new JsonNullableGenericData<String>();
         data.myData = JsonNullable.of("simpleString");
         String value = MAPPER.writeValueAsString(JsonNullable.of(data));
         assertEquals("{\"myData\":\"simpleString\"}", value);
     }
 
-    public void testSerOptDefault() throws Exception {
+    @Test
+    void testSerOptDefault() throws Exception {
         JsonNullableData data = new JsonNullableData();
         data.myString = JsonNullable.undefined();
         String value = mapperWithModule().setSerializationInclusion(
                 JsonInclude.Include.ALWAYS).writeValueAsString(data);
         assertEquals("{}", value);
     }
 
-    public void testSerOptNull() throws Exception {
+    @Test
+    void testSerOptNull() throws Exception {
         JsonNullableData data = new JsonNullableData();
         data.myString = null;
         String value = mapperWithModule().setSerializationInclusion(
                 JsonInclude.Include.NON_NULL).writeValueAsString(data);
         assertEquals("{}", value);
     }
 
-    public void testSerOptNullNulled() throws Exception {
+    @Test
+    void testSerOptNullNulled() throws Exception {
         JsonNullableData data = new JsonNullableData();
         data.myString = JsonNullable.of(null);
         String value = mapperWithModule().setSerializationInclusion(
                 JsonInclude.Include.NON_NULL).writeValueAsString(data);
         assertEquals("{\"myString\":null}", value);
     }
 
-    public void testSerOptAbsent() throws Exception {
+    @Test
+    void testSerOptAbsent() throws Exception {
         final JsonNullableData data = new JsonNullableData();
         data.myString = JsonNullable.undefined();
 
@@ -183,23 +201,26 @@ public void testSerOptAbsent() throws Exception {
         assertEquals("{}", mapper.writeValueAsString(data));
     }
 
-    public void testSerOptAbsentNull() throws Exception {
+    @Test
+    void testSerOptAbsentNull() throws Exception {
         JsonNullableData data = new JsonNullableData();
         data.myString = JsonNullable.of(null);
         String value = mapperWithModule().setSerializationInclusion(
                 JsonInclude.Include.NON_ABSENT).writeValueAsString(data);
         assertEquals("{\"myString\":null}", value);
     }
 
-    public void testSerOptNonEmpty() throws Exception {
+    @Test
+    void testSerOptNonEmpty() throws Exception {
         JsonNullableData data = new JsonNullableData();
         data.myString = null;
         String value = mapperWithModule().setSerializationInclusion(
                 JsonInclude.Include.NON_EMPTY).writeValueAsString(data);
         assertEquals("{}", value);
     }
 
-    public void testWithTypingEnabled() throws Exception {
+    @Test
+    void testWithTypingEnabled() throws Exception {
         final ObjectMapper objectMapper = mapperWithModule();
         // ENABLE TYPING
         objectMapper
@@ -214,7 +235,8 @@ public void testWithTypingEnabled() throws Exception {
         assertEquals(myData.myString, deserializedMyData.myString);
     }
 
-    public void testObjectId() throws Exception {
+    @Test
+    void testObjectId() throws Exception {
         final Unit input = new Unit();
         input.link(input);
         String json = MAPPER.writeValueAsString(input);
@@ -226,7 +248,8 @@ public void testObjectId() throws Exception {
         assertSame(result, base);
     }
 
-    public void testJsonNullableCollection() throws Exception {
+    @Test
+    void testJsonNullableCollection() throws Exception {
 
         TypeReference<List<JsonNullable<String>>> typeReference = new TypeReference<List<JsonNullable<String>>>() {
         };
@@ -242,17 +265,18 @@ public void testJsonNullableCollection() throws Exception {
         List<JsonNullable<String>> result = MAPPER.readValue(str, typeReference);
         assertEquals(list.size(), result.size());
         for (int i = 0; i < list.size(); ++i) {
-            assertEquals("Entry #" + i, list.get(i), result.get(i));
+            assertEquals(list.get(i), result.get(i),"Entry #" + i);
         }
     }
 
-    public void testDeserNull() throws Exception {
+    @Test
+    void testDeserNull() throws Exception {
         JsonNullable<?> value = MAPPER.readValue("\"\"", new TypeReference<JsonNullable<Integer>>() {});
         assertFalse(value.isPresent());
     }
 
-    public void testPolymorphic() throws Exception
-    {
+    @Test
+    void testPolymorphic() throws Exception {
         final Container dto = new Container();
         dto.contained = JsonNullable.of((Contained) new ContainedImpl());