diff --git a/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java b/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java index 021186c..1e46a77 100644 --- a/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java +++ b/bdd/src/main/java/org/apache/rocketmq/ClientInitStepdefs.java @@ -218,4 +218,203 @@ 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) { } + + @When("Create a PushConsumer, set the Endpoint\\({string}), ConsumerGroup\\({string}), Topic\\({string}), filterExpression\\(SubExpression:{string}, FilterExpressionType:{string}), and MessageListener\\({string})") + public void createAPushConsumerSetTheEndpointConsumerGroupTopicFilterExpressionSubExpressionFilterExpressionTypeAndMessageListener(String arg0, String arg1, String arg2, String arg3, String arg4, String arg5) { + + } + + @Then("Create a message, including the Topic\\({string}), Tag\\({string}), Key\\({string}), Body\\({string}), and msgProps\\(regionId:{string}, price:{string})") + public void createAMessageIncludingTheTopicTagKeyBodyAndMsgPropsRegionIdPrice(String arg0, String arg1, String arg2, String arg3, String arg4, String arg5) { + + } + + @And("Send {string} messages with msgProps\\(price:{string}) {string}") + public void sendMessagesWithMsgPropsPrice(String arg0, String arg1, String arg2) { + + } + + @Then("Check only all messages with msgProps\\(price:{string}) are consumed") + public void checkOnlyAllMessagesWithMsgPropsPriceAreConsumed(String arg0) { + + } + + @And("Check PushConsumer consumes {int} messages") + public void checkPushConsumerConsumesMessages(int arg0) { + + } + + @Then("Create a message, including the Topic\\({string}), Body\\({string}), messageGroup\\({string}), and msgProps\\(regionId:{string}, price:{string})") + public void createAMessageIncludingTheTopicBodyMessageGroupAndMsgPropsRegionIdPrice(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @And("Check the order of received messages consistent with the order of pre-sent messages") + public void checkTheOrderOfReceivedMessagesConsistentWithTheOrderOfPreSentMessages() { + + } + + @When("Create a PushConsumer, set the Endpoint\\({string}), ConsumerGroup\\({string}), Topic\\({string}), filterExpression\\({string}), and MessageListener\\({string})") + public void createAPushConsumerSetTheEndpointConsumerGroupTopicFilterExpressionAndMessageListener(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @And("Send {string} messages with Tag\\({string}) {string}") + public void sendMessagesWithTag(String arg0, String arg1, String arg2) { + + } + + @And("Create a SimpleConsumer, set the Endpoint\\({string}), Topic\\({string}), ConsumerGroup\\({string}), FilterExpressions\\({string}), Duration\\({string})") + public void createASimpleConsumerSetTheEndpointTopicConsumerGroupFilterExpressionsDuration(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @Then("Check SimpleConsumer pull a message once") + public void checkSimpleConsumerPullAMessageOnce() { + + } + + @And("SimpleConsumer invokes receive method {string} and returns acks {string}") + public void simpleconsumerInvokesReceiveMethodAndReturnsAcks(String arg0, String arg1) { + + } + + @Then("Check all messages are pulled by SimpleConsumer {string}") + public void checkAllMessagesArePulledBySimpleConsumer(String arg0) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), AwaitDuration\\({string}), SubscriptionExpressions\\(NULL)") + public void createASetTheClientConfigurationEndpointConsumerGroupAwaitDurationSubscriptionExpressionsNULL(String arg0, String arg1, String arg2, String arg3) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), AwaitDuration\\({string}), SubscriptionExpressions\\({string}, {string})") + public void createASetTheClientConfigurationEndpointConsumerGroupAwaitDurationSubscriptionExpressions(String arg0, String arg1, String arg2, String arg3, String arg4, String arg5) { + + } + + @Then("Consumer invoke receive\\(maxMessageNum:{int}, invisibleDuration:{int}s)") + public void consumerInvokeReceiveMaxMessageNumInvisibleDurationS(int arg0, int arg1) { + + } + + @Then("Check {string} receive messages successfully") + public void checkReceiveMessagesSuccessfully(String arg0) { + + } + + @And("Check the message request return duration between {int}s and {int}s") + public void checkTheMessageRequestReturnDurationBetweenSAndS(int arg0, int arg1) { + + } + + @Then("Check build {string} successfully") + public void checkBuildSuccessfully(String arg0) { + + } + + @When("Create a {string}, set the ConsumerGroup\\({string}), AwaitDuration\\({string}), SubscriptionExpressions\\({string}, {string})") + public void createASetTheConsumerGroupAwaitDurationSubscriptionExpressions(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), AwaitDuration\\({string}), SubscriptionExpressions\\({string}, {string})") + public void createASetTheClientConfigurationEndpointAwaitDurationSubscriptionExpressions(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), AwaitDuration\\({string})") + public void createASetTheClientConfigurationEndpointConsumerGroupAwaitDuration(String arg0, String arg1, String arg2, String arg3) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), SubscriptionExpressions\\({string}, {string})") + public void createASetTheClientConfigurationEndpointConsumerGroupSubscriptionExpressions(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @Given("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), SubscriptionExpressions\\({string}, {string}), ConsumptionThreadCount\\({int}), MaxCacheMessageCount\\({int}), MaxCacheMessageSizeInBytes\\({int}M), MessageListener\\({string})") + public void createASetTheClientConfigurationEndpointConsumerGroupSubscriptionExpressionsConsumptionThreadCountMaxCacheMessageCountMaxCacheMessageSizeInBytesMMessageListener(String arg0, String arg1, String arg2, String arg3, String arg4, int arg5, int arg6, int arg7, String arg8) { + + } + + @When("Create a {string}, set the ConsumerGroup\\({string}), SubscriptionExpressions\\({string}, {string}), MessageListener\\({string})") + public void createASetTheConsumerGroupSubscriptionExpressionsMessageListener(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @And("Set {string} ClientConfiguration\\(Endpoint:{string}, AccessKey:{string}, SecretKey:{string})") + public void setClientConfigurationEndpointAccessKeySecretKey(String arg0, String arg1, String arg2, String arg3) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), SubscriptionExpressions\\({string}, {string}), MessageListener\\({string})") + public void createASetTheClientConfigurationEndpointConsumerGroupSubscriptionExpressionsMessageListener(String arg0, String arg1, String arg2, String arg3, String arg4, String arg5) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), SubscriptionExpressions\\({string}, {string}), MessageListener\\({string})") + public void createASetTheClientConfigurationEndpointSubscriptionExpressionsMessageListener(String arg0, String arg1, String arg2, String arg3, String arg4) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), MessageListener\\({string})") + public void createASetTheClientConfigurationEndpointConsumerGroupMessageListener(String arg0, String arg1, String arg2, String arg3) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), ConsumerGroup\\({string}), SubscriptionExpressions\\(NULL), MessageListener\\({string})") + public void createASetTheClientConfigurationEndpointConsumerGroupSubscriptionExpressionsNULLMessageListener(String arg0, String arg1, String arg2, String arg3) { + + } + + @Given("Create a {string} ConsumerGroup if not exist") + public void createAConsumerGroupIfNotExist(String arg0) { + + } + + @When("Create a {string}, set the Endpoint\\({string}), ConsumerGroup\\({string}), AwaitDuration\\({string}), SubscriptionExpressions\\({string}, {string})") + public void createASetTheEndpointConsumerGroupAwaitDurationSubscriptionExpressions(String arg0, String arg1, String arg2, String arg3, String arg4, String arg5) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), Topics\\({string}), and MaxAttempts\\({int})") + public void createASetTheClientConfigurationEndpointTopicsAndMaxAttempts(String arg0, String arg1, String arg2, int arg3) { + + } + + @When("Create a {string}, set the Topics\\({string})") + public void createASetTheTopics(String arg0, String arg1) { + + } + + @And("Set {string} ClientConfiguration\\(Endpoint:{string}, AccessKey:NULL, SecretKey:{string})") + public void setClientConfigurationEndpointAccessKeyNULLSecretKey(String arg0, String arg1, String arg2) { + + } + + @And("Set {string} ClientConfiguration\\(Endpoint:{string}, AccessKey:{string}, SecretKey:NULL)") + public void setClientConfigurationEndpointAccessKeySecretKeyNULL(String arg0, String arg1, String arg2) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(NULL), Topics\\({string}), and MaxAttempts\\({int})") + public void createASetTheClientConfigurationNULLTopicsAndMaxAttempts(String arg0, String arg1, int arg2) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), Topics\\({string}, {string}), and MaxAttempts\\({int})") + public void createASetTheClientConfigurationEndpointTopicsAndMaxAttempts(String arg0, String arg1, String arg2, String arg3, int arg4) { + + } + + @When("Create a {string}, set the Topics\\({string}), and MaxAttempts\\({int})") + public void createASetTheTopicsAndMaxAttempts(String arg0, String arg1, int arg2) { + + } + + @When("Create a {string}, set the ClientConfiguration\\(Endpoint:{string}), and MaxAttempts\\({int})") + public void createASetTheClientConfigurationEndpointAndMaxAttempts(String arg0, String arg1, int arg2) { + } } diff --git a/bdd/src/main/resources/client/consumer/ConsumerGroup.feature b/bdd/src/main/resources/client/consumer/ConsumerGroup.feature new file mode 100644 index 0000000..1083ff7 --- /dev/null +++ b/bdd/src/main/resources/client/consumer/ConsumerGroup.feature @@ -0,0 +1,38 @@ +# 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 System inner ConsumerGroup + + Scenario Outline: Use the built-in ConsumerGroup to consume messages and expect consume failed + Given Create a "Concurrently" ConsumerGroup if not exist + When Create a "SimpleConsumer", set the Endpoint("127.0.0.1:9876"), ConsumerGroup(""), AwaitDuration("10s"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Consumer invoke receive(maxMessageNum:32, invisibleDuration:10s) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Examples: + | RmqSystemGroupConstant | + | GROUP_DEFAULT_CONSUMER | + | GROUP_TOOLS_CONSUMER | + | GROUP_FILTERSRV_CONSUMER | + | GROUP_MONITOR_CONSUMER | + | GROUP_CLIENT_INNER_PRODUCER | + | GROUP_SELF_TEST_P_GROUP | + | GROUP_SELF_TEST_C_GROUP | + | GROUP_CID_ONS_HTTP_PROXY | + | GROUP_CID_ONSAPI_PERMISSION | + | GROUP_CID_ONSAPI_OWNER | + | GROUP_CID_ONSAPI_PULL | + | GROUP_CID_RMQ_SYS_TRANS | \ No newline at end of file diff --git a/bdd/src/main/resources/client/consumer/PushConsumerInit.feature b/bdd/src/main/resources/client/consumer/PushConsumerInit.feature new file mode 100644 index 0000000..0e8cf2e --- /dev/null +++ b/bdd/src/main/resources/client/consumer/PushConsumerInit.feature @@ -0,0 +1,73 @@ +# 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 PushConsumer Initialization Parameters + + Scenario: PushConsumer all parameters are set properly, expect start successfully + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + Given Create a "PushConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), SubscriptionExpressions("random-topic", "random-filterExpression"), ConsumptionThreadCount(20), MaxCacheMessageCount(1000), MaxCacheMessageSizeInBytes(4M), MessageListener("default") + Then Check build "PushConsumer" successfully + And Shutdown the producer and consumer if they are started + + Scenario Outline: Error setting the ClientConfiguration(including Endpoint and CredentialProvider), expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "PushConsumer", set the ConsumerGroup("random-group"), SubscriptionExpressions("random-topic", "random-filterExpression"), MessageListener("default") + And Set "PushConsumer" ClientConfiguration(Endpoint:"", AccessKey:"", SecretKey:"") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Examples: + | Endpoint | AccessKey | SecretKey | + | 127.0.0.1:9876 | errorAk | accountSK | + | 127.0.0.1:9876 | accountAk | errorSK | + | https://www.aliyun.com | accountAk | accountSK | + + Scenario: Error setting the 'Topic' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "PushConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), SubscriptionExpressions("topicNotExist", "random-filterExpression"), MessageListener("default") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'ConsumerGroup' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "PushConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), SubscriptionExpressions("random-topic", "random-filterExpression"), MessageListener("default") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'SubscriptionExpressions' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "PushConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), MessageListener("default") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Error setting an empty 'SubscriptionExpressions' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "PushConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), SubscriptionExpressions(NULL), MessageListener("default") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'ClientConfiguration' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "PushConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), SubscriptionExpressions("random-topic", "random-filterExpression"), MessageListener("default") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'MessageListener' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "PushConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + diff --git a/bdd/src/main/resources/client/consumer/SimpleConsumerInit.feature b/bdd/src/main/resources/client/consumer/SimpleConsumerInit.feature new file mode 100644 index 0000000..0affc15 --- /dev/null +++ b/bdd/src/main/resources/client/consumer/SimpleConsumerInit.feature @@ -0,0 +1,95 @@ +# 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 SimpleConsumer Initialization Parameters + + Scenario: SimpleConsumer all parameters are set properly, expect start successfully + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration("10s"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Check build "SimpleConsumer" successfully + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'ClientConfiguration' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ConsumerGroup("random-group"), AwaitDuration("10s"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'ConsumerGroup' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), AwaitDuration("10s"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'Subscription' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration("10s") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'AwaitDuration' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Error setting 'SubscriptionExpressions' empty of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration("10s"), SubscriptionExpressions(NULL) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Error setting 'AwaitDuration=0' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration("0"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Consumer invoke receive(maxMessageNum:32, invisibleDuration:10s) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Error setting 'MaxMessageNum=0' of the consumer client, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration("15s"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Consumer invoke receive(maxMessageNum:0, invisibleDuration:20s) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Setting 'MaxMessageNum=100000', expect start successfully + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration("15s"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Consumer invoke receive(maxMessageNum:1000, invisibleDuration:20s) + Then Check "SimpleConsumer" receive messages successfully + And Shutdown the producer and consumer if they are started + + Scenario Outline: Error setting invisibleDuration shorter than 10000ms or longer than 43200000ms, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration(""), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Consumer invoke receive(maxMessageNum:1, invisibleDuration:20s) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Examples: + | IllegalInvisibleDuration | + | 9999ms | + | 43200001ms | + + Scenario: Setting 'AwaitDuration=10s', expect the empty pull message request to return between 10s and 20s + Given Create a "Normal" topic:"random-topic" if not exist, a "Concurrently" group:"random-group" + When Create a "SimpleConsumer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), ConsumerGroup("random-group"), AwaitDuration("10s"), SubscriptionExpressions("random-topic", "random-filterExpression") + Then Consumer invoke receive(maxMessageNum:100000, invisibleDuration:10s) + Then Check "SimpleConsumer" receive messages successfully + And Check the message request return duration between 10s and 20s + And Shutdown the producer and consumer if they are started + + diff --git a/bdd/src/main/resources/client/message/MessageBodyContent.feature b/bdd/src/main/resources/client/message/MessageBodyContent.feature new file mode 100644 index 0000000..1d98e97 --- /dev/null +++ b/bdd/src/main/resources/client/message/MessageBodyContent.feature @@ -0,0 +1,36 @@ +# 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 body contents + + 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"), 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"), Tag("TagA"), Key("Key"), and Body("") + And Send "a" messages "synchronous" + Then Check all messages that can be consumed within 60s + And Check the subscribed message body is equal to "" + And Shutdown the producer and consumer if they are started + + Examples: + | MessageBodyContent | + | | + | 中文字符 | + | 😱 | + + + + diff --git a/bdd/src/main/resources/client/message/MessageKey.feature b/bdd/src/main/resources/client/message/MessageKey.feature new file mode 100644 index 0000000..6345a0a --- /dev/null +++ b/bdd/src/main/resources/client/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/client/message/MessageProperties.feature b/bdd/src/main/resources/client/message/MessageProperties.feature new file mode 100644 index 0000000..106c935 --- /dev/null +++ b/bdd/src/main/resources/client/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/client/message/MessageSize.feature b/bdd/src/main/resources/client/message/MessageSize.feature new file mode 100644 index 0000000..7960d34 --- /dev/null +++ b/bdd/src/main/resources/client/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 "" 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 "" 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/client/message/MessageTag.feature b/bdd/src/main/resources/client/message/MessageTag.feature new file mode 100644 index 0000000..7c1692d --- /dev/null +++ b/bdd/src/main/resources/client/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/client/message/MessageUserProperty.feature b/bdd/src/main/resources/client/message/MessageUserProperty.feature new file mode 100644 index 0000000..8828e00 --- /dev/null +++ b/bdd/src/main/resources/client/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("", "") + 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/client/producer/ProducerInit.feature b/bdd/src/main/resources/client/producer/ProducerInit.feature new file mode 100644 index 0000000..8b46d6d --- /dev/null +++ b/bdd/src/main/resources/client/producer/ProducerInit.feature @@ -0,0 +1,97 @@ +# 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 Producer Initialization Parameters + + Scenario: Producer is normally set, expected start successfully + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), Topics("random-topic"), and MaxAttempts(3) + Then Check build "Producer" successfully + And Shutdown the producer and consumer if they are started + + Scenario Outline: Error setting the ClientConfiguration(including Endpoint and CredentialProvider) of Producer, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the Topics("random-topic") + And Set "Producer" ClientConfiguration(Endpoint:"", AccessKey:"", SecretKey:"") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Examples: + | Endpoint | AccessKey | SecretKey | + | 127.0.0.1:9876 | errorAk | accountSK | + | 127.0.0.1:9876 | accountAk | errorSK | + | https://www.aliyun.com | accountAk | accountSK | + + Scenario: Without setting the 'AccessKey' of Producer, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the Topics("random-topic") + And Set "Producer" ClientConfiguration(Endpoint:"127.0.0.1:9876", AccessKey:NULL, SecretKey:"accountSK") + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting the 'SecretKey' of Producer, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the Topics("random-topic") + And Set "Producer" ClientConfiguration(Endpoint:"127.0.0.1:9876", AccessKey:"accountAK", SecretKey:NULL) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting the properties(including Endpoints, AccessKey, SecretKey) in 'ClientConfiguration' of Producer, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(NULL), Topics("random-topic"), and MaxAttempts(3) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Set the 'MaxAttempts' of Producer to 0, expect start successfully + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), Topics("random-topic"), and MaxAttempts(0) + Then Check build "Producer" successfully + And Shutdown the producer and consumer if they are started + + Scenario: Error setting the 'MaxAttempts' of Producer, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), Topics("random-topic"), and MaxAttempts(-1) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Error setting the 'Topic' of the Producer to non-existent topic, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), Topics("topicNotExist"), and MaxAttempts(3) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Error setting the same 'Topics' of the producer, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), Topics("topic1", "topic1"), and MaxAttempts(3) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Set more topics of the Producer, one of which does not exist, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), Topics("random-topic", "topicNotExist"), and MaxAttempts(3) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'ClientConfiguration' of Producer, expect start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the Topics("random-topic"), and MaxAttempts(3) + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Without setting 'Topics' of Producer, expect start successfully + Given Create a "Normal" topic:"random-topic" if not exist + When Create a "Producer", set the ClientConfiguration(Endpoint:"127.0.0.1:9876"), and MaxAttempts(3) + Then Check build "Producer" successfully + And Shutdown the producer and consumer if they are started diff --git a/bdd/src/main/resources/filter.push/SqlFilter.feature b/bdd/src/main/resources/filter.push/SqlFilter.feature new file mode 100644 index 0000000..2fa164d --- /dev/null +++ b/bdd/src/main/resources/filter.push/SqlFilter.feature @@ -0,0 +1,59 @@ +# 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 SQL filtering + + Scenario: Send 10 messages synchronously, then filter the messages without any attribute filtering, expect to consume 10 messages + 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"), Topic("random-topic"), filterExpression(SubExpression:"TRUE", FilterExpressionType:"SQL92"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), Body("Body"), and msgProps(regionId:"cn-hangzhou", price:"30") + And Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Send 10 messages with messageProperty attribute 'price=10' and another 10 messages with 'price=30', then use 'price>20' to filter the messages, expect to consume 10 messages with 'price=30' + 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"), Topic("random-topic"), filterExpression(SubExpression:"price>20", FilterExpressionType:"SQL92"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), Body("Body"), and msgProps(regionId:"cn-hangzhou", price:"30") + And Send "10" messages with msgProps(price:"30") "synchronously" + And Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), Body("Body"), and msgProps(regionId:"cn-hangzhou", price:"10") + And Send "10" messages with msgProps(price:"10") "synchronously" + Then Check only all messages with msgProps(price:"30") are consumed + And Shutdown the producer and consumer if they are started + + Scenario: Send 10 messages synchronously, then use the attribute 'between{a,b}' to filter messages, expect to consume 10 messages + 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"), Topic("random-topic"), filterExpression(SubExpression:"(price BETWEEN 10 AND 100) AND regionId IS NOT NUll", FilterExpressionType:"SQL92"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), Body("Body"), and msgProps(regionId:"cn-hangzhou", price:"30") + And Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Send 10 messages synchronously, then use unknown attributes to filter messages, expect to consume 0 messages + 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"), Topic("random-topic"), filterExpression(SubExpression:"product = 'MQ'", FilterExpressionType:"SQL92"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), Body("Body"), and msgProps(regionId:"cn-hangzhou", price:"30") + And Send "10" messages "synchronous" + And Check PushConsumer consumes 0 messages + And Shutdown the producer and consumer if they are started + + + diff --git a/bdd/src/main/resources/filter.push/SqlFilterWithOrderMsg.feature b/bdd/src/main/resources/filter.push/SqlFilterWithOrderMsg.feature new file mode 100644 index 0000000..c0c838d --- /dev/null +++ b/bdd/src/main/resources/filter.push/SqlFilterWithOrderMsg.feature @@ -0,0 +1,47 @@ +# 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 SQL filtering with order messages + + Scenario: Send 10 order messages synchronously, then filter the messages without any attribute filtering, expect to consume 10 messages + Given Create a "FIFO" 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"), Topic("random-topic"), filterExpression(SubExpression:"TRUE", FilterExpressionType:"SQL92"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Body("Body"), messageGroup("messageGroup"), and msgProps(regionId:"cn-hangzhou", price:"30") + And Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Check the order of received messages consistent with the order of pre-sent messages + And Shutdown the producer and consumer if they are started + + Scenario: Send 10 order messages synchronously, then use the attribute 'between{a,b}' to filter messages, expect to consume 10 messages + Given Create a "FIFO" 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"), Topic("random-topic"), filterExpression(SubExpression:"(price BETWEEN 10 AND 100) AND regionId IS NOT NUll", FilterExpressionType:"SQL92"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Body("Body"), messageGroup("messageGroup"), and msgProps(regionId:"cn-hangzhou", price:"30") + And Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Check the order of received messages consistent with the order of pre-sent messages + And Shutdown the producer and consumer if they are started + + Scenario: Send 10 order messages synchronously, then use unknown attributes to filter messages, expect to consume 0 messages + Given Create a "FIFO" 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"), Topic("random-topic"), filterExpression(SubExpression:"product = 'MQ'", FilterExpressionType:"SQL92"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Body("Body"), messageGroup("messageGroup"), and msgProps(regionId:"cn-hangzhou", price:"30") + And Send "10" messages "synchronous" + And Check PushConsumer consumes 0 messages + And Shutdown the producer and consumer if they are started \ No newline at end of file diff --git a/bdd/src/main/resources/filter.push/TagFilter.feature b/bdd/src/main/resources/filter.push/TagFilter.feature new file mode 100644 index 0000000..862b36c --- /dev/null +++ b/bdd/src/main/resources/filter.push/TagFilter.feature @@ -0,0 +1,153 @@ +# 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 Tag filtering + + Scenario: Use Tag='TagA' to send 10 messages, then use 'TagA||TagB' to filter messages, expect to consume 10 messages + 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"), Topic("random-topic"), filterExpression("TagA||TagB"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") + And Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='TagA' to send 10 messages, and use Tag='TagB' to send another 10 messages, then use 'TagA||TagB' to filter messages, expect to consume 20 messages + 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"), Topic("random-topic"), filterExpression("TagA||TagB"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") + Then Send "10" messages with Tag("TagA") "synchronous" + And Create a message, including the Topic("random-topic"), Tag("TagB"), Key("Key"), and Body("Body") + And Send "10" messages with Tag("TagB") "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='TagA' to send 10 messages, and use Tag='TagB' to send another 10 messages, then use '*' to filter messages, expect to consume 20 messages + 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"), Topic("random-topic"), filterExpression("*"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") + And Send "10" messages with Tag("TagA") "synchronous" + And Create a message, including the Topic("random-topic"), Tag("TagB"), Key("Key"), and Body("Body") + And Send "10" messages with Tag("TagB") "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='TagA' to send 10 messages, then use Tag='TagB' to filter messages, expect to consume 0 message + 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"), Topic("random-topic"), filterExpression("TagB"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") + Then Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check PushConsumer consumes 0 messages + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='TagA' to send 10 messages, then use Tag='TagA' to filter messages, expect to consume 10 messages + 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"), Topic("random-topic"), filterExpression("TagA"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") + Then Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use a very long Tag to send 10 messages, expect to consume 10 messages + 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"), Topic("random-topic"), filterExpression("Tag"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagSize:10kB"), Key("Key"), and Body("Body") + Then Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='TagA' to send 10 messages, and use Tag='TagB' to send another 10 messages, then use a tag which adds space on both sides of sent tags to filter messages, expect to consume 20 messages + 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"), Topic("random-topic"), filterExpression(" TagA||TagB "), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") + And Send "10" messages with Tag("TagA") "synchronous" + And Create a message, including the Topic("random-topic"), Tag("TagB"), Key("Key"), and Body("Body") + And Send "10" messages with Tag("TagB") "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='|@' to send 10 messages, expect to start failed (tags are not allowed to contain '|') + Given Create a "Normal" topic:"random-topic" if not exist + When Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + And Create a message, including the Topic("random-topic"), Tag("|@"), Key("Key"), and Body("Body") + Then Send "10" messages "synchronous" + And Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='*' to send 10 messages, then use '*' to filter messages, expect to consume 10 messages + 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"), Topic("random-topic"), filterExpression("*"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("*"), Key("Key"), and Body("Body") + Then Send "10" messages "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='TagA' to send 10 messages, and use Tag='TagB' to send another 10 messages, then use use || separators between two tags to filter messages, expect to consume 20 messages + 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"), Topic("random-topic"), filterExpression("TagA||||TagB"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") + And Send "10" messages with Tag("TagA") "synchronous" + And Create a message, including the Topic("random-topic"), Tag("TagB"), Key("Key"), and Body("Body") + And Send "10" messages with Tag("TagB") "synchronous" + Then Check all messages send "successfully" + And Check all messages that can be consumed within 60s + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag="" to send 10 messages, and use Tag=" " to send another 10 messages, expect to start failed + Given Create a "Normal" topic:"random-topic" if not exist + When Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + And Create a message, including the Topic("random-topic"), Tag(""), Key("Key"), and Body("Body") + And Send "10" messages with Tag("") "synchronous" + And Create a message, including the Topic("random-topic"), Tag(" "), Key("Key"), and Body("Body") + And Send "10" messages with Tag(" ") "synchronous" + Then Check exceptions can be thrown + And Shutdown the producer and consumer if they are started + + Scenario: Use two Tags='BB' and 'Aa' with the same hash value to send 10 messages, respectively, then use 'BB' to filter messages, expect to consume 10 messages with Tag='BB' + 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"), Topic("random-topic"), filterExpression("BB"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + And Create a message, including the Topic("random-topic"), Tag("BB"), Key("Key"), and Body("Body") + Then Check all messages that can be consumed within 60s + And Create a message, including the Topic("random-topic"), Tag("Aa"), Key("Key"), and Body("Body") + And Check PushConsumer consumes 0 messages + And Shutdown the producer and consumer if they are started + + Scenario: Use Tag='BB' to send 10 messages, and use Tag='bb' to send another 10 messages, expect to consume messages with tag='BB' + 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"), Topic("random-topic"), filterExpression("BB"), and MessageListener("default") + And Create a Producer, set the Endpoint("127.0.0.1:9876"), RequestTimeout:("random-group"), Topic("random-topic") + And Create a message, including the Topic("random-topic"), Tag("BB"), Key("Key"), and Body("Body") + Then Check all messages that can be consumed within 60s + And Create a message, including the Topic("random-topic"), Tag("bb"), Key("Key"), and Body("Body") + And Check PushConsumer consumes 0 messages + And Shutdown the producer and consumer if they are started + diff --git a/bdd/src/main/resources/delay.feature b/bdd/src/main/resources/server/delay.feature similarity index 100% rename from bdd/src/main/resources/delay.feature rename to bdd/src/main/resources/server/delay.feature diff --git a/bdd/src/main/resources/normal.feature b/bdd/src/main/resources/server/normal.feature similarity index 100% rename from bdd/src/main/resources/normal.feature rename to bdd/src/main/resources/server/normal.feature diff --git a/bdd/src/main/resources/order.feature b/bdd/src/main/resources/server/order.feature similarity index 100% rename from bdd/src/main/resources/order.feature rename to bdd/src/main/resources/server/order.feature diff --git a/bdd/src/main/resources/transaction.feature b/bdd/src/main/resources/server/transaction.feature similarity index 97% rename from bdd/src/main/resources/transaction.feature rename to bdd/src/main/resources/server/transaction.feature index f4e13eb..23a3da4 100644 --- a/bdd/src/main/resources/transaction.feature +++ b/bdd/src/main/resources/server/transaction.feature @@ -23,7 +23,7 @@ Feature: Test the message transfer mode Then Create a message, including the Topic("random-topic"), Tag("TagA"), Key("Key"), and Body("Body") And Send a half message And Execute transaction:"" - Then Check all messages send "success" + Then Check all messages send "successfully" And Check all messages that can be consumed within 60s And Shutdown the producer and consumer if they are started diff --git a/java/e2e/src/test/java/org/apache/rocketmq/broker/client/consumer/SimpleConsumerInitTest.java b/java/e2e/src/test/java/org/apache/rocketmq/broker/client/consumer/SimpleConsumerInitTest.java index 6fe84a9..7965b97 100644 --- a/java/e2e/src/test/java/org/apache/rocketmq/broker/client/consumer/SimpleConsumerInitTest.java +++ b/java/e2e/src/test/java/org/apache/rocketmq/broker/client/consumer/SimpleConsumerInitTest.java @@ -83,7 +83,7 @@ public void testNormalSetting() { } @Test - @DisplayName("SimpleConsumer client start without setting 'ClientConfiguration', expect throw exception") + @DisplayName("Without setting 'ClientConfiguration' of the consumer client, expect start failed") public void testNoClientConfiguration() { assertThrows(NullPointerException.class, () -> { SimpleConsumer simpleConsumer = provider.newSimpleConsumerBuilder() @@ -95,7 +95,7 @@ public void testNoClientConfiguration() { } @Test - @DisplayName("SimpleConsumer client start without setting 'ConsumerGroup', expect throw exception") + @DisplayName("Without setting 'ConsumerGroup' of the consumer client, expect start failed") public void testNoConsumerGroup() { assertThrows(Exception.class, () -> { SimpleConsumer simpleConsumer = provider.newSimpleConsumerBuilder() @@ -107,7 +107,7 @@ public void testNoConsumerGroup() { } @Test - @DisplayName("SimpleConsumer client start without setting 'Subscription', expect throw exception") + @DisplayName("Without setting 'Subscription' of the consumer client, expect start failed") public void testNoSubscription() { assertThrows(Exception.class, () -> { SimpleConsumer simpleConsumer = provider.newSimpleConsumerBuilder() @@ -119,7 +119,7 @@ public void testNoSubscription() { } @Test - @DisplayName("SimpleConsumer client start without setting 'AwaitDuration', expect throw exception ") + @DisplayName("Without setting 'AwaitDuration' of the consumer client, expect start failed") public void testNoAwaitDuration() { assertThrows(Exception.class, () -> { SimpleConsumer simpleConsumer = provider.newSimpleConsumerBuilder() @@ -131,7 +131,7 @@ public void testNoAwaitDuration() { } @Test - @DisplayName("SimpleConsumer client start setting empty 'AwaitDuration', expect throw exception ") + @DisplayName("Error setting 'SubscriptionExpressions' empty of the consumer client, except start failed") public void testEmptySubscription() { assertThrows(Exception.class, () -> { SimpleConsumer simpleConsumer = provider.newSimpleConsumerBuilder() @@ -144,7 +144,7 @@ public void testEmptySubscription() { } @Test - @DisplayName("SimpleConsumer client start setting 'AwaitDuration=0', except invoke 'receive()' throw exception") + @DisplayName("Error setting 'MaxMessageNum=0' of the consumer client, except start failed") public void testAwaitDurationIs0s() { SimpleConsumer simpleConsumer = null; try { @@ -180,7 +180,7 @@ public void testReceiveMaxMessageNumIs0() { } @Test - @DisplayName("SimpleConsumer client start setting 'MaxMessageNum=100000', except success") + @DisplayName("Setting 'MaxMessageNum=100000', except start success") public void testReceiveMaxMessageNumMore100000() { SimpleConsumer simpleConsumer = null; try { @@ -197,8 +197,8 @@ public void testReceiveMaxMessageNumMore100000() { } @Test - @DisplayName("SimpleConsumer client start setting 'invisibleDuration<1000ms', except throw exception") - public void testReceiveInvisibleDurationLess1000ms() { + @DisplayName("SimpleConsumer client start setting 'invisibleDuration<10000ms', except throw exception") + public void testReceiveInvisibleDurationLess10000ms() { SimpleConsumer simpleConsumer = null; try { simpleConsumer = provider.newSimpleConsumerBuilder()