src/test/java/org/onap/dcaegen2/services/pmmapper/AppTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.dcaegen2.services.pmmapper;
  22
  23 import static org.junit.Assert.assertFalse;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.junit.jupiter.api.Assertions.assertThrows;
  26 import static org.mockito.Mockito.*;
  27 import static org.mockserver.integration.ClientAndServer.startClientAndServer;
  28 import static org.mockserver.model.HttpResponse.response;
  29
  30 import java.io.IOException;
  31 import java.nio.file.Files;
  32 import java.nio.file.Path;
  33 import java.nio.file.Paths;
  34 import java.util.Arrays;
  35 import java.util.List;
  36
  37 import com.google.gson.Gson;
  38 import io.undertow.server.HttpServerExchange;
  39 import io.undertow.util.StatusCodes;
  40 import org.onap.dcaegen2.services.pmmapper.utils.XMLValidator;
  41 import reactor.core.publisher.Flux;
  42
  43 import org.junit.jupiter.api.AfterAll;
  44 import org.junit.jupiter.api.BeforeAll;
  45 import org.junit.jupiter.api.Test;
  46 import org.junit.jupiter.api.extension.ExtendWith;
  47 import org.mockito.Mockito;
  48 import org.mockito.junit.jupiter.MockitoExtension;
  49 import org.mockserver.client.server.MockServerClient;
  50 import org.mockserver.integration.ClientAndServer;
  51 import org.mockserver.model.HttpRequest;
  52 import org.onap.dcaegen2.services.pmmapper.filtering.MeasFilterHandler;
  53 import org.onap.dcaegen2.services.pmmapper.mapping.Mapper;
  54 import org.onap.dcaegen2.services.pmmapper.model.Event;
  55 import org.onap.dcaegen2.services.pmmapper.model.EventMetadata;
  56 import org.onap.dcaegen2.services.pmmapper.model.MapperConfig;
  57 import org.onap.dcaegen2.services.pmmapper.utils.MeasConverter;
  58 import org.onap.dcaegen2.services.pmmapper.utils.MeasSplitter;
  59 import utils.EventUtils;
  60
  61
  62 @ExtendWith(MockitoExtension.class)
  63 class AppTest {
  64
  65     static ClientAndServer mockServer;
  66     static MockServerClient client;
  67
  68     private static EventMetadata eventMetadata;
  69
  70     private static final Path dataDirectory = Paths.get("src/test/resources/mapper_test/mapping_data/");
  71     private static final Path metadata = Paths.get("src/test/resources/valid_metadata.json");
  72     private static final Path schema = Paths.get("src/main/resources/measCollec_plusString.xsd");
  73
  74
  75     @BeforeAll
  76     public static void setup() {
  77         mockServer =  startClientAndServer(1080);
  78         client = new MockServerClient("127.0.0.1", 1080);
  79     }
  80
  81     @AfterAll
  82     public static void teardown() {
  83         mockServer.stop();
  84     }
  85
  86     @Test
  87     void testHandleBackPressureNullValue() {
  88         assertThrows(NullPointerException.class, () -> App.handleBackPressure(null));
  89     }
  90
  91     @Test
  92     void testHandleBackPressure() {
  93         Event event = utils.EventUtils.makeMockEvent("", mock(EventMetadata.class));
  94         App.handleBackPressure(event);
  95         verify(event.getHttpServerExchange(), times(1)).setStatusCode(StatusCodes.TOO_MANY_REQUESTS);
  96         verify(event.getHttpServerExchange(), times(1)).unDispatch();
  97     }
  98
  99     @Test
 100     void testReceiveRequestNullValue() {
 101         assertThrows(NullPointerException.class, () -> App.receiveRequest(null));
 102     }
 103
 104     @Test
 105     void testReceiveRequest() {
 106         Event event = utils.EventUtils.makeMockEvent("", mock(EventMetadata.class));
 107         App.receiveRequest(event);
 108         verify(event.getHttpServerExchange(), times(1)).setStatusCode(StatusCodes.OK);
 109         verify(event.getHttpServerExchange(), times(1)).unDispatch();
 110     }
 111
 112     @Test
 113     public void testFilterByFileType_success() {
 114         Event mockEvent = Mockito.mock(Event.class);
 115         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 116
 117         HttpServerExchange exchange = Mockito.mock(HttpServerExchange.class);
 118         when(mockEvent.getHttpServerExchange()).thenReturn(exchange);
 119         when(exchange.getRequestPath()).thenReturn("ATEST.xml");
 120
 121         boolean result = App.filterByFileType(new MeasFilterHandler(new MeasConverter()), mockEvent, mockConfig);
 122         assertTrue(result);
 123     }
 124
 125     @Test
 126     public void testFilterByFileType_NonXML() {
 127         Event mockEvent = Mockito.mock(Event.class);
 128         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 129
 130         HttpServerExchange exchange = Mockito.mock(HttpServerExchange.class);
 131         when(mockEvent.getHttpServerExchange()).thenReturn(exchange);
 132         when(exchange.getRequestPath()).thenReturn("ATEST.png");
 133
 134         boolean result = App.filterByFileType(new MeasFilterHandler(new MeasConverter()), mockEvent, mockConfig);
 135         assertFalse(result);
 136     }
 137
 138     @Test
 139     public void testFilterByFileType_throwException() {
 140         Event mockEvent = Mockito.mock(Event.class);
 141         MeasFilterHandler mockFilter = Mockito.mock(MeasFilterHandler.class);
 142         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 143
 144         Mockito.when(mockFilter.filterByFileType(mockEvent)).thenThrow(RuntimeException.class);
 145
 146         boolean result = App.filterByFileType(mockFilter, mockEvent, mockConfig);
 147         assertFalse(result);
 148     }
 149
 150     @Test
 151     public void testValidateXML_success() throws IOException {
 152         XMLValidator mockValidator = new XMLValidator(schema);
 153         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 154
 155         String metadataFileContents = new String(Files.readAllBytes(metadata));
 156         eventMetadata = new Gson().fromJson(metadataFileContents, EventMetadata.class);
 157
 158         Path testFile = Paths.get(dataDirectory + "/valid_data/meas_results.xml");
 159         Event mockEvent = EventUtils.makeMockEvent(EventUtils.fileContentsToString(testFile), eventMetadata);
 160
 161         boolean result = App.validate(mockValidator, mockEvent, mockConfig);
 162
 163         assertTrue(result);
 164     }
 165
 166     @Test
 167     public void testValidateXML_failure() throws IOException {
 168         XMLValidator mockValidator = new XMLValidator(schema);
 169         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 170
 171         String metadataFileContents = new String(Files.readAllBytes(metadata));
 172         eventMetadata = new Gson().fromJson(metadataFileContents, EventMetadata.class);
 173
 174         Path testFile = Paths.get("src/test/resources/xml_validator_test/test_data/invalid/no_managed_element.xml");
 175         Event mockEvent = EventUtils.makeMockEvent(EventUtils.fileContentsToString(testFile), eventMetadata);
 176
 177         boolean result = App.validate(mockValidator, mockEvent, mockConfig);
 178
 179         assertFalse(result);
 180     }
 181
 182     @Test
 183     public void testValidateXML_throwException() {
 184         Event mockEvent = Mockito.mock(Event.class);
 185         XMLValidator mockValidator = Mockito.mock(XMLValidator.class);
 186         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 187
 188         Mockito.when(mockValidator.validate(mockEvent)).thenThrow(RuntimeException.class);
 189         boolean result = App.validate(mockValidator, mockEvent, mockConfig);
 190
 191         assertFalse(result);
 192     }
 193
 194     @Test
 195     public void testFilter_success() {
 196         Event mockEvent = Mockito.mock(Event.class);
 197         List<Event> mockEvents = Arrays.asList(mockEvent);
 198         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 199         boolean result = App.filter(new MeasFilterHandler(new MeasConverter()), mockEvents, mockConfig);
 200         assertTrue(result);
 201     }
 202
 203     @Test
 204     public void testFilter_throwException() {
 205         HttpRequest req = HttpRequest.request();
 206         client.when(req).respond( response().withStatusCode(200));
 207
 208         Event mockEvent = Mockito.mock(Event.class);
 209         List<Event> mockEvents = Arrays.asList(mockEvent);
 210         MeasFilterHandler mockFilter = Mockito.mock(MeasFilterHandler.class);
 211         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 212
 213         Mockito.when(mockConfig.getDmaapDRDeleteEndpoint()).thenReturn("http://127.0.0.1:1080");
 214         Mockito.when(mockConfig.getSubscriberIdentity()).thenReturn("sid");
 215         Mockito.when(mockEvent.getPublishIdentity()).thenReturn("pid");
 216         Mockito.when(mockFilter.filterByMeasType(mockEvent)).thenThrow(RuntimeException.class);
 217
 218         boolean x = App.filter(mockFilter, mockEvents, mockConfig);
 219         assertFalse(x);
 220
 221         client.clear(req);
 222     }
 223
 224     @Test
 225     public void testSplit_empty_success() {
 226         Event mockEvent = Mockito.mock(Event.class);
 227         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 228         MeasConverter mockMeasConverter = Mockito.mock(MeasConverter.class);
 229         Flux<List<Event>> splitResult = App.split(new MeasSplitter(mockMeasConverter), mockEvent, mockConfig);
 230         splitResult.equals(Flux.<List<Event>>empty());
 231     }
 232
 233     @Test
 234     public void testSplit_success() {
 235         Event mockEvent = Mockito.mock(Event.class);
 236         List<Event> mockEvents = Arrays.asList(mockEvent,mockEvent);
 237         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 238         MeasSplitter mockSplitter  = Mockito.mock(MeasSplitter.class);
 239         Mockito.when(mockSplitter.split(mockEvent)).thenReturn(mockEvents);
 240
 241         Flux<List<Event>> splitResult = App.split(mockSplitter, mockEvent, mockConfig);
 242
 243         splitResult.equals(Flux.just(mockEvents));
 244     }
 245
 246     @Test
 247     public void testMapping_empty_success() {
 248         Event mockEvent = Mockito.mock(Event.class);
 249         MeasConverter mockMeasConverter = Mockito.mock(MeasConverter.class);
 250         List<Event> mockEvents = Arrays.asList(mockEvent);
 251         MapperConfig mockConfig = Mockito.mock(MapperConfig.class);
 252         Path mappingTemplate = Paths.get("src/main/resources/mapping.ftl");
 253         Flux<List<Event>> mappingResult = App.map(new Mapper(mappingTemplate,mockMeasConverter), mockEvents, mockConfig);
 254         mappingResult.equals(Flux.<List<Event>>empty());
 255     }
 256
 257 }