JAVA-15787 Created new messaging-modules and saas-modules

- Moved jgroups, rabbitmq, spring-amqp, spring-apache-camel, spring-jms to messaging-modules
- Moved twilio, twitter4j, strip to saas-modules
- Renamed existing saas to jira-rest-integration

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/Employee.java

@@ -0,0 +1,23 @@
+package com.baeldung.spring.jms;
+
+public class Employee {
+    private String name;
+    private Integer age;
+
+    public Employee(String name, Integer age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public String toString() {
+        return "Employee: name(" + name + "), age(" + age + ")";
+    }
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/SampleJmsErrorHandler.java

@@ -0,0 +1,17 @@
+package com.baeldung.spring.jms;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.ErrorHandler;
+
+public class SampleJmsErrorHandler implements ErrorHandler {
+
+    private static final Logger LOG = LoggerFactory.getLogger(SampleJmsErrorHandler.class);
+
+    @Override
+    public void handleError(Throwable t) {
+        LOG.warn("In default jms error handler...");
+        LOG.error("Error Message : {}", t.getMessage());
+    }
+
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/SampleJmsMessageSender.java

@@ -0,0 +1,33 @@
+package com.baeldung.spring.jms;
+
+import org.springframework.jms.core.JmsTemplate;
+
+import javax.jms.Queue;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SampleJmsMessageSender {
+
+    private JmsTemplate jmsTemplate;
+    private Queue queue;
+
+    public void setJmsTemplate(JmsTemplate jmsTemplate) {
+        this.jmsTemplate = jmsTemplate;
+    }
+
+    public void setQueue(Queue queue) {
+        this.queue = queue;
+    }
+
+    public void simpleSend() {
+        jmsTemplate.send(queue, s -> s.createTextMessage("hello queue world"));
+    }
+
+    public void sendMessage(final Employee employee) {
+        this.jmsTemplate.convertAndSend(employee);
+    }
+
+    public void sendTextMessage(String msg) {
+        this.jmsTemplate.send(queue, s -> s.createTextMessage(msg));
+    }
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/SampleListener.java

@@ -0,0 +1,44 @@
+package com.baeldung.spring.jms;
+
+import org.springframework.jms.core.JmsTemplate;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.Queue;
+import javax.jms.TextMessage;
+import java.util.Map;
+
+public class SampleListener implements MessageListener {
+
+    private JmsTemplate jmsTemplate;
+    private Queue queue;
+
+    public void setJmsTemplate(JmsTemplate jmsTemplate) {
+        this.jmsTemplate = jmsTemplate;
+    }
+
+    public void setQueue(Queue queue) {
+        this.queue = queue;
+    }
+
+    public void onMessage(Message message) {
+        if (message instanceof TextMessage) {
+            try {
+                String msg = ((TextMessage) message).getText();
+                System.out.println("Received message: " + msg);
+                if (msg == null) {
+                    throw new IllegalArgumentException("Null value received...");
+                }
+            } catch (JMSException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+    }
+
+    public Employee receiveMessage() throws JMSException {
+        Map map = (Map) this.jmsTemplate.receiveAndConvert();
+        return new Employee((String) map.get("name"), (Integer) map.get("age"));
+    }
+
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/SampleMessageConverter.java

@@ -0,0 +1,26 @@
+package com.baeldung.spring.jms;
+
+import org.springframework.jms.support.converter.MessageConversionException;
+import org.springframework.jms.support.converter.MessageConverter;
+
+import javax.jms.JMSException;
+import javax.jms.MapMessage;
+import javax.jms.Message;
+import javax.jms.Session;
+
+public class SampleMessageConverter implements MessageConverter {
+
+    public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
+        Employee employee = (Employee) object;
+        MapMessage message = session.createMapMessage();
+        message.setString("name", employee.getName());
+        message.setInt("age", employee.getAge());
+        return message;
+    }
+
+    public Object fromMessage(Message message) throws JMSException, MessageConversionException {
+        MapMessage mapMessage = (MapMessage) message;
+        return new Employee(mapMessage.getString("name"), mapMessage.getInt("age"));
+    }
+
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/testing/JmsApplication.java

@@ -0,0 +1,13 @@
+package com.baeldung.spring.jms.testing;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.ComponentScan;
+
+@ComponentScan
+public class JmsApplication {
+
+    public static void main(String[] args) {
+        ApplicationContext context = new AnnotationConfigApplicationContext(JmsApplication.class);
+    }
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/testing/JmsConfig.java

@@ -0,0 +1,34 @@
+package com.baeldung.spring.jms.testing;
+
+import javax.jms.ConnectionFactory;
+
+import org.apache.activemq.ActiveMQConnectionFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jms.annotation.EnableJms;
+import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
+import org.springframework.jms.config.JmsListenerContainerFactory;
+import org.springframework.jms.core.JmsTemplate;
+
+@Configuration
+@EnableJms
+public class JmsConfig {
+
+    @Bean
+    public JmsListenerContainerFactory<?> jmsListenerContainerFactory() {
+        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
+        factory.setConnectionFactory(connectionFactory());
+        return factory;
+    }
+
+    @Bean
+    public ConnectionFactory connectionFactory() {
+        return new ActiveMQConnectionFactory("tcp://localhost:61616");
+    }
+
+    @Bean
+    public JmsTemplate jmsTemplate() {
+        return new JmsTemplate(connectionFactory());
+    }
+
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/testing/MessageListener.java

@@ -0,0 +1,20 @@
+package com.baeldung.spring.jms.testing;
+
+import javax.jms.JMSException;
+import javax.jms.TextMessage;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jms.annotation.JmsListener;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MessageListener {
+
+    private static final Logger logger = LoggerFactory.getLogger(MessageListener.class);
+
+    @JmsListener(destination = "queue-1")
+    public void sampleJmsListenerMethod(TextMessage message) throws JMSException {
+        logger.info("JMS listener received text message: {}", message.getText());
+    }
+}

messaging-modules/spring-jms/src/main/java/com/baeldung/spring/jms/testing/MessageSender.java

@@ -0,0 +1,21 @@
+package com.baeldung.spring.jms.testing;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jms.core.JmsTemplate;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MessageSender {
+
+    @Autowired
+    private JmsTemplate jmsTemplate;
+
+    private static final Logger logger = LoggerFactory.getLogger(MessageSender.class);
+
+    public void sendTextMessage(String destination, String message) {
+        logger.info("Sending message to {} destination with text {}", destination, message);
+        jmsTemplate.send(destination, s -> s.createTextMessage(message));
+    }
+}

messaging-modules/spring-jms/src/main/resources/EmbeddedActiveMQ.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
+	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
+	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
+	xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task"
+	xmlns:amq="http://activemq.apache.org/schema/core"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://activemq.apache.org/schema/core
+                        http://activemq.apache.org/schema/core/activemq-core-5.2.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
+
+	<!-- Embedded ActiveMQ Broker -->
+	<amq:broker id="broker" useJmx="false" persistent="false"
+		useShutdownHook="false">
+		<amq:transportConnectors>
+			<amq:transportConnector uri="tcp://localhost:61616" />
+		</amq:transportConnectors>
+	</amq:broker>
+</beans>

messaging-modules/spring-jms/src/main/resources/applicationContext.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+  http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">
+
+    <!-- JmsTemplate Definition -->
+    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
+        <property name="connectionFactory" ref="connectionFactory" />
+        <property name="defaultDestination" ref="destinationQueue" />
+        <property name="messageConverter" ref="myMessageConverter" />
+    </bean>
+
+    <bean id="amqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
+        <constructor-arg index="0" value="tcp://localhost:61616" />
+    </bean>
+
+    <!-- ConnectionFactory Definition -->
+    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
+        <constructor-arg ref="amqConnectionFactory" />
+    </bean>
+
+    <bean id="destinationQueue" class="org.apache.activemq.command.ActiveMQQueue">
+        <constructor-arg index="0" value="IN_QUEUE" />
+    </bean>
+
+    <bean id="SampleJmsMessageSender" class="com.baeldung.spring.jms.SampleJmsMessageSender">
+        <property name="queue" ref="destinationQueue" />
+        <property name="jmsTemplate" ref="jmsTemplate" />
+    </bean>
+
+    <bean id="myMessageConverter" class="com.baeldung.spring.jms.SampleMessageConverter" />
+
+    <!-- this is the Message-Driven POJO (MDP) -->
+    <bean id="messageListener" class="com.baeldung.spring.jms.SampleListener">
+        <property name="jmsTemplate" ref="jmsTemplate" />
+        <property name="queue" ref="destinationQueue" />
+    </bean>
+
+    <bean id="errorHandler" class="com.baeldung.spring.jms.SampleJmsErrorHandler" />
+
+    <!-- and this is the message listener container -->
+    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
+        <property name="connectionFactory" ref="connectionFactory" />
+        <property name="destinationName" value="IN_QUEUE" />
+        <property name="messageListener" ref="messageListener" />
+        <property name="errorHandler" ref="errorHandler" />
+    </bean>
+</beans>

messaging-modules/spring-jms/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

messaging-modules/spring-jms/src/main/webapp/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: 
+

messaging-modules/spring-jms/src/test/java/com/baeldung/SpringContextTest.java

@@ -0,0 +1,15 @@
+package com.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

messaging-modules/spring-jms/src/test/java/com/baeldung/spring/jms/DefaultTextMessageSenderIntegrationTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.spring.jms;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public class DefaultTextMessageSenderIntegrationTest {
+
+    private static SampleJmsMessageSender messageProducer;
+    private static SampleListener messageListener;
+
+    @SuppressWarnings("resource")
+    @BeforeClass
+    public static void setUp() {
+        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:EmbeddedActiveMQ.xml", "classpath:applicationContext.xml");
+        messageProducer = (SampleJmsMessageSender) applicationContext.getBean("SampleJmsMessageSender");
+        messageListener = (SampleListener) applicationContext.getBean("messageListener");
+    }
+
+    @Test
+    public void testSimpleSend() {
+        messageProducer.simpleSend();
+    }
+
+    @Test
+    public void testSendTextMessage() {
+        messageProducer.sendTextMessage(null);
+    }
+
+}

messaging-modules/spring-jms/src/test/java/com/baeldung/spring/jms/testing/EmbeddedActiveMqIntegrationTest.java

@@ -0,0 +1,91 @@
+package com.baeldung.spring.jms.testing;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import javax.jms.ConnectionFactory;
+import javax.jms.JMSException;
+import javax.jms.TextMessage;
+
+import org.apache.activemq.ActiveMQConnectionFactory;
+import org.apache.activemq.junit.EmbeddedActiveMQBroker;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jms.annotation.EnableJms;
+import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
+import org.springframework.jms.config.JmsListenerContainerFactory;
+import org.springframework.jms.core.JmsTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.spring.jms.testing.EmbeddedActiveMqIntegrationTest.TestConfiguration;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = { TestConfiguration.class })
+public class EmbeddedActiveMqIntegrationTest {
+
+    @ClassRule
+    public static EmbeddedActiveMQBroker embeddedBroker = new EmbeddedActiveMQBroker();
+
+    @SpyBean
+    private MessageListener messageListener;
+
+    @SpyBean
+    private MessageSender messageSender;
+
+    @Test
+    public void whenListening_thenReceivingCorrectMessage() throws JMSException {
+        String queueName = "queue-1";
+        String messageText = "Test message";
+
+        embeddedBroker.pushMessage(queueName, messageText);
+        assertEquals(1, embeddedBroker.getMessageCount(queueName));
+
+        ArgumentCaptor<TextMessage> messageCaptor = ArgumentCaptor.forClass(TextMessage.class);
+
+        Mockito.verify(messageListener, Mockito.timeout(100))
+            .sampleJmsListenerMethod(messageCaptor.capture());
+        
+        TextMessage receivedMessage = messageCaptor.getValue();
+        assertEquals(messageText, receivedMessage.getText());
+    }
+
+    @Test
+    public void whenSendingMessage_thenCorrectQueueAndMessageText() throws JMSException {
+        String queueName = "queue-2";
+        String messageText = "Test message";
+
+        messageSender.sendTextMessage(queueName, messageText);
+
+        assertEquals(1, embeddedBroker.getMessageCount(queueName));
+        TextMessage sentMessage = embeddedBroker.peekTextMessage(queueName);
+        assertEquals(messageText, sentMessage.getText());
+    }
+
+    @Configuration
+    @EnableJms
+    static class TestConfiguration {
+        @Bean
+        public JmsListenerContainerFactory<?> jmsListenerContainerFactory() {
+            DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
+            factory.setConnectionFactory(connectionFactory());
+            return factory;
+        }
+
+        @Bean
+        public ConnectionFactory connectionFactory() {
+            return new ActiveMQConnectionFactory(embeddedBroker.getVmURL());
+        }
+
+        @Bean
+        public JmsTemplate jmsTemplate() {
+            return new JmsTemplate(connectionFactory());
+        }
+    }
+
+}

messaging-modules/spring-jms/src/test/java/com/baeldung/spring/jms/testing/TestContainersActiveMqLiveTest.java

@@ -0,0 +1,101 @@
+package com.baeldung.spring.jms.testing;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import javax.jms.ConnectionFactory;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.TextMessage;
+
+import org.apache.activemq.ActiveMQConnectionFactory;
+import org.assertj.core.api.Assertions;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jms.annotation.EnableJms;
+import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
+import org.springframework.jms.config.JmsListenerContainerFactory;
+import org.springframework.jms.core.JmsTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.utility.DockerImageName;
+
+import com.baeldung.spring.jms.testing.TestContainersActiveMqLiveTest.TestConfiguration;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = { TestConfiguration.class, MessageSender.class })
+public class TestContainersActiveMqLiveTest {
+
+    @ClassRule
+    public static GenericContainer<?> activeMqContainer = new GenericContainer<>(DockerImageName.parse("rmohr/activemq:5.14.3")).withExposedPorts(61616);
+
+    @SpyBean
+    private MessageListener messageListener;
+
+    @Autowired
+    private MessageSender messageSender;
+
+    @Autowired
+    private JmsTemplate jmsTemplate;
+
+    @Test
+    public void whenListening_thenReceivingCorrectMessage() throws JMSException {
+        String queueName = "queue-1";
+        String messageText = "Test message";
+
+        jmsTemplate.send(queueName, s -> s.createTextMessage(messageText));
+
+        ArgumentCaptor<TextMessage> messageCaptor = ArgumentCaptor.forClass(TextMessage.class);
+
+        Mockito.verify(messageListener, Mockito.timeout(100))
+            .sampleJmsListenerMethod(messageCaptor.capture());
+
+        TextMessage receivedMessage = messageCaptor.getValue();
+        assertEquals(messageText, receivedMessage.getText());
+    }
+
+    @Test
+    public void whenSendingMessage_thenCorrectQueueAndMessageText() throws JMSException {
+        String queueName = "queue-2";
+        String messageText = "Test message";
+
+        messageSender.sendTextMessage(queueName, messageText);
+
+        Message sentMessage = jmsTemplate.receive(queueName);
+        Assertions.assertThat(sentMessage)
+            .isInstanceOf(TextMessage.class);
+
+        assertEquals(messageText, ((TextMessage) sentMessage).getText());
+    }
+
+    @Configuration
+    @EnableJms
+    static class TestConfiguration {
+        @Bean
+        public JmsListenerContainerFactory<?> jmsListenerContainerFactory() {
+            DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
+            factory.setConnectionFactory(connectionFactory());
+            return factory;
+        }
+
+        @Bean
+        public ConnectionFactory connectionFactory() {
+            String brokerUrlFormat = "tcp://%s:%d";
+            String brokerUrl = String.format(brokerUrlFormat, activeMqContainer.getHost(), activeMqContainer.getFirstMappedPort());
+            return new ActiveMQConnectionFactory(brokerUrl);
+        }
+
+        @Bean
+        public JmsTemplate jmsTemplate() {
+            return new JmsTemplate(connectionFactory());
+        }
+    }
+
+}