1 package org.oransc.rappcatalogue.api;
\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
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
31 @ExtendWith(MockitoExtension.class)
\r
32 class ServicesApiDelegateImplTest {
\r
35 NativeWebRequest webRequestMock;
\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
44 void getAddedService_shouldReturnService() {
\r
45 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);
\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
52 whenPrintResponseShouldWork();
\r
54 delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
56 ResponseEntity<Service> response = delegateUnderTest.getIndividualService(SERVICE_NAME);
\r
58 assertThat(response.getStatusCode()).isEqualTo(OK);
\r
59 assertThat(response.getBody().getName()).isEqualTo(SERVICE_NAME);
\r
63 void getMissingService_shouldThrowException() {
\r
64 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(null);
\r
66 Exception exception = assertThrows(ServiceNotFoundException.class, () -> {
\r
67 delegateUnderTest.getIndividualService(SERVICE_NAME);
\r
70 String expectedMessage = "Service " + SERVICE_NAME + " not found";
\r
71 String actualMessage = exception.getMessage();
\r
73 assertThat(actualMessage).isEqualTo(expectedMessage);
\r
77 void putNewValidService_shouldBeCreatedAndRegisteredAndUrlToNewServiceAddedToLocationHeaderInResponse() {
\r
78 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);
\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
85 String urlToCreatedService = "URL to created Service";
\r
86 HttpServletResponse servletResponseMock = whenPrintResponseShouldWork(urlToCreatedService);
\r
88 ResponseEntity<Void> putResponse = delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
90 assertThat(putResponse.getStatusCode()).isEqualTo(CREATED);
\r
91 verify(servletResponseMock).addHeader("Location", urlToCreatedService);
\r
93 ResponseEntity<Service> getResponse = delegateUnderTest.getIndividualService(SERVICE_NAME);
\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
102 void putModifiedService_shouldBeModified() {
\r
103 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);
\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
110 whenPrintResponseShouldWork();
\r
112 delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
114 String newDescription = "New description";
\r
115 service.setDescription(newDescription);
\r
116 ResponseEntity<Void> putResponse = delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
118 assertThat(putResponse.getStatusCode()).isEqualTo(OK);
\r
120 ResponseEntity<Service> getResponse = delegateUnderTest.getIndividualService(SERVICE_NAME);
\r
122 assertThat(getResponse.getStatusCode()).isEqualTo(OK);
\r
123 assertThat(getResponse.getBody().getDescription()).isEqualTo(newDescription);
\r
127 void putServiceWithVersionNull_shouldThrowException() {
\r
128 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(null);
\r
130 InputService service = new InputService();
\r
131 service.setDescription(SERVICE_DESCRIPTION);
\r
132 service.setDisplayName(SERVICE_DISPLAY_NAME);
\r
134 Exception exception = assertThrows(InvalidServiceException.class, () -> {
\r
135 delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
138 assertThat(exception.getMessage()).isEqualTo(INVALID_SERVICE_MESSAGE);
\r
142 void putServiceWithBlankVersion_shouldThrowException() {
\r
143 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(null);
\r
145 InputService service = new InputService();
\r
146 service.setVersion("");
\r
147 service.setDescription(SERVICE_DESCRIPTION);
\r
148 service.setDisplayName(SERVICE_DISPLAY_NAME);
\r
150 Exception exception = assertThrows(InvalidServiceException.class, () -> {
\r
151 delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
154 assertThat(exception.getMessage()).isEqualTo(INVALID_SERVICE_MESSAGE);
\r
158 void putServiceWhenIoException_shouldThrowExceptionAndNoServiceCreated() throws Exception {
\r
159 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);
\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
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
171 Exception exception = assertThrows(HeaderException.class, () -> {
\r
172 delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
175 assertThat(exception.getMessage()).isEqualTo("Unable to set header Location in response. Cause: Error");
\r
177 ResponseEntity<List<Service>> response = delegateUnderTest.getServices();
\r
178 assertThat(response.getBody()).isEmpty();
\r
182 void getServices_shouldProvideArrayOfAddedServiceNames() throws Exception {
\r
183 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);
\r
185 InputService service1 = new InputService();
\r
186 service1.setDescription("description 1");
\r
187 service1.setVersion(SERVICE_VERSION);
\r
188 service1.setDisplayName("Display Name 1");
\r
190 InputService service2 = new InputService();
\r
191 service2.setDescription("description 2");
\r
192 service2.setVersion(SERVICE_VERSION);
\r
193 service2.setDisplayName("Display Name 2");
\r
195 whenPrintResponseShouldWork();
\r
197 String serviceName1 = "Service Name 1";
\r
198 delegateUnderTest.putIndividualService(serviceName1, service1);
\r
199 String serviceName2 = "Service Name 2";
\r
200 delegateUnderTest.putIndividualService(serviceName2, service2);
\r
202 ResponseEntity<List<Service>> response = delegateUnderTest.getServices();
\r
204 assertThat(response.getStatusCode()).isEqualTo(OK);
\r
205 List<Service> services = response.getBody();
\r
206 assertThat(services).hasSize(2);
\r
207 List<String> expectedServiceNames = Arrays.asList(serviceName1, serviceName2);
\r
208 assertThat(expectedServiceNames).contains(services.get(0).getName()) //
\r
209 .contains(services.get(1).getName());
\r
213 void deleteService_shouldBeOk() {
\r
214 ServicesApiDelegateImpl delegateUnderTest = new ServicesApiDelegateImpl(webRequestMock);
\r
216 InputService service = new InputService();
\r
217 service.setDescription(SERVICE_DESCRIPTION);
\r
218 service.setVersion(SERVICE_VERSION);
\r
219 service.setDisplayName(SERVICE_DISPLAY_NAME);
\r
221 whenPrintResponseShouldWork();
\r
223 delegateUnderTest.putIndividualService(SERVICE_NAME, service);
\r
225 ResponseEntity<List<Service>> servicesResponse = delegateUnderTest.getServices();
\r
227 assertThat(servicesResponse.getBody()).hasSize(1);
\r
229 ResponseEntity<Void> deleteResponse = delegateUnderTest.deleteIndividualService(SERVICE_NAME);
\r
231 assertThat(deleteResponse.getStatusCode()).isEqualTo(NO_CONTENT);
\r
233 servicesResponse = delegateUnderTest.getServices();
\r
235 assertThat(servicesResponse.getBody()).isEmpty();
\r
238 private void whenGetRequestUrlThenReturnUrl() {
\r
239 whenGetRequestUrlThenReturnUrl("URL");
\r
242 private void whenGetRequestUrlThenReturnUrl(String url) {
\r
243 HttpServletRequest servletRequestMock = mock(HttpServletRequest.class);
\r
244 when(webRequestMock.getNativeRequest(HttpServletRequest.class)).thenReturn(servletRequestMock);
\r
245 when(servletRequestMock.getRequestURL()).thenReturn(new StringBuffer(url));
\r
248 private HttpServletResponse whenPrintResponseShouldWork() {
\r
249 return whenPrintResponseShouldWork("URL");
\r
252 private HttpServletResponse whenPrintResponseShouldWork(String url) {
\r
253 whenGetRequestUrlThenReturnUrl(url);
\r
254 HttpServletResponse servletResponseMock = mock(HttpServletResponse.class);
\r
255 when(webRequestMock.getNativeResponse(HttpServletResponse.class)).thenReturn(servletResponseMock);
\r
256 PrintWriter printWriterMock = mock(PrintWriter.class);
\r
258 when(servletResponseMock.getWriter()).thenReturn(printWriterMock);
\r
259 } catch (IOException e) {
\r
262 return servletResponseMock;
\r
265 private String getTodaysDate() {
\r
266 long millis = System.currentTimeMillis();
\r
267 Date date = new Date(millis);
\r
268 return date.toString();
\r