Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Polishing

Browse Source
This commit is contained in:
Sam Brannen
2023-06-01 14:31:55 +02:00
parent 5b471a5349
commit e8ab53e76d
4 changed files with 80 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
spring-messaging/src/test/java/org/springframework/messaging/simp/broker/DefaultSubscriptionRegistryTests.java
View File

@@ -16,7 +16,6 @@
package org.springframework.messaging.simp.broker;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
@@ -33,41 +32,38 @@ import org.springframework.util.MultiValueMap;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Test fixture for
* {@link org.springframework.messaging.simp.broker.DefaultSubscriptionRegistry}.
* Tests for {@link DefaultSubscriptionRegistry}.
*
* @author Rossen Stoyanchev
* @author Sebastien Deleuze
* @author Sam Brannen
*/
public class DefaultSubscriptionRegistryTests {
class DefaultSubscriptionRegistryTests {
private final DefaultSubscriptionRegistry registry = new DefaultSubscriptionRegistry();
@Test
public void registerSubscriptionInvalidInput() {
void registerSubscriptionInvalidInput() {
String sessId = "sess01";
String subsId = "subs01";
String dest = "/foo";
this.registry.registerSubscription(subscribeMessage(null, subsId, dest));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).isEmpty();
this.registry.registerSubscription(subscribeMessage(sessId, null, dest));
actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).isEmpty();
this.registry.registerSubscription(subscribeMessage(sessId, subsId, null));
actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).isEmpty();
}
@Test
public void registerSubscription() {
void registerSubscription() {
String sessId = "sess01";
String subsId = "subs01";
String dest = "/foo";
@@ -75,15 +71,14 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sessId, subsId, dest));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected one element " + actual).hasSize(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
assertThat(actual).hasSize(1);
assertThat(actual.get(sessId)).containsExactly(subsId);
}
@Test
public void registerSubscriptionOneSession() {
void registerSubscriptionOneSession() {
String sessId = "sess01";
List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
List<String> subscriptionIds = List.of("subs01", "subs02", "subs03");
String dest = "/foo";
for (String subId : subscriptionIds) {
@@ -91,13 +86,12 @@ public class DefaultSubscriptionRegistryTests {
}
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).hasSize(1);
assertThat(sort(actual.get(sessId))).isEqualTo(subscriptionIds);
}
@Test
public void registerSameSubscriptionTwice() {
void registerSameSubscriptionTwice() {
String sessId = "sess01";
String subId = "subs01";
String dest = "/foo";
@@ -106,15 +100,14 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sessId, subId, dest));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).hasSize(1);
assertThat(actual.get(sessId)).containsExactly(subId);
}
@Test
public void registerSubscriptionMultipleSessions() {
List<String> sessIds = Arrays.asList("sess01", "sess02", "sess03");
List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
void registerSubscriptionMultipleSessions() {
List<String> sessIds = List.of("sess01", "sess02", "sess03");
List<String> subscriptionIds = List.of("subs01", "subs02", "subs03");
String dest = "/foo";
for (String sessId : sessIds) {
@@ -124,7 +117,6 @@ public class DefaultSubscriptionRegistryTests {
}
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).hasSize(3);
assertThat(sort(actual.get(sessIds.get(0)))).isEqualTo(subscriptionIds);
assertThat(sort(actual.get(sessIds.get(1)))).isEqualTo(subscriptionIds);
@@ -132,7 +124,7 @@ public class DefaultSubscriptionRegistryTests {
}
@Test
public void registerSubscriptionWithDestinationPattern() {
void registerSubscriptionWithDestinationPattern() {
String sessId = "sess01";
String subsId = "subs01";
String destPattern = "/topic/PRICE.STOCK.*.IBM";
@@ -140,13 +132,12 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sessId, subsId, destPattern));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected one element " + actual).hasSize(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
assertThat(actual).hasSize(1);
assertThat(actual.get(sessId)).containsExactly(subsId);
}
@Test // SPR-11657
public void registerSubscriptionsWithSimpleAndPatternDestinations() {
void registerSubscriptionsWithSimpleAndPatternDestinations() {
String sess1 = "sess01";
String sess2 = "sess02";
@@ -161,7 +152,6 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sess1, subs1, "/topic/PRICE.STOCK.*.IBM"));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(1);
assertThat(actual.get(sess1)).containsExactlyInAnyOrder(subs2, subs1);
@@ -170,51 +160,45 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sess2, subs3, "/topic/PRICE.STOCK.NASDAQ.GOOG"));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(2);
assertThat(actual.get(sess1)).containsExactlyInAnyOrder(subs2, subs1);
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
assertThat(actual.get(sess2)).containsExactly(subs1);
this.registry.unregisterAllSubscriptions(sess1);
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(1);
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
assertThat(actual.get(sess2)).containsExactly(subs1);
this.registry.registerSubscription(subscribeMessage(sess1, subs1, "/topic/PRICE.STOCK.*.IBM"));
this.registry.registerSubscription(subscribeMessage(sess1, subs2, destNasdaqIbm));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(2);
assertThat(actual.get(sess1)).containsExactlyInAnyOrder(subs1, subs2);
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
assertThat(actual.get(sess2)).containsExactly(subs1);
this.registry.unregisterSubscription(unsubscribeMessage(sess1, subs2));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(2);
assertThat(actual.get(sess1)).isEqualTo(Collections.singletonList(subs1));
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
assertThat(actual.get(sess1)).containsExactly(subs1);
assertThat(actual.get(sess2)).containsExactly(subs1);
this.registry.unregisterSubscription(unsubscribeMessage(sess1, subs1));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(1);
assertThat(actual.get(sess2)).isEqualTo(Collections.singletonList(subs1));
assertThat(actual.get(sess2)).containsExactly(subs1);
this.registry.unregisterSubscription(unsubscribeMessage(sess2, subs1));
actual = this.registry.findSubscriptions(destNasdaqIbmMessage);
assertThat(actual).isNotNull();
assertThat(actual).isEmpty();
}
@Test // SPR-11755
public void registerAndUnregisterMultipleDestinations() {
void registerAndUnregisterMultipleDestinations() {
String sess1 = "sess01";
String sess2 = "sess02";
@@ -247,7 +231,7 @@ public class DefaultSubscriptionRegistryTests {
}
@Test
public void registerSubscriptionWithDestinationPatternRegex() {
void registerSubscriptionWithDestinationPatternRegex() {
String sessId = "sess01";
String subsId = "subs01";
String destPattern = "/topic/PRICE.STOCK.*.{ticker:(IBM|MSFT)}";
@@ -255,24 +239,21 @@ public class DefaultSubscriptionRegistryTests {
this.registry.registerSubscription(subscribeMessage(sessId, subsId, destPattern));
Message<?> message = createMessage("/topic/PRICE.STOCK.NASDAQ.IBM");
MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
assertThat(actual).isNotNull();
assertThat(actual).as("Expected one element " + actual).hasSize(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
assertThat(actual).hasSize(1);
assertThat(actual.get(sessId)).containsExactly(subsId);
message = createMessage("/topic/PRICE.STOCK.NASDAQ.MSFT");
actual = this.registry.findSubscriptions(message);
assertThat(actual).isNotNull();
assertThat(actual).as("Expected one element " + actual).hasSize(1);
assertThat(actual.get(sessId)).isEqualTo(Collections.singletonList(subsId));
assertThat(actual).hasSize(1);
assertThat(actual.get(sessId)).containsExactly(subsId);
message = createMessage("/topic/PRICE.STOCK.NASDAQ.VMW");
actual = this.registry.findSubscriptions(message);
assertThat(actual).isNotNull();
assertThat(actual).as("Expected no elements " + actual).isEmpty();
assertThat(actual).isEmpty();
}
@Test
public void registerSubscriptionWithSelector() {
void registerSubscriptionWithSelector() {
String sessionId = "sess01";
String subscriptionId = "subs01";
String destination = "/foo";
@@ -288,19 +269,17 @@ public class DefaultSubscriptionRegistryTests {
Message<?> message = MessageBuilder.createMessage("", accessor.getMessageHeaders());
MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(1);
assertThat(actual.get(sessionId)).isEqualTo(Collections.singletonList(subscriptionId));
assertThat(actual.get(sessionId)).containsExactly(subscriptionId);
// Then without
// Then without selector header
actual = this.registry.findSubscriptions(createMessage(destination));
assertThat(actual).isNotNull();
assertThat(actual).isEmpty();
}
@Test
public void registerSubscriptionWithSelectorNotSupported() {
void registerSubscriptionWithSelectorNotSupported() {
String sessionId = "sess01";
String subscriptionId = "subs01";
String destination = "/foo";
@@ -315,39 +294,35 @@ public class DefaultSubscriptionRegistryTests {
Message<?> message = MessageBuilder.createMessage("", accessor.getMessageHeaders());
MultiValueMap<String, String> actual = this.registry.findSubscriptions(message);
assertThat(actual).isNotNull();
assertThat(actual).hasSize(1);
assertThat(actual.get(sessionId)).isEqualTo(Collections.singletonList(subscriptionId));
assertThat(actual.get(sessionId)).containsExactly(subscriptionId);
}
@Test // SPR-11931
public void registerSubscriptionTwiceAndUnregister() {
void registerSubscriptionTwiceAndUnregister() {
this.registry.registerSubscription(subscribeMessage("sess01", "subs01", "/foo"));
this.registry.registerSubscription(subscribeMessage("sess01", "subs02", "/foo"));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage("/foo"));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected 1 element").hasSize(1);
assertThat(actual.get("sess01")).isEqualTo(Arrays.asList("subs01", "subs02"));
assertThat(actual).hasSize(1);
assertThat(actual.get("sess01")).containsExactly("subs01", "subs02");
this.registry.unregisterSubscription(unsubscribeMessage("sess01", "subs01"));
actual = this.registry.findSubscriptions(createMessage("/foo"));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected 1 element").hasSize(1);
assertThat(actual.get("sess01")).isEqualTo(Collections.singletonList("subs02"));
assertThat(actual).hasSize(1);
assertThat(actual.get("sess01")).containsExactly("subs02");
this.registry.unregisterSubscription(unsubscribeMessage("sess01", "subs02"));
actual = this.registry.findSubscriptions(createMessage("/foo"));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected no element").isEmpty();
assertThat(actual).isEmpty();
}
@Test
public void unregisterSubscription() {
List<String> sessIds = Arrays.asList("sess01", "sess02", "sess03");
List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
void unregisterSubscription() {
List<String> sessIds = List.of("sess01", "sess02", "sess03");
List<String> subscriptionIds = List.of("subs01", "subs02", "subs03");
String dest = "/foo";
for (String sessId : sessIds) {
@@ -361,16 +336,15 @@ public class DefaultSubscriptionRegistryTests {
this.registry.unregisterSubscription(unsubscribeMessage(sessIds.get(0), subscriptionIds.get(2)));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected two elements: " + actual).hasSize(2);
assertThat(actual).hasSize(2);
assertThat(sort(actual.get(sessIds.get(1)))).isEqualTo(subscriptionIds);
assertThat(sort(actual.get(sessIds.get(2)))).isEqualTo(subscriptionIds);
}
@Test
public void unregisterAllSubscriptions() {
List<String> sessIds = Arrays.asList("sess01", "sess02", "sess03");
List<String> subscriptionIds = Arrays.asList("subs01", "subs02", "subs03");
void unregisterAllSubscriptions() {
List<String> sessIds = List.of("sess01", "sess02", "sess03");
List<String> subscriptionIds = List.of("subs01", "subs02", "subs03");
String dest = "/foo";
for (String sessId : sessIds) {
@@ -383,31 +357,28 @@ public class DefaultSubscriptionRegistryTests {
this.registry.unregisterAllSubscriptions(sessIds.get(1));
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage(dest));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected one element: " + actual).hasSize(1);
assertThat(actual).hasSize(1);
assertThat(sort(actual.get(sessIds.get(2)))).isEqualTo(subscriptionIds);
}
@Test
public void unregisterAllSubscriptionsNoMatch() {
void unregisterAllSubscriptionsNoMatch() {
this.registry.unregisterAllSubscriptions("bogus");
// no exceptions
}
@Test
public void findSubscriptionsNoMatches() {
void findSubscriptionsNoMatches() {
MultiValueMap<String, String> actual = this.registry.findSubscriptions(createMessage("/foo"));
assertThat(actual).isNotNull();
assertThat(actual).as("Expected no elements " + actual).isEmpty();
assertThat(actual).isEmpty();
}
@Test // SPR-12665
public void findSubscriptionsReturnsMapSafeToIterate() throws Exception {
void findSubscriptionsReturnsMapSafeToIterate() throws Exception {
this.registry.registerSubscription(subscribeMessage("sess1", "1", "/foo"));
this.registry.registerSubscription(subscribeMessage("sess2", "1", "/foo"));
MultiValueMap<String, String> subscriptions = this.registry.findSubscriptions(createMessage("/foo"));
assertThat(subscriptions).isNotNull();
assertThat(subscriptions).hasSize(2);
Iterator<Map.Entry<String, List<String>>> iterator = subscriptions.entrySet().iterator();
@@ -420,12 +391,11 @@ public class DefaultSubscriptionRegistryTests {
}
@Test // SPR-13185
public void findSubscriptionsReturnsMapSafeToIterateIncludingValues() throws Exception {
void findSubscriptionsReturnsMapSafeToIterateIncludingValues() throws Exception {
this.registry.registerSubscription(subscribeMessage("sess1", "1", "/foo"));
this.registry.registerSubscription(subscribeMessage("sess1", "2", "/foo"));
MultiValueMap<String, String> allSubscriptions = this.registry.findSubscriptions(createMessage("/foo"));
assertThat(allSubscriptions).isNotNull();
assertThat(allSubscriptions).hasSize(1);
Iterator<String> iteratorValues = allSubscriptions.get("sess1").iterator();
@@ -438,7 +408,7 @@ public class DefaultSubscriptionRegistryTests {
}
@Test // SPR-13555
public void cacheLimitExceeded() throws Exception {
void cacheLimitExceeded() throws Exception {
this.registry.setCacheLimit(1);
this.registry.registerSubscription(subscribeMessage("sess1", "1", "/foo"));
this.registry.registerSubscription(subscribeMessage("sess1", "2", "/bar"));