gerrit.onap Code Review - policy/apex-pdp.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   4  *  Modifications Copyright (C) 2019-2020 Nordix Foundation.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.apex.plugins.event.carrier.restclient;
  23
  24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  25 import static org.awaitility.Awaitility.await;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertNotNull;
  28 import static org.junit.Assert.assertTrue;
  29
  30 import java.io.ByteArrayOutputStream;
  31 import java.io.PrintStream;
  32 import java.util.concurrent.TimeUnit;
  33 import javax.ws.rs.client.Client;
  34 import javax.ws.rs.client.Invocation.Builder;
  35 import javax.ws.rs.client.WebTarget;
  36 import javax.ws.rs.core.Response;
  37 import org.junit.After;
  38 import org.junit.Test;
  39 import org.mockito.Mock;
  40 import org.mockito.Mockito;
  41 import org.mockito.MockitoAnnotations;
  42 import org.onap.policy.apex.service.engine.event.ApexEventException;
  43 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerParameters;
  44 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerPeeredMode;
  45
  46 /**
  47  * This class tests the ApexRestClientConusmer class.
  48  *
  49  */
  50 public class ApexRestClientConusmerTest {
  51     private final PrintStream stdout = System.out;
  52
  53     @Mock
  54     private Client httpClientMock;
  55
  56     @Mock
  57     private WebTarget targetMock;
  58
  59     @Mock
  60     private Builder builderMock;
  61
  62     @Mock
  63     private Response responseMock;
  64
  65     @After
  66     public void after() {
  67         System.setOut(stdout);
  68     }
  69
  70     @Test
  71     public void testApexRestClientConsumerErrors() throws ApexEventException {
  72         MockitoAnnotations.initMocks(this);
  73
  74         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
  75         assertNotNull(arcc);
  76
  77         EventHandlerParameters consumerParameters = new EventHandlerParameters();
  78         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
  79         assertThatThrownBy(() -> arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver))
  80             .hasMessageContaining(
  81                 "specified consumer properties are not applicable to REST client" + " consumer (RestClientConsumer)");
  82
  83         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
  84         consumerParameters.setCarrierTechnologyParameters(rcctp);
  85         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.DELETE);
  86         assertThatThrownBy(() -> {
  87             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
  88         }).hasMessageContaining("specified HTTP method of \"DELETE\" is invalid, only HTTP method \"GET\" is "
  89             + "supported for event reception on REST client consumer (RestClientConsumer)");
  90
  91         assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.DELETE, rcctp.getHttpMethod());
  92         rcctp.setHttpMethod(null);
  93         rcctp.setHttpCodeFilter("zzz");
  94
  95         arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
  96         assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
  97
  98         assertEquals("RestClientConsumer", arcc.getName());
  99
 100         arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 101         assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 102
 103         rcctp.setUrl("http://some.place.that.does.not/exist");
 104         Mockito.doReturn(Response.Status.BAD_REQUEST.getStatusCode()).when(responseMock).getStatus();
 105         Mockito.doReturn(responseMock).when(builderMock).get();
 106         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 107         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 108         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getHttpCodeFilter());
 109         arcc.setClient(httpClientMock);
 110
 111         // We have not set the URL, this test should not receive any events
 112         arcc.start();
 113         await().atMost(200, TimeUnit.MILLISECONDS).until(() -> incomingEventReceiver.getEventCount() == 0);
 114         arcc.stop();
 115         assertEquals(0, incomingEventReceiver.getEventCount());
 116
 117         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 118
 119         // We have not set the URL, this test should not receive any events
 120         arcc.start();
 121         await().atMost(200, TimeUnit.MILLISECONDS).until(() -> incomingEventReceiver.getEventCount() == 0);
 122         arcc.stop();
 123         assertEquals(0, incomingEventReceiver.getEventCount());
 124     }
 125
 126     @Test
 127     public void testApexRestClientConsumerHttpError() throws ApexEventException {
 128         MockitoAnnotations.initMocks(this);
 129
 130         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 131         assertNotNull(arcc);
 132
 133         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 134         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 135         consumerParameters.setCarrierTechnologyParameters(rcctp);
 136         rcctp.setUrl("http://some.place.that.does.not/exist");
 137         rcctp.setHttpCodeFilter("[1-5][0][0-5]");
 138         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 139
 140         arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 141         assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 142
 143         assertEquals("[1-5][0][0-5]", rcctp.getHttpCodeFilter());
 144
 145         assertEquals("RestClientConsumer", arcc.getName());
 146
 147         arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 148         assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 149
 150         Mockito.doReturn(Response.Status.BAD_REQUEST.getStatusCode()).when(responseMock).getStatus();
 151         Mockito.doReturn(responseMock).when(builderMock).get();
 152         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 153         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 154         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 155         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getHttpCodeFilter());
 156         arcc.setClient(httpClientMock);
 157
 158         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 159         System.setOut(new PrintStream(outContent));
 160
 161         // We have not set the URL, this test should not receive any events
 162         arcc.start();
 163         await().atMost(200, TimeUnit.MILLISECONDS).until(() -> incomingEventReceiver.getEventCount() == 0);
 164         arcc.stop();
 165         assertEquals(0, incomingEventReceiver.getEventCount());
 166     }
 167
 168     @Test
 169     public void testApexRestClientConsumerJsonError() throws ApexEventException {
 170         MockitoAnnotations.initMocks(this);
 171
 172         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 173         assertNotNull(arcc);
 174
 175         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 176         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 177         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 178         consumerParameters.setCarrierTechnologyParameters(rcctp);
 179         rcctp.setHttpCodeFilter("[1-5][0][0-5]");
 180
 181         arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 182         assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 183         assertEquals("RestClientConsumer", arcc.getName());
 184
 185         arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 186
 187         assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 188
 189         rcctp.setUrl("http://some.place.that.does.not/exist");
 190         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 191         Mockito.doReturn(responseMock).when(builderMock).get();
 192         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 193         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 194         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 195         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getHttpCodeFilter());
 196         arcc.setClient(httpClientMock);
 197
 198         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 199         System.setOut(new PrintStream(outContent));
 200
 201         // We have not set the URL, this test should not receive any events
 202         arcc.start();
 203         await().atMost(400, TimeUnit.MILLISECONDS).until(() -> outContent.toString()
 204             .contains("received an empty event from URL \"http://some.place.that.does.not/exist\""));
 205         arcc.stop();
 206         assertEquals(0, incomingEventReceiver.getEventCount());
 207     }
 208
 209     @Test
 210     public void testApexRestClientConsumerJsonEmpty() throws ApexEventException {
 211         MockitoAnnotations.initMocks(this);
 212
 213         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 214         assertNotNull(arcc);
 215
 216         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 217         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 218         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 219         consumerParameters.setCarrierTechnologyParameters(rcctp);
 220         rcctp.setHttpCodeFilter("[1-5][0][0-5]");
 221
 222         arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 223         assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 224
 225         assertEquals("RestClientConsumer", arcc.getName());
 226
 227         arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 228
 229         assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 230
 231         rcctp.setUrl("http://some.place.that.does.not/exist");
 232         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 233         Mockito.doReturn("").when(responseMock).readEntity(String.class);
 234         Mockito.doReturn(responseMock).when(builderMock).get();
 235         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 236         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 237         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 238         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getHttpCodeFilter());
 239         arcc.setClient(httpClientMock);
 240
 241         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 242         System.setOut(new PrintStream(outContent));
 243
 244         // We have not set the URL, this test should not receive any events
 245         arcc.start();
 246         await().atMost(200, TimeUnit.MILLISECONDS).until(() -> outContent.toString()
 247             .contains("received an empty event from URL \"http://some.place.that.does.not/exist\""));
 248         arcc.stop();
 249
 250         assertEquals(0, incomingEventReceiver.getEventCount());
 251
 252         final String outString = outContent.toString();
 253
 254         assertTrue(outString.contains("received an empty event from URL \"http://some.place.that.does.not/exist\""));
 255     }
 256
 257     @Test
 258     public void testApexRestClientConsumerJsonOk() throws ApexEventException {
 259         MockitoAnnotations.initMocks(this);
 260
 261         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 262         assertNotNull(arcc);
 263
 264         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 265         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 266         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 267         consumerParameters.setCarrierTechnologyParameters(rcctp);
 268         rcctp.setHttpCodeFilter("[1-5][0][0-5]");
 269
 270         arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 271         assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 272
 273         assertEquals("RestClientConsumer", arcc.getName());
 274
 275         arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 276
 277         assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 278
 279         rcctp.setUrl("http://some.place.that.does.not/exist");
 280         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 281         Mockito.doReturn("This is an event").when(responseMock).readEntity(String.class);
 282         Mockito.doReturn(responseMock).when(builderMock).get();
 283         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 284         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 285         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 286         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getHttpCodeFilter());
 287         arcc.setClient(httpClientMock);
 288
 289         // We have not set the URL, this test should not receive any events
 290         arcc.start();
 291         await().atMost(400, TimeUnit.MILLISECONDS)
 292             .until(() -> incomingEventReceiver.getLastEvent().equals("This is an event"));
 293         arcc.stop();
 294     }
 295
 296     @Test
 297     public void testApexRestClientConsumerInvalidStatusCode() throws ApexEventException {
 298         MockitoAnnotations.initMocks(this);
 299
 300         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 301         assertNotNull(arcc);
 302
 303         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 304         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 305         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 306         consumerParameters.setCarrierTechnologyParameters(rcctp);
 307         rcctp.setHttpCodeFilter("zzz");
 308
 309         arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 310         assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 311
 312         assertEquals("RestClientConsumer", arcc.getName());
 313
 314         arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 315
 316         assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 317
 318         rcctp.setUrl("http://some.place.that.does.not/exist");
 319         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 320         Mockito.doReturn("This is an event").when(responseMock).readEntity(String.class);
 321         Mockito.doReturn(responseMock).when(builderMock).get();
 322         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 323         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 324         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 325         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getHttpCodeFilter());
 326         arcc.setClient(httpClientMock);
 327
 328         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 329         System.setOut(new PrintStream(outContent));
 330
 331         arcc.start();
 332         await().atMost(200, TimeUnit.MILLISECONDS).until(() -> incomingEventReceiver.getEventCount() == 0);
 333         arcc.stop();
 334     }
 335 }