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(targetMock).when(httpClientMock).target(rcctp.getUrl());
 167         arcc.setClient(httpClientMock);
 168
 169         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 170         System.setOut(new PrintStream(outContent));
 171
 172         try {
 173             // We have not set the URL, this test should not receive any events
 174             arcc.start();
 175             ThreadUtilities.sleep(200);
 176             arcc.stop();
 177
 178             assertEquals(0, incomingEventReceiver.getEventCount());
 179         } catch (Exception e) {
 180             fail("test should not throw an exception");
 181         }
 182
 183         final String outString = outContent.toString();
 184         System.setOut(stdout);
 185
 186         assertTrue(outString.contains(
 187             "reception of event from URL \"http://some.place.that.does.not/exist\" failed with status code 400"));
 188     }
 189
 190     @Test
 191     public void testApexRestClientConusmerJsonError() {
 192         MockitoAnnotations.initMocks(this);
 193
 194         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 195         assertNotNull(arcc);
 196
 197         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 198         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 199         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 200         consumerParameters.setCarrierTechnologyParameters(rcctp);
 201
 202         try {
 203             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 204             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 205
 206             assertEquals("RestClientConsumer", arcc.getName());
 207
 208             arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 209             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 210         } catch (ApexEventException e) {
 211             fail("test should not throw an exception");
 212         }
 213
 214         rcctp.setUrl("http://some.place.that.does.not/exist");
 215         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 216         Mockito.doReturn(responseMock).when(builderMock).get();
 217         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 218         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 219         arcc.setClient(httpClientMock);
 220
 221         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 222         System.setOut(new PrintStream(outContent));
 223
 224         try {
 225             // We have not set the URL, this test should not receive any events
 226             arcc.start();
 227             ThreadUtilities.sleep(200);
 228             arcc.stop();
 229
 230             assertEquals(0, incomingEventReceiver.getEventCount());
 231         } catch (Exception e) {
 232             fail("test should not throw an exception");
 233         }
 234
 235         final String outString = outContent.toString();
 236         System.setOut(stdout);
 237
 238         assertTrue(outString.contains(
 239             "received an empty event from URL \"http://some.place.that.does.not/exist\""));
 240     }
 241
 242     @Test
 243     public void testApexRestClientConusmerJsonEmpty() {
 244         MockitoAnnotations.initMocks(this);
 245
 246         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 247         assertNotNull(arcc);
 248
 249         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 250         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 251         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 252         consumerParameters.setCarrierTechnologyParameters(rcctp);
 253
 254         try {
 255             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 256             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 257
 258             assertEquals("RestClientConsumer", arcc.getName());
 259
 260             arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 261             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 262         } catch (ApexEventException e) {
 263             fail("test should not throw an exception");
 264         }
 265
 266         rcctp.setUrl("http://some.place.that.does.not/exist");
 267         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 268         Mockito.doReturn("").when(responseMock).readEntity(String.class);
 269         Mockito.doReturn(responseMock).when(builderMock).get();
 270         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 271         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 272         arcc.setClient(httpClientMock);
 273
 274         ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 275         System.setOut(new PrintStream(outContent));
 276
 277         try {
 278             // We have not set the URL, this test should not receive any events
 279             arcc.start();
 280             ThreadUtilities.sleep(200);
 281             arcc.stop();
 282
 283             assertEquals(0, incomingEventReceiver.getEventCount());
 284         } catch (Exception e) {
 285             fail("test should not throw an exception");
 286         }
 287
 288         final String outString = outContent.toString();
 289         System.setOut(stdout);
 290
 291         assertTrue(outString.contains(
 292             "received an empty event from URL \"http://some.place.that.does.not/exist\""));
 293     }
 294
 295     @Test
 296     public void testApexRestClientConusmerJsonOk() {
 297         MockitoAnnotations.initMocks(this);
 298
 299         ApexRestClientConsumer arcc = new ApexRestClientConsumer();
 300         assertNotNull(arcc);
 301
 302         EventHandlerParameters consumerParameters = new EventHandlerParameters();
 303         SupportApexEventReceiver incomingEventReceiver = new SupportApexEventReceiver();
 304         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 305         consumerParameters.setCarrierTechnologyParameters(rcctp);
 306
 307         try {
 308             arcc.init("RestClientConsumer", consumerParameters, incomingEventReceiver);
 309             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
 310
 311             assertEquals("RestClientConsumer", arcc.getName());
 312
 313             arcc.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 314             assertEquals(null, arcc.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 315         } catch (ApexEventException e) {
 316             fail("test should not throw an exception");
 317         }
 318
 319         rcctp.setUrl("http://some.place.that.does.not/exist");
 320         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 321         Mockito.doReturn("This is an event").when(responseMock).readEntity(String.class);
 322         Mockito.doReturn(responseMock).when(builderMock).get();
 323         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 324         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 325         arcc.setClient(httpClientMock);
 326
 327         try {
 328             // We have not set the URL, this test should not receive any events
 329             arcc.start();
 330             ThreadUtilities.sleep(200);
 331             arcc.stop();
 332
 333             assertEquals("This is an event", incomingEventReceiver.getLastEvent());
 334         } catch (Exception e) {
 335             fail("test should not throw an exception");
 336         }
 337     }
 338 }