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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   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.policy.apex.plugins.event.carrier.restclient;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertNotNull;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.junit.Assert.fail;
  27
  28 import java.io.ByteArrayOutputStream;
  29 import java.io.PrintStream;
  30
  31 import javax.ws.rs.client.Client;
  32 import javax.ws.rs.client.Invocation.Builder;
  33 import javax.ws.rs.client.WebTarget;
  34 import javax.ws.rs.core.Response;
  35
  36 import org.junit.Test;
  37 import org.mockito.Mock;
  38 import org.mockito.Mockito;
  39 import org.mockito.MockitoAnnotations;
  40 import org.onap.policy.apex.core.infrastructure.threading.ThreadUtilities;
  41 import org.onap.policy.apex.service.engine.event.ApexEventException;
  42 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerParameters;
  43 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerPeeredMode;
  44
  45 /**
  46  * This class tests the ApexRestClientConusmer class.
  47  *
  48  */
  49 public class ApexRestClientConusmerTest {
  50     private final PrintStream stdout = System.out;
  51
  52     @Mock
  53     private Client httpClientMock;
  54
  55     @Mock
  56     private WebTarget targetMock;
  57
  58     @Mock
  59     private Builder builderMock;
  60
  61     @Mock
  62     private Response responseMock;
  63
  64     @Test
  65     public void testApexRestClientConusmerErrors() {
  66         MockitoAnnotations.initMocks(this);
  67
  68         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
  69         assertNotNull(arcc);
  70
  71         EventHandlerParameters consumerParameters = new EventHandlerParameters();
  72         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
  73         try {
  74             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
  75             fail("test should throw an exception here");
  76         } catch (ApexEventException e) {
  77             assertEquals(
  78                 "specified consumer properties are not applicable to REST client consumer (RestClientConsumer)",
  79                 e.getMessage());
  80         }
  81
  82         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
  83         consumerParameters.setCarrierTechnologyParameters(rcctp);
  84         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.DELETE);
  85         try {
  86             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
  87             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
  88             fail("test should throw an exception here");
  89         } catch (ApexEventException e) {
  90             assertEquals("specified HTTP method of \"DELETE\" is invalid, only HTTP method \"GET\" is supported "
  91                 + "for event reception on REST client consumer (RestClientConsumer)", e.getMessage());
  92         }
  93
  94         rcctp.setHttpMethod(null);
  95         try {
  96             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
  97             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
  98
  99             assertEquals("RestClientConsumer", arcc.getName());
 100
 101             arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 102             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 103         } catch (ApexEventException e) {
 104             fail("test should not throw an exception");
 105         }
 106
 107         rcctp.setUrl("http://some.place.that.does.not/exist");
 108         Mockito.doReturn(Response.Status.BAD_REQUEST.getStatusCode()).when(responseMock).getStatus();
 109         Mockito.doReturn(responseMock).when(builderMock).get();
 110         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 111         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 112         arcc.setClient(httpClientMock);
 113
 114         try {
 115             // We have not set the URL, this test should not receive any events
 116             arcc.start();
 117             ThreadUtilities.sleep(200);
 118             arcc.stop();
 119
 120             assertEquals(0, incomingEventReceiver.getEventCount());
 121         } catch (Exception e) {
 122             fail("test should not throw an exception");
 123         }
 124
 125         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 126         try {
 127             // We have not set the URL, this test should not receive any events
 128             arcc.start();
 129             ThreadUtilities.sleep(200);
 130             arcc.stop();
 131
 132             assertEquals(0, incomingEventReceiver.getEventCount());
 133         } catch (Exception e) {
 134             fail("test should not throw an exception");
 135         }
 136     }
 137
 138     @Test
 139     public void testApexRestClientConusmerHttpError() {
 140         MockitoAnnotations.initMocks(this);
 141
 142         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 143         assertNotNull(arcc);
 144
 145         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 146         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 147         consumerParameters.setCarrierTechnologyParameters(rcctp);
 148         rcctp.setUrl("http://some.place.that.does.not/exist");
 149         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 150
 151         try {
 152             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 153             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 154
 155             assertEquals("RestClientConsumer", arcc.getName());
 156
 157             arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 158             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 159         } catch (ApexEventException e) {
 160             fail("test should not throw an exception");
 161         }
 162
 163         Mockito.doReturn(Response.Status.BAD_REQUEST.getStatusCode()).when(responseMock).getStatus();
 164         Mockito.doReturn(responseMock).when(builderMock).get();
 165         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 166         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 167         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 168         arcc.setClient(httpClientMock);
 169
 170         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 171         System.setOut(new PrintStream(outContent));
 172
 173         try {
 174             // We have not set the URL, this test should not receive any events
 175             arcc.start();
 176             ThreadUtilities.sleep(200);
 177             arcc.stop();
 178
 179             assertEquals(0, incomingEventReceiver.getEventCount());
 180         } catch (Exception e) {
 181             fail("test should not throw an exception");
 182         }
 183
 184         final String outString = outContent.toString();
 185         System.setOut(stdout);
 186
 187         assertTrue(outString.contains(
 188             "reception of event from URL \"http://some.place.that.does.not/exist\" failed with status code 400"));
 189     }
 190
 191     @Test
 192     public void testApexRestClientConusmerJsonError() {
 193         MockitoAnnotations.initMocks(this);
 194
 195         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 196         assertNotNull(arcc);
 197
 198         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 199         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 200         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 201         consumerParameters.setCarrierTechnologyParameters(rcctp);
 202
 203         try {
 204             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 205             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 206
 207             assertEquals("RestClientConsumer", arcc.getName());
 208
 209             arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 210             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 211         } catch (ApexEventException e) {
 212             fail("test should not throw an exception");
 213         }
 214
 215         rcctp.setUrl("http://some.place.that.does.not/exist");
 216         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 217         Mockito.doReturn(responseMock).when(builderMock).get();
 218         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 219         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 220         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 221         arcc.setClient(httpClientMock);
 222
 223         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 224         System.setOut(new PrintStream(outContent));
 225
 226         try {
 227             // We have not set the URL, this test should not receive any events
 228             arcc.start();
 229             ThreadUtilities.sleep(200);
 230             arcc.stop();
 231
 232             assertEquals(0, incomingEventReceiver.getEventCount());
 233         } catch (Exception e) {
 234             fail("test should not throw an exception");
 235         }
 236
 237         final String outString = outContent.toString();
 238         System.setOut(stdout);
 239
 240         assertTrue(outString.contains("received an empty event from URL \"http://some.place.that.does.not/exist\""));
 241     }
 242
 243     @Test
 244     public void testApexRestClientConusmerJsonEmpty() {
 245         MockitoAnnotations.initMocks(this);
 246
 247         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 248         assertNotNull(arcc);
 249
 250         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 251         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 252         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 253         consumerParameters.setCarrierTechnologyParameters(rcctp);
 254
 255         try {
 256             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 257             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 258
 259             assertEquals("RestClientConsumer", arcc.getName());
 260
 261             arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 262             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 263         } catch (ApexEventException e) {
 264             fail("test should not throw an exception");
 265         }
 266
 267         rcctp.setUrl("http://some.place.that.does.not/exist");
 268         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 269         Mockito.doReturn("").when(responseMock).readEntity(String.class);
 270         Mockito.doReturn(responseMock).when(builderMock).get();
 271         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 272         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 273         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 274         arcc.setClient(httpClientMock);
 275
 276         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 277         System.setOut(new PrintStream(outContent));
 278
 279         try {
 280             // We have not set the URL, this test should not receive any events
 281             arcc.start();
 282             ThreadUtilities.sleep(200);
 283             arcc.stop();
 284
 285             assertEquals(0, incomingEventReceiver.getEventCount());
 286         } catch (Exception e) {
 287             fail("test should not throw an exception");
 288         }
 289
 290         final String outString = outContent.toString();
 291         System.setOut(stdout);
 292
 293         assertTrue(outString.contains("received an empty event from URL \"http://some.place.that.does.not/exist\""));
 294     }
 295
 296     @Test
 297     public void testApexRestClientConusmerJsonOk() {
 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
 308         try {
 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             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 316         } catch (ApexEventException e) {
 317             fail("test should not throw an exception");
 318         }
 319
 320         rcctp.setUrl("http://some.place.that.does.not/exist");
 321         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 322         Mockito.doReturn("This is an event").when(responseMock).readEntity(String.class);
 323         Mockito.doReturn(responseMock).when(builderMock).get();
 324         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 325         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 326         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 327         arcc.setClient(httpClientMock);
 328
 329         try {
 330             // We have not set the URL, this test should not receive any events
 331             arcc.start();
 332             ThreadUtilities.sleep(200);
 333             arcc.stop();
 334
 335             assertEquals("This is an event", incomingEventReceiver.getLastEvent());
 336         } catch (Exception e) {
 337             fail("test should not throw an exception");
 338         }
 339     }
 340 }