Upgrade to JUnit 5

nightowlengineer · nightowlengineer · commit d13a1dabda1f · 2023-02-12T17:20:11.000-05:00
diff --git a/pom.xml b/pom.xml
@@ -58,14 +58,14 @@
 
     <dependencies>
         <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.13.2</version>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.9.2</version>
         </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>4.6.1</version>
+            <version>5.1.1</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -190,6 +190,11 @@
                     <tagNameFormat>@{project.version}</tagNameFormat>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.0.0-M8</version>
+            </plugin>
         </plugins>
     </build>
 </project>
diff --git a/src/test/java/engineer/nightowl/sonos/api/BaseTestSetup.java b/src/test/java/engineer/nightowl/sonos/api/BaseTestSetup.java
@@ -1,15 +1,15 @@
 package engineer.nightowl.sonos.api;
 
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.BeforeAll;
 
 public class BaseTestSetup
 {
     protected static final SonosApiConfiguration configuration = new SonosApiConfiguration();
 
     protected final SonosApiClient apiClient = new SonosApiClient(configuration);
 
-    @BeforeClass
-    public static void setup()
+    @BeforeAll
+    static void setup()
     {
         configuration.setApiKey("testApiKey");
         configuration.setApiSecret("testApiSecret");
diff --git a/src/test/java/engineer/nightowl/sonos/api/resource/AuthorizeResourceTest.java b/src/test/java/engineer/nightowl/sonos/api/resource/AuthorizeResourceTest.java
@@ -3,40 +3,41 @@
 import engineer.nightowl.sonos.api.BaseTestSetup;
 import org.apache.http.NameValuePair;
 import org.apache.http.client.utils.URLEncodedUtils;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.List;
 
-public class AuthorizeResourceTest extends BaseTestSetup
+class AuthorizeResourceTest extends BaseTestSetup
 {
     private final AuthorizeResource authorizeResource = new AuthorizeResource(apiClient);
 
     @Test
     public void testGetAuthorizeCodeUri() throws URISyntaxException
     {
         final URI uri = authorizeResource.getAuthorizeCodeUri("https://localhost");
-        Assert.assertEquals("https", uri.getScheme());
+        assertEquals("https", uri.getScheme());
     }
 
     @Test
     public void testGetAuthorizeCodeWithState() throws URISyntaxException
     {
         final String state = authorizeResource.generateStateValue();
         final URI uri = authorizeResource.getAuthorizeCodeUri("https://localhost", state);
-        Assert.assertEquals("https", uri.getScheme());
+        assertEquals("https", uri.getScheme());
         uri.getQuery();
 
         final List<NameValuePair> params = URLEncodedUtils.parse(uri, StandardCharsets.UTF_8);
         final HashMap<String, String> map = new HashMap<>();
         params.forEach(p -> map.put(p.getName(), p.getValue()));
 
-        Assert.assertEquals(state, map.get("state"));
-        Assert.assertEquals(configuration.getApiKey(), map.get("client_id"));
+        assertEquals(state, map.get("state"));
+        assertEquals(configuration.getApiKey(), map.get("client_id"));
     }
 
 }
diff --git a/src/test/java/engineer/nightowl/sonos/api/resource/BaseResourceTest.java b/src/test/java/engineer/nightowl/sonos/api/resource/BaseResourceTest.java
@@ -18,31 +18,26 @@
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.message.BasicHeader;
 import org.apache.http.message.BasicStatusLine;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.quality.Strictness;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 public class BaseResourceTest
 {
-    @Rule
-    public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
-
     private static BaseResource baseResource;
     private static SonosApiClient client;
     private static SonosApiConfiguration configuration;
     private static CloseableHttpClient mockedClient;
 
-    @BeforeClass
+    @BeforeAll
     public static void setUp() throws Exception
     {
         client = mock(SonosApiClient.class);
@@ -56,18 +51,18 @@ public static void setUp() throws Exception
     }
 
     @Test
-    public void getTypeFromHeader() throws SonosApiClientException
+    void getTypeFromHeader() throws SonosApiClientException
     {
         final CloseableHttpResponse response = mock(CloseableHttpResponse.class);
         when(response.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))
                 .thenReturn(new BasicHeader(BaseResource.SONOS_TYPE_HEADER, "homeTheaterOptions"));
         final SonosType type = baseResource.getTypeFromHeader(response);
 
-        Assert.assertEquals(SonosType.homeTheaterOptions, type);
+        assertEquals(SonosType.homeTheaterOptions, type);
     }
 
     @Test
-    public void getInvalidTypeFromHeader() throws SonosApiClientException
+    void getInvalidTypeFromHeader() throws SonosApiClientException
     {
         final CloseableHttpResponse response = mock(CloseableHttpResponse.class);
         when(response.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))
@@ -76,16 +71,16 @@ public void getInvalidTypeFromHeader() throws SonosApiClientException
         try
         {
             baseResource.getTypeFromHeader(response);
-            Assert.fail("Did not fail as expected");
+            fail("Did not fail as expected");
         }
         catch(SonosApiClientException sace)
         {
-            Assert.assertEquals(IllegalArgumentException.class, sace.getCause().getClass());
+            assertEquals(IllegalArgumentException.class, sace.getCause().getClass());
         }
     }
 
     @Test
-    public void testThatMainApiCallWorks() throws IOException, SonosApiClientException, SonosApiError
+    void testThatMainApiCallWorks() throws IOException, SonosApiClientException, SonosApiError
     {
         // Test data
         final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();
@@ -104,11 +99,11 @@ public void testThatMainApiCallWorks() throws IOException, SonosApiClientExcepti
         final SonosHomeTheaterOptions responseOptions = baseResource.getFromApi(SonosHomeTheaterOptions.class,
                 "token123", "some/test");
 
-        Assert.assertEquals(options, responseOptions);
+        assertEquals(options, responseOptions);
     }
 
     @Test
-    public void testSonosNotDeclaringTypeStillWorks() throws IOException, SonosApiClientException, SonosApiError
+    void testSonosNotDeclaringTypeStillWorks() throws IOException, SonosApiClientException, SonosApiError
     {
         // Test data
         final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();
@@ -129,11 +124,11 @@ public void testSonosNotDeclaringTypeStillWorks() throws IOException, SonosApiCl
         final SonosHomeTheaterOptions responseOptions = baseResource.getFromApi(SonosHomeTheaterOptions.class,
                 "token123", "some/test");
 
-        Assert.assertEquals(options, responseOptions);
+        assertEquals(options, responseOptions);
     }
 
     @Test
-    public void testAuthErrorThrown() throws IOException, SonosApiClientException, SonosApiError
+    void testAuthErrorThrown() throws IOException, SonosApiClientException, SonosApiError
     {
         final CloseableHttpResponse mockedResponse = mock(CloseableHttpResponse.class);
         final StatusLine sl = new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 401, null);
@@ -142,16 +137,16 @@ public void testAuthErrorThrown() throws IOException, SonosApiClientException, S
         try
         {
             baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");
-            Assert.fail("Did not handle error response correctly");
+            fail("Did not handle error response correctly");
         }
         catch (final SonosApiClientException e)
         {
-            Assert.assertEquals("Invalid token", e.getMessage());
+            assertEquals("Invalid token", e.getMessage());
         }
     }
 
     @Test
