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 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.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.fail;
  27
  28 import ch.qos.logback.classic.Level;
  29
  30 import javax.ws.rs.client.Client;
  31 import javax.ws.rs.client.Invocation.Builder;
  32 import javax.ws.rs.client.WebTarget;
  33 import javax.ws.rs.core.Response;
  34
  35 import org.junit.Test;
  36 import org.mockito.Mock;
  37 import org.mockito.Mockito;
  38 import org.mockito.MockitoAnnotations;
  39 import org.onap.policy.apex.service.engine.event.ApexEventConsumer;
  40 import org.onap.policy.apex.service.engine.event.ApexEventException;
  41 import org.onap.policy.apex.service.engine.event.SynchronousEventCache;
  42 import org.onap.policy.apex.service.engine.event.impl.filecarrierplugin.consumer.ApexFileEventConsumer;
  43 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerParameters;
  44 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerPeeredMode;
  45 import org.onap.policy.common.parameters.GroupValidationResult;
  46 import org.onap.policy.common.parameters.ParameterException;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 import java.util.Properties;
  51
  52 /**
  53  * Test the ApexRestClientProducer class.
  54  *
  55  */
  56 public class ApexRestClientProducerTest {
  57     private static final Logger LOGGER = LoggerFactory.getLogger(ApexRestClientProducer.class);
  58
  59     @Mock
  60     private Client httpClientMock;
  61
  62     @Mock
  63     private WebTarget targetMock;
  64
  65     @Mock
  66     private Builder builderMock;
  67
  68     @Mock
  69     private Response responseMock;
  70
  71     @Test
  72     public void testApexRestClientProducerErrors() {
  73         ApexRestClientProducer arcp = new ApexRestClientProducer();
  74         assertNotNull(arcp);
  75
  76         EventHandlerParameters producerParameters = new EventHandlerParameters();
  77         try {
  78             arcp.init("RestClientProducer", producerParameters);
  79             fail("test should throw an exception here");
  80         } catch (ApexEventException e) {
  81             assertEquals(
  82                 "specified producer properties are not applicable to REST client producer (RestClientProducer)",
  83                 e.getMessage());
  84         }
  85
  86         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
  87         producerParameters.setCarrierTechnologyParameters(rcctp);
  88         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.DELETE);
  89         try {
  90             arcp.init("RestClientConsumer", producerParameters);
  91             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.GET, rcctp.getHttpMethod());
  92             fail("test should throw an exception here");
  93         } catch (ApexEventException e) {
  94             assertEquals("specified HTTP method of \"DELETE\" is invalid, only HTTP methods \"POST\" and \"PUT\" "
  95                 + "are supproted for event sending on REST client producer (RestClientConsumer)", e.getMessage());
  96         }
  97
  98         rcctp.setHttpMethod(null);
  99         try {
 100             arcp.init("RestClientConsumer", producerParameters);
 101             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.POST, rcctp.getHttpMethod());
 102
 103             assertEquals("RestClientConsumer", arcp.getName());
 104
 105             arcp.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 106             assertEquals(null, arcp.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 107
 108             arcp.stop();
 109         } catch (ApexEventException e) {
 110             fail("test should not throw an exception");
 111         }
 112
 113         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.POST);
 114         try {
 115             arcp.init("RestClientConsumer", producerParameters);
 116             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.POST, rcctp.getHttpMethod());
 117
 118             assertEquals("RestClientConsumer", arcp.getName());
 119
 120             arcp.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 121             assertEquals(null, arcp.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 122
 123             arcp.stop();
 124         } catch (ApexEventException e) {
 125             fail("test should not throw an exception");
 126         }
 127
 128         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.PUT);
 129         try {
 130             arcp.init("RestClientConsumer", producerParameters);
 131             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.PUT, rcctp.getHttpMethod());
 132
 133             assertEquals("RestClientConsumer", arcp.getName());
 134
 135             arcp.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, null);
 136             assertEquals(null, arcp.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 137
 138             arcp.stop();
 139         } catch (ApexEventException e) {
 140             fail("test should not throw an exception");
 141         }
 142     }
 143
 144     @Test
 145     public void testApexRestClientProducerPutEvent() {
 146         MockitoAnnotations.initMocks(this);
 147
 148         ApexRestClientProducer arcp = new ApexRestClientProducer();
 149         assertNotNull(arcp);
 150
 151         EventHandlerParameters producerParameters = new EventHandlerParameters();
 152         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 153         producerParameters.setCarrierTechnologyParameters(rcctp);
 154
 155         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.PUT);
 156         try {
 157             arcp.init("RestClientConsumer", producerParameters);
 158             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.PUT, rcctp.getHttpMethod());
 159
 160             assertEquals("RestClientConsumer", arcp.getName());
 161         } catch (ApexEventException e) {
 162             fail("test should not throw an exception");
 163         }
 164
 165         rcctp.setUrl("http://some.place.that.does.not/exist");
 166         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 167         Mockito.doReturn(responseMock).when(builderMock).put(Mockito.any());
 168         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 169         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 170         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 171         arcp.setClient(httpClientMock);
 172
 173         try {
 174             arcp.sendEvent(123, null, "EventName", "This is an Event");
 175             arcp.stop();
 176         } catch (Exception ex) {
 177             fail("test should not throw an exception");
 178         }
 179     }
 180
 181     @Test
 182     public void testApexRestClientProducerPostEventFail() {
 183         MockitoAnnotations.initMocks(this);
 184
 185         ApexRestClientProducer arcp = new ApexRestClientProducer();
 186         assertNotNull(arcp);
 187
 188         EventHandlerParameters producerParameters = new EventHandlerParameters();
 189         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 190         producerParameters.setCarrierTechnologyParameters(rcctp);
 191
 192         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.POST);
 193         try {
 194             arcp.init("RestClientConsumer", producerParameters);
 195             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.POST, rcctp.getHttpMethod());
 196
 197             assertEquals("RestClientConsumer", arcp.getName());
 198         } catch (ApexEventException e) {
 199             fail("test should not throw an exception");
 200         }
 201
 202         rcctp.setUrl("http://some.place.that.does.not/exist");
 203         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 204         Mockito.doReturn(responseMock).when(builderMock).post(Mockito.any());
 205         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 206         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 207         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 208         arcp.setClient(httpClientMock);
 209
 210         //test property not found
 211         rcctp.setUrl("http://some.place2.that.{key}.not/{tag}and.again.{tag}");
 212         Properties properties = new Properties();
 213         properties.put("tag", "exist");
 214         try {
 215             arcp.sendEvent(123, properties, "EventName", "This is an Event");
 216             arcp.stop();
 217             fail("test should throw an exception");
 218         } catch (Exception e) {
 219             assertEquals(
 220                     "key\"key\"specified on url "
 221                             + "\"http://some.place2.that.{key}.not/{tag}and.again.{tag}\"not found "
 222                             + "in execution properties passed by the current policy",
 223                     e.getMessage());
 224         }
 225     }
 226
 227     @Test
 228     public void testApexRestClientProducerPostEventOK() {
 229         MockitoAnnotations.initMocks(this);
 230
 231         ApexRestClientProducer arcp = new ApexRestClientProducer();
 232         assertNotNull(arcp);
 233
 234         EventHandlerParameters producerParameters = new EventHandlerParameters();
 235         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 236         producerParameters.setCarrierTechnologyParameters(rcctp);
 237
 238         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.PUT);
 239         try {
 240             arcp.init("RestClientConsumer", producerParameters);
 241             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.PUT, rcctp.getHttpMethod());
 242
 243             assertEquals("RestClientConsumer", arcp.getName());
 244         } catch (ApexEventException e) {
 245             fail("test should not throw an exception");
 246         }
 247
 248         System.out.println("fail test");
 249         rcctp.setUrl("http://some.place.{key}.does.not/{tag}");
 250         Properties properties = new Properties();
 251         properties.put("tag", "exist");
 252         properties.put("key", "that");
 253         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 254         Mockito.doReturn(responseMock).when(builderMock).put(Mockito.any());
 255         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 256         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 257         Mockito.doReturn(targetMock).when(httpClientMock).target("http://some.place.that.does.not/exist");
 258         arcp.setClient(httpClientMock);
 259
 260         try {
 261             arcp.sendEvent(123, properties, "EventName", "This is an Event");
 262             arcp.stop();
 263         } catch (Exception ex) {
 264             fail("test should not throw an exception");
 265         }
 266     }
 267
 268     @Test
 269     public void testApexRestClientProducerPostEventCache() {
 270         MockitoAnnotations.initMocks(this);
 271
 272         ApexRestClientProducer arcp = new ApexRestClientProducer();
 273         assertNotNull(arcp);
 274
 275         EventHandlerParameters producerParameters = new EventHandlerParameters();
 276         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 277         producerParameters.setCarrierTechnologyParameters(rcctp);
 278
 279         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.POST);
 280
 281         ApexEventConsumer consumer = new ApexFileEventConsumer();
 282         SynchronousEventCache cache = new SynchronousEventCache(EventHandlerPeeredMode.SYNCHRONOUS, consumer, arcp,
 283             1000);
 284         arcp.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, cache);
 285         assertEquals(cache, arcp.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 286         try {
 287             arcp.init("RestClientConsumer", producerParameters);
 288             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.POST, rcctp.getHttpMethod());
 289
 290             assertEquals("RestClientConsumer", arcp.getName());
 291         } catch (ApexEventException e) {
 292             fail("test should not throw an exception");
 293         }
 294
 295         rcctp.setUrl("http://some.place.that.does.not/exist");
 296         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 297         Mockito.doReturn(responseMock).when(builderMock).post(Mockito.any());
 298         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 299         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 300         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 301         arcp.setClient(httpClientMock);
 302
 303         try {
 304             arcp.sendEvent(123, null, "EventName", "This is an Event");
 305             arcp.stop();
 306         } catch (Exception e) {
 307             fail("test should not throw an exception");
 308         }
 309     }
 310
 311     @Test
 312     public void testApexRestClientProducerPostEventCacheTrace() {
 313         MockitoAnnotations.initMocks(this);
 314
 315         ch.qos.logback.classic.Logger classicLogger = (ch.qos.logback.classic.Logger) LOGGER;
 316         classicLogger.setLevel(Level.TRACE);
 317
 318         ApexRestClientProducer arcp = new ApexRestClientProducer();
 319         assertNotNull(arcp);
 320
 321         EventHandlerParameters producerParameters = new EventHandlerParameters();
 322         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 323         producerParameters.setCarrierTechnologyParameters(rcctp);
 324
 325         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.POST);
 326
 327         ApexEventConsumer consumer = new ApexFileEventConsumer();
 328         SynchronousEventCache cache = new SynchronousEventCache(EventHandlerPeeredMode.SYNCHRONOUS, consumer, arcp,
 329             1000);
 330         arcp.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS, cache);
 331         assertEquals(cache, arcp.getPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS));
 332         try {
 333             arcp.init("RestClientConsumer", producerParameters);
 334             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.POST, rcctp.getHttpMethod());
 335
 336             assertEquals("RestClientConsumer", arcp.getName());
 337         } catch (ApexEventException e) {
 338             fail("test should not throw an exception");
 339         }
 340
 341         rcctp.setUrl("http://some.place.that.does.not/exist");
 342         Mockito.doReturn(Response.Status.OK.getStatusCode()).when(responseMock).getStatus();
 343         Mockito.doReturn(responseMock).when(builderMock).post(Mockito.any());
 344         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 345         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 346         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 347         arcp.setClient(httpClientMock);
 348
 349         try {
 350             arcp.sendEvent(123, null, "EventName", "This is an Event");
 351             arcp.stop();
 352         } catch (Exception e) {
 353             fail("test should not throw an exception");
 354         }
 355     }
 356
 357     @Test
 358     public void testApexRestClientProducerHttpError() {
 359         MockitoAnnotations.initMocks(this);
 360
 361         ApexRestClientProducer arcp = new ApexRestClientProducer();
 362         assertNotNull(arcp);
 363
 364         EventHandlerParameters producerParameters = new EventHandlerParameters();
 365         RestClientCarrierTechnologyParameters rcctp = new RestClientCarrierTechnologyParameters();
 366         producerParameters.setCarrierTechnologyParameters(rcctp);
 367
 368         rcctp.setHttpMethod(RestClientCarrierTechnologyParameters.HttpMethod.POST);
 369         try {
 370             arcp.init("RestClientConsumer", producerParameters);
 371             assertEquals(RestClientCarrierTechnologyParameters.HttpMethod.POST, rcctp.getHttpMethod());
 372
 373             assertEquals("RestClientConsumer", arcp.getName());
 374         } catch (ApexEventException e) {
 375             fail("test should not throw an exception");
 376         }
 377
 378         rcctp.setUrl("http://some.place.that.does.not/exist");
 379         Mockito.doReturn(Response.Status.BAD_REQUEST.getStatusCode()).when(responseMock).getStatus();
 380         Mockito.doReturn(responseMock).when(builderMock).post(Mockito.any());
 381         Mockito.doReturn(builderMock).when(targetMock).request("application/json");
 382         Mockito.doReturn(builderMock).when(builderMock).headers(Mockito.any());
 383         Mockito.doReturn(targetMock).when(httpClientMock).target(rcctp.getUrl());
 384         arcp.setClient(httpClientMock);
 385
 386         try {
 387             arcp.sendEvent(123, null, "EventName", "This is an Event");
 388             fail("test should throw an exception here");
 389         } catch (Exception e) {
 390             assertEquals(
 391                 "send of event to URL \"http://some.place.that.does.not/exist\" using HTTP \"POST\" "
 392                     + "failed with status code 400 and message \"null\", event:\n" + "This is an Event",
 393                 e.getMessage());
 394         }
 395     }
 396 }