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