r-app-catalogue/src/test/java/org/oransc/rappcatalogue/api/ServicesApiDelegateImplTest.java

   1 package org.oransc.rappcatalogue.api;\r
   2 \r
   3 import static org.assertj.core.api.Assertions.assertThat;\r
   4 import static org.junit.jupiter.api.Assertions.assertThrows;\r
   5 import static org.mockito.Mockito.mock;\r
   6 import static org.mockito.Mockito.verify;\r
   7 import static org.mockito.Mockito.when;\r
   8 import static org.springframework.http.HttpStatus.CREATED;\r
   9 import static org.springframework.http.HttpStatus.NO_CONTENT;\r
  10 import static org.springframework.http.HttpStatus.OK;\r
  11 \r
  12 import java.io.IOException;\r
  13 import java.io.PrintWriter;\r
  14 import java.sql.Date;\r
  15 import java.util.Arrays;\r
  16 import java.util.List;\r
  17 import javax.servlet.http.HttpServletRequest;\r
  18 import javax.servlet.http.HttpServletResponse;\r
  19 import org.junit.jupiter.api.Test;\r
  20 import org.junit.jupiter.api.extension.ExtendWith;\r
  21 import org.mockito.Mock;\r
  22 import org.mockito.junit.jupiter.MockitoExtension;\r
  23 import org.oransc.rappcatalogue.exception.HeaderException;\r
  24 import org.oransc.rappcatalogue.exception.InvalidServiceException;\r
  25 import org.oransc.rappcatalogue.exception.ServiceNotFoundException;\r
  26 import org.oransc.rappcatalogue.model.InputService;\r
  27 import org.oransc.rappcatalogue.model.Service;\r
  28 import org.springframework.http.ResponseEntity;\r
  29 import org.springframework.web.context.request.NativeWebRequest;\r
  30 \r
  31 @ExtendWith(MockitoExtension.class)\r
  32 class ServicesApiDelegateImplTest {\r
  33 \r
  34     @Mock\r
  35     NativeWebRequest webRequestMock;\r
  36 \r
  37     private static final String INVALID_SERVICE_MESSAGE = "Service is missing required property: version";\r
  38     private static final String SERVICE_NAME = "Service Name";\r
  39     private static final String SERVICE_DESCRIPTION = "description";\r
  40     private static final String SERVICE_VERSION = "1.0";\r
  41     private static final String SERVICE_DISPLAY_NAME = "Display Name";\r
  42 \r
  43     @Test\r
  44     void getAddedService_shouldReturnService() {\r
  45         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);\r
  46 \r
  47         InputService service = new InputService();\r
  48         service.setDescription(SERVICE_DESCRIPTION);\r
  49         service.setVersion(SERVICE_VERSION);\r
  50         service.setDisplayName(SERVICE_DISPLAY_NAME);\r
  51 \r
  52         whenPrintResponseShouldWork();\r
  53 \r
  54         delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
  55 \r
  56         ResponseEntity<Service> response = delegateUnderTest.getIndividualService(SERVICE_NAME);\r
  57 \r
  58         assertThat(response.getStatusCode()).isEqualTo(OK);\r
  59         assertThat(response.getBody().getName()).isEqualTo(SERVICE_NAME);\r
  60     }\r
  61 \r
  62     @Test\r
  63     void getMissingService_shouldThrowException() {\r
  64         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(null);\r
  65 \r
  66         Exception exception = assertThrows(ServiceNotFoundException.class, () -> {\r
  67             delegateUnderTest.getIndividualService(SERVICE_NAME);\r
  68         });\r
  69 \r
  70         String expectedMessage = "Service " + SERVICE_NAME + " not found";\r
  71         String actualMessage = exception.getMessage();\r
  72 \r
  73         assertThat(actualMessage).isEqualTo(expectedMessage);\r
  74     }\r
  75 \r
  76     @Test\r
  77     void putNewValidService_shouldBeCreatedAndRegisteredAndUrlToNewServiceAddedToLocationHeaderInResponse() {\r
  78         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);\r
  79 \r
  80         InputService service = new InputService();\r
  81         service.setDescription(SERVICE_DESCRIPTION);\r
  82         service.setVersion(SERVICE_VERSION);\r
  83         service.setDisplayName(SERVICE_DISPLAY_NAME);\r
  84 \r
  85         String urlToCreatedService = "URL to created Service";\r
  86         HttpServletResponse servletResponseMock = whenPrintResponseShouldWork(urlToCreatedService);\r
  87 \r
  88         ResponseEntity<Void> putResponse = delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
  89 \r
  90         assertThat(putResponse.getStatusCode()).isEqualTo(CREATED);\r
  91         verify(servletResponseMock).addHeader("Location", urlToCreatedService);\r
  92 \r
  93         ResponseEntity<Service> getResponse = delegateUnderTest.getIndividualService(SERVICE_NAME);\r
  94 \r
  95         assertThat(getResponse.getStatusCode()).isEqualTo(OK);\r
  96         Service body = getResponse.getBody();\r
  97         assertThat(body.getName()).isEqualTo(SERVICE_NAME);\r
  98         assertThat(body.getRegistrationDate()).isEqualTo(getTodaysDate());\r
  99     }\r
 100 \r
 101     @Test\r
 102     void putModifiedService_shouldBeModified() {\r
 103         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);\r
 104 \r
 105         InputService service = new InputService();\r
 106         service.setDescription(SERVICE_DESCRIPTION);\r
 107         service.setVersion(SERVICE_VERSION);\r
 108         service.setDisplayName(SERVICE_DISPLAY_NAME);\r
 109 \r
 110         whenPrintResponseShouldWork();\r
 111 \r
 112         delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
 113 \r
 114         String newDescription = "New description";\r
 115         service.setDescription(newDescription);\r
 116         ResponseEntity<Void> putResponse = delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
 117 \r
 118         assertThat(putResponse.getStatusCode()).isEqualTo(OK);\r
 119 \r
 120         ResponseEntity<Service> getResponse = delegateUnderTest.getIndividualService(SERVICE_NAME);\r
 121 \r
 122         assertThat(getResponse.getStatusCode()).isEqualTo(OK);\r
 123         assertThat(getResponse.getBody().getDescription()).isEqualTo(newDescription);\r
 124     }\r
 125 \r
 126     @Test\r
 127     void putServiceWithVersionNull_shouldThrowException() {\r
 128         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(null);\r
 129 \r
 130         InputService service = new InputService();\r
 131         service.setDescription(SERVICE_DESCRIPTION);\r
 132         service.setDisplayName(SERVICE_DISPLAY_NAME);\r
 133 \r
 134         Exception exception = assertThrows(InvalidServiceException.class, () -> {\r
 135             delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
 136         });\r
 137 \r
 138         assertThat(exception.getMessage()).isEqualTo(INVALID_SERVICE_MESSAGE);\r
 139     }\r
 140 \r
 141     @Test\r
 142     void putServiceWithBlankVersion_shouldThrowException() {\r
 143         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(null);\r
 144 \r
 145         InputService service = new InputService();\r
 146         service.setVersion("");\r
 147         service.setDescription(SERVICE_DESCRIPTION);\r
 148         service.setDisplayName(SERVICE_DISPLAY_NAME);\r
 149 \r
 150         Exception exception = assertThrows(InvalidServiceException.class, () -> {\r
 151             delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
 152         });\r
 153 \r
 154         assertThat(exception.getMessage()).isEqualTo(INVALID_SERVICE_MESSAGE);\r
 155     }\r
 156 \r
 157     @Test\r
 158     void putServiceWhenIoExceptionAddingHeader_shouldThrowExceptionAndNoServiceCreated() throws Exception {\r
 159         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);\r
 160 \r
 161         whenGetRequestUrlThenReturnUrl();\r
 162         HttpServletResponse servletResponseMock = mock(HttpServletResponse.class);\r
 163         when(webRequestMock.getNativeResponse(HttpServletResponse.class)).thenReturn(servletResponseMock);\r
 164         when(servletResponseMock.getWriter()).thenThrow(new IOException("Error"));\r
 165 \r
 166         InputService service = new InputService();\r
 167         service.setVersion("1.0");\r
 168         service.setDescription(SERVICE_DESCRIPTION);\r
 169         service.setDisplayName(SERVICE_DISPLAY_NAME);\r
 170 \r
 171         Exception exception = assertThrows(HeaderException.class, () -> {\r
 172             delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
 173         });\r
 174 \r
 175         assertThat(exception.getMessage())\r
 176             .isEqualTo("Unable to set header Location in put response for service " + SERVICE_NAME + ". Cause: Error");\r
 177 \r
 178         ResponseEntity<List<Service>> response = delegateUnderTest.getServices();\r
 179         assertThat(response.getBody()).isEmpty();\r
 180     }\r
 181 \r
 182     @Test\r
 183     void getServices_shouldProvideArrayOfAddedServiceNames() throws Exception {\r
 184         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);\r
 185 \r
 186         InputService service1 = new InputService();\r
 187         service1.setDescription("description 1");\r
 188         service1.setVersion(SERVICE_VERSION);\r
 189         service1.setDisplayName("Display Name 1");\r
 190 \r
 191         InputService service2 = new InputService();\r
 192         service2.setDescription("description 2");\r
 193         service2.setVersion(SERVICE_VERSION);\r
 194         service2.setDisplayName("Display Name 2");\r
 195 \r
 196         whenPrintResponseShouldWork();\r
 197 \r
 198         String serviceName1 = "Service Name 1";\r
 199         delegateUnderTest.putIndividualService(serviceName1, service1);\r
 200         String serviceName2 = "Service Name 2";\r
 201         delegateUnderTest.putIndividualService(serviceName2, service2);\r
 202 \r
 203         ResponseEntity<List<Service>> response = delegateUnderTest.getServices();\r
 204 \r
 205         assertThat(response.getStatusCode()).isEqualTo(OK);\r
 206         List<Service> services = response.getBody();\r
 207         assertThat(services).hasSize(2);\r
 208         List<String> expectedServiceNames = Arrays.asList(serviceName1, serviceName2);\r
 209         assertThat(expectedServiceNames).contains(services.get(0).getName()) //\r
 210             .contains(services.get(1).getName());\r
 211     }\r
 212 \r
 213     @Test\r
 214     void deleteService_shouldBeOk() {\r
 215         ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);\r
 216 \r
 217         InputService service = new InputService();\r
 218         service.setDescription(SERVICE_DESCRIPTION);\r
 219         service.setVersion(SERVICE_VERSION);\r
 220         service.setDisplayName(SERVICE_DISPLAY_NAME);\r
 221 \r
 222         whenPrintResponseShouldWork();\r
 223 \r
 224         delegateUnderTest.putIndividualService(SERVICE_NAME, service);\r
 225 \r
 226         ResponseEntity<List<Service>> servicesResponse = delegateUnderTest.getServices();\r
 227 \r
 228         assertThat(servicesResponse.getBody()).hasSize(1);\r
 229 \r
 230         ResponseEntity<Void> deleteResponse = delegateUnderTest.deleteIndividualService(SERVICE_NAME);\r
 231 \r
 232         assertThat(deleteResponse.getStatusCode()).isEqualTo(NO_CONTENT);\r
 233 \r
 234         servicesResponse = delegateUnderTest.getServices();\r
 235 \r
 236         assertThat(servicesResponse.getBody()).isEmpty();\r
 237     }\r
 238 \r
 239     private void whenGetRequestUrlThenReturnUrl() {\r
 240         whenGetRequestUrlThenReturnUrl("URL");\r
 241     }\r
 242 \r
 243     private void whenGetRequestUrlThenReturnUrl(String url) {\r
 244         HttpServletRequest servletRequestMock = mock(HttpServletRequest.class);\r
 245         when(webRequestMock.getNativeRequest(HttpServletRequest.class)).thenReturn(servletRequestMock);\r
 246         when(servletRequestMock.getRequestURL()).thenReturn(new StringBuffer(url));\r
 247     }\r
 248 \r
 249     private HttpServletResponse whenPrintResponseShouldWork() {\r
 250         return whenPrintResponseShouldWork("URL");\r
 251     }\r
 252 \r
 253     private HttpServletResponse whenPrintResponseShouldWork(String url) {\r
 254         whenGetRequestUrlThenReturnUrl(url);\r
 255         HttpServletResponse servletResponseMock = mock(HttpServletResponse.class);\r
 256         when(webRequestMock.getNativeResponse(HttpServletResponse.class)).thenReturn(servletResponseMock);\r
 257         PrintWriter printWriterMock = mock(PrintWriter.class);\r
 258         try {\r
 259             when(servletResponseMock.getWriter()).thenReturn(printWriterMock);\r
 260         } catch (IOException e) {\r
 261             // Nothing\r
 262         }\r
 263         return servletResponseMock;\r
 264     }\r
 265 \r
 266     private String getTodaysDate() {\r
 267         long millis = System.currentTimeMillis();\r
 268         Date date = new Date(millis);\r
 269         return date.toString();\r
 270     }\r
 271 }\r