jmstemplate102tests.java

Java/J2EE application framework based on [Expert One-on-One J2EE Design and Development] by Rod John

	 * a topic and default QOS values.
	 */
	public void testSendStringTopic() throws Exception {
		sendTopic(true, false);
	}

	/**
	 * Test the method send(String destination, MessageCreator c) using explicit
	 * QOS values.
	 */
	public void testSendStringTopicWithQOS() throws Exception {
		sendTopic(false, false);
	}

	/**
	 * Test the method send(Destination queue, MessgaeCreator c) using
	 * a queue and default QOS values.
	 */
	public void testSendQueue() throws Exception {
		sendQueue(true, false, false);
	}

	/**
	 * Test the method send(Destination queue, MessageCreator c) sing explicit
	 * QOS values.
	 */
	public void testSendQueueWithQOS() throws Exception {
		sendQueue(false, false, false);
	}

	/**
	 * Test the method send(Destination queue, MessgaeCreator c) using
	 * a topic and default QOS values.
	 */
	public void testSendTopic() throws Exception {
		sendTopic(true, false);
	}

	/**
	 * Test the method send(Destination queue, MessageCreator c) using explicity
	 * QOS values.
	 */
	public void testSendTopicWithQOS() throws Exception {
		sendQueue(false, false, false);
	}

	/**
	 * Common method for testing a send method that uses the MessageCreator
	 * callback but with different QOS options.
	 * @param ignoreQOS test using default QOS options.
	 */
	private void sendQueue(boolean ignoreQOS, boolean explicitQueue, boolean useDefaultDestination)
			throws Exception {

		JmsTemplate102 sender = new JmsTemplate102();
		setJndiTemplate(sender);
		sender.setConnectionFactory(mockQueueConnectionFactory);
		setJndiTemplate(sender);
		sender.afterPropertiesSet();

		if (useDefaultDestination) {
			sender.setDefaultDestination(mockQueue);
		}

		//Mock the javax.jms QueueSender
		MockControl queueSenderControl = MockControl.createControl(QueueSender.class);
		QueueSender mockQueueSender = (QueueSender) queueSenderControl.getMock();

		MockControl messageControl = MockControl.createControl(TextMessage.class);
		TextMessage mockMessage = (TextMessage) messageControl.getMock();

		mockQueueConnection.close();
		queueConnectionControl.setVoidCallable(1);

		mockQueueSession.createSender(this.mockQueue);
		queueSessionControl.setReturnValue(mockQueueSender);
		mockQueueSession.createTextMessage("just testing");
		queueSessionControl.setReturnValue(mockMessage);

		mockQueueSession.close();
		queueSessionControl.setVoidCallable(1);

		queueConnectionControl.replay();
		queueSessionControl.replay();

		if (ignoreQOS) {
			mockQueueSender.send(mockMessage);
		}
		else {
			sender.setExplicitQosEnabled(true);
			sender.setDeliveryMode(deliveryMode);
			sender.setPriority(priority);
			sender.setTimeToLive(timeToLive);
			mockQueueSender.send(mockMessage, deliveryMode, priority, timeToLive);
		}
		queueSenderControl.replay();

		if (useDefaultDestination) {
			sender.send(new MessageCreator() {
				public Message createMessage(Session session) throws JMSException {
					return session.createTextMessage("just testing");
				}
			});
		}
		else {
			if (explicitQueue) {
				sender.send(mockQueue, new MessageCreator() {
					public Message createMessage(Session session) throws JMSException {
						return session.createTextMessage("just testing");
					}
				});
			}
			else {
				sender.send("testQueue", new MessageCreator() {
					public Message createMessage(Session session)
					    throws JMSException {
						return session.createTextMessage("just testing");
					}
				});
			}
		}

		queueConnectionFactoryControl.verify();
		queueConnectionControl.verify();
		queueSenderControl.verify();

		queueSessionControl.verify();
	}

	private void sendTopic(boolean ignoreQOS, boolean explicitTopic) throws Exception {
		JmsTemplate102 sender = new JmsTemplate102();
		sender.setPubSubDomain(true);
		sender.setConnectionFactory(mockTopicConnectionFactory);
		setJndiTemplate(sender);
		sender.afterPropertiesSet();

		MockControl topicPublisherControl = MockControl.createControl(TopicPublisher.class);
		TopicPublisher mockTopicPublisher = (TopicPublisher) topicPublisherControl.getMock();

		MockControl messageControl = MockControl.createControl(TextMessage.class);
		TextMessage mockMessage = (TextMessage) messageControl.getMock();

		mockTopicConnection.close();
		topicConnectionControl.setVoidCallable(1);

		mockTopicSession.getTransacted();
		topicSessionControl.setReturnValue(false);
		mockTopicSession.createPublisher(this.mockTopic);
		topicSessionControl.setReturnValue(mockTopicPublisher);
		mockTopicSession.createTextMessage("just testing");
		topicSessionControl.setReturnValue(mockMessage);

		mockTopicSession.close();
		topicSessionControl.setVoidCallable(1);

		topicConnectionControl.replay();
		topicSessionControl.replay();

		if (ignoreQOS) {
			mockTopicPublisher.publish(mockMessage);
		}
		else {
			sender.setExplicitQosEnabled(true);
			sender.setDeliveryMode(deliveryMode);
			sender.setPriority(priority);
			sender.setTimeToLive(timeToLive);
			mockTopicPublisher.publish(mockMessage, deliveryMode, priority, timeToLive);
		}
		topicPublisherControl.replay();

		sender.setPubSubDomain(true);

		if (explicitTopic) {
			sender.send(mockTopic, new MessageCreator() {
				public Message createMessage(Session session)
				    throws JMSException {
					return session.createTextMessage("just testing");
				}
			});
		}
		else {
			sender.send("testTopic", new MessageCreator() {
				public Message createMessage(Session session)
				    throws JMSException {
					return session.createTextMessage("just testing");
				}
			});
		}

		topicConnectionFactoryControl.verify();
		topicConnectionControl.verify();
		topicSessionControl.verify();
		topicPublisherControl.verify();
	}

	public void testConverter() throws Exception {
		JmsTemplate102 sender = new JmsTemplate102();
		setJndiTemplate(sender);
		sender.setConnectionFactory(mockQueueConnectionFactory);
		sender.setMessageConverter(new SimpleMessageConverter());
		String s = "Hello world";

		MockControl queueSenderControl = MockControl.createControl(QueueSender.class);
		QueueSender mockQueueSender = (QueueSender) queueSenderControl.getMock();

		MockControl messageControl = MockControl.createControl(TextMessage.class);
		TextMessage mockMessage = (TextMessage) messageControl.getMock();

		mockQueueConnection.close();
		queueConnectionControl.setVoidCallable(1);

		mockQueueSession.createSender(this.mockQueue);
		queueSessionControl.setReturnValue(mockQueueSender);
		mockQueueSession.createTextMessage("Hello world");
		queueSessionControl.setReturnValue(mockMessage);

		mockQueueSession.close();
		queueSessionControl.setVoidCallable(1);

		queueConnectionControl.replay();
		queueSessionControl.replay();

		mockQueueSender.send(mockMessage);
		queueSenderControl.replay();

		sender.convertAndSend(mockQueue, s);

		queueConnectionFactoryControl.verify();
		queueConnectionControl.verify();
		queueSenderControl.verify();

		queueSessionControl.verify();
	}

	public void testReceiveDefaultDestination() throws Exception {
		doTestReceive(false, true, false, false);
	}
	
	public void testReceiveDestination() throws Exception {
		doTestReceive(true, false, false, false);
	}

	public void testReceiveDestinationWithClientAcknowledge() throws Exception {
		doTestReceive(true, false, false, true);
	}

	public void testReceiveStringDestination() throws Exception {
		doTestReceive(false, false, false, false);
	}

	public void testReceiveAndConvertDefaultDestination() throws Exception {
		doTestReceive(false, true, true, false);
	}

	public void testReceiveAndConvertStringDestination() throws Exception {
		doTestReceive(false, false, true, false);
	}

	public void testReceiveAndConvertDestination() throws Exception {
		doTestReceive(true, false, true, false);
	}
	
	private void doTestReceive(boolean explicitDestination, boolean useDefaultDestination,
			boolean testConverter, boolean clientAcknowledge) throws Exception {

		JmsTemplate102 sender = new JmsTemplate102();
		sender.setConnectionFactory(mockQueueConnectionFactory);
		//Override the default settings for client ack used in the testSetup - createMockForQueues()
		//Can't use Session.getAcknowledgeMode()
		queueConnectionControl.reset();
		if (clientAcknowledge) {
			sender.setSessionAcknowledgeMode(Session.CLIENT_ACKNOWLEDGE);
			mockQueueConnection.createQueueSession(false, Session.CLIENT_ACKNOWLEDGE);			
		} else {
			sender.setSessionAcknowledgeMode(Session.AUTO_ACKNOWLEDGE);
			mockQueueConnection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
		}
		queueConnectionControl.setReturnValue(mockQueueSession);
		setJndiTemplate(sender);


		if (useDefaultDestination) {
			sender.setDefaultDestination(mockQueue);
		}

		mockQueueConnection.start();
		queueConnectionControl.setVoidCallable(1);
		mockQueueConnection.close();
		queueConnectionControl.setVoidCallable(1);

		MockControl queueReceiverControl = MockControl.createControl(QueueReceiver.class);
		QueueReceiver mockQueueReceiver = (QueueReceiver) queueReceiverControl.getMock();

		mockQueueSession.createReceiver(mockQueue);
		queueSessionControl.setReturnValue(mockQueueReceiver);

		mockQueueSession.close();
		queueSessionControl.setVoidCallable(1);

		MockControl messageControl = MockControl.createControl(TextMessage.class);
		TextMessage mockMessage = (TextMessage) messageControl.getMock();

		if (testConverter) {
			mockMessage.getText();
			messageControl.setReturnValue("Hello World!");
		}
		if (clientAcknowledge) {
			mockMessage.acknowledge();
			messageControl.setVoidCallable(1);
		}

		queueSessionControl.replay();
		queueConnectionControl.replay();
		messageControl.replay();

		mockQueueReceiver.receive();
		queueReceiverControl.setReturnValue(mockMessage);
		mockQueueReceiver.close();
		queueReceiverControl.setVoidCallable(1);
		queueReceiverControl.replay();

		Message m = null;
		String textFromMessage = null;
		if (useDefaultDestination) {
			if (testConverter) {
				textFromMessage = (String) sender.receiveAndConvert();
			}
			else {
				m = sender.receive();
			}
		}
		else {
			if (explicitDestination) {
				if (testConverter) {
					textFromMessage = (String) sender.receiveAndConvert(mockQueue);
				}
				else {
					m = sender.receive(mockQueue);
				}
			}
			else {
				if (testConverter) {
					textFromMessage = (String) sender.receiveAndConvert("testQueue");
				}
				else {
					m = sender.receive("testQueue");
				}
			}
		}

		queueConnectionFactoryControl.verify();
		queueConnectionControl.verify();
		queueSessionControl.verify();
		queueReceiverControl.verify();
		messageControl.verify();

		if (testConverter) {
			assertEquals("Message Text should be equal", "Hello World!", textFromMessage);
		}
		else {
			assertEquals("Messages should refer to the same object", m, mockMessage);
		}
	}
	private void setJndiTemplate(JmsTemplate sender) {
		JndiDestinationResolver destMan = new JndiDestinationResolver();
		destMan.setJndiTemplate(new JndiTemplate() {
			protected Context createInitialContext() throws NamingException {
				return mockJndiContext;
			}
		});
		sender.setDestinationResolver(destMan);
	}

}