-    public void testApiErrorHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError
+    void testApiErrorHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError
     {
         // Test data
         final SonosApiError error = new SonosApiError();
@@ -171,16 +166,16 @@ public void testApiErrorHandledCorrectly() throws IOException, SonosApiClientExc
         try
         {
             baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");
-            Assert.fail("Did not handle error response correctly");
+            fail("Did not handle error response correctly");
         }
         catch (final SonosApiError e)
         {
-            Assert.assertEquals(SonosErrorCode.ERROR_NOT_CAPABLE, e.getErrorCode());
+            assertEquals(SonosErrorCode.ERROR_NOT_CAPABLE, e.getErrorCode());
         }
     }
 
     @Test
-    public void testApiMismatchHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError
+    void testApiMismatchHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError
     {
         // Test data
         final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();
@@ -201,55 +196,55 @@ public void testApiMismatchHandledCorrectly() throws IOException, SonosApiClient
         try
         {
             baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");
-            Assert.fail("Did not handle error response correctly");
+            fail("Did not handle error response correctly");
         }
         catch (final SonosApiClientException e)
         {
-            Assert.assertEquals("Sonos declared SonosAudioClip as the response type, but the integration requested SonosHomeTheaterOptions", e.getMessage());
+            assertEquals("Sonos declared SonosAudioClip as the response type, but the integration requested SonosHomeTheaterOptions", e.getMessage());
         }
     }
 
     @Test
