Update testing to use junit5

Author: rbygrave

controller/pom.xml

@@ -11,16 +11,5 @@
     <relativePath>..</relativePath>
   </parent>
 
-  <dependencies>
-
-    <dependency>
-      <groupId>org.avaje.composite</groupId>
-      <artifactId>junit</artifactId>
-      <version>1.1</version>
-      <scope>test</scope>
-    </dependency>
-
-  </dependencies>
-
 
 </project>

controller/src/test/java/io/dinject/controller/PathSegmentTest.java

@@ -1,8 +1,9 @@
 package io.dinject.controller;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 public class PathSegmentTest {
 

controller/src/test/java/io/dinject/controller/PathTypeConversionTest.java

@@ -1,6 +1,6 @@
 package io.dinject.controller;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.Instant;
 import java.time.LocalDate;
@@ -10,13 +10,14 @@
 import java.util.UUID;
 
 import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class PathTypeConversionTest {
 
-  @Test(expected = RequiredArgumentException.class)
+  @Test
   public void checkNull_when_null() {
-    PathTypeConversion.checkNull(null, "id");
+    assertThrows(RequiredArgumentException.class, () -> PathTypeConversion.checkNull(null, "id"));
   }
 
   @Test
@@ -29,64 +30,64 @@ public void asInt() {
     assertEquals(42, PathTypeConversion.asInt("42"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asInt_when_null() {
-    PathTypeConversion.asInt(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asInt(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asInt_when_invalid() {
-    PathTypeConversion.asInt("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asInt("junk"));
   }
 
   @Test
   public void asLong() {
     assertEquals(42L, PathTypeConversion.asInt("42"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLong_when_invalid() {
-    PathTypeConversion.asLong("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLong("junk"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLong_when_null() {
-    PathTypeConversion.asLong(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLong(null));
   }
 
   @Test
   public void asDouble() {
     assertThat(PathTypeConversion.asDouble("42")).isEqualTo(42d);
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asDouble_when_invalid() {
-    PathTypeConversion.asDouble("jukn");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asDouble("jukn"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asDouble_when_null() {
-    PathTypeConversion.asDouble(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asDouble(null));
   }
 
   @Test
   public void asFloat() {
     assertThat(PathTypeConversion.asFloat("42")).isEqualTo(42f);
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asFloat_when_null() {
-    PathTypeConversion.asFloat(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asFloat(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asFloat_when_invalid() {
-    PathTypeConversion.asFloat("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asFloat("junk"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asBool_when_null() {
-    PathTypeConversion.asBool(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asBool(null));
   }
 
   @Test
@@ -103,74 +104,74 @@ public void asBigDecimal() {
     assertThat(PathTypeConversion.asBigDecimal("42.3")).isEqualByComparingTo("42.3");
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asBigDecimal_when_null() {
-    PathTypeConversion.asBigDecimal(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asBigDecimal(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asBigDecimal_when_invalid() {
-    PathTypeConversion.asBigDecimal("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asBigDecimal("junk"));
   }
 
   @Test
   public void asLocalDate() {
     assertThat(PathTypeConversion.asLocalDate("2018-06-03")).isEqualTo(LocalDate.of(2018, 6, 3));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLocalDate_when_null() {
-    PathTypeConversion.asLocalDate(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLocalDate(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLocalDate_when_invalid() {
-    PathTypeConversion.asLocalDate("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLocalDate("junk"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLocalTime_when_invalid() {
-    PathTypeConversion.asLocalTime("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLocalTime("junk"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLocalTime_when_null() {
-    PathTypeConversion.asLocalTime(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLocalTime(null));
   }
 
   @Test
   public void asLocalTime() {
     assertThat(PathTypeConversion.asLocalTime("23:34:09")).isEqualTo(LocalTime.of(23, 34, 9));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asInstant_when_null() {
-    PathTypeConversion.asInstant(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asInstant(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asOffsetDateTime_when_null() {
-    PathTypeConversion.asOffsetDateTime(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asOffsetDateTime(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLocalDateTime_when_null() {
-    PathTypeConversion.asLocalDateTime(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLocalDateTime(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asInstant_when_invalid() {
-    PathTypeConversion.asInstant("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asInstant("junk"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asOffsetDateTime_when_invalid() {
-    PathTypeConversion.asOffsetDateTime("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asOffsetDateTime("junk"));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asLocalDateTime_when_invalid() {
-    PathTypeConversion.asLocalDateTime("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asLocalDateTime("junk"));
   }
 
   @Test
@@ -197,29 +198,29 @@ public void asUUID() {
     assertThat(PathTypeConversion.asUUID(uuid.toString())).isEqualTo(uuid);
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asUUID_when_null() {
-    PathTypeConversion.asUUID(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asUUID(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asUUID_when_invalid() {
-    PathTypeConversion.asUUID("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asUUID("junk"));
   }
 
   @Test
   public void asInteger() {
     assertThat(PathTypeConversion.asInteger("42")).isEqualTo(42);
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asInteger_null() {
-    PathTypeConversion.asInteger(null);
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asInteger(null));
   }
 
-  @Test(expected = InvalidPathArgumentException.class)
+  @Test
   public void asInteger_invalid() {
-    PathTypeConversion.asInteger("junk");
+    assertThrows(InvalidPathArgumentException.class, () -> PathTypeConversion.asInteger("junk"));
   }
 
   @Test
@@ -228,9 +229,9 @@ public void toInteger() {
     assertThat(PathTypeConversion.toInteger(null)).isNull();
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void toInteger_invalid() {
-    PathTypeConversion.toInteger("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toInteger("junk"));
   }
 
   @Test
@@ -239,9 +240,9 @@ public void toLong() {
     assertThat(PathTypeConversion.toLong(null)).isNull();
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void toLong_invalid() {
-    PathTypeConversion.toLong("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toLong("junk"));
   }
 
   @Test
@@ -250,9 +251,9 @@ public void toBigDecimal() {
     assertThat(PathTypeConversion.toBigDecimal(null)).isNull();
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void toBigDecimal_invalid() {
-    PathTypeConversion.toBigDecimal("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toBigDecimal("junk"));
   }
 
   @Test
@@ -269,29 +270,29 @@ public void toUUID() {
     assertThat(PathTypeConversion.toUUID(uuid.toString())).isEqualTo(uuid);
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void toUUID_invalid() {
-    PathTypeConversion.toUUID("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toUUID("junk"));
   }
 
   @Test
   public void toLocalDate() {
     assertThat(PathTypeConversion.toLocalDate("2018-09-07")).isEqualTo(LocalDate.of(2018, 9, 7));
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void toLocalDate_invalid() {
-    PathTypeConversion.toLocalDate("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toLocalDate("junk"));
   }
 
   @Test
   public void toLocalTime() {
     assertThat(PathTypeConversion.toLocalTime("23:34:09")).isEqualTo(LocalTime.of(23, 34, 9));
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void toLocalTime_invalid() {
-    PathTypeConversion.toLocalTime("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toLocalTime("junk"));
   }
 
   @Test
@@ -300,9 +301,9 @@ public void toInstant() {
     assertThat(PathTypeConversion.toInstant("2018-09-23T23:34:09Z")).isEqualTo(instant);
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void toInstant_invalid() {
-    PathTypeConversion.toInstant("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toInstant("junk"));
   }
 
   @Test
@@ -311,9 +312,9 @@ public void toOffsetDateTime() {
     assertThat(PathTypeConversion.toOffsetDateTime("2018-09-23T23:34:09Z")).isEqualTo(instant);
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void OffsetDateTime_invalid() {
-    PathTypeConversion.toOffsetDateTime("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toOffsetDateTime("junk"));
   }
 
   @Test
@@ -322,8 +323,8 @@ public void toLocalDateTime() {
     assertThat(PathTypeConversion.toLocalDateTime("2018-09-23T23:34:09")).isEqualTo(instant);
   }
 
-  @Test(expected = InvalidTypeArgumentException.class)
+  @Test
   public void LocalDateTime_invalid() {
-    PathTypeConversion.toLocalDateTime("junk");
+    assertThrows(InvalidTypeArgumentException.class, () -> PathTypeConversion.toLocalDateTime("junk"));
   }
 }

generator-core/pom.xml

@@ -54,15 +54,6 @@
       <version>${swagger.version}</version>
     </dependency>
 
-    <!-- test dependencies -->
-
-    <dependency>
-      <groupId>org.avaje.composite</groupId>
-      <artifactId>junit</artifactId>
-      <version>1.1</version>
-      <scope>test</scope>
-    </dependency>
-
   </dependencies>