/*-
* ============LICENSE_START=======================================================
* Copyright (C) 2019 Samsung. All rights reserved.
- * Modifications Copyright (C) 2019-2020 Nordix Foundation.
+ * Modifications Copyright (C) 2019-2021 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import java.util.Properties;
+import javax.jms.Connection;
+import javax.jms.ConnectionFactory;
+import javax.jms.JMSException;
import javax.jms.Message;
-import javax.jms.Session;
+import javax.jms.Topic;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
import org.onap.policy.apex.service.engine.event.ApexEventException;
import org.onap.policy.apex.service.engine.event.ApexEventProducer;
import org.onap.policy.apex.service.engine.event.ApexEventReceiver;
public class ApexJmsConsumerTest {
- ApexJmsConsumer apexJmsConsumer = null;
- EventHandlerParameters consumerParameters = null;
- ApexEventReceiver incomingEventReceiver = null;
- ApexEventProducer apexJmsProducer = null;
- Session jmsSession = null;
- JmsCarrierTechnologyParameters jmsCarrierTechnologyParameters = null;
+ private static final String CONSUMER_NAME = "TestApexJmsConsumer";
+ private ApexJmsConsumer apexJmsConsumer = null;
+ private EventHandlerParameters consumerParameters = null;
+ private ApexEventReceiver incomingEventReceiver = null;
+ private ApexEventProducer apexJmsProducer = null;
+ private JmsCarrierTechnologyParameters jmsCarrierTechnologyParameters = null;
/**
* Set up testing.
- *
- * @throws Exception on test set up errors.
*/
@Before
- public void setUp() throws Exception {
- apexJmsConsumer = new ApexJmsConsumer();
+ public void setUp() {
+ apexJmsConsumer = Mockito.spy(new ApexJmsConsumer());
consumerParameters = new EventHandlerParameters();
apexJmsProducer = new ApexJmsProducer();
}
@Test
- public void testInitWithNonJmsCarrierTechnologyParameters() throws ApexEventException {
- consumerParameters.setCarrierTechnologyParameters(new CarrierTechnologyParameters() {});
- assertThatThrownBy(() -> apexJmsConsumer.init("TestApexJmsConsumer", consumerParameters, incomingEventReceiver))
+ public void testInitWithNonJmsCarrierTechnologyParameters() {
+ consumerParameters.setCarrierTechnologyParameters(new CarrierTechnologyParameters() {
+ });
+ assertThatThrownBy(
+ () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
+ )
.isInstanceOf(ApexEventException.class);
}
@Test
- public void testInitWithJmsCarrierTechnologyParameters() throws ApexEventException {
+ public void testInitWithJmsCarrierTechnologyParameters() {
jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
- assertThatThrownBy(() -> apexJmsConsumer.init("TestApexJmsConsumer", consumerParameters, incomingEventReceiver))
+ assertThatThrownBy(
+ () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
+ )
.isInstanceOf(ApexEventException.class);
}
+ @Test
+ public void testInitNoConnectionFactory() throws NamingException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ assertThatThrownBy(
+ () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
+ )
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitNoConsumerTopic() throws NamingException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ assertThatThrownBy(
+ () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
+ )
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitNoConnection() throws NamingException, JMSException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
+ Mockito.doThrow(JMSException.class)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ assertThatThrownBy(
+ () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
+ )
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitConnectionError() throws NamingException, JMSException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doThrow(JMSException.class).when(connection).start();
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ assertThatThrownBy(
+ () -> apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver)
+ )
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInit() throws NamingException, JMSException, ApexEventException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
+
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
@Test
public void testStart() {
assertThatCode(apexJmsConsumer::start).doesNotThrowAnyException();
@Test
public void testSetPeeredReference() {
PeeredReference peeredReference = new PeeredReference(EventHandlerPeeredMode.REQUESTOR,
- apexJmsConsumer, apexJmsProducer);
+ apexJmsConsumer, apexJmsProducer);
apexJmsConsumer.setPeeredReference(EventHandlerPeeredMode.REQUESTOR, peeredReference);
assertNotNull(apexJmsConsumer.getPeeredReference(EventHandlerPeeredMode.REQUESTOR));
}
}
@Test
- public void testOnMessage() {
+ public void testOnMessageUninitialized() {
Message jmsMessage = null;
assertThatThrownBy(() -> apexJmsConsumer.onMessage(jmsMessage))
.isInstanceOf(ApexEventRuntimeException.class);
}
@Test
- public void testStop() {
+ public void testOnMessage() throws JMSException, NamingException, ApexEventException {
+ // prepare ApexJmsConsumer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ incomingEventReceiver = Mockito.mock(ApexEventReceiver.class);
+
+
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
+
+ final Message message = Mockito.mock(Message.class);
+
+ apexJmsConsumer.onMessage(message);
+ Mockito
+ .verify(incomingEventReceiver, Mockito.times(1))
+ .receiveEvent(ArgumentMatchers.any(Properties.class), ArgumentMatchers.eq(message));
+ }
+
+ @Test
+ public void testConnectionError() throws NamingException, JMSException, ApexEventException {
+ // prepare ApexJmsConsumer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
+
+ Mockito.doThrow(JMSException.class).when(connection).close();
+
+ // do tests
+ apexJmsConsumer.start();
+ assertThatCode(() -> apexJmsConsumer.stop()).doesNotThrowAnyException();
+ Mockito.verify(connection, Mockito.times(1)).close();
+ }
+
+ @Test
+ public void testStop() throws NamingException, JMSException, ApexEventException {
+ // prepare ApexJmsConsumer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ consumerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getConsumerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(context).when(apexJmsConsumer).getInitialContext();
+
+ apexJmsConsumer.init(CONSUMER_NAME, consumerParameters, incomingEventReceiver);
+
+ Mockito.doNothing().when(connection).close();
+
+ apexJmsConsumer.start();
+
+ // do tests
+ apexJmsConsumer.stop();
+ Mockito.verify(connection, Mockito.times(1)).close();
+ }
+
+ @Test
+ public void testStopNoJmsProperties() {
assertThatThrownBy(apexJmsConsumer::stop).isInstanceOf(NullPointerException.class);
}
}
package org.onap.policy.apex.plugins.event.carrier.jms;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.Random;
+import javax.jms.Connection;
+import javax.jms.ConnectionFactory;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageProducer;
+import javax.jms.ObjectMessage;
import javax.jms.Session;
+import javax.jms.TextMessage;
+import javax.jms.Topic;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mockito;
import org.onap.policy.apex.service.engine.event.ApexEvent;
import org.onap.policy.apex.service.engine.event.ApexEventException;
-import org.onap.policy.apex.service.engine.event.ApexEventProducer;
-import org.onap.policy.apex.service.engine.event.ApexEventReceiver;
import org.onap.policy.apex.service.engine.event.ApexEventRuntimeException;
import org.onap.policy.apex.service.engine.event.PeeredReference;
import org.onap.policy.apex.service.engine.event.SynchronousEventCache;
public class ApexJmsProducerTest {
- ApexJmsConsumer apexJmsConsumer = null;
- EventHandlerParameters producerParameters = null;
- ApexEventReceiver incomingEventReceiver = null;
- ApexEventProducer apexJmsProducer = null;
- Session jmsSession = null;
- JmsCarrierTechnologyParameters jmsCarrierTechnologyParameters = null;
- SynchronousEventCache synchronousEventCache = null;
+ private static final String PRODUCER_NAME = "TestApexJmsProducer";
+ private ApexJmsConsumer apexJmsConsumer;
+ private EventHandlerParameters producerParameters;
+ private ApexJmsProducer apexJmsProducer;
+ private JmsCarrierTechnologyParameters jmsCarrierTechnologyParameters;
private static final long DEFAULT_SYNCHRONOUS_EVENT_TIMEOUT = 1000;
+ private final Random random = new Random();
+ private final PrintStream out = System.out;
/**
* Set up testing.
*
- * @throws Exception on test set up errors.
*/
@Before
- public void setUp() throws Exception {
+ public void setUp() {
apexJmsConsumer = new ApexJmsConsumer();
producerParameters = new EventHandlerParameters();
- apexJmsProducer = new ApexJmsProducer();
+ apexJmsProducer = Mockito.spy(new ApexJmsProducer());
+ }
+
+ @After
+ public void tearDown() {
+ // restore system.out
+ System.setOut(out);
}
@Test
public void testInitWithNonJmsCarrierTechnologyParameters() {
- producerParameters.setCarrierTechnologyParameters(new CarrierTechnologyParameters() {});
- assertThatThrownBy(() -> apexJmsProducer.init("TestApexJmsProducer", producerParameters))
+ producerParameters.setCarrierTechnologyParameters(new CarrierTechnologyParameters() {
+ });
+ assertThatThrownBy(() -> apexJmsProducer.init(PRODUCER_NAME, producerParameters))
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitWithJmsCarrierTechnologyParameters() {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+ assertThatThrownBy(() -> apexJmsProducer.init(PRODUCER_NAME, producerParameters))
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitWithoutConnectionFactory() throws NamingException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+ final String producerName = RandomStringUtils.randomAlphabetic(5);
+
+ InitialContext context = Mockito.mock(InitialContext.class);
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+
+ assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitWithoutTopic() throws NamingException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+ final String producerName = RandomStringUtils.randomAlphabetic(5);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(null).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+
+ assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitConnectionCreateError() throws NamingException, JMSException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+ final String producerName = RandomStringUtils.randomAlphabetic(5);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doThrow(JMSException.class).when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+
+ assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitConnectionStartError() throws NamingException, JMSException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+ final String producerName = RandomStringUtils.randomAlphabetic(5);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doThrow(JMSException.class).when(connection).start();
+
+ assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
+ .isInstanceOf(ApexEventException.class);
+ }
+
+ @Test
+ public void testInitSessionCreateError() throws NamingException, JMSException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+ final String producerName = RandomStringUtils.randomAlphabetic(5);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doThrow(JMSException.class).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+ assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
.isInstanceOf(ApexEventException.class);
}
@Test
- public void testInitWithJmsCarrierTechnologyParameters() throws ApexEventException {
+ public void testInitProducerCreateError() throws NamingException, JMSException {
jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
- assertThatThrownBy(() -> apexJmsProducer.init("TestApexJmsProducer", producerParameters))
+ final String producerName = RandomStringUtils.randomAlphabetic(5);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doThrow(JMSException.class).when(session).createProducer(topic);
+ assertThatThrownBy(() -> apexJmsProducer.init(producerName, producerParameters))
.isInstanceOf(ApexEventException.class);
}
+ @Test
+ public void testInit() throws NamingException, JMSException {
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+ final String producerName = RandomStringUtils.randomAlphabetic(5);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ assertThatCode(() -> apexJmsProducer.init(producerName, producerParameters))
+ .doesNotThrowAnyException();
+ }
+
@Test
public void testGetName() {
assertNull(apexJmsProducer.getName());
@Test
public void testSetPeeredReference() {
PeeredReference peeredReference = new PeeredReference(EventHandlerPeeredMode.REQUESTOR,
- apexJmsConsumer, apexJmsProducer);
+ apexJmsConsumer, apexJmsProducer);
apexJmsProducer.setPeeredReference(EventHandlerPeeredMode.REQUESTOR, peeredReference);
- assertNotNull(apexJmsProducer.getPeeredReference(EventHandlerPeeredMode.REQUESTOR));
+ final PeeredReference actual = apexJmsProducer.getPeeredReference(EventHandlerPeeredMode.REQUESTOR);
+ assertSame(peeredReference, actual);
+ }
+
+ @Test
+ public void testSendEventNotSerializable() {
+ producerParameters.setCarrierTechnologyParameters(new JmsCarrierTechnologyParameters());
+ Object object = new Object();
+ final long executionId = random.nextLong();
+ assertThatThrownBy(() -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, object))
+ .isInstanceOf(ApexEventRuntimeException.class);
}
@Test
- public void testSendEvent() throws ApexEventException {
- producerParameters.setCarrierTechnologyParameters(new JmsCarrierTechnologyParameters() {});
- synchronousEventCache = new SynchronousEventCache(EventHandlerPeeredMode.SYNCHRONOUS,
- apexJmsConsumer, apexJmsProducer, DEFAULT_SYNCHRONOUS_EVENT_TIMEOUT);
+ public void testSendEventRemoveCache() {
+ producerParameters.setCarrierTechnologyParameters(new JmsCarrierTechnologyParameters());
+ final SynchronousEventCache synchronousEventCache =
+ Mockito.spy(new SynchronousEventCache(EventHandlerPeeredMode.SYNCHRONOUS,
+ apexJmsConsumer, apexJmsProducer, DEFAULT_SYNCHRONOUS_EVENT_TIMEOUT));
apexJmsProducer.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS,
- synchronousEventCache);
+ synchronousEventCache);
+
+ Object object = new Object();
+ final long executionId = random.nextLong();
+
+ assertThatThrownBy(() -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, object))
+ .isInstanceOf(ApexEventRuntimeException.class);
+ Mockito.verify(synchronousEventCache, Mockito.times(1)).removeCachedEventToApexIfExists(executionId);
+ }
+
+ @Test
+ public void testSendEventCreateObjectMessageError() throws ApexEventException, NamingException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare sendEvent
+
ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
- "testSource", "testTarget");
- assertThatThrownBy(() -> apexJmsProducer.sendEvent(1000L, null, "TestApexJmsProducer", apexEvent))
- .isInstanceOf(NullPointerException.class);
+ "testSource", "testTarget");
+ Mockito.doThrow(JMSException.class).when(session).createObjectMessage(apexEvent);
+
+ final long executionId = random.nextLong();
+
+
+ assertThatThrownBy(() -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, apexEvent))
+ .isInstanceOf(ApexEventRuntimeException.class);
}
@Test
- public void testSendEventWithNonSerializableObject() throws ApexEventException {
- producerParameters.setCarrierTechnologyParameters(new JmsCarrierTechnologyParameters() {});
- synchronousEventCache = new SynchronousEventCache(EventHandlerPeeredMode.SYNCHRONOUS,
- apexJmsConsumer, apexJmsProducer, DEFAULT_SYNCHRONOUS_EVENT_TIMEOUT);
- apexJmsProducer.setPeeredReference(EventHandlerPeeredMode.SYNCHRONOUS,
- synchronousEventCache);
+ public void testSendEventCreateObjectMessageSendError() throws ApexEventException, NamingException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare sendEvent
+ final Message message = Mockito.mock(ObjectMessage.class);
+ ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
+ "testSource", "testTarget");
+ Mockito.doReturn(message).when(session).createObjectMessage(apexEvent);
+ Mockito.doThrow(JMSException.class).when(messageProducer).send(message);
+
+ final long executionId = random.nextLong();
+
+
+ assertThatThrownBy(
+ () -> apexJmsProducer
+ .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
+ )
+ .isInstanceOf(ApexEventRuntimeException.class);
+ }
+
+ @Test
+ public void testSendEventCreateObjectMessageSend() throws ApexEventException, NamingException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare sendEvent
+ final Message message = Mockito.mock(ObjectMessage.class);
+ ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
+ "testSource", "testTarget");
+ Mockito.doReturn(message).when(session).createObjectMessage(apexEvent);
+ Mockito.doNothing().when(messageProducer).send(message);
+
+ final long executionId = random.nextLong();
+
+
+ assertThatCode(
+ () -> apexJmsProducer
+ .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
+ )
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ public void testSendEventCreateTextMessageError() throws ApexEventException, NamingException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ jmsCarrierTechnologyParameters.setObjectMessageSending(false);
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare sendEvent
+ ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
+ "testSource", "testTarget");
+
+ Mockito.doThrow(JMSException.class).when(session).createTextMessage(apexEvent.toString());
- ApexJmsProducerTest producerTest = new ApexJmsProducerTest();
+ final long executionId = random.nextLong();
- assertThatThrownBy(() -> apexJmsProducer.sendEvent(-1L, null, "TestApexJmsProducer", producerTest))
+ assertThatThrownBy(
+ () -> apexJmsProducer
+ .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
+ )
.isInstanceOf(ApexEventRuntimeException.class);
}
@Test
- public void testStop() {
+ public void testSendEventCreateTextMessageSendError() throws ApexEventException, NamingException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ jmsCarrierTechnologyParameters.setObjectMessageSending(false);
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare sendEvent
+ final Message message = Mockito.mock(TextMessage.class);
+ ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
+ "testSource", "testTarget");
+ Mockito.doReturn(message).when(session).createTextMessage(apexEvent.toString());
+ Mockito.doThrow(JMSException.class).when(messageProducer).send(message);
+
+ final long executionId = random.nextLong();
+
+
+ assertThatThrownBy(
+ () -> apexJmsProducer
+ .sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
+ )
+ .isInstanceOf(ApexEventRuntimeException.class);
+ }
+
+ @Test
+ public void testSendEventCreateTextMessageSend() throws ApexEventException, NamingException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ jmsCarrierTechnologyParameters.setObjectMessageSending(false);
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare sendEvent
+ final Message message = Mockito.mock(TextMessage.class);
+ ApexEvent apexEvent = new ApexEvent("testEvent", "testVersion", "testNameSpace",
+ "testSource", "testTarget");
+ Mockito.doReturn(message).when(session).createTextMessage(apexEvent.toString());
+ Mockito.doNothing().when(messageProducer).send(message);
+
+ final long executionId = random.nextLong();
+
+
+ assertThatCode(
+ () -> apexJmsProducer.sendEvent(executionId, null, PRODUCER_NAME, apexEvent)
+ )
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ public void testStopProducerException() throws NamingException, ApexEventException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ jmsCarrierTechnologyParameters.setObjectMessageSending(false);
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare stop mock
+ Mockito.doThrow(JMSException.class).when(messageProducer).close();
+
+ // Prepare system.out
+ final ByteArrayOutputStream testBuffer = new ByteArrayOutputStream();
+ System.setOut(new PrintStream(testBuffer));
+
+ // do the test
+ assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
+ assertThat(testBuffer.toString()).contains("failed to close JMS message producer");
+ }
+
+ @Test
+ public void testStopCloseSessionException() throws NamingException, ApexEventException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ jmsCarrierTechnologyParameters.setObjectMessageSending(false);
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare stop mocks
+ Mockito.doNothing().when(messageProducer).close();
+ Mockito.doThrow(JMSException.class).when(session).close();
+
+ // Prepare system.out
+ final ByteArrayOutputStream testBuffer = new ByteArrayOutputStream();
+ System.setOut(new PrintStream(testBuffer));
+
+ // do the test
+ assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
+ assertThat(testBuffer.toString()).contains("failed to close the JMS session");
+ }
+
+ @Test
+ public void testStopCloseConnectionException() throws NamingException, ApexEventException, JMSException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ jmsCarrierTechnologyParameters.setObjectMessageSending(false);
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare stop mocks
+ Mockito.doNothing().when(messageProducer).close();
+ Mockito.doNothing().when(session).close();
+ Mockito.doThrow(JMSException.class).when(connection).close();
+
+ // Prepare system.out
+ final ByteArrayOutputStream testBuffer = new ByteArrayOutputStream();
+ System.setOut(new PrintStream(testBuffer));
+
+ // do the test
+ assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
+ assertThat(testBuffer.toString()).contains("close of connection");
+ }
+
+ @Test
+ public void testStop() throws NamingException, JMSException, ApexEventException {
+ // Prepare ApexJmsProducer
+ jmsCarrierTechnologyParameters = new JmsCarrierTechnologyParameters();
+ jmsCarrierTechnologyParameters.setObjectMessageSending(false);
+ producerParameters.setCarrierTechnologyParameters(jmsCarrierTechnologyParameters);
+
+ final InitialContext context = Mockito.mock(InitialContext.class);
+ final ConnectionFactory connectionFactory = Mockito.mock(ConnectionFactory.class);
+ final Topic topic = Mockito.mock(Topic.class);
+ final Connection connection = Mockito.mock(Connection.class);
+ final Session session = Mockito.mock(Session.class);
+ final MessageProducer messageProducer = Mockito.mock(MessageProducer.class);
+
+ Mockito.doReturn(context).when(apexJmsProducer).getInitialContext();
+ Mockito.doReturn(connectionFactory).when(context).lookup(jmsCarrierTechnologyParameters.getConnectionFactory());
+ Mockito.doReturn(topic).when(context).lookup(jmsCarrierTechnologyParameters.getProducerTopic());
+ Mockito.doReturn(connection)
+ .when(connectionFactory)
+ .createConnection(jmsCarrierTechnologyParameters.getSecurityPrincipal(),
+ jmsCarrierTechnologyParameters.getSecurityCredentials());
+ Mockito.doNothing().when(connection).start();
+ Mockito.doReturn(session).when(connection).createSession(false, Session.AUTO_ACKNOWLEDGE);
+ Mockito.doReturn(messageProducer).when(session).createProducer(topic);
+
+ apexJmsProducer.init(RandomStringUtils.random(5), producerParameters);
+
+ // Prepare stop mocks
+ Mockito.doNothing().when(messageProducer).close();
+ Mockito.doNothing().when(session).close();
+ Mockito.doNothing().when(connection).close();
+
+ // do the test
assertThatCode(apexJmsProducer::stop).doesNotThrowAnyException();
}
}
Code Review / policy / apex-pdp.git / commitdiff