-    public void getStandardRequest() throws SonosApiClientException
+    void getStandardRequest() throws SonosApiClientException
     {
         final HttpGet req = baseResource.getStandardRequest(HttpGet.class, "token123", "/some/path");
-        Assert.assertEquals(HttpGet.METHOD_NAME,
+        assertEquals(HttpGet.METHOD_NAME,
                 req.getMethod());
 
-        Assert.assertEquals("Bearer token123",
+        assertEquals("Bearer token123",
                 req.getFirstHeader("Authorization").getValue());
 
-        Assert.assertEquals(
+        assertEquals(
                 "/control/api/some/path",
                 req.getURI().getPath());
     }
 
     @Test
-    public void testValidateNotNullNoFieldName() throws SonosApiClientException
+    void testValidateNotNullNoFieldName() throws SonosApiClientException
     {
         baseResource.validateNotNull("nonEmptyString");
     }
 
-    @Test(expected=SonosApiClientException.class)
-    public void testValidateNotNullBothNulls() throws SonosApiClientException
+    @Test
+    void testValidateNotNullBothNulls()
     {
-        baseResource.validateNotNull(null, null);
+        assertThrows(SonosApiClientException.class, () -> baseResource.validateNotNull(null, null));
     }
 
-    @Test(expected=SonosApiClientException.class)
-    public void testValidateNotNullObjectNull() throws SonosApiClientException
+    @Test
+    void testValidateNotNullObjectNull()
     {
-        baseResource.validateNotNull(null, "sonos-api-java");
+        assertThrows(SonosApiClientException.class, () -> baseResource.validateNotNull(null, "sonos-api-java"));
     }
 
-    @Test(expected=SonosApiClientException.class)
-    public void testValidateNotNullEmptyObject() throws SonosApiClientException
+    @Test
+    void testValidateNotNullEmptyObject()
     {
-        baseResource.validateNotNull("", "sonos-api-java");
+        assertThrows(SonosApiClientException.class, () -> baseResource.validateNotNull("", "sonos-api-java"));
     }
 
     @Test
-    public void testValidateNotNullNonEmptyObject() throws SonosApiClientException
+    void testValidateNotNullNonEmptyObject() throws SonosApiClientException
     {
         baseResource.validateNotNull("nonEmptyString", "sonos-api-java");
     }
diff --git a/src/test/java/engineer/nightowl/sonos/api/util/SonosCallbackHelperTest.java b/src/test/java/engineer/nightowl/sonos/api/util/SonosCallbackHelperTest.java
@@ -2,14 +2,16 @@
 
 import engineer.nightowl.sonos.api.exception.SonosApiClientException;
 import org.apache.http.entity.ContentType;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.security.NoSuchAlgorithmException;
 import java.util.HashMap;
 import java.util.Map;
 
-public class SonosCallbackHelperTest
+class SonosCallbackHelperTest
 {
     final String apiKey = "sonos";
     final String apiSecret = "secret";
@@ -43,14 +45,14 @@ private Map<String, String> getInvalidHeaders()
     }
 
     @Test
-    public void testVerifySignatureWithValidHeaders() throws SonosApiClientException, NoSuchAlgorithmException
+    void testVerifySignatureWithValidHeaders() throws SonosApiClientException, NoSuchAlgorithmException
     {
-        Assert.assertTrue(SonosCallbackHelper.verifySignature(getValidHeaders(), apiKey, apiSecret));
+        assertTrue(SonosCallbackHelper.verifySignature(getValidHeaders(), apiKey, apiSecret));
     }
 
     @Test
-    public void testVerifySignatureWithInvalidHeaders() throws SonosApiClientException, NoSuchAlgorithmException
+    void testVerifySignatureWithInvalidHeaders() throws SonosApiClientException, NoSuchAlgorithmException
     {
-        Assert.assertFalse(SonosCallbackHelper.verifySignature(getInvalidHeaders(), apiKey, apiSecret));
+        assertFalse(SonosCallbackHelper.verifySignature(getInvalidHeaders(), apiKey, apiSecret));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -18,31 +18,26 @@`
`18`	`18`	`import org.apache.http.impl.client.CloseableHttpClient;`
`19`	`19`	`import org.apache.http.message.BasicHeader;`
`20`	`20`	`import org.apache.http.message.BasicStatusLine;`
`21`		`-import org.junit.Assert;`
`22`		`-import org.junit.BeforeClass;`
`23`		`-import org.junit.Rule;`
`24`		`-import org.junit.Test;`
`25`		`-import org.mockito.junit.MockitoJUnit;`
`26`		`-import org.mockito.junit.MockitoRule;`
`27`		`-import org.mockito.quality.Strictness;`
	`21`	`+import org.junit.jupiter.api.BeforeAll;`
	`22`	`+import org.junit.jupiter.api.Test;`
`28`	`23`
`29`	`24`	`import java.io.IOException;`
`30`	`25`
	`26`	`+import static org.junit.jupiter.api.Assertions.assertEquals;`
	`27`	`+import static org.junit.jupiter.api.Assertions.assertThrows;`
	`28`	`+import static org.junit.jupiter.api.Assertions.fail;`
`31`	`29`	`import static org.mockito.ArgumentMatchers.any;`
`32`	`30`	`import static org.mockito.Mockito.mock;`
`33`	`31`	`import static org.mockito.Mockito.when;`
`34`	`32`
`35`	`33`	`public class BaseResourceTest`
`36`	`34`	`{`
`37`		`- @Rule`
`38`		`- public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);`
`39`		`-`
`40`	`35`	`private static BaseResource baseResource;`
`41`	`36`	`private static SonosApiClient client;`
`42`	`37`	`private static SonosApiConfiguration configuration;`
`43`	`38`	`private static CloseableHttpClient mockedClient;`
`44`	`39`
`45`		`- @BeforeClass`
	`40`	`+ @BeforeAll`
`46`	`41`	`public static void setUp() throws Exception`
`47`	`42`	`{`
`48`	`43`	`client = mock(SonosApiClient.class);`
`@@ -56,18 +51,18 @@ public static void setUp() throws Exception`
`56`	`51`	`}`
`57`	`52`
`58`	`53`	`@Test`
`59`		`- public void getTypeFromHeader() throws SonosApiClientException`
	`54`	`+ void getTypeFromHeader() throws SonosApiClientException`
`60`	`55`	`{`
`61`	`56`	`final CloseableHttpResponse response = mock(CloseableHttpResponse.class);`
`62`	`57`	`when(response.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))`
`63`	`58`	`.thenReturn(new BasicHeader(BaseResource.SONOS_TYPE_HEADER, "homeTheaterOptions"));`
`64`	`59`	`final SonosType type = baseResource.getTypeFromHeader(response);`
`65`	`60`
`66`		`- Assert.assertEquals(SonosType.homeTheaterOptions, type);`
	`61`	`+ assertEquals(SonosType.homeTheaterOptions, type);`
`67`	`62`	`}`
`68`	`63`
`69`	`64`	`@Test`
`70`		`- public void getInvalidTypeFromHeader() throws SonosApiClientException`
	`65`	`+ void getInvalidTypeFromHeader() throws SonosApiClientException`
`71`	`66`	`{`
`72`	`67`	`final CloseableHttpResponse response = mock(CloseableHttpResponse.class);`
`73`	`68`	`when(response.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))`
`@@ -76,16 +71,16 @@ public void getInvalidTypeFromHeader() throws SonosApiClientException`
`76`	`71`	`try`
`77`	`72`	`{`
`78`	`73`	`baseResource.getTypeFromHeader(response);`
`79`		`- Assert.fail("Did not fail as expected");`
	`74`	`+ fail("Did not fail as expected");`
`80`	`75`	`}`
`81`	`76`	`catch(SonosApiClientException sace)`
`82`	`77`	`{`
`83`		`- Assert.assertEquals(IllegalArgumentException.class, sace.getCause().getClass());`
	`78`	`+ assertEquals(IllegalArgumentException.class, sace.getCause().getClass());`
`84`	`79`	`}`
`85`	`80`	`}`
`86`	`81`
`87`	`82`	`@Test`
`88`		`- public void testThatMainApiCallWorks() throws IOException, SonosApiClientException, SonosApiError`
	`83`	`+ void testThatMainApiCallWorks() throws IOException, SonosApiClientException, SonosApiError`
`89`	`84`	`{`
`90`	`85`	`// Test data`
`91`	`86`	`final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();`
`@@ -104,11 +99,11 @@ public void testThatMainApiCallWorks() throws IOException, SonosApiClientExcepti`
`104`	`99`	`final SonosHomeTheaterOptions responseOptions = baseResource.getFromApi(SonosHomeTheaterOptions.class,`
`105`	`100`	`"token123", "some/test");`
`106`	`101`
`107`		`- Assert.assertEquals(options, responseOptions);`
	`102`	`+ assertEquals(options, responseOptions);`
`108`	`103`	`}`
`109`	`104`
`110`	`105`	`@Test`
`111`		`- public void testSonosNotDeclaringTypeStillWorks() throws IOException, SonosApiClientException, SonosApiError`
	`106`	`+ void testSonosNotDeclaringTypeStillWorks() throws IOException, SonosApiClientException, SonosApiError`
`112`	`107`	`{`
`113`	`108`	`// Test data`
`114`	`109`	`final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();`
`@@ -129,11 +124,11 @@ public void testSonosNotDeclaringTypeStillWorks() throws IOException, SonosApiCl`
`129`	`124`	`final SonosHomeTheaterOptions responseOptions = baseResource.getFromApi(SonosHomeTheaterOptions.class,`
`130`	`125`	`"token123", "some/test");`
`131`	`126`
`132`		`- Assert.assertEquals(options, responseOptions);`
	`127`	`+ assertEquals(options, responseOptions);`
`133`	`128`	`}`
`134`	`129`
`135`	`130`	`@Test`
`136`		`- public void testAuthErrorThrown() throws IOException, SonosApiClientException, SonosApiError`
	`131`	`+ void testAuthErrorThrown() throws IOException, SonosApiClientException, SonosApiError`
`137`	`132`	`{`
`138`	`133`	`final CloseableHttpResponse mockedResponse = mock(CloseableHttpResponse.class);`
`139`	`134`	`final StatusLine sl = new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 401, null);`
`@@ -142,16 +137,16 @@ public void testAuthErrorThrown() throws IOException, SonosApiClientException, S`
`142`	`137`	`try`
`143`	`138`	`{`
`144`	`139`	`baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");`
`145`		`- Assert.fail("Did not handle error response correctly");`
	`140`	`+ fail("Did not handle error response correctly");`
`146`	`141`	`}`
`147`	`142`	`catch (final SonosApiClientException e)`
`148`	`143`	`{`
`149`		`- Assert.assertEquals("Invalid token", e.getMessage());`
	`144`	`+ assertEquals("Invalid token", e.getMessage());`
`150`	`145`	`}`
`151`	`146`	`}`
`152`	`147`
`153`	`148`	`@Test`
`154`		`- public void testApiErrorHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError`
	`149`	`+ void testApiErrorHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError`
`155`	`150`	`{`
`156`	`151`	`// Test data`
`157`	`152`	`final SonosApiError error = new SonosApiError();`
`@@ -171,16 +166,16 @@ public void testApiErrorHandledCorrectly() throws IOException, SonosApiClientExc`
`171`	`166`	`try`
`172`	`167`	`{`
`173`	`168`	`baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");`
`174`		`- Assert.fail("Did not handle error response correctly");`
	`169`	`+ fail("Did not handle error response correctly");`
`175`	`170`	`}`
`176`	`171`	`catch (final SonosApiError e)`
`177`	`172`	`{`
`178`		`- Assert.assertEquals(SonosErrorCode.ERROR_NOT_CAPABLE, e.getErrorCode());`
	`173`	`+ assertEquals(SonosErrorCode.ERROR_NOT_CAPABLE, e.getErrorCode());`
`179`	`174`	`}`
`180`	`175`	`}`
`181`	`176`
`182`	`177`	`@Test`
`183`		`- public void testApiMismatchHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError`
	`178`	`+ void testApiMismatchHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError`
`184`	`179`	`{`
`185`	`180`	`// Test data`
`186`	`181`	`final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();`
`@@ -201,55 +196,55 @@ public void testApiMismatchHandledCorrectly() throws IOException, SonosApiClient`
`201`	`196`	`try`
`202`	`197`	`{`
`203`	`198`	`baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");`
`204`		`- Assert.fail("Did not handle error response correctly");`
	`199`	`+ fail("Did not handle error response correctly");`
`205`	`200`	`}`
`206`	`201`	`catch (final SonosApiClientException e)`
`207`	`202`	`{`
`208`		`- Assert.assertEquals("Sonos declared SonosAudioClip as the response type, but the integration requested SonosHomeTheaterOptions", e.getMessage());`
	`203`	`+ assertEquals("Sonos declared SonosAudioClip as the response type, but the integration requested SonosHomeTheaterOptions", e.getMessage());`
`209`	`204`	`}`
`210`	`205`	`}`
`211`	`206`
`212`	`207`	`@Test`
`213`		`- public void getStandardRequest() throws SonosApiClientException`
	`208`	`+ void getStandardRequest() throws SonosApiClientException`
`214`	`209`	`{`
`215`	`210`	`final HttpGet req = baseResource.getStandardRequest(HttpGet.class, "token123", "/some/path");`
`216`		`- Assert.assertEquals(HttpGet.METHOD_NAME,`
	`211`	`+ assertEquals(HttpGet.METHOD_NAME,`
`217`	`212`	`req.getMethod());`
`218`	`213`
`219`		`- Assert.assertEquals("Bearer token123",`
	`214`	`+ assertEquals("Bearer token123",`
`220`	`215`	`req.getFirstHeader("Authorization").getValue());`
`221`	`216`
`222`		`- Assert.assertEquals(`
	`217`	`+ assertEquals(`
`223`	`218`	`"/control/api/some/path",`
`224`	`219`	`req.getURI().getPath());`
`225`	`220`	`}`
`226`	`221`
`227`	`222`	`@Test`
`228`		`- public void testValidateNotNullNoFieldName() throws SonosApiClientException`
	`223`	`+ void testValidateNotNullNoFieldName() throws SonosApiClientException`
`229`	`224`	`{`
`230`	`225`	`baseResource.validateNotNull("nonEmptyString");`
`231`	`226`	`}`
`232`	`227`
`233`		`- @Test(expected=SonosApiClientException.class)`
`234`		`- public void testValidateNotNullBothNulls() throws SonosApiClientException`
	`228`	`+ @Test`
	`229`	`+ void testValidateNotNullBothNulls()`
`235`	`230`	`{`
`236`		`- baseResource.validateNotNull(null, null);`
	`231`	`+ assertThrows(SonosApiClientException.class, () -> baseResource.validateNotNull(null, null));`
`237`	`232`	`}`
`238`	`233`
`239`		`- @Test(expected=SonosApiClientException.class)`
`240`		`- public void testValidateNotNullObjectNull() throws SonosApiClientException`
	`234`	`+ @Test`
	`235`	`+ void testValidateNotNullObjectNull()`
`241`	`236`	`{`
`242`		`- baseResource.validateNotNull(null, "sonos-api-java");`
	`237`	`+ assertThrows(SonosApiClientException.class, () -> baseResource.validateNotNull(null, "sonos-api-java"));`
`243`	`238`	`}`
`244`	`239`
`245`		`- @Test(expected=SonosApiClientException.class)`
`246`		`- public void testValidateNotNullEmptyObject() throws SonosApiClientException`
	`240`	`+ @Test`
	`241`	`+ void testValidateNotNullEmptyObject()`
`247`	`242`	`{`
`248`		`- baseResource.validateNotNull("", "sonos-api-java");`
	`243`	`+ assertThrows(SonosApiClientException.class, () -> baseResource.validateNotNull("", "sonos-api-java"));`
`249`	`244`	`}`
`250`	`245`
`251`	`246`	`@Test`
`252`		`- public void testValidateNotNullNonEmptyObject() throws SonosApiClientException`
	`247`	`+ void testValidateNotNullNonEmptyObject() throws SonosApiClientException`
`253`	`248`	`{`
`254`	`249`	`baseResource.validateNotNull("nonEmptyString", "sonos-api-java");`
`255`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,14 +2,16 @@`
`2`	`2`
`3`	`3`	`import engineer.nightowl.sonos.api.exception.SonosApiClientException;`
`4`	`4`	`import org.apache.http.entity.ContentType;`
`5`		`-import org.junit.Assert;`
`6`		`-import org.junit.Test;`
	`5`	`+import org.junit.jupiter.api.Test;`
	`6`	`+`
	`7`	`+import static org.junit.jupiter.api.Assertions.assertFalse;`
	`8`	`+import static org.junit.jupiter.api.Assertions.assertTrue;`
`7`	`9`
`8`	`10`	`import java.security.NoSuchAlgorithmException;`
`9`	`11`	`import java.util.HashMap;`
`10`	`12`	`import java.util.Map;`
`11`	`13`
`12`		`-public class SonosCallbackHelperTest`
	`14`	`+class SonosCallbackHelperTest`
`13`	`15`	`{`
`14`	`16`	`final String apiKey = "sonos";`
`15`	`17`	`final String apiSecret = "secret";`
`@@ -43,14 +45,14 @@ private Map<String, String> getInvalidHeaders()`
`43`	`45`	`}`
`44`	`46`
`45`	`47`	`@Test`
`46`		`- public void testVerifySignatureWithValidHeaders() throws SonosApiClientException, NoSuchAlgorithmException`
	`48`	`+ void testVerifySignatureWithValidHeaders() throws SonosApiClientException, NoSuchAlgorithmException`
`47`	`49`	`{`
`48`		`- Assert.assertTrue(SonosCallbackHelper.verifySignature(getValidHeaders(), apiKey, apiSecret));`
	`50`	`+ assertTrue(SonosCallbackHelper.verifySignature(getValidHeaders(), apiKey, apiSecret));`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`@Test`
`52`		`- public void testVerifySignatureWithInvalidHeaders() throws SonosApiClientException, NoSuchAlgorithmException`
	`54`	`+ void testVerifySignatureWithInvalidHeaders() throws SonosApiClientException, NoSuchAlgorithmException`
`53`	`55`	`{`
`54`		`- Assert.assertFalse(SonosCallbackHelper.verifySignature(getInvalidHeaders(), apiKey, apiSecret));`
	`56`	`+ assertFalse(SonosCallbackHelper.verifySignature(getInvalidHeaders(), apiKey, apiSecret));`
`55`	`57`	`}`
`56`	`58`	`}`