feat(rocketmq): add agent and management console

This commit is contained in:
AiLi authored and GitHub committed 2026-07-20 22:58:05 +08:00
1 parent d642d01eac
commit 574172f667
86 files changed
+12373 -505

No files matched your search

File diff suppressed because it is too large. Load diff
@@ -0,0 +1,280 @@
package com.dbx.agent.rocketmq;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.TopicConfig;
import org.apache.rocketmq.common.MixAll;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.protocol.subscription.SubscriptionGroupConfig;
import org.apache.rocketmq.remoting.protocol.admin.TopicStatsTable;
import org.apache.rocketmq.remoting.protocol.admin.TopicOffset;
import org.apache.rocketmq.remoting.protocol.body.ProducerInfo;
import org.apache.rocketmq.remoting.protocol.body.ProducerTableInfo;
import org.apache.rocketmq.common.message.MessageQueue;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.IntStream;
import org.junit.jupiter.api.Test;
class RocketMqAgentTest {
@Test
void namesrvAddrAcceptsSnakeCaseField() {
assertEquals(
"127.0.0.1:9876",
RocketMqAgent.namesrvAddr(JsonParser.parseString("""
{"namesrv_addr":"127.0.0.1:9876"}
""").getAsJsonObject())
);
}
@Test
void namesrvAddrAcceptsCamelCaseField() {
assertEquals(
"127.0.0.1:9876",
RocketMqAgent.namesrvAddr(JsonParser.parseString("""
{"namesrvAddr":"127.0.0.1:9876"}
""").getAsJsonObject())
);
}
@Test
void namesrvAddrRequiresValue() {
assertThrows(
IllegalArgumentException.class,
() -> RocketMqAgent.namesrvAddr(JsonParser.parseString("{}").getAsJsonObject())
);
}
@Test
void isUserTopicFiltersRocketMqSystemTopics() {
assertEquals(false, RocketMqAgent.isUserTopic("RMQ_SYS_TRANS_HALF_TOPIC"));
assertEquals(false, RocketMqAgent.isUserTopic("BenchmarkTest"));
assertEquals(false, RocketMqAgent.isUserTopic("SCHEDULE_TOPIC_XXXX"));
assertEquals(false, RocketMqAgent.isUserTopic("DefaultCluster_REPLY_TOPIC"));
assertEquals(false, RocketMqAgent.isUserTopic("%RETRY%MyGroup"));
assertEquals(true, RocketMqAgent.isUserTopic("CS123"));
assertEquals(true, RocketMqAgent.isUserTopic("OrderCreated"));
}
@Test
void classifyTopicMessageTypeMatchesDashboardRules() {
assertEquals("RETRY", RocketMqAgent.classifyTopicMessageType(
"%RETRY%MyGroup", null, Set.of(), Set.of(), ""));
assertEquals("DLQ", RocketMqAgent.classifyTopicMessageType(
"%DLQ%MyGroup", null, Set.of(), Set.of(), ""));
assertEquals("SYSTEM", RocketMqAgent.classifyTopicMessageType(
"RMQ_SYS_TRANS_HALF_TOPIC", null, Set.of(), Set.of(), ""));
assertEquals("UNSPECIFIED", RocketMqAgent.classifyTopicMessageType(
"CS123", null, Set.of(), Set.of(), ""));
assertEquals("UNSPECIFIED", RocketMqAgent.classifyTopicMessageType(
"CS123", Map.of(), Set.of(), Set.of(), ""));
assertEquals("NORMAL", RocketMqAgent.classifyTopicMessageType(
"CS123",
Map.of("+message.type", "NORMAL"),
Set.of(),
Set.of(),
""));
assertEquals("NORMAL", RocketMqAgent.classifyTopicMessageType(
"OrderCreated",
Map.of("message.type", "NORMAL"),
Set.of(),
Set.of(),
""));
assertEquals("DELAY", RocketMqAgent.classifyTopicMessageType(
"DelayTopic",
Map.of("message.type", "DELAY"),
Set.of(),
Set.of(),
""));
assertEquals("UNSPECIFIED", RocketMqAgent.classifyTopicMessageType(
"LegacyTopic",
Map.of("message.type", "UNSPECIFIED"),
Set.of(),
Set.of(),
""));
assertEquals("FIFO", RocketMqAgent.classifyTopicMessageType(
"OrderedTopic",
Map.of("message.type", "ORDER"),
Set.of(),
Set.of(),
""));
}
@Test
void remapBrokerAddrUsesNamesrvHostForDockerBrokerIp() {
JsonObject conn = JsonParser.parseString("""
{"namesrv_addr":"127.0.0.1:9876"}
""").getAsJsonObject();
assertEquals("127.0.0.1:10911", RocketMqAgent.remapBrokerAddrForClient("172.18.0.3:10911", conn));
assertEquals("127.0.0.1:10911", RocketMqAgent.remapBrokerAddrForClient("10.0.0.5:10911", conn));
assertEquals("broker.example.com:10911", RocketMqAgent.remapBrokerAddrForClient("broker.example.com:10911", conn));
}
@Test
void remapBrokerAddrUsesFirstNamesrvHostWhenMultipleConfigured() {
JsonObject conn = JsonParser.parseString("""
{"namesrv_addr":"ns1:9876;ns2:9876"}
""").getAsJsonObject();
assertEquals("ns1:10911", RocketMqAgent.remapBrokerAddrForClient("172.18.0.3:10911", conn));
}
@Test
void remapBrokerAddrSupportsIpv6NamesrvHost() {
JsonObject conn = JsonParser.parseString("""
{"namesrv_addr":"[2001:db8::1]:9876"}
""").getAsJsonObject();
assertEquals("[2001:db8::1]:10911", RocketMqAgent.remapBrokerAddrForClient("10.0.0.5:10911", conn));
assertEquals("[::1]:10911", RocketMqAgent.remapBrokerAddrForClient("172.18.0.2:10911", JsonParser.parseString("""
{"namesrv_addr":"[::1]:9876"}
""").getAsJsonObject()));
}
@Test
void remapBrokerAddrHonorsExplicitBrokerAddress() {
JsonObject conn = JsonParser.parseString("""
{"namesrv_addr":"127.0.0.1:9876","broker_addr":"published.example.com:10911"}
""").getAsJsonObject();
assertEquals("published.example.com:10911", RocketMqAgent.remapBrokerAddrForClient("172.18.0.3:10911", conn));
}
@Test
void parseHostFromSocketAddressHandlesIpv6AndPorts() {
assertEquals("127.0.0.1", RocketMqAgent.parseHostFromSocketAddress("127.0.0.1:9876"));
assertEquals("2001:db8::1", RocketMqAgent.parseHostFromSocketAddress("[2001:db8::1]:9876"));
assertEquals("::1", RocketMqAgent.parseHostFromSocketAddress("[::1]:9876"));
}
@Test
void applySendHeadersSetsUserPropertiesAndSkipsSystemKeys() {
Message message = new Message("TopicA", "tag-a", "body".getBytes());
JsonObject params = JsonParser.parseString("""
{"headers":{"TAGS":"tag-a","KEYS":"k1","Region":"Hangzhou","color":"blue"}}
""").getAsJsonObject();
RocketMqAgent.applySendHeaders(message, params);
assertEquals("Hangzhou", message.getProperty("Region"));
assertEquals("blue", message.getProperty("color"));
assertEquals("tag-a", message.getTags());
assertEquals(null, message.getProperty("KEYS"));
}
@Test
void paginateReturnsSecondPageAfter200Topics() {
List<Integer> items = IntStream.range(0, 201).boxed().toList();
assertEquals(200, RocketMqAgent.paginate(items, 0, 200).size());
assertEquals(1, RocketMqAgent.paginate(items, 200, 200).size());
assertEquals(200, RocketMqAgent.paginate(items, 200, 200).get(0));
}
@Test
void resolveNameServerAddrSetSplitsMultiAddr() {
JsonObject conn = JsonParser.parseString("""
{"namesrv_addr":"127.0.0.1:9876;192.168.1.2:9876"}
""").getAsJsonObject();
assertEquals(
Set.of("127.0.0.1:9876", "192.168.1.2:9876"),
RocketMqAgent.resolveNameServerAddrSet(conn)
);
}
@Test
void buildTopicConfigForCreateSetsPartitionsAndMessageType() {
TopicConfig config = RocketMqAgent.buildTopicConfigForCreate("OrderCreated", 8, "DELAY");
assertEquals("OrderCreated", config.getTopicName());
assertEquals(8, config.getReadQueueNums());
assertEquals(8, config.getWriteQueueNums());
assertEquals(6, config.getPerm());
assertEquals("DELAY", config.getAttributes().get("+message.type"));
}
@Test
void buildTopicConfigForCreateSupportsSeparateQueuesAndPerm() {
TopicConfig config = RocketMqAgent.buildTopicConfigForCreate("T1", 8, 4, "NORMAL", 4);
assertEquals(8, config.getReadQueueNums());
assertEquals(4, config.getWriteQueueNums());
assertEquals(4, config.getPerm());
}
@Test
void normalizeTopicPermAllowsReadWriteValues() {
assertEquals(6, RocketMqAgent.normalizeTopicPerm(6));
assertEquals(4, RocketMqAgent.normalizeTopicPerm(4));
assertEquals(2, RocketMqAgent.normalizeTopicPerm(2));
assertEquals(6, RocketMqAgent.normalizeTopicPerm(7));
}
@Test
void classifyConsumerGroupTypeMatchesDashboard() {
assertEquals("SYSTEM", RocketMqAgent.classifyConsumerGroupType(MixAll.CID_SYS_RMQ_TRANS, null));
SubscriptionGroupConfig fifo = new SubscriptionGroupConfig();
fifo.setConsumeMessageOrderly(true);
assertEquals("FIFO", RocketMqAgent.classifyConsumerGroupType("OrderGroup", fifo));
SubscriptionGroupConfig normal = new SubscriptionGroupConfig();
normal.setConsumeMessageOrderly(false);
assertEquals("NORMAL", RocketMqAgent.classifyConsumerGroupType("MyGroup", normal));
}
@Test
void isEmptyQueryMessageResultDetectsRocketMqCode208() {
MQClientException empty = new MQClientException(208, "query message by key finished, but no message");
assertTrue(RocketMqAgent.isEmptyQueryMessageResult(empty));
MQClientException other = new MQClientException(1, "other error");
assertFalse(RocketMqAgent.isEmptyQueryMessageResult(other));
}
@Test
void shouldQueryClusterProducerTableOnlyWithoutTopicOrGroup() {
assertTrue(RocketMqAgent.shouldQueryClusterProducerTable("", ""));
assertTrue(RocketMqAgent.shouldQueryClusterProducerTable(null, null));
assertFalse(RocketMqAgent.shouldQueryClusterProducerTable("CS-SW", ""));
assertFalse(RocketMqAgent.shouldQueryClusterProducerTable("CS-SW", null));
assertFalse(RocketMqAgent.shouldQueryClusterProducerTable("", "p-test"));
assertFalse(RocketMqAgent.shouldQueryClusterProducerTable("CS-SW", "p-test"));
}
@Test
void topicHasProduceActivityDetectsQueuedMessages() {
TopicStatsTable empty = new TopicStatsTable();
MessageQueue queue = new MessageQueue("CS-SX", "broker-a", 0);
TopicOffset offset = new TopicOffset();
offset.setMinOffset(0);
offset.setMaxOffset(0);
empty.getOffsetTable().put(queue, offset);
assertFalse(RocketMqAgent.topicHasProduceActivity(empty));
assertFalse(RocketMqAgent.topicHasProduceActivity(null));
TopicStatsTable active = new TopicStatsTable();
TopicOffset activeOffset = new TopicOffset();
activeOffset.setMinOffset(0);
activeOffset.setMaxOffset(2);
active.getOffsetTable().put(new MessageQueue("CS-PT", "broker-a", 0), activeOffset);
assertTrue(RocketMqAgent.topicHasProduceActivity(active));
}
@Test
void appendProducerTableRowsDedupesDuplicateConnections() {
ProducerInfo first = new ProducerInfo("client-1", "127.0.0.1:39688", null, 5050, 1L);
ProducerInfo duplicate = new ProducerInfo("client-2", "127.0.0.1:39688", null, 5050, 2L);
Map<String, List<ProducerInfo>> data = new LinkedHashMap<>();
data.put("CLIENT_INNER_PRODUCER", List.of(first, duplicate));
ProducerTableInfo tableInfo = new ProducerTableInfo(data);
List<Map<String, Object>> producers = new ArrayList<>();
Set<String> seen = new LinkedHashSet<>();
RocketMqAgent.appendProducerTableRows(producers, seen, 1L, tableInfo);
assertEquals(1, producers.size());
assertEquals("CLIENT_INNER_PRODUCER", producers.get(0).get("producerName"));
assertEquals("127.0.0.1:39688", producers.get(0).get("address"));
}
}
@@ -0,0 +1,179 @@
package com.dbx.agent.rocketmq;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.MessageSelector;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.tools.admin.DefaultMQAdminExt;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
/**
* Live RocketMQ tests on 127.0.0.1:9876. SQL92 filtering requires broker
* {@code enablePropertyFilter=true} (skipped when unsupported).
*/
class RocketMqLiveMessagePropertyTest {
private static final String NAMESRV = "127.0.0.1:9876";
private static final String TOPIC = "CS-PT";
private static DefaultMQAdminExt admin;
private static JsonObject conn;
private static boolean available;
@BeforeAll
static void connect() {
conn = JsonParser.parseString("""
{"namesrv_addr":"127.0.0.1:9876"}
""").getAsJsonObject();
admin = new DefaultMQAdminExt();
admin.setNamesrvAddr(NAMESRV);
try {
admin.start();
admin.examineBrokerClusterInfo();
available = true;
} catch (Exception e) {
available = false;
}
}
@AfterAll
static void shutdown() {
if (admin != null) {
admin.shutdown();
}
}
@Test
void sendMessageUserPropertyRoundTripViaPeek() throws Exception {
assumeTrue(available, "RocketMQ namesrv not available on " + NAMESRV);
DefaultMQProducer producer = RocketMqAgent.buildProducer(conn);
try {
String marker = "dbx-prop-" + UUID.randomUUID();
JsonObject sendParams = JsonParser.parseString("""
{
"topic":"%s",
"tag":"prop-test",
"payloadBase64":"%s",
"headers":{"TAGS":"prop-test","Region":"Hangzhou","marker":"%s"}
}
""".formatted(
TOPIC,
Base64.getEncoder().encodeToString(marker.getBytes(StandardCharsets.UTF_8)),
marker
)).getAsJsonObject();
@SuppressWarnings("unchecked")
Map<String, Object> sendResult = (Map<String, Object>) RocketMqAgent.sendMessageForTest(producer, sendParams);
Number partition = (Number) sendResult.get("partition");
Number offset = (Number) sendResult.get("offset");
assertNotNull(partition);
assertNotNull(offset);
JsonObject peekParams = JsonParser.parseString("""
{
"connection":{"namesrv_addr":"127.0.0.1:9876"},
"topic":"%s",
"count":1,
"partition":%d,
"offset":%d
}
""".formatted(TOPIC, partition.intValue(), offset.longValue())).getAsJsonObject();
@SuppressWarnings("unchecked")
Map<String, Object> peekResult = (Map<String, Object>) RocketMqAgent.peekMessagesForTest(admin, peekParams);
@SuppressWarnings("unchecked")
List<Map<String, Object>> messages = (List<Map<String, Object>>) peekResult.get("messages");
assumeTrue(messages != null && !messages.isEmpty(), "peek returned no messages at sent offset");
@SuppressWarnings("unchecked")
Map<String, String> headers = (Map<String, String>) messages.get(0).get("headers");
assertEquals("Hangzhou", headers.get("Region"));
assertEquals(marker, headers.get("marker"));
} finally {
producer.shutdown();
}
}
@Test
void sql92ConsumerFiltersOnUserProperty() throws Exception {
assumeTrue(available, "RocketMQ namesrv not available on " + NAMESRV);
String group = "dbx-sql92-" + UUID.randomUUID();
String markerMatch = "match-" + UUID.randomUUID();
String markerSkip = "skip-" + UUID.randomUUID();
CountDownLatch matched = new CountDownLatch(1);
AtomicInteger received = new AtomicInteger();
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(group);
consumer.setNamesrvAddr(NAMESRV);
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
try {
consumer.subscribe(
TOPIC,
MessageSelector.bySql("Region IS NOT NULL AND Region='Hangzhou' AND marker IS NOT NULL")
);
} catch (MQClientException e) {
assumeTrue(false, "Broker does not support SQL92 property filter: " + e.getMessage());
}
consumer.registerMessageListener((MessageListenerConcurrently) (messages, context) -> {
for (var message : messages) {
String marker = message.getProperty("marker");
if (markerMatch.equals(marker)) {
received.incrementAndGet();
matched.countDown();
}
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
});
try {
consumer.start();
} catch (MQClientException e) {
assumeTrue(false, "Consumer start failed for SQL92: " + e.getMessage());
}
DefaultMQProducer producer = RocketMqAgent.buildProducer(conn);
try {
sendWithMarker(producer, markerSkip, "Shanghai");
sendWithMarker(producer, markerMatch, "Hangzhou");
assumeTrue(matched.await(15, TimeUnit.SECONDS), "SQL92 consumer did not receive matching message");
assertEquals(1, received.get(), "only the Hangzhou message should match the filter");
} finally {
producer.shutdown();
consumer.shutdown();
}
}
private static void sendWithMarker(DefaultMQProducer producer, String marker, String region) throws Exception {
JsonObject sendParams = JsonParser.parseString("""
{
"topic":"%s",
"tag":"sql92-test",
"payloadBase64":"%s",
"headers":{"TAGS":"sql92-test","Region":"%s","marker":"%s"}
}
""".formatted(
TOPIC,
Base64.getEncoder().encodeToString(marker.getBytes(StandardCharsets.UTF_8)),
region,
marker
)).getAsJsonObject();
RocketMqAgent.sendMessageForTest(producer, sendParams);
}
}
@@ -0,0 +1,125 @@
package com.dbx.agent.rocketmq;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.util.List;
import java.util.Map;
import org.apache.rocketmq.common.TopicConfig;
import org.apache.rocketmq.remoting.protocol.body.TopicConfigSerializeWrapper;
import org.apache.rocketmq.tools.admin.DefaultMQAdminExt;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
/**
* Live verification against local RocketMQ (127.0.0.1:9876). Skipped when namesrv is unavailable.
*/
class RocketMqLiveTopicTypeTest {
private static DefaultMQAdminExt admin;
private static boolean available;
@BeforeAll
static void connect() {
admin = new DefaultMQAdminExt();
admin.setNamesrvAddr("127.0.0.1:9876");
try {
admin.start();
admin.examineBrokerClusterInfo();
available = true;
} catch (Exception e) {
available = false;
}
}
@AfterAll
static void shutdown() {
if (admin != null) {
admin.shutdown();
}
}
@Test
void cs123BrokerConfigHasNormalMessageType() throws Exception {
assumeTrue(available, "RocketMQ namesrv not available on 127.0.0.1:9876");
JsonObject conn = JsonParser.parseString("""
{"namesrv_addr":"127.0.0.1:9876"}
""").getAsJsonObject();
String brokerAddr = RocketMqAgent.remapBrokerAddrForClient(
admin.examineBrokerClusterInfo().getBrokerAddrTable().values().iterator().next().selectBrokerAddr(),
conn);
TopicConfig config = admin.examineTopicConfig(brokerAddr, "CS123");
assumeTrue(config != null, "CS123 topic config missing");
String fromAttributes = config.getAttributes() == null ? null : config.getAttributes().get("message.type");
assertEquals("NORMAL", fromAttributes, "attributes.message.type");
}
@Test
void getAllTopicConfigIncludesCs123MessageType() throws Exception {
assumeTrue(available, "RocketMQ namesrv not available on 127.0.0.1:9876");
JsonObject conn = JsonParser.parseString("""
{"namesrv_addr":"127.0.0.1:9876"}
""").getAsJsonObject();
String brokerAddr = RocketMqAgent.remapBrokerAddrForClient(
admin.examineBrokerClusterInfo().getBrokerAddrTable().values().iterator().next().selectBrokerAddr(),
conn);
TopicConfigSerializeWrapper wrapper = admin.getAllTopicConfig(brokerAddr, 10_000L);
TopicConfig config = wrapper.getTopicConfigTable().get("CS123");
assumeTrue(config != null, "CS123 missing from getAllTopicConfig");
String fromAttributes = config.getAttributes() == null ? null : config.getAttributes().get("message.type");
assertEquals("NORMAL", fromAttributes, "bulk attributes.message.type");
}
@Test
void agentListTopicsClassifiesAllTopicsAgainstBroker() throws Exception {
assumeTrue(available, "RocketMQ namesrv not available on 127.0.0.1:9876");
JsonObject params = JsonParser.parseString("""
{"connection":{"namesrv_addr":"127.0.0.1:9876"},"limit":500,"offset":0}
""").getAsJsonObject();
Object result = RocketMqAgent.listTopicsWithAdminForTest(admin, params);
assumeTrue(result instanceof Map, "unexpected listTopics result");
@SuppressWarnings("unchecked")
List<Map<String, Object>> topics = (List<Map<String, Object>>) ((Map<?, ?>) result).get("topics");
assumeTrue(topics != null && !topics.isEmpty(), "no topics returned");
Map<String, Object> cs123 = topics.stream()
.filter(row -> "CS123".equals(String.valueOf(row.get("name"))))
.findFirst()
.orElse(null);
assumeTrue(cs123 != null, "CS123 not in agent topic list");
assertEquals("NORMAL", String.valueOf(cs123.get("messageType")), "agent messageType for CS123");
Map<String, String> expected = Map.ofEntries(
Map.entry("CS123", "NORMAL"),
Map.entry("BenchmarkTest", "SYSTEM"),
Map.entry("SCHEDULE_TOPIC_XXXX", "SYSTEM"),
Map.entry("RMQ_SYS_TRANS_HALF_TOPIC", "SYSTEM"),
Map.entry("RMQ_SYS_TRANS_OP_HALF_TOPIC", "SYSTEM"),
Map.entry("RMQ_SYS_ROCKSDB_TRANS_HALF_TOPIC", "SYSTEM"),
Map.entry("RMQ_SYS_ROCKSDB_TRANS_OP_HALF_TOPIC", "SYSTEM"),
Map.entry("rmq_sys_wheel_timer", "SYSTEM"),
Map.entry("rmq_sys_REVIVE_LOG_DefaultCluster", "SYSTEM"),
Map.entry("rmq_sys_SYNC_BROKER_MEMBER_37e06a7b803c", "SYSTEM"),
Map.entry("rmq_sys_SYNC_BROKER_MEMBER_broker-a", "SYSTEM"),
Map.entry("DefaultHeartBeatSyncerTopic", "SYSTEM"),
Map.entry("DefaultCluster_REPLY_TOPIC", "SYSTEM"),
Map.entry("SELF_TEST_TOPIC", "SYSTEM"),
Map.entry("OFFSET_MOVED_EVENT", "SYSTEM"),
Map.entry("TBW102", "SYSTEM"),
Map.entry("DefaultCluster", "SYSTEM"),
Map.entry("broker-a", "SYSTEM"),
Map.entry("37e06a7b803c", "UNSPECIFIED"),
Map.entry("%RETRY%CID_DefaultHeartBeatSyncerTopic", "RETRY")
);
for (Map<String, Object> row : topics) {
String name = String.valueOf(row.get("name"));
String messageType = String.valueOf(row.get("messageType"));
if (expected.containsKey(name)) {
assertEquals(expected.get(name), messageType, "messageType for " + name);
}
}
}
}