plugins/plugins-event/plugins-event-carrier/plugins-event-carrier-jms/src/test/java/org/onap/policy/apex/plugins/event/carrier/jms/ApexJmsConsumerTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Samsung. All rights reserved.
   4  *  Modifications Copyright (C) 2019-2021, 2023 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.jms;
  23
  24 import static org.assertj.core.api.Assertions.assertThatCode;
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.junit.Assert.assertNull;
  28
  29 import jakarta.jms.Connection;
  30 import jakarta.jms.ConnectionFactory;
  31 import jakarta.jms.JMSException;
  32 import jakarta.jms.Message;
  33 import jakarta.jms.Topic;
  34 import java.util.Properties;
  35 import javax.naming.InitialContext;
  36 import javax.naming.NamingException;
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.mockito.ArgumentMatchers;
  40 import org.mockito.Mockito;
  41 import org.onap.policy.apex.service.engine.event.ApexEventException;
  42 import org.onap.policy.apex.service.engine.event.ApexEventProducer;
  43 import org.onap.policy.apex.service.engine.event.ApexEventReceiver;
  44 import org.onap.policy.apex.service.engine.event.ApexEventRuntimeException;
  45 import org.onap.policy.apex.service.engine.event.PeeredReference;
  46 import org.onap.policy.apex.service.parameters.carriertechnology.CarrierTechnologyParameters;
  47 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerParameters;
  48 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerPeeredMode;
  49
  50 public class ApexJmsConsumerTest {
  51
  52     private static final String CONSUMER_NAME = "TestApexJmsConsumer";
  53     private ApexJmsConsumer apexJmsConsumer = null;
  54     private EventHandlerParameters consumerParameters = null;
  55     private ApexEventReceiver incomingEventReceiver = null;
  56     private ApexEventProducer apexJmsProducer = null;
  57     private JmsCarrierTechnologyParameters jmsCarrierTechnologyParameters = null;
  58
  59     /**
  60      * Set up testing.
  61      */
  62     @Before
  63     public void setUp() {
  64         apexJmsConsumer = Mockito.spy(new ApexJmsConsumer());
  65         consumerParameters = new EventHandlerParameters();
  66         apexJmsProducer = new ApexJmsProducer();
  67     }
  68
  69     @Test
  70     public void testInitWithNonJmsCarrierTechnologyParameters() {
  71         consumerParameters.setCarrierTechnologyParameters(new CarrierTechnologyParameters() {
  72         });
  73         assertThatThrownBy(
  74             () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
  75         )
  76             .isInstanceOf(ApexEventException.class);
  77     }
  78
  79     @Test
  80     public void testInitWithJmsCarrierTechnologyParameters() {
  81         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
  82         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
  83         assertThatThrownBy(
  84             () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
  85         )
  86             .isInstanceOf(ApexEventException.class);
  87     }
  88
  89     @Test
  90     public void testInitNoConnectionFactory() throws NamingException {
  91         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
  92         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
  93
  94         final InitialContext context = Mockito.mock(InitialContext.class);
  95         Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
  96         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
  97
  98         assertThatThrownBy(
  99             () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
 100         )
 101             .isInstanceOf(ApexEventException.class);
 102     }
 103
 104     @Test
 105     public void testInitNoConsumerTopic() throws NamingException {
 106         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 107         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 108
 109         final InitialContext context = Mockito.mock(InitialContext.class);
 110         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 111
 112         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 113         Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
 114         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
 115
 116         assertThatThrownBy(
 117             () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
 118         )
 119             .isInstanceOf(ApexEventException.class);
 120     }
 121
 122     @Test
 123     public void testInitNoConnection() throws NamingException, JMSException {
 124         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 125         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 126
 127         final InitialContext context = Mockito.mock(InitialContext.class);
 128         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 129         final Topic topic = Mockito.mock(Topic.class);
 130
 131         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 132         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
 133         Mockito.doThrow(JMSException.class)
 134             .when(connectionFactory)
 135             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 136                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 137
 138         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
 139
 140         assertThatThrownBy(
 141             () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
 142         )
 143             .isInstanceOf(ApexEventException.class);
 144     }
 145
 146     @Test
 147     public void testInitConnectionError() throws NamingException, JMSException {
 148         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 149         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 150
 151         final InitialContext context = Mockito.mock(InitialContext.class);
 152         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 153         final Topic topic = Mockito.mock(Topic.class);
 154         final Connection connection = Mockito.mock(Connection.class);
 155
 156         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 157         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
 158         Mockito.doReturn(connection)
 159             .when(connectionFactory)
 160             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 161                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 162         Mockito.doThrow(JMSException.class).when(connection).start();
 163         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
 164
 165         assertThatThrownBy(
 166             () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
 167         )
 168             .isInstanceOf(ApexEventException.class);
 169     }
 170
 171     @Test
 172     public void testInit() throws NamingException, JMSException, ApexEventException {
 173         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 174         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 175
 176         final InitialContext context = Mockito.mock(InitialContext.class);
 177         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 178         final Topic topic = Mockito.mock(Topic.class);
 179         final Connection connection = Mockito.mock(Connection.class);
 180
 181         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 182         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
 183         Mockito.doReturn(connection)
 184             .when(connectionFactory)
 185             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 186                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 187         Mockito.doNothing().when(connection).start();
 188         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
 189
 190         apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
 191
 192         Mockito.verify(connection, Mockito.times(1)).start();
 193     }
 194
 195     @Test
 196     public void testStart() {
 197         assertThatCode(apexJmsConsumer::start).doesNotThrowAnyException();
 198     }
 199
 200     @Test
 201     public void testGetName() {
 202         assertNull(apexJmsConsumer.getName());
 203     }
 204
 205     @Test
 206     public void testGetPeeredReference() {
 207         assertNull(apexJmsConsumer.getPeeredReference(EventHandlerPeeredMode.REQUESTOR));
 208     }
 209
 210     @Test
 211     public void testSetPeeredReference() {
 212         PeeredReference peeredReference = new PeeredReference(EventHandlerPeeredMode.REQUESTOR,
 213             apexJmsConsumer, apexJmsProducer);
 214         apexJmsConsumer.setPeeredReference(EventHandlerPeeredMode.REQUESTOR, peeredReference);
 215         assertNotNull(apexJmsConsumer.getPeeredReference(EventHandlerPeeredMode.REQUESTOR));
 216     }
 217
 218     @Test
 219     public void testRun() {
 220         assertThatThrownBy(apexJmsConsumer::run).isInstanceOf(ApexEventRuntimeException.class);
 221     }
 222
 223     @Test
 224     public void testOnMessageUninitialized() {
 225         Message jmsMessage = null;
 226         assertThatThrownBy(() -> apexJmsConsumer.onMessage(jmsMessage))
 227             .isInstanceOf(ApexEventRuntimeException.class);
 228     }
 229
 230     @Test
 231     public void testOnMessage() throws JMSException, NamingException, ApexEventException {
 232         // prepare ApexJmsConsumer
 233         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 234         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 235
 236         final InitialContext context = Mockito.mock(InitialContext.class);
 237         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 238         final Topic topic = Mockito.mock(Topic.class);
 239         final Connection connection = Mockito.mock(Connection.class);
 240         incomingEventReceiver = Mockito.mock(ApexEventReceiver.class);
 241
 242
 243         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 244         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
 245         Mockito.doReturn(connection)
 246             .when(connectionFactory)
 247             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 248                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 249         Mockito.doNothing().when(connection).start();
 250         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
 251
 252         apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
 253
 254         final Message message = Mockito.mock(Message.class);
 255
 256         apexJmsConsumer.onMessage(message);
 257         Mockito
 258             .verify(incomingEventReceiver, Mockito.times(1))
 259             .receiveEvent(ArgumentMatchers.any(Properties.class), ArgumentMatchers.eq(message));
 260     }
 261
 262     @Test
 263     public void testConnectionError() throws NamingException, JMSException, ApexEventException {
 264         // prepare ApexJmsConsumer
 265         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 266         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 267
 268         final InitialContext context = Mockito.mock(InitialContext.class);
 269         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 270         final Topic topic = Mockito.mock(Topic.class);
 271         final Connection connection = Mockito.mock(Connection.class);
 272
 273         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 274         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
 275         Mockito.doReturn(connection)
 276             .when(connectionFactory)
 277             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 278                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 279         Mockito.doNothing().when(connection).start();
 280         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
 281
 282         apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
 283
 284         Mockito.doThrow(JMSException.class).when(connection).close();
 285
 286         // do tests
 287         apexJmsConsumer.start();
 288         assertThatCode(() -> apexJmsConsumer.stop()).doesNotThrowAnyException();
 289         Mockito.verify(connection, Mockito.times(1)).close();
 290     }
 291
 292     @Test
 293     public void testStop() throws NamingException, JMSException, ApexEventException {
 294         // prepare ApexJmsConsumer
 295         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 296         consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 297
 298         final InitialContext context = Mockito.mock(InitialContext.class);
 299         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 300         final Topic topic = Mockito.mock(Topic.class);
 301         final Connection connection = Mockito.mock(Connection.class);
 302
 303         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 304         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
 305         Mockito.doReturn(connection)
 306             .when(connectionFactory)
 307             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 308                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 309         Mockito.doNothing().when(connection).start();
 310         Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
 311
 312         apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
 313
 314         Mockito.doNothing().when(connection).close();
 315
 316         apexJmsConsumer.start();
 317
 318         // do tests
 319         apexJmsConsumer.stop();
 320         Mockito.verify(connection, Mockito.times(1)).close();
 321     }
 322
 323     @Test
 324     public void testStopNoJmsProperties() {
 325         assertThatThrownBy(apexJmsConsumer::stop).isInstanceOf(NullPointerException.class);
 326     }
 327 }