Create spring-messaging module

Consolidates new, messaging-related classes from spring-context and
spring-websocket into one module.

spring-messaging/src/test/java/org/springframework/messaging/simp/handler/DefaultSubscriptionRegistryTests.java

@@ -0,0 +1,242 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.simp.handler;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
+import org.springframework.messaging.simp.SimpMessageType;
+import org.springframework.messaging.simp.handler.DefaultSubscriptionRegistry;
+import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.util.MultiValueMap;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * Test fixture for {@link DefaultSubscriptionRegistry}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class DefaultSubscriptionRegistryTests {
+
+	private DefaultSubscriptionRegistry registry;
+
+
+	@Before
+	public void setup() {
+		this.registry = new DefaultSubscriptionRegistry();
+	}
+
+
+	@Test
+	public void addSubscriptionInvalidInput() {
+
+		String sessId = "sess01";
+		String subsId = "subs01";
+		String dest = "/foo";
+
+		this.registry.addSubscription(subscribeMessage(null, subsId, dest));
+		assertEquals(0, this.registry.findSubscriptions(message(dest)).size());
+
+		this.registry.addSubscription(subscribeMessage(sessId, null, dest));
+		assertEquals(0, this.registry.findSubscriptions(message(dest)).size());
+
+		this.registry.addSubscription(subscribeMessage(sessId, subsId, null));
+		assertEquals(0, this.registry.findSubscriptions(message(dest)).size());
+	}
+
+	@Test
+	public void addSubscription() {
+
+		String sessId = "sess01";
+		String subsId = "subs01";
+		String dest = "/foo";
+
+		this.registry.addSubscription(subscribeMessage(sessId, subsId, dest));
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message(dest));
+
+		assertEquals("Expected one element " + actual, 1, actual.size());
+		assertEquals(Arrays.asList(subsId), actual.get(sessId));
+	}
+
+	@Test
+	public void addSubscriptionOneSession() {
+
+		String sessId = "sess01";
+		List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
+		String dest = "/foo";
+
+		for (String subId : subscriptionIds) {
+			this.registry.addSubscription(subscribeMessage(sessId, subId, dest));
+		}
+
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message(dest));
+
+		assertEquals("Expected one element " + actual, 1, actual.size());
+		assertEquals(subscriptionIds, sort(actual.get(sessId)));
+	}
+
+	@Test
+	public void addSubscriptionMultipleSessions() {
+
+		List<String> sessIds = Arrays.asList("sess01", "sess02", "sess03");
+		List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
+		String dest = "/foo";
+
+		for (String sessId : sessIds) {
+			for (String subsId : subscriptionIds) {
+				this.registry.addSubscription(subscribeMessage(sessId, subsId, dest));
+			}
+		}
+
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message(dest));
+
+		assertEquals("Expected three elements " + actual, 3, actual.size());
+		assertEquals(subscriptionIds, sort(actual.get(sessIds.get(0))));
+		assertEquals(subscriptionIds, sort(actual.get(sessIds.get(1))));
+		assertEquals(subscriptionIds, sort(actual.get(sessIds.get(2))));
+	}
+
+	@Test
+	public void addSubscriptionWithDestinationPattern() {
+
+		String sessId = "sess01";
+		String subsId = "subs01";
+		String destPattern = "/topic/PRICE.STOCK.*.IBM";
+		String dest = "/topic/PRICE.STOCK.NASDAQ.IBM";
+
+		this.registry.addSubscription(subscribeMessage(sessId, subsId, destPattern));
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message(dest));
+
+		assertEquals("Expected one element " + actual, 1, actual.size());
+		assertEquals(Arrays.asList(subsId), actual.get(sessId));
+	}
+
+	@Test
+	public void addSubscriptionWithDestinationPatternRegex() {
+
+		String sessId = "sess01";
+		String subsId = "subs01";
+		String destPattern = "/topic/PRICE.STOCK.*.{ticker:(IBM|MSFT)}";
+
+		this.registry.addSubscription(subscribeMessage(sessId, subsId, destPattern));
+		Message<?> message = message("/topic/PRICE.STOCK.NASDAQ.IBM");
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
+
+		assertEquals("Expected one element " + actual, 1, actual.size());
+		assertEquals(Arrays.asList(subsId), actual.get(sessId));
+
+		message = message("/topic/PRICE.STOCK.NASDAQ.MSFT");
+		actual = this.registry.findSubscriptions(message);
+
+		assertEquals("Expected one element " + actual, 1, actual.size());
+		assertEquals(Arrays.asList(subsId), actual.get(sessId));
+
+		message = message("/topic/PRICE.STOCK.NASDAQ.VMW");
+		actual = this.registry.findSubscriptions(message);
+
+		assertEquals("Expected no elements " + actual, 0, actual.size());
+	}
+
+	@Test
+	public void removeSubscription() {
+
+		List<String> sessIds = Arrays.asList("sess01", "sess02", "sess03");
+		List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
+		String dest = "/foo";
+
+		for (String sessId : sessIds) {
+			for (String subsId : subscriptionIds) {
+				this.registry.addSubscription(subscribeMessage(sessId, subsId, dest));
+			}
+		}
+
+		this.registry.removeSubscription(unsubscribeMessage(sessIds.get(0), subscriptionIds.get(0)));
+		this.registry.removeSubscription(unsubscribeMessage(sessIds.get(0), subscriptionIds.get(1)));
+		this.registry.removeSubscription(unsubscribeMessage(sessIds.get(0), subscriptionIds.get(2)));
+
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message(dest));
+
+		assertEquals("Expected three elements " + actual, 2, actual.size());
+		assertEquals(subscriptionIds, sort(actual.get(sessIds.get(1))));
+		assertEquals(subscriptionIds, sort(actual.get(sessIds.get(2))));
+	}
+
+	@Test
+	public void removeSessionSubscriptions() {
+
+		List<String> sessIds = Arrays.asList("sess01", "sess02", "sess03");
+		List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
+		String dest = "/foo";
+
+		for (String sessId : sessIds) {
+			for (String subsId : subscriptionIds) {
+				this.registry.addSubscription(subscribeMessage(sessId, subsId, dest));
+			}
+		}
+
+		this.registry.removeSessionSubscriptions(sessIds.get(0));
+		this.registry.removeSessionSubscriptions(sessIds.get(1));
+
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message(dest));
+
+		assertEquals("Expected three elements " + actual, 1, actual.size());
+		assertEquals(subscriptionIds, sort(actual.get(sessIds.get(2))));
+	}
+
+	@Test
+	public void findSubscriptionsNoMatches() {
+		MultiValueMap<String, String> actual = this.registry.findSubscriptions(message("/foo"));
+		assertEquals("Expected no elements " + actual, 0, actual.size());
+	}
+
+
+	private Message<?> subscribeMessage(String sessionId, String subscriptionId, String destination) {
+		SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.SUBSCRIBE);
+		headers.setSessionId(sessionId);
+		headers.setSubscriptionId(subscriptionId);
+		if (destination != null) {
+			headers.setDestination(destination);
+		}
+		return MessageBuilder.withPayload("").copyHeaders(headers.toMap()).build();
+	}
+
+	private Message<?> unsubscribeMessage(String sessionId, String subscriptionId) {
+		SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.UNSUBSCRIBE);
+		headers.setSessionId(sessionId);
+		headers.setSubscriptionId(subscriptionId);
+		return MessageBuilder.withPayload("").copyHeaders(headers.toMap()).build();
+	}
+
+	private Message<?> message(String destination) {
+		SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create();
+		headers.setDestination(destination);
+		return MessageBuilder.withPayload("").copyHeaders(headers.toMap()).build();
+	}
+
+	private List<String> sort(List<String> list) {
+		Collections.sort(list);
+		return list;
+	}
+
+}

