Add some tests for the base resource class

Author: nightowlengineer

src/main/java/engineer/nightowl/sonos/api/resource/BaseResource.java

@@ -45,7 +45,7 @@ class BaseResource
      *
      * @see engineer.nightowl.sonos.api.enums.SonosType
      */
-    private static final String SONOS_TYPE_HEADER = "X-Sonos-Type";
+    static final String SONOS_TYPE_HEADER = "X-Sonos-Type";
     private final Logger logger = LoggerFactory.getLogger(getClass());
     SonosApiClient apiClient;
 
@@ -118,6 +118,7 @@ <T> T callApi(final HttpUriRequest request, final Class<T> type) throws SonosApi
             {
                 throw new SonosApiClientException("Unable to parse error response from Sonos", e);
             }
+
             if (SonosType.getErrorTypes().contains(sonosDeclaredClass))
             {
                 throw (SonosApiError) sonosDeclaredClass.getClazz().cast(responseContent);
@@ -135,7 +136,7 @@ <T> T callApi(final HttpUriRequest request, final Class<T> type) throws SonosApi
      * @param response - raw response to fetch the header from
      * @return the {@link SonosType} declared, or null if not found
      */
-    private SonosType getTypeFromHeader(final CloseableHttpResponse response)
+    SonosType getTypeFromHeader(final CloseableHttpResponse response) throws SonosApiClientException
     {
         if (response != null)
         {
@@ -261,7 +262,7 @@ <T, U> T postToApi(final Class<T> returnType, final String token, final String p
      * @return a generic request
      * @throws SonosApiClientException if an error occurs building the request
      */
-    private <T extends HttpRequestBase> T getStandardRequest(final Class<T> requestType, final String token,
+    <T extends HttpRequestBase> T getStandardRequest(final Class<T> requestType, final String token,
                                                              final String path) throws SonosApiClientException
     {
         final T request;
@@ -300,7 +301,7 @@ private <T extends HttpRequestBase> T getStandardRequest(final Class<T> requestT
      * @return a basic GET request
      * @throws SonosApiClientException if an error occurs building the request
      */
-    private HttpGet getGetRequest(final String token, final String path) throws SonosApiClientException
+    HttpGet getGetRequest(final String token, final String path) throws SonosApiClientException
     {
         return getStandardRequest(HttpGet.class, token, path);
     }
@@ -313,7 +314,7 @@ private HttpGet getGetRequest(final String token, final String path) throws Sono
      * @return a basic DELETE request
      * @throws SonosApiClientException if an error occurs building the request
      */
-    private HttpDelete getDeleteRequest(final String token, final String path) throws SonosApiClientException
+    HttpDelete getDeleteRequest(final String token, final String path) throws SonosApiClientException
     {
         return getStandardRequest(HttpDelete.class, token, path);
     }
@@ -326,7 +327,7 @@ private HttpDelete getDeleteRequest(final String token, final String path) throw
      * @return a basic POST request
      * @throws SonosApiClientException if an error occurs building the request
      */
-    private HttpPost getPostRequest(final String token, final String path) throws SonosApiClientException
+    HttpPost getPostRequest(final String token, final String path) throws SonosApiClientException
     {
         return getStandardRequest(HttpPost.class, token, path);
     }

src/test/java/engineer/nightowl/sonos/api/resource/BaseResourceTest.java

@@ -0,0 +1,263 @@
+package engineer.nightowl.sonos.api.resource;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import engineer.nightowl.sonos.api.SonosApiClient;
+import engineer.nightowl.sonos.api.SonosApiConfiguration;
+import engineer.nightowl.sonos.api.domain.SonosHomeTheaterOptions;
+import engineer.nightowl.sonos.api.enums.SonosErrorCode;
+import engineer.nightowl.sonos.api.enums.SonosType;
+import engineer.nightowl.sonos.api.exception.SonosApiClientException;
+import engineer.nightowl.sonos.api.exception.SonosApiError;
+import org.apache.http.HttpEntity;
+import org.apache.http.ProtocolVersion;
+import org.apache.http.StatusLine;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+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 java.io.IOException;
+
+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
+    public static void setUp() throws Exception
+    {
+        client = mock(SonosApiClient.class);
+        configuration = mock(SonosApiConfiguration.class);
+        mockedClient = mock(CloseableHttpClient.class);
+        baseResource = new BaseResource(client);
+
+        when(client.getConfiguration()).thenReturn(configuration);
+        when(client.getHttpClient()).thenReturn(mockedClient);
+        when(configuration.getControlBaseUrl()).thenReturn("/control/api");
+    }
+
+    @Test
+    public 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);
+    }
+
+    @Test
+    public void getInvalidTypeFromHeader() throws SonosApiClientException
+    {
+        final CloseableHttpResponse response = mock(CloseableHttpResponse.class);
+        when(response.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))
+                .thenReturn(new BasicHeader(BaseResource.SONOS_TYPE_HEADER, "unexpectedValue"));
+
+        try
+        {
+            baseResource.getTypeFromHeader(response);
+            Assert.fail("Did not fail as expected");
+        }
+        catch(SonosApiClientException sace)
+        {
+            Assert.assertEquals(IllegalArgumentException.class, sace.getCause().getClass());
+        }
+    }
+
+    @Test
+    public void testThatMainApiCallWorks() throws IOException, SonosApiClientException, SonosApiError
+    {
+        // Test data
+        final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();
+        options.setNightMode(true);
+        options.setEnhanceDialog(true);
+        options.setGroupingLatency(50);
+
+        // Mocks
+        final HttpGet req = baseResource.getGetRequest("token123", "some/test");
+        final HttpEntity entity = new StringEntity(new ObjectMapper().writeValueAsString(options), ContentType.APPLICATION_JSON);
+
+        final CloseableHttpResponse mockedResponse = mock(CloseableHttpResponse.class);
+        when(mockedResponse.getEntity()).thenReturn(entity);
+        final StatusLine sl = new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, null);
+        when(mockedResponse.getStatusLine()).thenReturn(sl);
+        when(client.getHttpClient().execute(any())).thenReturn(mockedResponse);
+        final SonosHomeTheaterOptions responseOptions = baseResource.getFromApi(SonosHomeTheaterOptions.class,
+                "token123", "some/test");
+
+        Assert.assertEquals(options, responseOptions);
+    }
+
+    @Test
+    public void testSonosNotDeclaringTypeStillWorks() throws IOException, SonosApiClientException, SonosApiError
+    {
+        // Test data
+        final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();
+        options.setNightMode(true);
+        options.setEnhanceDialog(true);
+        options.setGroupingLatency(50);
+
+        // Mocks
+        final HttpGet req = baseResource.getGetRequest("token123", "some/test");
+        final HttpEntity entity = new StringEntity(new ObjectMapper().writeValueAsString(options), ContentType.APPLICATION_JSON);
+
+        final CloseableHttpResponse mockedResponse = mock(CloseableHttpResponse.class);
+        when(mockedResponse.getEntity()).thenReturn(entity);
+        final StatusLine sl = new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, null);
+        when(mockedResponse.getStatusLine()).thenReturn(sl);
+        when(mockedResponse.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))
+                .thenReturn(null);
+        when(client.getHttpClient().execute(any())).thenReturn(mockedResponse);
+        final SonosHomeTheaterOptions responseOptions = baseResource.getFromApi(SonosHomeTheaterOptions.class,
+                "token123", "some/test");
+
+        Assert.assertEquals(options, responseOptions);
+    }
+
+    @Test
+    public void testAuthErrorThrown() throws IOException, SonosApiClientException, SonosApiError
+    {
+        // Mocks
+        final HttpGet req = baseResource.getGetRequest("token123", "some/test");
+
+        final CloseableHttpResponse mockedResponse = mock(CloseableHttpResponse.class);
+        final StatusLine sl = new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 401, null);
+        when(mockedResponse.getStatusLine()).thenReturn(sl);
+        when(client.getHttpClient().execute(any())).thenReturn(mockedResponse);
+        try
+        {
+            baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");
+            Assert.fail("Did not handle error response correctly");
+        }
+        catch (final SonosApiClientException e)
+        {
+            Assert.assertEquals("Invalid token", e.getMessage());
+        }
+    }
+
+    @Test
+    public void testApiErrorHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError
+    {
+        // Test data
+        final SonosApiError error = new SonosApiError();
+        error.setErrorCode(SonosErrorCode.ERROR_NOT_CAPABLE);
+        error.setReason("Some test information");
+
+        // Mocks
+        final HttpGet req = baseResource.getGetRequest("token123", "some/test");
+        final HttpEntity entity = new StringEntity(new ObjectMapper().writeValueAsString(error), ContentType.APPLICATION_JSON);
+
+        final CloseableHttpResponse mockedResponse = mock(CloseableHttpResponse.class);
+        when(mockedResponse.getEntity()).thenReturn(entity);
+        final StatusLine sl = new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 500, null);
+        when(mockedResponse.getStatusLine()).thenReturn(sl);
+        when(mockedResponse.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))
+                .thenReturn(new BasicHeader(BaseResource.SONOS_TYPE_HEADER, "globalError"));
+        when(client.getHttpClient().execute(any())).thenReturn(mockedResponse);
+        try
+        {
+            baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");
+            Assert.fail("Did not handle error response correctly");
+        }
+        catch (final SonosApiError e)
+        {
+            Assert.assertEquals(SonosErrorCode.ERROR_NOT_CAPABLE, e.getErrorCode());
+        }
+    }
+
+    @Test
+    public void testApiMismatchHandledCorrectly() throws IOException, SonosApiClientException, SonosApiError
+    {
+        // Test data
+        final SonosHomeTheaterOptions options = new SonosHomeTheaterOptions();
+        options.setNightMode(true);
+        options.setEnhanceDialog(true);
+        options.setGroupingLatency(50);
+
+        // Mocks
+        final HttpGet req = baseResource.getGetRequest("token123", "some/test");
+        final HttpEntity entity = new StringEntity(new ObjectMapper().writeValueAsString(options), ContentType.APPLICATION_JSON);
+
+        final CloseableHttpResponse mockedResponse = mock(CloseableHttpResponse.class);
+        when(mockedResponse.getEntity()).thenReturn(entity);
+        final StatusLine sl = new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, null);
+        when(mockedResponse.getStatusLine()).thenReturn(sl);
+        when(mockedResponse.getFirstHeader(BaseResource.SONOS_TYPE_HEADER))
+                .thenReturn(new BasicHeader(BaseResource.SONOS_TYPE_HEADER, "audioClip"));
+        when(client.getHttpClient().execute(any())).thenReturn(mockedResponse);
+        try
+        {
+            baseResource.getFromApi(SonosHomeTheaterOptions.class, "token123", "some/test");
+            Assert.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());
+        }
+    }
+
+    @Test
+    public void getStandardRequest() throws SonosApiClientException
+    {
+        final HttpGet req = baseResource.getStandardRequest(HttpGet.class, "token123", "/some/path");
+        Assert.assertEquals(HttpGet.METHOD_NAME,
+                req.getMethod());
+
+        Assert.assertEquals("Bearer token123",
+                req.getFirstHeader("Authorization").getValue());
+
+        Assert.assertEquals(
+                "/control/api/some/path",
+                req.getURI().getPath());
+    }
+
+    @Test
+    public void testValidateNotNullNoFieldName() throws SonosApiClientException
+    {
+        baseResource.validateNotNull("nonEmptyString");
+    }
+
+    @Test(expected=SonosApiClientException.class)
+    public void testValidateNotNullBothNulls() throws SonosApiClientException
+    {
+        baseResource.validateNotNull(null, null);
+    }
+
+    @Test(expected=SonosApiClientException.class)
+    public void testValidateNotNullObjectNull() throws SonosApiClientException
+    {
+        baseResource.validateNotNull(null, "sonos-api-java");
+    }
+
+    @Test(expected=SonosApiClientException.class)
+    public void testValidateNotNullEmptyObject() throws SonosApiClientException
+    {
+        baseResource.validateNotNull("", "sonos-api-java");
+    }
+
+    @Test
+    public void testValidateNotNullNonEmptyObject() throws SonosApiClientException
+    {
+        baseResource.validateNotNull("nonEmptyString", "sonos-api-java");
+    }
+}