jmstemplate102tests.java

spring的源代码

		QueueSender mockQueueSender = (QueueSender) queueSenderControl.getMock();

		mockQueueSession.createSender(null);
		queueSessionControl.setReturnValue(mockQueueSender);

		mockQueueSender.setDisableMessageID(true);
		queueSenderControl.setVoidCallable(1);
		mockQueueSender.setDisableMessageTimestamp(true);
		queueSenderControl.setVoidCallable(1);
		mockQueueSender.getPriority();
		queueSenderControl.setReturnValue(4);

		mockQueueSender.close();
		queueSenderControl.setVoidCallable(1);
		mockQueueSession.close();
		queueSessionControl.setVoidCallable(1);
		mockQueueConnection.close();
		queueConnectionControl.setVoidCallable(1);

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

		template.execute(new ProducerCallback() {
			public Object doInJms(Session session, MessageProducer producer) throws JMSException {
				boolean b = session.getTransacted();
				int i = producer.getPriority();
				return null;
			}
		});

		queueConnectionFactoryControl.verify();
		queueConnectionControl.verify();
		queueSessionControl.verify();
	}

	/**
	 * Test the setting of the JmsTemplate properties.
	 */
	public void testBeanProperties() throws Exception {
		JmsTemplate102 template = createTemplate();
		template.setConnectionFactory(mockQueueConnectionFactory);

		assertTrue("connection factory ok", template.getConnectionFactory() == mockQueueConnectionFactory);

		JmsTemplate102 s102 = createTemplate();
		try {
			s102.afterPropertiesSet();
			fail("IllegalArgumentException not thrown. ConnectionFactory should be set");
		}
		catch (IllegalArgumentException ex) {
			assertEquals("Exception message not matching", "connectionFactory is required", ex.getMessage());
		}

		// The default is for the JmsTemplate102 to send to queues.
		// Test to make sure exeception is thrown and has reasonable message.
		s102 = createTemplate();
		s102.setConnectionFactory(mockTopicConnectionFactory);
		try {
			s102.afterPropertiesSet();
			fail("IllegalArgumentException not thrown. Mismatch of Destination and ConnectionFactory types.");
		}
		catch (IllegalArgumentException ex) {
			// expected
		}

		s102 = createTemplate();
		s102.setConnectionFactory(mockQueueConnectionFactory);
		s102.setPubSubDomain(true);
		try {
			s102.afterPropertiesSet();
			fail("IllegalArgumentException not thrown. Mismatch of Destination and ConnectionFactory types.");
		}
		catch (IllegalArgumentException ex) {
			// expected
		}
	}

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

	/**
	 * Test the method send(String destination, MessageCreator c) when
	 * explicit QOS parameters are enabled, using a queue.
	 */
	public void testSendStringQueueWithQOS() throws Exception {
		sendQueue(false, false, false, false);
	}

	/**
	 * Test the method send(MessageCreator c) using default QOS values.
	 */
	public void testSendDefaultDestinationQueue() throws Exception {
		sendQueue(true, false, true, true);
	}

	/**
	 * Test the method send(MessageCreator c) using explicit QOS values.
	 */
	public void testSendDefaultDestinationQueueWithQOS() throws Exception {
		sendQueue(false, false, true, false);
	}

	/**
	 * Test the method send(String destination, MessageCreator c) using
	 * 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, true);
	}

	/**
	 * Test the method send(Destination queue, MessageCreator c) sing explicit
	 * QOS values.
	 */
	public void testSendQueueWithQOS() throws Exception {
		sendQueue(false, 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, true);
	}

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

		JmsTemplate102 template = createTemplate();
		template.setConnectionFactory(mockQueueConnectionFactory);
		template.afterPropertiesSet();

		if (useDefaultDestination) {
			template.setDefaultDestination(mockQueue);
		}
		if (disableIdAndTimestamp) {
			template.setMessageIdEnabled(false);
			template.setMessageTimestampEnabled(false);
		}

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

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

		if (disableIdAndTimestamp) {
			mockQueueSender.setDisableMessageID(true);
			queueSenderControl.setVoidCallable(1);
			mockQueueSender.setDisableMessageTimestamp(true);
			queueSenderControl.setVoidCallable(1);
		}

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

		if (useTransactedTemplate()) {
			mockQueueSession.commit();
			queueSessionControl.setVoidCallable(1);
		}

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

		mockQueueSender.close();
		queueSenderControl.setVoidCallable(1);
		mockQueueSession.close();
		queueSessionControl.setVoidCallable(1);
		mockQueueConnection.close();
		queueConnectionControl.setVoidCallable(1);

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

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

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

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

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

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

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

		if (useTransactedTemplate()) {
			mockTopicSession.commit();
			topicSessionControl.setVoidCallable(1);
		}

		mockTopicPublisher.close();
		topicPublisherControl.setVoidCallable(1);
		mockTopicSession.close();
		topicSessionControl.setVoidCallable(1);
		mockTopicConnection.close();
		topicConnectionControl.setVoidCallable(1);


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

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

		template.setPubSubDomain(true);

		if (explicitTopic) {
			template.send(mockTopic, new MessageCreator() {
				public Message createMessage(Session session)
				    throws JMSException {
					return session.createTextMessage("just testing");
				}
			});
		}
		else {
			template.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 template = createTemplate();
		template.setConnectionFactory(mockQueueConnectionFactory);
		template.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();

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

		if (useTransactedTemplate()) {
			mockQueueSession.commit();
			queueSessionControl.setVoidCallable(1);
		}

		mockQueueSender.send(mockMessage);
		queueSenderControl.setVoidCallable(1);

		mockQueueSender.close();
		queueSenderControl.setVoidCallable(1);
		mockQueueSession.close();
		queueSessionControl.setVoidCallable(1);
		mockQueueConnection.close();
		queueConnectionControl.setVoidCallable(1);

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

		template.convertAndSend(mockQueue, s);

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

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

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

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

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

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

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