spring-messaging/src/test/java/org/springframework/messaging/simp/handler/SimpleBrokerWebMessageHandlerTests.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.simp.handler;
+
+import java.util.Arrays;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
+import org.springframework.messaging.simp.SimpMessageType;
+import org.springframework.messaging.simp.handler.SimpleBrokerMessageHandler;
+import org.springframework.messaging.support.MessageBuilder;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+
+/**
+ *
+ * @author Rossen Stoyanchev
+ * @since 4.0
+ */
+public class SimpleBrokerWebMessageHandlerTests {
+
+	private SimpleBrokerMessageHandler messageHandler;
+
+	@Mock
+	private MessageChannel clientChannel;
+
+	@Captor
+	ArgumentCaptor<Message<?>> messageCaptor;
+
+
+	@Before
+	public void setup() {
+		MockitoAnnotations.initMocks(this);
+		this.messageHandler = new SimpleBrokerMessageHandler(this.clientChannel);
+	}
+
+
+	@Test
+	public void getSupportedMessageTypes() {
+		assertEquals(Arrays.asList(SimpMessageType.MESSAGE, SimpMessageType.SUBSCRIBE, SimpMessageType.UNSUBSCRIBE),
+				this.messageHandler.getSupportedMessageTypes());
+	}
+
+	@Test
+	public void subcribePublish() {
+
+		this.messageHandler.handleSubscribe(createSubscriptionMessage("sess1", "sub1", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage("sess1", "sub2", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage("sess1", "sub3", "/bar"));
+
+		this.messageHandler.handleSubscribe(createSubscriptionMessage("sess2", "sub1", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage("sess2", "sub2", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage("sess2", "sub3", "/bar"));
+
+		this.messageHandler.handlePublish(createMessage("/foo", "message1"));
+		this.messageHandler.handlePublish(createMessage("/bar", "message2"));
+
+		verify(this.clientChannel, times(6)).send(this.messageCaptor.capture());
+		assertCapturedMessage("sess1", "sub1", "/foo");
+		assertCapturedMessage("sess1", "sub2", "/foo");
+		assertCapturedMessage("sess2", "sub1", "/foo");
+		assertCapturedMessage("sess2", "sub2", "/foo");
+		assertCapturedMessage("sess1", "sub3", "/bar");
+		assertCapturedMessage("sess2", "sub3", "/bar");
+	}
+
+	@Test
+	public void subcribeDisconnectPublish() {
+
+		String sess1 = "sess1";
+		String sess2 = "sess2";
+
+		this.messageHandler.handleSubscribe(createSubscriptionMessage(sess1, "sub1", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage(sess1, "sub2", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage(sess1, "sub3", "/bar"));
+
+		this.messageHandler.handleSubscribe(createSubscriptionMessage(sess2, "sub1", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage(sess2, "sub2", "/foo"));
+		this.messageHandler.handleSubscribe(createSubscriptionMessage(sess2, "sub3", "/bar"));
+
+		SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.DISCONNECT);
+		headers.setSessionId(sess1);
+		Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).copyHeaders(headers.toMap()).build();
+		this.messageHandler.handleDisconnect(message);
+
+		this.messageHandler.handlePublish(createMessage("/foo", "message1"));
+		this.messageHandler.handlePublish(createMessage("/bar", "message2"));
+
+		verify(this.clientChannel, times(3)).send(this.messageCaptor.capture());
+		assertCapturedMessage(sess2, "sub1", "/foo");
+		assertCapturedMessage(sess2, "sub2", "/foo");
+		assertCapturedMessage(sess2, "sub3", "/bar");
+	}
+
+
+	protected Message<String> createSubscriptionMessage(String sessionId, String subcriptionId, String destination) {
+
+		SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.SUBSCRIBE);
+		headers.setSubscriptionId(subcriptionId);
+		headers.setDestination(destination);
+		headers.setSessionId(sessionId);
+
+		return MessageBuilder.withPayload("").copyHeaders(headers.toMap()).build();
+	}
+
+	protected Message<String> createMessage(String destination, String payload) {
+
+		SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.MESSAGE);
+		headers.setDestination(destination);
+
+		return MessageBuilder.withPayload(payload).copyHeaders(headers.toMap()).build();
+	}
+
+	protected boolean assertCapturedMessage(String sessionId, String subcriptionId, String destination) {
+		for (Message<?> message : this.messageCaptor.getAllValues()) {
+			SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.wrap(message);
+			if (sessionId.equals(headers.getSessionId())) {
+				if (subcriptionId.equals(headers.getSubscriptionId())) {
+					if (destination.equals(headers.getDestination())) {
+						return true;
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+}

spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompMessageConverterTests.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.messaging.simp.stomp;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
+import org.springframework.messaging.simp.SimpMessageType;
+import org.springframework.messaging.simp.stomp.StompCommand;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.messaging.simp.stomp.StompMessageConverter;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author Gary Russell
+ * @author Rossen Stoyanchev
+ */
+public class StompMessageConverterTests {
+
+	private StompMessageConverter converter;
+
+
+	@Before
+	public void setup() {
+		this.converter = new StompMessageConverter();
+	}
+
+	@SuppressWarnings("unchecked")
+	@Test
+	public void connectFrame() throws Exception {
+
+		String accept = "accept-version:1.1\n";
+		String host = "host:github.org\n";
+		String frame = "\n\n\nCONNECT\n" + accept + host + "\n";
+		Message<byte[]> message = (Message<byte[]>) this.converter.toMessage(frame.getBytes("UTF-8"), "session-123");
+
+		assertEquals(0, message.getPayload().length);
+
+		MessageHeaders headers = message.getHeaders();
+		StompHeaderAccessor stompHeaders = StompHeaderAccessor.wrap(message);
+		Map<String, Object> map = stompHeaders.toMap();
+		assertEquals(6, map.size());
+		assertNotNull(map.get(MessageHeaders.ID));
+		assertNotNull(map.get(MessageHeaders.TIMESTAMP));
+		assertNotNull(map.get(SimpMessageHeaderAccessor.SESSION_ID));
+		assertNotNull(map.get(SimpMessageHeaderAccessor.NATIVE_HEADERS));
+		assertNotNull(map.get(SimpMessageHeaderAccessor.MESSAGE_TYPE));
+		assertNotNull(map.get(SimpMessageHeaderAccessor.PROTOCOL_MESSAGE_TYPE));
+
+		assertEquals(Collections.singleton("1.1"), stompHeaders.getAcceptVersion());
+		assertEquals("github.org", stompHeaders.getHost());
+
+		assertEquals(SimpMessageType.CONNECT, stompHeaders.getMessageType());
+		assertEquals(StompCommand.CONNECT, stompHeaders.getStompCommand());
+		assertEquals("session-123", stompHeaders.getSessionId());
+		assertNotNull(headers.get(MessageHeaders.ID));
+		assertNotNull(headers.get(MessageHeaders.TIMESTAMP));
+
+		String convertedBack = new String(this.converter.fromMessage(message), "UTF-8");
+
+		assertEquals("CONNECT\n", convertedBack.substring(0,8));
+		assertTrue(convertedBack.contains(accept));
+		assertTrue(convertedBack.contains(host));
+	}
+
+	@Test
+	public void connectWithEscapes() throws Exception {
+
+		String accept = "accept-version:1.1\n";
+		String host = "ho\\c\\ns\\rt:st\\nomp.gi\\cthu\\b.org\n";
+		String frame = "CONNECT\n" + accept + host + "\n";
+		@SuppressWarnings("unchecked")
+		Message<byte[]> message = (Message<byte[]>) this.converter.toMessage(frame.getBytes("UTF-8"), "session-123");
+
+		assertEquals(0, message.getPayload().length);
+
+		StompHeaderAccessor stompHeaders = StompHeaderAccessor.wrap(message);
+		assertEquals(Collections.singleton("1.1"), stompHeaders.getAcceptVersion());
+		assertEquals("st\nomp.gi:thu\\b.org", stompHeaders.toNativeHeaderMap().get("ho:\ns\rt").get(0));
+
+		String convertedBack = new String(this.converter.fromMessage(message), "UTF-8");
+
+		assertEquals("CONNECT\n", convertedBack.substring(0,8));
+		assertTrue(convertedBack.contains(accept));
+		assertTrue(convertedBack.contains(host));
+	}
+
+	@Test
+	public void connectCR12() throws Exception {
+
+		String accept = "accept-version:1.2\n";
+		String host = "host:github.org\n";
+		String test = "CONNECT\r\n" + accept.replaceAll("\n", "\r\n") + host.replaceAll("\n", "\r\n") + "\r\n";
+		@SuppressWarnings("unchecked")
+		Message<byte[]> message = (Message<byte[]>) this.converter.toMessage(test.getBytes("UTF-8"), "session-123");
+
+		assertEquals(0, message.getPayload().length);
+
+		StompHeaderAccessor stompHeaders = StompHeaderAccessor.wrap(message);
+		assertEquals(Collections.singleton("1.2"), stompHeaders.getAcceptVersion());
+		assertEquals("github.org", stompHeaders.getHost());
+
+		String convertedBack = new String(this.converter.fromMessage(message), "UTF-8");
+
+		assertEquals("CONNECT\n", convertedBack.substring(0,8));
+		assertTrue(convertedBack.contains(accept));
+		assertTrue(convertedBack.contains(host));
+	}
+
+	@Test
+	public void connectWithEscapesAndCR12() throws Exception {
+
+		String accept = "accept-version:1.1\n";
+		String host = "ho\\c\\ns\\rt:st\\nomp.gi\\cthu\\b.org\n";
+		String test = "\n\n\nCONNECT\r\n" + accept.replaceAll("\n", "\r\n") + host.replaceAll("\n", "\r\n") + "\r\n";
+		@SuppressWarnings("unchecked")
+		Message<byte[]> message = (Message<byte[]>) this.converter.toMessage(test.getBytes("UTF-8"), "session-123");
+
+		assertEquals(0, message.getPayload().length);
+
+		StompHeaderAccessor stompHeaders = StompHeaderAccessor.wrap(message);
+		assertEquals(Collections.singleton("1.1"), stompHeaders.getAcceptVersion());
+		assertEquals("st\nomp.gi:thu\\b.org", stompHeaders.toNativeHeaderMap().get("ho:\ns\rt").get(0));
+
+		String convertedBack = new String(this.converter.fromMessage(message), "UTF-8");
+
+		assertEquals("CONNECT\n", convertedBack.substring(0,8));
+		assertTrue(convertedBack.contains(accept));
+		assertTrue(convertedBack.contains(host));
+	}
+
+}

spring-messaging/src/test/java/org/springframework/messaging/support/MessageBuilderTests.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.support;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import org.junit.Test;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * @author Mark Fisher
+ */
+public class MessageBuilderTests {
+
+	@Test
+	public void testSimpleMessageCreation() {
+		Message<String> message = MessageBuilder.withPayload("foo").build();
+		assertEquals("foo", message.getPayload());
+	}
+
+	@Test
+	public void testHeaderValues() {
+		Message<String> message = MessageBuilder.withPayload("test")
+				.setHeader("foo", "bar")
+				.setHeader("count", new Integer(123))
+				.build();
+		assertEquals("bar", message.getHeaders().get("foo", String.class));
+		assertEquals(new Integer(123), message.getHeaders().get("count", Integer.class));
+	}
+
+	@Test
+	public void testCopiedHeaderValues() {
+		Message<String> message1 = MessageBuilder.withPayload("test1")
+				.setHeader("foo", "1")
+				.setHeader("bar", "2")
+				.build();
+		Message<String> message2 = MessageBuilder.withPayload("test2")
+				.copyHeaders(message1.getHeaders())
+				.setHeader("foo", "42")
+				.setHeaderIfAbsent("bar", "99")
+				.build();
+		assertEquals("test1", message1.getPayload());
+		assertEquals("test2", message2.getPayload());
+		assertEquals("1", message1.getHeaders().get("foo"));
+		assertEquals("42", message2.getHeaders().get("foo"));
+		assertEquals("2", message1.getHeaders().get("bar"));
+		assertEquals("2", message2.getHeaders().get("bar"));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testIdHeaderValueReadOnly() {
+		UUID id = UUID.randomUUID();
+		MessageBuilder.withPayload("test").setHeader(MessageHeaders.ID, id);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testTimestampValueReadOnly() {
+		Long timestamp = 12345L;
+		MessageBuilder.withPayload("test").setHeader(MessageHeaders.TIMESTAMP, timestamp).build();
+	}
+
+	@Test
+	public void copyHeadersIfAbsent() {
+		Message<String> message1 = MessageBuilder.withPayload("test1")
+				.setHeader("foo", "bar").build();
+		Message<String> message2 = MessageBuilder.withPayload("test2")
+				.setHeader("foo", 123)
+				.copyHeadersIfAbsent(message1.getHeaders())
+				.build();
+		assertEquals("test2", message2.getPayload());
+		assertEquals(123, message2.getHeaders().get("foo"));
+	}
+
+	@Test
+	public void createFromMessage() {
+		Message<String> message1 = MessageBuilder.withPayload("test")
+				.setHeader("foo", "bar").build();
+		Message<String> message2 = MessageBuilder.fromMessage(message1).build();
+		assertEquals("test", message2.getPayload());
+		assertEquals("bar", message2.getHeaders().get("foo"));
+	}
+
+	@Test
+	public void createIdRegenerated() {
+		Message<String> message1 = MessageBuilder.withPayload("test")
+				.setHeader("foo", "bar").build();
+		Message<String> message2 = MessageBuilder.fromMessage(message1).setHeader("another", 1).build();
+		assertEquals("bar", message2.getHeaders().get("foo"));
+		assertNotSame(message1.getHeaders().getId(), message2.getHeaders().getId());
+	}
+
+	@Test
+	public void testRemove() {
+		Message<Integer> message1 = MessageBuilder.withPayload(1)
+			.setHeader("foo", "bar").build();
+		Message<Integer> message2 = MessageBuilder.fromMessage(message1)
+			.removeHeader("foo")
+			.build();
+		assertFalse(message2.getHeaders().containsKey("foo"));
+	}
+
+	@Test
+	public void testSettingToNullRemoves() {
+		Message<Integer> message1 = MessageBuilder.withPayload(1)
+			.setHeader("foo", "bar").build();
+		Message<Integer> message2 = MessageBuilder.fromMessage(message1)
+			.setHeader("foo", null)
+			.build();
+		assertFalse(message2.getHeaders().containsKey("foo"));
+	}
+
+	@Test
+	public void testNotModifiedSameMessage() throws Exception {
+		Message<?> original = MessageBuilder.withPayload("foo").build();
+		Message<?> result = MessageBuilder.fromMessage(original).build();
+		assertEquals(original, result);
+	}
+
+	@Test
+	public void testContainsHeaderNotModifiedSameMessage() throws Exception {
+		Message<?> original = MessageBuilder.withPayload("foo").setHeader("bar", 42).build();
+		Message<?> result = MessageBuilder.fromMessage(original).build();
+		assertEquals(original, result);
+	}
+
+	@Test
+	public void testSameHeaderValueAddedNotModifiedSameMessage() throws Exception {
+		Message<?> original = MessageBuilder.withPayload("foo").setHeader("bar", 42).build();
+		Message<?> result = MessageBuilder.fromMessage(original).setHeader("bar", 42).build();
+		assertEquals(original, result);
+	}
+
+	@Test
+	public void testCopySameHeaderValuesNotModifiedSameMessage() throws Exception {
+		Date current = new Date();
+		Map<String, Object> originalHeaders = new HashMap<String, Object>();
+		originalHeaders.put("b", "xyz");
+		originalHeaders.put("c", current);
+		Message<?> original = MessageBuilder.withPayload("foo").setHeader("a", 123).copyHeaders(originalHeaders).build();
+		Map<String, Object> newHeaders = new HashMap<String, Object>();
+		newHeaders.put("a", 123);
+		newHeaders.put("b", "xyz");
+		newHeaders.put("c", current);
+		Message<?> result = MessageBuilder.fromMessage(original).copyHeaders(newHeaders).build();
+		assertEquals(original, result);
+	}
+
+}

spring-messaging/src/test/java/org/springframework/messaging/support/channel/PublishSubscibeChannelTests.java

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.support.channel;
+
+import java.util.concurrent.Executor;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHandler;
+import org.springframework.messaging.MessagingException;
+import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.messaging.support.channel.PublishSubscribeChannel;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+import static org.mockito.BDDMockito.*;
+
+/**
+ * Tests for {@link PublishSubscribeChannel}.
+ *
+ * @author Phillip Webb
+ */
+public class PublishSubscibeChannelTests {
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+
+	private PublishSubscribeChannel channel = new PublishSubscribeChannel();
+
+	@Mock
+	private MessageHandler handler;
+
+	private final Object payload = new Object();
+
+	private final Message<Object> message = MessageBuilder.withPayload(this.payload).build();
+
+	@Captor
+	private ArgumentCaptor<Runnable> runnableCaptor;
+
+
+	@Before
+	public void setup() {
+		MockitoAnnotations.initMocks(this);
+	}
+
+	@Test
+	public void messageMustNotBeNull() throws Exception {
+		thrown.expect(IllegalArgumentException.class);
+		thrown.expectMessage("Message must not be null");
+		this.channel.send(null);
+	}
+
+	@Test
+	public void payloadMustNotBeNull() throws Exception {
+		Message<?> message = mock(Message.class);
+		thrown.expect(IllegalArgumentException.class);
+		thrown.expectMessage("Message payload must not be null");
+		this.channel.send(message);
+	}
+
+	@Test
+	public void sendWithoutExecutor() {
+		this.channel.subscribe(this.handler);
+		this.channel.send(this.message);
+		verify(this.handler).handleMessage(this.message);
+	}
+
+	@Test
+	public void sendWithExecutor() throws Exception {
+		Executor executor = mock(Executor.class);
+		this.channel = new PublishSubscribeChannel(executor);
+		this.channel.subscribe(this.handler);
+		this.channel.send(this.message);
+		verify(executor).execute(this.runnableCaptor.capture());
+		verify(this.handler, never()).handleMessage(this.message);
+		this.runnableCaptor.getValue().run();
+		verify(this.handler).handleMessage(this.message);
+	}
+
+	@Test
+	public void subscribeTwice() throws Exception {
+		assertThat(this.channel.subscribe(this.handler), equalTo(true));
+		assertThat(this.channel.subscribe(this.handler), equalTo(false));
+		this.channel.send(this.message);
+		verify(this.handler, times(1)).handleMessage(this.message);
+	}
+
+	@Test
+	public void unsubscribeTwice() throws Exception {
+		this.channel.subscribe(this.handler);
+		assertThat(this.channel.unsubscribe(this.handler), equalTo(true));
+		assertThat(this.channel.unsubscribe(this.handler), equalTo(false));
+		this.channel.send(this.message);
+		verify(this.handler, never()).handleMessage(this.message);
+	}
+
+	@Test
+	public void failurePropagates() throws Exception {
+		RuntimeException ex = new RuntimeException();
+		willThrow(ex).given(this.handler).handleMessage(this.message);
+		MessageHandler secondHandler = mock(MessageHandler.class);
+		this.channel.subscribe(this.handler);
+		this.channel.subscribe(secondHandler);
+		try {
+			this.channel.send(message);
+		}
+		catch(RuntimeException actualException) {
+			assertThat(actualException, equalTo(ex));
+		}
+		verifyZeroInteractions(secondHandler);
+	}
+
+	@Test
+	public void concurrentModification() throws Exception {
+		this.channel.subscribe(new MessageHandler() {
+			@Override
+			public void handleMessage(Message<?> message) throws MessagingException {
+				channel.unsubscribe(handler);
+			}
+		});
+		this.channel.subscribe(this.handler);
+		this.channel.send(this.message);
+		verify(this.handler).handleMessage(this.message);
+	}
+
+}

spring-messaging/src/test/resources/log4j.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
+
+<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
+
+	<!-- Appenders -->
+	<appender name="console" class="org.apache.log4j.ConsoleAppender">
+		<param name="Target" value="System.out" />
+		<layout class="org.apache.log4j.PatternLayout">
+			<param name="ConversionPattern" value="%-5p: %c - %m%n" />
+		</layout>
+	</appender>
+
+	<logger name="org.springframework.messaging">
+		<level value="info" />
+	</logger>
+
+	<!-- Root Logger -->
+	<root>
+		<priority value="warn" />
+		<appender-ref ref="console" />
+	</root>
+	
+</log4j:configuration>