Skip to content

Commit 742c8cb

Browse files
onobconobc
committed
Do not run tests for XDELEX and XACKDEL on Valkey.
Groups the integration tests in DefaultStreamOperationsIntegrationTests for XACKDEL and XDELEX and adds an `@EnabledOnCommand` guard to each test group to prevent them from being run in environments that do not support these commands (e.g. Valkey). Original pull request #3247 See #3232 Signed-off-by: Chris Bono <chris.bono@broadcom.com>
1 parent 9cb4db8 commit 742c8cb

File tree

1 file changed

+98
-87
lines changed

1 file changed

+98
-87
lines changed

‎src/test/java/org/springframework/data/redis/core/DefaultStreamOperationsIntegrationTests.java‎

Lines changed: 98 additions & 87 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@
2525
import java.util.List;
2626

2727
import org.junit.jupiter.api.BeforeEach;
28+
import org.junit.jupiter.api.Nested;
2829
import org.junit.jupiter.api.Test;
2930
import org.junit.jupiter.params.ParameterizedClass;
3031
import org.junit.jupiter.params.provider.MethodSource;
@@ -781,139 +782,149 @@ void claimShouldReadMessageDetails() {
781782
}
782783
}
783784

784-
@Test // GH-3232
785-
void deleteWithOptionsShouldDeleteEntries() {
785+
@Nested // GH-3232
786+
@EnabledOnCommand("XDELEX")
787+
class DeleteWithOptions {
786788

787-
K key = keyFactory.instance();
788-
HK hashKey = hashKeyFactory.instance();
789-
HV value = hashValueFactory.instance();
789+
@Test
790+
void shouldDeleteEntries() {
790791

791-
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
792-
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
793-
RecordId messageId3 = streamOps.add(key, Collections.singletonMap(hashKey, value));
792+
K key = keyFactory.instance();
793+
HK hashKey = hashKeyFactory.instance();
794+
HV value = hashValueFactory.instance();
794795

795-
assertThat(streamOps.size(key)).isEqualTo(3L);
796+
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
797+
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
798+
RecordId messageId3 = streamOps.add(key, Collections.singletonMap(hashKey, value));
796799

797-
XDelOptions options = XDelOptions.defaults();
800+
assertThat(streamOps.size(key)).isEqualTo(3L);
798801

799-
List<StreamEntryDeletionResult> results = streamOps.deleteWithOptions(key, options, messageId1, messageId2);
802+
XDelOptions options = XDelOptions.defaults();
800803

801-
assertThat(results).hasSize(2);
802-
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
803-
assertThat(results.get(1)).isEqualTo(StreamEntryDeletionResult.DELETED);
804+
List<StreamEntryDeletionResult> results = streamOps.deleteWithOptions(key, options, messageId1, messageId2);
804805

805-
assertThat(streamOps.size(key)).isEqualTo(1L);
806-
}
806+
assertThat(results).hasSize(2);
807+
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
808+
assertThat(results.get(1)).isEqualTo(StreamEntryDeletionResult.DELETED);
807809

808-
@Test // GH-3232
809-
void deleteWithOptionsUsingStringIdsShouldDeleteEntries() {
810+
assertThat(streamOps.size(key)).isEqualTo(1L);
811+
}
810812

811-
K key = keyFactory.instance();
812-
HK hashKey = hashKeyFactory.instance();
813-
HV value = hashValueFactory.instance();
813+
@Test
814+
void usingStringIdsShouldDeleteEntries() {
814815

815-
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
816-
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
816+
K key = keyFactory.instance();
817+
HK hashKey = hashKeyFactory.instance();
818+
HV value = hashValueFactory.instance();
817819

818-
assertThat(streamOps.size(key)).isEqualTo(2L);
820+
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
821+
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
819822

820-
XDelOptions options = XDelOptions.defaults();
823+
assertThat(streamOps.size(key)).isEqualTo(2L);
821824

822-
List<StreamEntryDeletionResult> results = streamOps.deleteWithOptions(key, options, messageId1, messageId2);
825+
XDelOptions options = XDelOptions.defaults();
823826

824-
assertThat(results).hasSize(2);
825-
assertThat(streamOps.size(key)).isEqualTo(0L);
826-
}
827+
List<StreamEntryDeletionResult> results = streamOps.deleteWithOptions(key, options, messageId1, messageId2);
827828

828-
@Test // GH-3232
829-
void deleteWithOptionsUsingRecordShouldDeleteEntry() {
829+
assertThat(results).hasSize(2);
830+
assertThat(streamOps.size(key)).isEqualTo(0L);
831+
}
830832

831-
K key = keyFactory.instance();
832-
HK hashKey = hashKeyFactory.instance();
833-
HV value = hashValueFactory.instance();
833+
@Test
834+
void usingRecordShouldDeleteEntry() {
834835

835-
RecordId messageId = streamOps.add(key, Collections.singletonMap(hashKey, value));
836+
K key = keyFactory.instance();
837+
HK hashKey = hashKeyFactory.instance();
838+
HV value = hashValueFactory.instance();
839+
840+
RecordId messageId = streamOps.add(key, Collections.singletonMap(hashKey, value));
836841

837-
assertThat(streamOps.size(key)).isEqualTo(1L);
842+
assertThat(streamOps.size(key)).isEqualTo(1L);
838843

839-
MapRecord<K, HK, HV> record = StreamRecords.newRecord().in(key).withId(messageId)
840-
.ofMap(Collections.singletonMap(hashKey, value));
841-
XDelOptions options = XDelOptions.defaults();
844+
MapRecord<K, HK, HV> record = StreamRecords.newRecord().in(key).withId(messageId)
845+
.ofMap(Collections.singletonMap(hashKey, value));
846+
XDelOptions options = XDelOptions.defaults();
842847

843-
List<StreamEntryDeletionResult> results = streamOps.deleteWithOptions(record, options);
848+
List<StreamEntryDeletionResult> results = streamOps.deleteWithOptions(record, options);
844849

845-
assertThat(results).hasSize(1);
846-
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
850+
assertThat(results).hasSize(1);
851+
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
847852

848-
assertThat(streamOps.size(key)).isEqualTo(0L);
853+
assertThat(streamOps.size(key)).isEqualTo(0L);
854+
}
849855
}
850856

851-
@Test // GH-3232
852-
void acknowledgeAndDeleteShouldAcknowledgeAndDeleteEntries() {
857+
@Nested // GH-3232
858+
@EnabledOnCommand("XACKDEL")
859+
class AcknowledgeAndDelete {
853860

854-
K key = keyFactory.instance();
855-
HK hashKey = hashKeyFactory.instance();
856-
HV value = hashValueFactory.instance();
861+
@Test
862+
void shouldAcknowledgeAndDeleteEntries() {
857863

858-
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
859-
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
864+
K key = keyFactory.instance();
865+
HK hashKey = hashKeyFactory.instance();
866+
HV value = hashValueFactory.instance();
860867

861-
streamOps.createGroup(key, ReadOffset.from("0-0"), "my-group");
868+
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
869+
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
862870

863-
streamOps.read(Consumer.from("my-group", "my-consumer"), StreamOffset.create(key, ReadOffset.lastConsumed()));
871+
streamOps.createGroup(key, ReadOffset.from("0-0"), "my-group");
864872

865-
XDelOptions options = XDelOptions.deletionPolicy(StreamDeletionPolicy.removeAcknowledged());
873+
streamOps.read(Consumer.from("my-group", "my-consumer"), StreamOffset.create(key, ReadOffset.lastConsumed()));
866874

867-
List<StreamEntryDeletionResult> results = streamOps.acknowledgeAndDelete(key, "my-group", options, messageId1,
868-
messageId2);
875+
XDelOptions options = XDelOptions.deletionPolicy(StreamDeletionPolicy.removeAcknowledged());
869876

870-
assertThat(results).hasSize(2);
871-
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
872-
assertThat(results.get(1)).isEqualTo(StreamEntryDeletionResult.DELETED);
873-
}
877+
List<StreamEntryDeletionResult> results = streamOps.acknowledgeAndDelete(key, "my-group", options, messageId1,
878+
messageId2);
874879

875-
@Test // GH-3232
876-
void acknowledgeAndDeleteUsingStringIdsShouldWork() {
880+
assertThat(results).hasSize(2);
881+
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
882+
assertThat(results.get(1)).isEqualTo(StreamEntryDeletionResult.DELETED);
883+
}
877884

878-
K key = keyFactory.instance();
879-
HK hashKey = hashKeyFactory.instance();
880-
HV value = hashValueFactory.instance();
885+
@Test
886+
void usingStringIdsShouldWork() {
881887

882-
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
883-
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
888+
K key = keyFactory.instance();
889+
HK hashKey = hashKeyFactory.instance();
890+
HV value = hashValueFactory.instance();
884891

885-
streamOps.createGroup(key, ReadOffset.from("0-0"), "my-group");
892+
RecordId messageId1 = streamOps.add(key, Collections.singletonMap(hashKey, value));
893+
RecordId messageId2 = streamOps.add(key, Collections.singletonMap(hashKey, value));
886894

887-
streamOps.read(Consumer.from("my-group", "my-consumer"), StreamOffset.create(key, ReadOffset.lastConsumed()));
895+
streamOps.createGroup(key, ReadOffset.from("0-0"), "my-group");
888896

889-
XDelOptions options = XDelOptions.deletionPolicy(StreamDeletionPolicy.removeAcknowledged());
897+
streamOps.read(Consumer.from("my-group", "my-consumer"), StreamOffset.create(key, ReadOffset.lastConsumed()));
890898

891-
List<StreamEntryDeletionResult> results = streamOps.acknowledgeAndDelete(key, "my-group", options, messageId1,
892-
messageId2);
899+
XDelOptions options = XDelOptions.deletionPolicy(StreamDeletionPolicy.removeAcknowledged());
893900

894-
assertThat(results).hasSize(2);
895-
}
901+
List<StreamEntryDeletionResult> results = streamOps.acknowledgeAndDelete(key, "my-group", options, messageId1,
902+
messageId2);
896903

897-
@Test // GH-3232
898-
void acknowledgeAndDeleteUsingRecordShouldWork() {
904+
assertThat(results).hasSize(2);
905+
}
899906

900-
K key = keyFactory.instance();
901-
HK hashKey = hashKeyFactory.instance();
902-
HV value = hashValueFactory.instance();
907+
@Test
908+
void usingRecordShouldWork() {
903909

904-
RecordId messageId = streamOps.add(key, Collections.singletonMap(hashKey, value));
910+
K key = keyFactory.instance();
911+
HK hashKey = hashKeyFactory.instance();
912+
HV value = hashValueFactory.instance();
905913

906-
streamOps.createGroup(key, ReadOffset.from("0-0"), "my-group");
914+
RecordId messageId = streamOps.add(key, Collections.singletonMap(hashKey, value));
907915

908-
streamOps.read(Consumer.from("my-group", "my-consumer"), StreamOffset.create(key, ReadOffset.lastConsumed()));
916+
streamOps.createGroup(key, ReadOffset.from("0-0"), "my-group");
917+
918+
streamOps.read(Consumer.from("my-group", "my-consumer"), StreamOffset.create(key, ReadOffset.lastConsumed()));
909919

910-
MapRecord<K, HK, HV> record = StreamRecords.newRecord().in(key).withId(messageId)
911-
.ofMap(Collections.singletonMap(hashKey, value));
912-
XDelOptions options = XDelOptions.deletionPolicy(RedisStreamCommands.StreamDeletionPolicy.removeAcknowledged());
920+
MapRecord<K, HK, HV> record = StreamRecords.newRecord().in(key).withId(messageId)
921+
.ofMap(Collections.singletonMap(hashKey, value));
922+
XDelOptions options = XDelOptions.deletionPolicy(RedisStreamCommands.StreamDeletionPolicy.removeAcknowledged());
913923

914-
List<StreamEntryDeletionResult> results = streamOps.acknowledgeAndDelete("my-group", record, options);
924+
List<StreamEntryDeletionResult> results = streamOps.acknowledgeAndDelete("my-group", record, options);
915925

916-
assertThat(results).hasSize(1);
917-
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
926+
assertThat(results).hasSize(1);
927+
assertThat(results.get(0)).isEqualTo(StreamEntryDeletionResult.DELETED);
928+
}
918929
}
919930
}

0 commit comments

Comments
 (0)