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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Samsung. All rights reserved.
   4  *  Modifications Copyright (C) 2019-2021, 2023 Nordix Foundation.
   5  *  Modifications Copyright (C) 2022 Bell Canada. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * SPDX-License-Identifier: Apache-2.0
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.apex.plugins.event.carrier.jms;
  24
  25 import static org.assertj.core.api.Assertions.assertThat;
  26 import static org.assertj.core.api.Assertions.assertThatCode;
  27 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  28 import static org.junit.Assert.assertNull;
  29 import static org.junit.Assert.assertSame;
  30
  31 import jakarta.jms.Connection;
  32 import jakarta.jms.ConnectionFactory;
  33 import jakarta.jms.JMSException;
  34 import jakarta.jms.Message;
  35 import jakarta.jms.MessageProducer;
  36 import jakarta.jms.ObjectMessage;
  37 import jakarta.jms.Session;
  38 import jakarta.jms.TextMessage;
  39 import jakarta.jms.Topic;
  40 import java.io.ByteArrayOutputStream;
  41 import java.io.PrintStream;
  42 import java.util.Random;
  43 import javax.naming.InitialContext;
  44 import javax.naming.NamingException;
  45 import org.apache.commons.lang3.RandomStringUtils;
  46 import org.junit.After;
  47 import org.junit.Before;
  48 import org.junit.Test;
  49 import org.mockito.Mockito;
  50 import org.onap.policy.apex.service.engine.event.ApexEvent;
  51 import org.onap.policy.apex.service.engine.event.ApexEventException;
  52 import org.onap.policy.apex.service.engine.event.ApexEventRuntimeException;
  53 import org.onap.policy.apex.service.engine.event.PeeredReference;
  54 import org.onap.policy.apex.service.engine.event.SynchronousEventCache;
  55 import org.onap.policy.apex.service.parameters.carriertechnology.CarrierTechnologyParameters;
  56 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerParameters;
  57 import org.onap.policy.apex.service.parameters.eventhandler.EventHandlerPeeredMode;
  58
  59 public class ApexJmsProducerTest {
  60
  61     private static final String PRODUCER_NAME = "TestApexJmsProducer";
  62     private ApexJmsConsumer apexJmsConsumer;
  63     private EventHandlerParameters producerParameters;
  64     private ApexJmsProducer apexJmsProducer;
  65     private JmsCarrierTechnologyParameters jmsCarrierTechnologyParameters;
  66     private static final long DEFAULT_SYNCHRONOUS_EVENT_TIMEOUT = 1000;
  67     private final Random random = new Random();
  68     private final PrintStream out = System.out;
  69
  70     /**
  71      * Set up testing.
  72      *
  73      */
  74     @Before
  75     public void setUp() {
  76         apexJmsConsumer = new ApexJmsConsumer();
  77         producerParameters = new EventHandlerParameters();
  78         apexJmsProducer = Mockito.spy(new ApexJmsProducer());
  79     }
  80
  81     @After
  82     public void tearDown() {
  83         // restore system.out
  84         System.setOut(out);
  85     }
  86
  87     @Test
  88     public void testInitWithNonJmsCarrierTechnologyParameters() {
  89         producerParameters.setCarrierTechnologyParameters(new CarrierTechnologyParameters() {
  90         });
  91         assertThatThrownBy(() -> apexJmsProducer.init(PRODUCER_NAME, producerParameters))
  92             .isInstanceOf(ApexEventException.class);
  93     }
  94
  95     @Test
  96     public void testInitWithJmsCarrierTechnologyParameters() {
  97         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
  98         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
  99         assertThatThrownBy(() -> apexJmsProducer.init(PRODUCER_NAME, producerParameters))
 100             .isInstanceOf(ApexEventException.class);
 101     }
 102
 103     @Test
 104     public void testInitWithoutConnectionFactory() throws NamingException {
 105         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 106         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 107         final String producerName = RandomStringUtils.randomAlphabetic(5);
 108
 109         InitialContext context = Mockito.mock(InitialContext.class);
 110         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 111         Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 112
 113         assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
 114             .isInstanceOf(ApexEventException.class);
 115     }
 116
 117     @Test
 118     public void testInitWithoutTopic() throws NamingException {
 119         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 120         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 121         final String producerName = RandomStringUtils.randomAlphabetic(5);
 122
 123         final InitialContext context = Mockito.mock(InitialContext.class);
 124         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 125
 126         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 127         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 128         Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 129
 130         assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
 131             .isInstanceOf(ApexEventException.class);
 132     }
 133
 134     @Test
 135     public void testInitConnectionCreateError() throws NamingException, JMSException {
 136         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 137         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 138         final String producerName = RandomStringUtils.randomAlphabetic(5);
 139
 140         final InitialContext context = Mockito.mock(InitialContext.class);
 141         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 142         final Topic topic = Mockito.mock(Topic.class);
 143
 144         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 145         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 146         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 147         Mockito.doThrow(JMSException.class).when(connectionFactory)
 148             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 149                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 150
 151         assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
 152             .isInstanceOf(ApexEventException.class);
 153     }
 154
 155     @Test
 156     public void testInitConnectionStartError() throws NamingException, JMSException {
 157         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 158         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 159         final String producerName = RandomStringUtils.randomAlphabetic(5);
 160
 161         final InitialContext context = Mockito.mock(InitialContext.class);
 162         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 163         final Topic topic = Mockito.mock(Topic.class);
 164         final Connection connection = Mockito.mock(Connection.class);
 165
 166         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 167         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 168         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 169         Mockito.doReturn(connection)
 170             .when(connectionFactory)
 171             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 172                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 173         Mockito.doThrow(JMSException.class).when(connection).start();
 174
 175         assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
 176             .isInstanceOf(ApexEventException.class);
 177     }
 178
 179     @Test
 180     public void testInitSessionCreateError() throws NamingException, JMSException {
 181         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 182         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 183         final String producerName = RandomStringUtils.randomAlphabetic(5);
 184
 185         final InitialContext context = Mockito.mock(InitialContext.class);
 186         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 187         final Topic topic = Mockito.mock(Topic.class);
 188         final Connection connection = Mockito.mock(Connection.class);
 189
 190         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 191         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 192         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 193         Mockito.doReturn(connection)
 194             .when(connectionFactory)
 195             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 196                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 197         Mockito.doNothing().when(connection).start();
 198         Mockito.doThrow(JMSException.class).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 199
 200         assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
 201             .isInstanceOf(ApexEventException.class);
 202     }
 203
 204     @Test
 205     public void testInitProducerCreateError() throws NamingException, JMSException {
 206         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 207         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 208         final String producerName = RandomStringUtils.randomAlphabetic(5);
 209
 210         final InitialContext context = Mockito.mock(InitialContext.class);
 211         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 212         final Topic topic = Mockito.mock(Topic.class);
 213         final Connection connection = Mockito.mock(Connection.class);
 214         final Session session = Mockito.mock(Session.class);
 215
 216         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 217         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 218         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 219         Mockito.doReturn(connection)
 220             .when(connectionFactory)
 221             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 222                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 223         Mockito.doNothing().when(connection).start();
 224         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 225         Mockito.doThrow(JMSException.class).when(session).createProducer(topic);
 226         assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
 227             .isInstanceOf(ApexEventException.class);
 228     }
 229
 230     @Test
 231     public void testInit() throws NamingException, JMSException {
 232         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 233         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 234         final String producerName = RandomStringUtils.randomAlphabetic(5);
 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         final Session session = Mockito.mock(Session.class);
 241         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 242
 243         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 244         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 245         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 246         Mockito.doReturn(connection)
 247             .when(connectionFactory)
 248             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 249                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 250         Mockito.doNothing().when(connection).start();
 251         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 252         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 253
 254         assertThatCode(() -> apexJmsProducer.init(producerName, producerParameters))
 255             .doesNotThrowAnyException();
 256     }
 257
 258     @Test
 259     public void testGetName() {
 260         assertNull(apexJmsProducer.getName());
 261     }
 262
 263     @Test
 264     public void testGetPeeredReference() {
 265         assertNull(apexJmsProducer.getPeeredReference(EventHandlerPeeredMode.REQUESTOR));
 266     }
 267
 268     @Test
 269     public void testSetPeeredReference() {
 270         PeeredReference peeredReference = new PeeredReference(EventHandlerPeeredMode.REQUESTOR,
 271             apexJmsConsumer, apexJmsProducer);
 272         apexJmsProducer.setPeeredReference(EventHandlerPeeredMode.REQUESTOR, peeredReference);
 273         final PeeredReference actual = apexJmsProducer.getPeeredReference(EventHandlerPeeredMode.REQUESTOR);
 274         assertSame(peeredReference, actual);
 275     }
 276
 277     @Test
 278     public void testSendEventNotSerializable() {
 279         producerParameters.setCarrierTechnologyParameters(new JmsCarrierTechnologyParameters());
 280         Object object = new Object();
 281         final long executionId = random.nextLong();
 282         assertThatThrownBy(() -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, object))
 283             .isInstanceOf(ApexEventRuntimeException.class);
 284     }
 285
 286     @Test
 287     public void testSendEventRemoveCache() {
 288         producerParameters.setCarrierTechnologyParameters(new JmsCarrierTechnologyParameters());
 289         final SynchronousEventCache synchronousEventCache =
 290             Mockito.spy(new SynchronousEventCache(EventHandlerPeeredMode.SYNCHRONOUS,
 291                 apexJmsConsumer, apexJmsProducer, DEFAULT_SYNCHRONOUS_EVENT_TIMEOUT));
 292         apexJmsProducer.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS,
 293             synchronousEventCache);
 294
 295         Object object = new Object();
 296         final long executionId = random.nextLong();
 297
 298         assertThatThrownBy(() -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, object))
 299             .isInstanceOf(ApexEventRuntimeException.class);
 300         Mockito.verify(synchronousEventCache, Mockito.times(1)).removeCachedEventToApexIfExists(executionId);
 301     }
 302
 303     @Test
 304     public void testSendEventCreateObjectMessageError() throws ApexEventException, NamingException, JMSException {
 305         // Prepare ApexJmsProducer
 306         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 307         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 308
 309         final InitialContext context = Mockito.mock(InitialContext.class);
 310         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 311         final Topic topic = Mockito.mock(Topic.class);
 312         final Connection connection = Mockito.mock(Connection.class);
 313         final Session session = Mockito.mock(Session.class);
 314         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 315
 316         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 317         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 318         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 319         Mockito.doReturn(connection)
 320             .when(connectionFactory)
 321             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 322                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 323         Mockito.doNothing().when(connection).start();
 324         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 325         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 326
 327         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 328
 329         // Prepare sendEvent
 330
 331         ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
 332             "testSource", "testTarget", "");
 333         Mockito.doThrow(JMSException.class).when(session).createObjectMessage(apexEvent);
 334
 335         final long executionId = random.nextLong();
 336
 337
 338         assertThatThrownBy(() -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, apexEvent))
 339             .isInstanceOf(ApexEventRuntimeException.class);
 340     }
 341
 342     @Test
 343     public void testSendEventCreateObjectMessageSendError() throws ApexEventException, NamingException, JMSException {
 344         // Prepare ApexJmsProducer
 345         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 346         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 347
 348         final InitialContext context = Mockito.mock(InitialContext.class);
 349         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 350         final Topic topic = Mockito.mock(Topic.class);
 351         final Connection connection = Mockito.mock(Connection.class);
 352         final Session session = Mockito.mock(Session.class);
 353         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 354
 355         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 356         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 357         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 358         Mockito.doReturn(connection)
 359             .when(connectionFactory)
 360             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 361                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 362         Mockito.doNothing().when(connection).start();
 363         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 364         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 365
 366         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 367
 368         // Prepare sendEvent
 369         final Message message = Mockito.mock(ObjectMessage.class);
 370         ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
 371             "testSource", "testTarget", "");
 372         Mockito.doReturn(message).when(session).createObjectMessage(apexEvent);
 373         Mockito.doThrow(JMSException.class).when(messageProducer).send(message);
 374
 375         final long executionId = random.nextLong();
 376
 377
 378         assertThatThrownBy(
 379             () -> apexJmsProducer
 380                 .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
 381         )
 382             .isInstanceOf(ApexEventRuntimeException.class);
 383     }
 384
 385     @Test
 386     public void testSendEventCreateObjectMessageSend() throws ApexEventException, NamingException, JMSException {
 387         // Prepare ApexJmsProducer
 388         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 389         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 390
 391         final InitialContext context = Mockito.mock(InitialContext.class);
 392         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 393         final Topic topic = Mockito.mock(Topic.class);
 394         final Connection connection = Mockito.mock(Connection.class);
 395         final Session session = Mockito.mock(Session.class);
 396         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 397
 398         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 399         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 400         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 401         Mockito.doReturn(connection)
 402             .when(connectionFactory)
 403             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 404                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 405         Mockito.doNothing().when(connection).start();
 406         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 407         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 408
 409         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 410
 411         // Prepare sendEvent
 412         final Message message = Mockito.mock(ObjectMessage.class);
 413         ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
 414             "testSource", "testTarget", "");
 415         Mockito.doReturn(message).when(session).createObjectMessage(apexEvent);
 416         Mockito.doNothing().when(messageProducer).send(message);
 417
 418         final long executionId = random.nextLong();
 419
 420
 421         assertThatCode(
 422             () -> apexJmsProducer
 423                 .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
 424         )
 425             .doesNotThrowAnyException();
 426     }
 427
 428     @Test
 429     public void testSendEventCreateTextMessageError() throws ApexEventException, NamingException, JMSException {
 430         // Prepare ApexJmsProducer
 431         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 432         jmsCarrierTechnologyParameters.setObjectMessageSending(false);
 433         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 434
 435         final InitialContext context = Mockito.mock(InitialContext.class);
 436         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 437         final Topic topic = Mockito.mock(Topic.class);
 438         final Connection connection = Mockito.mock(Connection.class);
 439         final Session session = Mockito.mock(Session.class);
 440         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 441
 442         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 443         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 444         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 445         Mockito.doReturn(connection)
 446             .when(connectionFactory)
 447             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 448                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 449         Mockito.doNothing().when(connection).start();
 450         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 451         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 452         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 453
 454         // Prepare sendEvent
 455         ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
 456             "testSource", "testTarget", "");
 457
 458         Mockito.doThrow(JMSException.class).when(session).createTextMessage(apexEvent.toString());
 459
 460         final long executionId = random.nextLong();
 461
 462         assertThatThrownBy(
 463             () -> apexJmsProducer
 464                 .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
 465         )
 466             .isInstanceOf(ApexEventRuntimeException.class);
 467     }
 468
 469     @Test
 470     public void testSendEventCreateTextMessageSendError() throws ApexEventException, NamingException, JMSException {
 471         // Prepare ApexJmsProducer
 472         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 473         jmsCarrierTechnologyParameters.setObjectMessageSending(false);
 474         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 475
 476         final InitialContext context = Mockito.mock(InitialContext.class);
 477         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 478         final Topic topic = Mockito.mock(Topic.class);
 479         final Connection connection = Mockito.mock(Connection.class);
 480         final Session session = Mockito.mock(Session.class);
 481         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 482
 483         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 484         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 485         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 486         Mockito.doReturn(connection)
 487             .when(connectionFactory)
 488             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 489                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 490         Mockito.doNothing().when(connection).start();
 491         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 492         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 493
 494         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 495
 496         // Prepare sendEvent
 497         final Message message = Mockito.mock(TextMessage.class);
 498         ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
 499             "testSource", "testTarget", "");
 500         Mockito.doReturn(message).when(session).createTextMessage(apexEvent.toString());
 501         Mockito.doThrow(JMSException.class).when(messageProducer).send(message);
 502
 503         final long executionId = random.nextLong();
 504
 505
 506         assertThatThrownBy(
 507             () -> apexJmsProducer
 508                 .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
 509         )
 510             .isInstanceOf(ApexEventRuntimeException.class);
 511     }
 512
 513     @Test
 514     public void testSendEventCreateTextMessageSend() throws ApexEventException, NamingException, JMSException {
 515         // Prepare ApexJmsProducer
 516         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 517         jmsCarrierTechnologyParameters.setObjectMessageSending(false);
 518         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 519
 520         final InitialContext context = Mockito.mock(InitialContext.class);
 521         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 522         final Topic topic = Mockito.mock(Topic.class);
 523         final Connection connection = Mockito.mock(Connection.class);
 524         final Session session = Mockito.mock(Session.class);
 525         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 526
 527         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 528         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 529         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 530         Mockito.doReturn(connection)
 531             .when(connectionFactory)
 532             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 533                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 534         Mockito.doNothing().when(connection).start();
 535         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 536         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 537
 538         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 539
 540         // Prepare sendEvent
 541         final Message message = Mockito.mock(TextMessage.class);
 542         ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
 543             "testSource", "testTarget", "");
 544         Mockito.doReturn(message).when(session).createTextMessage(apexEvent.toString());
 545         Mockito.doNothing().when(messageProducer).send(message);
 546
 547         final long executionId = random.nextLong();
 548
 549
 550         assertThatCode(
 551             () -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
 552         )
 553             .doesNotThrowAnyException();
 554     }
 555
 556     @Test
 557     public void testStopProducerException() throws NamingException, ApexEventException, JMSException {
 558         // Prepare ApexJmsProducer
 559         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 560         jmsCarrierTechnologyParameters.setObjectMessageSending(false);
 561         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 562
 563         final InitialContext context = Mockito.mock(InitialContext.class);
 564         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 565         final Topic topic = Mockito.mock(Topic.class);
 566         final Connection connection = Mockito.mock(Connection.class);
 567         final Session session = Mockito.mock(Session.class);
 568         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 569
 570         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 571         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 572         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 573         Mockito.doReturn(connection)
 574             .when(connectionFactory)
 575             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 576                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 577         Mockito.doNothing().when(connection).start();
 578         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 579         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 580
 581         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 582
 583         // Prepare stop mock
 584         Mockito.doThrow(JMSException.class).when(messageProducer).close();
 585
 586         // Prepare system.out
 587         final ByteArrayOutputStream testBuffer = new ByteArrayOutputStream();
 588         System.setOut(new PrintStream(testBuffer));
 589
 590         // do the test
 591         assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
 592         assertThat(testBuffer.toString()).contains("failed to close JMS message producer");
 593     }
 594
 595     @Test
 596     public void testStopCloseSessionException() throws NamingException, ApexEventException, JMSException {
 597         // Prepare ApexJmsProducer
 598         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 599         jmsCarrierTechnologyParameters.setObjectMessageSending(false);
 600         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 601
 602         final InitialContext context = Mockito.mock(InitialContext.class);
 603         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 604         final Topic topic = Mockito.mock(Topic.class);
 605         final Connection connection = Mockito.mock(Connection.class);
 606         final Session session = Mockito.mock(Session.class);
 607         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 608
 609         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 610         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 611         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 612         Mockito.doReturn(connection)
 613             .when(connectionFactory)
 614             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 615                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 616         Mockito.doNothing().when(connection).start();
 617         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 618         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 619
 620         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 621
 622         // Prepare stop mocks
 623         Mockito.doNothing().when(messageProducer).close();
 624         Mockito.doThrow(JMSException.class).when(session).close();
 625
 626         // Prepare system.out
 627         final ByteArrayOutputStream testBuffer = new ByteArrayOutputStream();
 628         System.setOut(new PrintStream(testBuffer));
 629
 630         // do the test
 631         assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
 632         assertThat(testBuffer.toString()).contains("failed to close the JMS session");
 633     }
 634
 635     @Test
 636     public void testStopCloseConnectionException() throws NamingException, ApexEventException, JMSException {
 637         // Prepare ApexJmsProducer
 638         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 639         jmsCarrierTechnologyParameters.setObjectMessageSending(false);
 640         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 641
 642         final InitialContext context = Mockito.mock(InitialContext.class);
 643         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 644         final Topic topic = Mockito.mock(Topic.class);
 645         final Connection connection = Mockito.mock(Connection.class);
 646         final Session session = Mockito.mock(Session.class);
 647         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 648
 649         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 650         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 651         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 652         Mockito.doReturn(connection)
 653             .when(connectionFactory)
 654             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 655                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 656         Mockito.doNothing().when(connection).start();
 657         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 658         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 659
 660         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 661
 662         // Prepare stop mocks
 663         Mockito.doNothing().when(messageProducer).close();
 664         Mockito.doNothing().when(session).close();
 665         Mockito.doThrow(JMSException.class).when(connection).close();
 666
 667         // Prepare system.out
 668         final ByteArrayOutputStream testBuffer = new ByteArrayOutputStream();
 669         System.setOut(new PrintStream(testBuffer));
 670
 671         // do the test
 672         assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
 673         assertThat(testBuffer.toString()).contains("close of connection");
 674     }
 675
 676     @Test
 677     public void testStop() throws NamingException, JMSException, ApexEventException {
 678         // Prepare ApexJmsProducer
 679         jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
 680         jmsCarrierTechnologyParameters.setObjectMessageSending(false);
 681         producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
 682
 683         final InitialContext context = Mockito.mock(InitialContext.class);
 684         final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
 685         final Topic topic = Mockito.mock(Topic.class);
 686         final Connection connection = Mockito.mock(Connection.class);
 687         final Session session = Mockito.mock(Session.class);
 688         final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
 689
 690         Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
 691         Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
 692         Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
 693         Mockito.doReturn(connection)
 694             .when(connectionFactory)
 695             .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
 696                 jmsCarrierTechnologyParameters.getSecurityCredentials());
 697         Mockito.doNothing().when(connection).start();
 698         Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
 699         Mockito.doReturn(messageProducer).when(session).createProducer(topic);
 700
 701         apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
 702
 703         // Prepare stop mocks
 704         Mockito.doNothing().when(messageProducer).close();
 705         Mockito.doNothing().when(session).close();
 706         Mockito.doNothing().when(connection).close();
 707
 708         // do the test
 709         assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
 710     }
 711 }