This is an automated email from the ASF dual-hosted git repository.
jinrongtong pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/rocketmq-e2e.git
The following commit(s) were added to refs/heads/master by this push:
new 8c94688 [ISSUE #33] Add 6 features according to original message test
classes to bdd resource (#34)
8c94688 is described below
commit 8c94688c7e72772959423f072c3e2320794ae22c
Author: alani <[email protected]>
AuthorDate: Thu Jun 1 16:40:25 2023 +0800
[ISSUE #33] Add 6 features according to original message test classes to
bdd resource (#34)
* features
* Delete ConsumerGroup.feature
* features
* Delete bdd/src/main/resources/consumer directory
* features
* features
---------
Co-authored-by: alani <[email protected]>
---
.../org/apache/rocketmq/ClientInitStepdefs.java | 128 +++++++++++++++++++--
bdd/src/main/resources/delay.feature | 16 +--
.../MessageBodyContent.feature} | 26 +++--
bdd/src/main/resources/message/MessageKey.feature | 61 ++++++++++
.../resources/message/MessageProperties.feature | 57 +++++++++
bdd/src/main/resources/message/MessageSize.feature | 105 +++++++++++++++++
bdd/src/main/resources/message/MessageTag.feature | 62 ++++++++++
.../resources/message/MessageUserProperty.feature | 113 ++++++++++++++++++
bdd/src/main/resources/normal.feature | 6 +-
bdd/src/main/resources/order.feature | 6 +-
bdd/src/main/resources/transaction.feature | 6 +-
.../broker/client/message/MessageTagTest.java | 14 ---
12 files changed, 547 insertions(+), 53 deletions(-)
diff --git a/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java
b/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java
index c7bdc2d..021186c 100644
--- a/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java
+++ b/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java
@@ -23,9 +23,6 @@ import io.cucumber.java.en.Then;
import io.cucumber.java.en.When;
public class ClientInitStepdefs {
- @And("Shutdown the producer and consumer")
- public void shutdownTheProducerAndConsumer() {
- }
@And("Create a Producer, set the <NameServer>, <RequestTimeout>")
public void createAProducerSetTheNameServerRequestTimeout() {
@@ -46,11 +43,7 @@ public class ClientInitStepdefs {
@And("Send {string} messages {string}")
public void sendMessages(String arg0, String arg1) {
-
- }
-
- @And("Shutdown the producer")
- public void shutdownTheProducer() {
+
}
@@ -90,8 +83,9 @@ public class ClientInitStepdefs {
}
- @When("Create a PushConsumer, set the Endpoint\\({string}),
ConsumerGroup\\({string}), SubscriptionExpression\\({string}),
Topic\\({string}), MessageListener\\({string})")
- public void
createAPushConsumerSetTheEndpointConsumerGroupSubscriptionExpressionTopicMessageListener(String
arg0, String arg1, String arg2, String arg3, String arg4) {
+ @When("Create a PushConsumer, set the Endpoint\\({string}),
ConsumerGroup\\({string}), Tag\\({string}), Topic\\({string}),
MessageListener\\({string})")
+ public void
createAPushConsumerSetTheEndpointConsumerGroupTagTopicMessageListener(String
arg0, String arg1, String arg2, String arg3, String arg4) {
+
}
@@ -100,13 +94,15 @@ public class ClientInitStepdefs {
}
- @Then("Create a message, including the Topic\\({string}),
SubscriptionExpression\\({string}), Key\\({string}), and Body\\({string})")
- public void
createAMessageIncludingTheTopicSubscriptionExpressionKeyAndBody(String arg0,
String arg1, String arg2, String arg3) {
+ @Then("Create a message, including the Topic\\({string}), Tag\\({string}),
Key\\({string}), and Body\\({string})")
+ public void createAMessageIncludingTheTopicTagKeyAndBody(String arg0,
String arg1, String arg2, String arg3) {
+
}
@And("Create a Producer, set the Endpoint\\({string}),
RequestTimeout:\\({string}), Topic\\({string})")
public void createAProducerSetTheEndpointRequestTimeoutTopic(String arg0,
String arg1, String arg2) {
+
}
@@ -114,4 +110,112 @@ public class ClientInitStepdefs {
public void checkSendMessageFailed() {
}
+
+ @And("Check each MessageGroup consumes up to {int} messages separately and
is consumed orderly")
+ public void
checkEachMessageGroupConsumesUpToMessagesSeparatelyAndIsConsumedOrderly(int
arg0) {
+ }
+
+
+ @And("Create a SimpleConsumer, set the Endpoint\\({string}),
ConsumerGroup\\({string}), SubscriptionExpression\\({string}),
Topic\\({string}), Duration\\({string})")
+ public void
createASimpleConsumerSetTheEndpointConsumerGroupSubscriptionExpressionTopicDuration(String
arg0, String arg1, String arg2, String arg3, String arg4) {
+ }
+
+ @And("Check the subscribed message body is equal to {string}")
+ public void checkTheSubscribedMessageBodyEqualsTo(String arg0) {
+ }
+
+ @And("Create a message, including the Topic\\({string}), Tag\\({string}),
Key\\({string}), and Body\\(null)")
+ public void createAMessageIncludingTheTopicTagKeyAndBodyNull(String arg0,
String arg1, String arg2) {
+ }
+
+
+ @And("Create a message, including the Topic\\(null), Tag\\({string}),
Key\\({string}), and Body\\({string})")
+ public void createAMessageIncludingTheTopicNullTagKeyAndBody(String arg0,
String arg1, String arg2) {
+
+ }
+
+ @And("Create a message, including the Topic\\({string}), Tag\\(null),
Key\\({string}), and Body\\({string})")
+ public void createAMessageIncludingTheTopicTagNullKeyAndBody(String arg0,
String arg1, String arg2) {
+
+ }
+
+ @And("Create a message, including the Topic\\({string}),
SubscriptionExpression\\({string}),
Key\\(RandomStringUtils.randomAlphabetic\\({int} * {int} + {int})), and
Body\\({string})")
+ public void
createAMessageIncludingTheTopicSubscriptionExpressionKeyRandomStringUtilsRandomAlphabeticAndBody(String
arg0, String arg1, int arg2, int arg3, int arg4, String arg5) {
+
+ }
+
+ @Then("Check exceptions can be thrown")
+ public void checkBuildMethodThatCanThrowExceptions() {
+ }
+
+ @Given("Create a {string} topic:{string} if not exist")
+ public void createATopicIfNotExist(String arg0, String arg1) {
+
+
+ }
+
+ @And("Shutdown the producer and consumer if they are started")
+ public void shutdownTheProducerAndConsumerIfTheyAreStarted() {
+ }
+
+ @And("Create a message, including the Topic\\({string}), Tag\\({string}),
Key\\({string}, {string}), and Body\\({string})")
+ public void createAMessageIncludingTheTopicTagKeyAndBody(String arg0,
String arg1, String arg2, String arg3, String arg4) {
+
+ }
+
+ @And("Send a half message")
+ public void sendAHalfMessage() {
+
+ }
+
+ @And("Create a transaction branch")
+ public void createATransactionBranch() {
+ }
+
+ @And("Create a message, including the Topic\\({string}), Tag\\({string}),
and Body\\({string})")
+ public void createAMessageIncludingTheTopicTagAndBody(String arg0, String
arg1, String arg2) {
+
+ }
+
+ @And("Create a message, including the Topic\\({string}), Tag\\({string}),
Body\\({string}), deliveryTimestamp\\({string})")
+ public void createAMessageIncludingTheTopicTagBodyDeliveryTimestamp(String
arg0, String arg1, String arg2, String arg3) {
+
+ }
+
+ @And("Create a message, including the Topic\\({string}), Tag\\({string}),
Body\\({string}), messageGroup\\({string})")
+ public void createAMessageIncludingTheTopicTagBodyMessageGroup(String
arg0, String arg1, String arg2, String arg3) {
+
+ }
+
+ @And("Create a message, including the Topic\\({string}), Tag\\({string}),
Key\\({string}), Value\\({string}), Body\\({string}), msgKey\\({string})")
+ public void createAMessageIncludingTheTopicTagKeyValueBodyMsgKey(String
arg0, String arg1, String arg2, String arg3, String arg4, String arg5) {
+
+ }
+
+ @And("Create a message, including the Topic\\({string}), and
messageProperty\\({string}, {string})")
+ public void createAMessageIncludingTheTopicAndMessageProperty(String arg0,
String arg1, String arg2) {
+ }
+
+ @And("Create a message, including the Topic\\({string}), Body\\({string}),
and messageProperty\\({string})")
+ public void createAMessageIncludingTheTopicBodyAndMessageProperty(String
arg0, String arg1, String arg2) {
+
+ }
+
+ @And("Create a message, including the Topic\\({string}), Body\\({string}),
messageGroup\\({string}), and messageProperty\\({string})")
+ public void
createAMessageIncludingTheTopicBodyMessageGroupAndMessageProperty(String arg0,
String arg1, String arg2, String arg3) {
+ }
+
+ @And("Set message {string} {string} times")
+ public void setMessageTimes(String arg0, String arg1) {
+
+ }
+
+ @And("Set Key\\({string}), Value\\({string})")
+ public void setKeyValue(String arg0, String arg1) {
+
+ }
+
+ @And("Set messageProperty {string} to {string} and {string} to {string}")
+ public void setMessagePropertyToAndTo(String arg0, String arg1, String
arg2, String arg3) {
+ }
}
diff --git a/bdd/src/main/resources/delay.feature
b/bdd/src/main/resources/delay.feature
index 511403a..7842fbe 100644
--- a/bdd/src/main/resources/delay.feature
+++ b/bdd/src/main/resources/delay.feature
@@ -17,32 +17,32 @@ Feature: Test the message transfer mode and topic type
Scenario: Send 10 messages set delivery timestamp after 30s after the
current system time. Expect to consume all 10 messages after 30s
Given Create a "DELAY" topic:"random-topic" if not exist, a "Concurrently"
group:"random-group"
- When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), SubscriptionExpression("TagA"),
Topic("random-topic"), MessageListener("default")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
And Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
- Then Create a message, including the Topic("random-topic"),
SubscriptionExpression("TagA"), Key("Key"), and Body("Body")
+ Then Create a message, including the Topic("random-topic"), Tag("TagA"),
Key("Key"), and Body("Body")
And Set message "DeliveryTimestamp" to 20 seconds before the current
system time
And Send "10" messages "synchronous"
Then Check all messages that can be consumed within 60s
And Check the received message's "DeliveryTimestamp" property "isNotNull"
and value is expected
And Check consume all messages immediately
- And Shutdown the producer and consumer
+ And Shutdown the producer and consumer if they are started
Scenario: Send 10 messages set delivery timestamp 10s before the current
system time. Expect timing does not take effect, all 10 messages can be
consumed immediately
Given Create a "DELAY" topic:"random-topic" if not exist, a "Concurrently"
group:"random-group"
- When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), SubscriptionExpression("TagA"),
Topic("random-topic"), MessageListener("default")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
And Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
- Then Create a message, including the Topic("random-topic"),
SubscriptionExpression("TagA"), Key("Key"), and Body("Body")
+ Then Create a message, including the Topic("random-topic"), Tag("TagA"),
Key("Key"), and Body("Body")
And Set message "DeliveryTimestamp" to 30 seconds after the current system
time
And Send "10" messages "synchronous"
Then Check consume all 10 messages after 30s(±5s)
And Check the received message's "DeliveryTimestamp" property "isNotNull"
and value is expected
- And Shutdown the producer and consumer
+ And Shutdown the producer and consumer if they are started
Scenario: Send a message set delivery timestamp 24h+5s after the current
system time. Expect send message failed
Given Create a "DELAY" topic:"random-topic" if not exist, a "Concurrently"
group:"random-group"
And Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
- Then Create a message, including the Topic("random-topic"),
SubscriptionExpression("TagA"), Key("Key"), and Body("Body")
+ Then Create a message, including the Topic("random-topic"), Tag("TagA"),
Key("Key"), and Body("Body")
And Set message "DeliveryTimestamp" to 86405 seconds after the current
system time
And Send "1" messages "synchronous"
Then Check send message failed
- And Shutdown the producer
\ No newline at end of file
+ And Shutdown the producer and consumer if they are started
\ No newline at end of file
diff --git a/bdd/src/main/resources/normal.feature
b/bdd/src/main/resources/message/MessageBodyContent.feature
similarity index 63%
copy from bdd/src/main/resources/normal.feature
copy to bdd/src/main/resources/message/MessageBodyContent.feature
index 550e7b0..1d98e97 100644
--- a/bdd/src/main/resources/normal.feature
+++ b/bdd/src/main/resources/message/MessageBodyContent.feature
@@ -13,18 +13,24 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-Feature: Test the message transfer mode
+Feature: Test message body contents
- Scenario Outline: 10 normal messages are sent synchronously and are
expected to be received
+ Scenario Outline: Send normal message, setting message body, expect send and
consume success
Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
- When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), SubscriptionExpression("TagA"),
Topic("random-topic"), MessageListener("default")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
And Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
- Then Create a message, including the Topic("random-topic"),
SubscriptionExpression("TagA"), Key("Key"), and Body("Body")
- And Send "10" messages "<TransmissionMode>"
- Then Check all messages that can be consumed within 60s
- And Shutdown the producer and consumer
+ Then Create a message, including the Topic("random-topic"), Tag("TagA"),
Key("Key"), and Body("<MessageBodyContent>")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Check the subscribed message body is equal to "<MessageBodyContent>"
+ And Shutdown the producer and consumer if they are started
Examples:
- | TransmissionMode |
- | synchronous |
- | asynchronous |
+ | MessageBodyContent |
+ | |
+ | 中文字符 |
+ | 😱 |
+
+
+
+
diff --git a/bdd/src/main/resources/message/MessageKey.feature
b/bdd/src/main/resources/message/MessageKey.feature
new file mode 100644
index 0000000..6345a0a
--- /dev/null
+++ b/bdd/src/main/resources/message/MessageKey.feature
@@ -0,0 +1,61 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+Feature: Test message key
+
+ Scenario: Message Key beyond 16KB, expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Key("size:16kB+1"), and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message Key beyond 16KB, expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Key("\u0000"), and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message Key equals 16KB, expect send and consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Key("size:16KB"), and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message key contains Chinese, expect send and consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Key("中文字符"), and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: The message contains multiple keys, expect send and consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Key("random-key1", "random-key2"), and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+
diff --git a/bdd/src/main/resources/message/MessageProperties.feature
b/bdd/src/main/resources/message/MessageProperties.feature
new file mode 100644
index 0000000..106c935
--- /dev/null
+++ b/bdd/src/main/resources/message/MessageProperties.feature
@@ -0,0 +1,57 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+Feature: Test message properties
+
+ Scenario: producer invoke send(messageBody=null), expect build message throw
exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Key("Key"), and Body(null)
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: producer invoke send(topic=""), expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic(""), Tag("random-tag"),
Key("Key"), and Body("Body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: producer invoke send(topic=null), expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic(null), Tag("random-tag"),
Key("Key"), and Body("Body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: producer invoke send(tag=null), expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"), Tag(null),
Key("Key"), and Body("Body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: producer invoke send(tag=""), expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"), Tag(" "),
Key("Key"), and Body("Body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
diff --git a/bdd/src/main/resources/message/MessageSize.feature
b/bdd/src/main/resources/message/MessageSize.feature
new file mode 100644
index 0000000..7960d34
--- /dev/null
+++ b/bdd/src/main/resources/message/MessageSize.feature
@@ -0,0 +1,105 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+Feature: Test message size
+
+ Scenario Outline: Send normal/transaction messages with the body size of
4M+1, expect send failed
+ Given Create a "<MessageType>" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), and Body("size:4M+1")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Examples:
+ | MessageType |
+ | Normal |
+ | Transaction |
+
+ Scenario: Send delay messages with the body size of 4M+1, expect send failed
+ Given Create a "delay" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Body("size:4M+1"), deliveryTimestamp("10L")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Send FIFO messages with the body size of 4M+1, expect send failed
+ Given Create a "FIFO" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Body("size:4M+1"), messageGroup("a")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario Outline: Send normal/transaction messages with the body size of 4M,
expect send and consume success
+ Given Create a "<MessageType>" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), and Body("size:4M")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Examples:
+ | MessageType |
+ | Normal |
+ | Transaction |
+
+ Scenario: Send delay messages with the body size of 4M, expect send and
consume success
+ Given Create a "delay" topic:"random-topic" if not exist, a "Concurrently"
group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Body("size:4M"), deliveryTimestamp("10s")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Send FIFO messages with the body size of 4M, expect send and
consume success
+ Given Create a "FIFO" topic:"random-topic" if not exist, a "Concurrently"
group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Body("size:4M"), messageGroup("a")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Send normal messages with the body size of 4M and the property
size of 16KB, expect send and consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Body("size:4M"), and messageProperty("size:16kB")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Send FIFO messages with the body size of 4M and the property size
of 16KB, expect send and consume success
+ Given Create a "FIFO" topic:"random-topic" if not exist, a "Concurrently"
group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Body("size:4M"), messageGroup("a"), and messageProperty("size:16kB")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+
+
+
+
+
+
+
+
+
diff --git a/bdd/src/main/resources/message/MessageTag.feature
b/bdd/src/main/resources/message/MessageTag.feature
new file mode 100644
index 0000000..7c1692d
--- /dev/null
+++ b/bdd/src/main/resources/message/MessageTag.feature
@@ -0,0 +1,62 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+Feature: Test message tag
+
+ Scenario: Message Tag beyond 16KB, expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("size:16kB+1"), and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message Tag equals 16KB, expect send and consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("size:16kB"), and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message Tag contains invisible characters \u0000, expect throw
exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"), Tag("\u0000"),
and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message Tag contains | , expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"), Tag("tag|"),
and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message Tag contains Chinese, expect send and consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"), Tag("中文字符"),
and Body("random-body")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+
+
+
diff --git a/bdd/src/main/resources/message/MessageUserProperty.feature
b/bdd/src/main/resources/message/MessageUserProperty.feature
new file mode 100644
index 0000000..8828e00
--- /dev/null
+++ b/bdd/src/main/resources/message/MessageUserProperty.feature
@@ -0,0 +1,113 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+Feature: Test message property
+
+ Scenario: Message property beyond limit 128 ,expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Body("random-body"), and messageProperty("random-messageProperty")
+ And Set message "messageProperty" "129" times
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: The number of message properties equals limit 128, expect send and
consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Body("random-body"), and messageProperty("random-messageProperty")
+ And Set message "messageProperty" "128" times
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message property equals 16KB, expect send and consume success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Body("random-body"), and messageProperty("size:16kB")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+
+ Scenario: Message property beyond 16KB, expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Body("random-body"), and messageProperty("size:16kB+1")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario Outline: Message property contains invisible character \u0000 / use
SystemKey UNIQ_KEY ,expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"), and
messageProperty("<KeyContent>", "<ValueContent>")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Examples:
+ | KeyContent | ValueContent |
+ | \u0000 | value |
+ | UNIQ_KEY | value |
+
+ Scenario: Message property ,key and tag beyond 16KB ,expect throw exception
+ Given Create a "Normal" topic:"random-topic" if not exist
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("size:4kB"), Key("size:4kB"), Value("size:4kB"), Body("size:4M"),
msgKey("size:4kB+1")
+ And Send "a" messages "synchronous"
+ Then Check exceptions can be thrown
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message property ,key and tag equals 16KB, expect send and consume
success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("size:4kB"), Key("size:4kB"), Value("size:4kB"), Body("size:4M"),
msgKey("size:4kB")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message property ,key and tag equals 64B, expect send and consume
success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a message, including the Topic("random-topic"),
Tag("size:64B"), Key("size:64B"), Value("size:64B"), Body("size:64B"),
msgKey("size:64B")
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+ Scenario: Message property is the visible character, expect send and consume
success
+ Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
+ When Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
+ And Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
+ And Create a message, including the Topic("random-topic"),
Tag("random-tag"), Key("中文"), Value("中文"), Body("random-body"),
msgKey("random-msgkey")
+ And Set messageProperty "Key" to "_" and "Value" to "_"
+ And Set messageProperty "Key" to "%" and "Value" to "%"
+ And Set messageProperty "Key" to "。" and "Value" to "。"
+ And Set messageProperty "Key" to "｜" and "Value" to "｜"
+ And Set messageProperty "Key" to "&&" and "Value" to "&&"
+ And Set messageProperty "Key" to "🏷" and "Value" to "🏷"
+ And Send "a" messages "synchronous"
+ Then Check all messages that can be consumed within 60s
+ And Shutdown the producer and consumer if they are started
+
+
+
+
+
+
+
diff --git a/bdd/src/main/resources/normal.feature
b/bdd/src/main/resources/normal.feature
index 550e7b0..0ba6c3d 100644
--- a/bdd/src/main/resources/normal.feature
+++ b/bdd/src/main/resources/normal.feature
@@ -17,12 +17,12 @@ Feature: Test the message transfer mode
Scenario Outline: 10 normal messages are sent synchronously and are
expected to be received
Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
- When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), SubscriptionExpression("TagA"),
Topic("random-topic"), MessageListener("default")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
And Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
- Then Create a message, including the Topic("random-topic"),
SubscriptionExpression("TagA"), Key("Key"), and Body("Body")
+ Then Create a message, including the Topic("random-topic"), Tag("TagA"),
Key("Key"), and Body("Body")
And Send "10" messages "<TransmissionMode>"
Then Check all messages that can be consumed within 60s
- And Shutdown the producer and consumer
+ And Shutdown the producer and consumer if they are started
Examples:
| TransmissionMode |
diff --git a/bdd/src/main/resources/order.feature
b/bdd/src/main/resources/order.feature
index e1e12c4..a224336 100644
--- a/bdd/src/main/resources/order.feature
+++ b/bdd/src/main/resources/order.feature
@@ -17,10 +17,10 @@ Feature: Test the message transfer mode and topic type
Scenario: Send 100 messages with in 2 MessageGroup, expect consumed all
messages orderly
Given Create a "FIFO" topic:"random-topic" if not exist, a "Orderly"
group:"random-group"
- When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), SubscriptionExpression("TagA"),
Topic("random-topic"), MessageListener("default")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
And Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic")
- Then Create a message, including the Topic("random-topic"),
SubscriptionExpression("TagA"), Key("Key"), and Body("Body")
+ Then Create a message, including the Topic("random-topic"), Tag("TagA"),
Key("Key"), and Body("Body")
And A total of 100 messages are sent "<TransmissionMode>" to the 2
MessageGroups in turn
Then Check all messages that can be consumed within 60s
And Check each MessageGroup consumes up to 50 messages separately and is
consumed orderly
- And Shutdown the producer and consumer
+ And Shutdown the producer and consumer if they are started
diff --git a/bdd/src/main/resources/transaction.feature
b/bdd/src/main/resources/transaction.feature
index 733f601..f4e13eb 100644
--- a/bdd/src/main/resources/transaction.feature
+++ b/bdd/src/main/resources/transaction.feature
@@ -17,15 +17,15 @@ Feature: Test the message transfer mode
Scenario Outline: 10 transaction messages are sent synchronously and are
expected to be received
Given Create a "Normal" topic:"random-topic" if not exist, a
"Concurrently" group:"random-group"
- When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), SubscriptionExpression("TagA"),
Topic("random-topic"), MessageListener("default")
+ When Create a PushConsumer, set the Endpoint("127.0.0.1:9876"),
ConsumerGroup("random-group"), Tag("TagA"), Topic("random-topic"),
MessageListener("default")
And Create a Producer, set the Endpoint("127.0.0.1:9876"),
RequestTimeout:("10s"), Topic("random-topic"),
TransactionChecker:("<TransactionChecker>")
And Create a transaction branch
- Then Create a message, including the Topic("random-topic"),
SubscriptionExpression("TagA"), Key("Key"), and Body("Body")
+ Then Create a message, including the Topic("random-topic"), Tag("TagA"),
Key("Key"), and Body("Body")
And Send a half message
And Execute transaction:"<TransactionExecutor>"
Then Check all messages send "success"
And Check all messages that can be consumed within 60s
- And Shutdown the producer and consumer
+ And Shutdown the producer and consumer if they are started
Examples:
| TransactionChecker | TransactionExecutor |
diff --git
a/java/e2e/src/test/java/org/apache/rocketmq/broker/client/message/MessageTagTest.java
b/java/e2e/src/test/java/org/apache/rocketmq/broker/client/message/MessageTagTest.java
index 07e6c2a..594a1e0 100644
---
a/java/e2e/src/test/java/org/apache/rocketmq/broker/client/message/MessageTagTest.java
+++
b/java/e2e/src/test/java/org/apache/rocketmq/broker/client/message/MessageTagTest.java
@@ -111,20 +111,6 @@ public class MessageTagTest extends BaseOperate {
}, " message tag contains invisible character ,expect throw exception
but it didn't");
}
- @Test
- @DisplayName("Message Tag and User Property beyond 16KB ,expect throw
exception")
- public void testMessageUserPropertyAndTagBeyond16KB() {
- producer = ProducerFactory.getRMQProducer(account, topic);
- String tag = RandomStringUtils.randomAlphabetic(16 * 1024 + 1);
- String body = RandomStringUtils.randomAlphabetic(64);
-
- Assertions.assertNotNull(producer);
- assertThrows(Exception.class, () -> {
- Message message = MessageFactory.buildMessage(topic, tag, body);
- producer.getProducer().send(message);
- }, " message tag and user property beyond 16KB ,expect throw exception
but it didn't");
- }
-
@Test
@DisplayName("Message Tag contains | , expect throw exception")
public void testMessageTagContentWith() {
