package it.cavallium.dbengine; import static it.cavallium.dbengine.DbTestUtils.tempDatabaseMapDictionaryDeepMap; import static it.cavallium.dbengine.DbTestUtils.tempDb; import static it.cavallium.dbengine.DbTestUtils.tempDictionary; import it.cavallium.dbengine.database.UpdateMode; import java.util.Arrays; import java.util.Map; import java.util.Map.Entry; import java.util.Objects; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; import java.util.stream.Stream; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; import reactor.test.StepVerifier.FirstStep; import reactor.test.StepVerifier.Step; import reactor.util.function.Tuple2; import reactor.util.function.Tuple3; import reactor.util.function.Tuple4; import reactor.util.function.Tuples; public class TestDictionaryMapDeep { private static boolean isTestBadKeysEnabled() { return System.getProperty("badkeys", "true").equalsIgnoreCase("true"); } private static final String BIG_STRING = "012345678901234567890123456789"; private static Stream provideArgumentsSet() { var goodKeys = Set.of("12345"); Set badKeys; if (isTestBadKeysEnabled()) { badKeys = Set.of("", "aaaa", "aaaaaa"); } else { badKeys = Set.of(); } Set> keys = Stream.concat( goodKeys.stream().map(s -> Tuples.of(s, false)), badKeys.stream().map(s -> Tuples.of(s, true)) ).collect(Collectors.toSet()); var values = Set.of( Map.of("123456", "a", "234567", ""), Map.of("123456", "\0", "234567", "\0\0", "345678", BIG_STRING) ); return keys .stream() .flatMap(keyTuple -> { Stream> strm; if (keyTuple.getT2()) { strm = values.stream().limit(1); } else { strm = values.stream(); } return strm.map(val -> Tuples.of(keyTuple.getT1(), val, keyTuple.getT2())); }) .flatMap(entryTuple -> Arrays.stream(UpdateMode.values()).map(updateMode -> Tuples.of(updateMode, entryTuple.getT1(), entryTuple.getT2(), entryTuple.getT3() ))) .map(fullTuple -> Arguments.of(fullTuple.getT1(), fullTuple.getT2(), fullTuple.getT3(), fullTuple.getT4())); } private static Stream provideArgumentsPut() { var goodKeys1 = Set.of("12345", "zebra"); Set badKeys1; if (isTestBadKeysEnabled()) { badKeys1 = Set.of("", "a", "aaaa", "aaaaaa"); } else { badKeys1 = Set.of(); } var goodKeys2 = Set.of("123456", "anatra"); Set badKeys2; if (isTestBadKeysEnabled()) { badKeys2 = Set.of("", "a", "aaaaa", "aaaaaaa"); } else { badKeys2 = Set.of(); } var values = Set.of("a", "", "\0", "\0\0", "z", "azzszgzczqz", BIG_STRING); Flux> failOnKeys1 = Flux .fromIterable(badKeys1) .map(badKey1 -> Tuples.of( badKey1, goodKeys2.stream().findAny().orElseThrow(), values.stream().findAny().orElseThrow(), true )); Flux> failOnKeys2 = Flux .fromIterable(badKeys2) .map(badKey2 -> Tuples.of( goodKeys1.stream().findAny().orElseThrow(), badKey2, values.stream().findAny().orElseThrow(), true )); Flux> goodKeys1And2 = Flux .fromIterable(values) .map(value -> Tuples.of( goodKeys1.stream().findAny().orElseThrow(), goodKeys2.stream().findAny().orElseThrow(), value, false )); Flux> keys1And2 = Flux .concat( goodKeys1And2, failOnKeys1, failOnKeys2 ); return keys1And2 .flatMap(entryTuple -> Flux .fromArray(UpdateMode.values()) .map(updateMode -> Tuples.of(updateMode, entryTuple.getT1(), entryTuple.getT2(), entryTuple.getT3(), entryTuple.getT4() )) ) .map(fullTuple -> Arguments.of(fullTuple.getT1(), fullTuple.getT2(), fullTuple.getT3(), fullTuple.getT4(), fullTuple.getT5() )) .toStream(); } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testSetValueGetValue(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMap(map -> map .putValue(key, value) .then(map.getValue(null, key)) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(value).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testSetValueGetAllValues(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> map .putValue(key, value) .thenMany(map.getAllValues(null)) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(Map.entry(key, value)).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testAtSetGetAllStagesGetAllValues(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> map .at(null, key) .flatMap(v -> v .set(value) .doAfterTerminate(v::release) ) .then(map .at(null, "capra") .flatMap(v -> v .set(Map.of("normal", "123", "ormaln", "456")) .doAfterTerminate(v::release) ) ) .thenMany(map .getAllStages(null) .flatMap(v -> v.getValue() .getAllValues(null) .map(result -> Tuples.of(v.getKey(), result.getKey(), result.getValue())) .doAfterTerminate(() -> v.getValue().release()) ) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { value.forEach((k, v) -> remainingEntries.add(Tuples.of(key, k, v))); remainingEntries.add(Tuples.of("capra", "normal", "123")); remainingEntries.add(Tuples.of("capra", "ormaln", "456")); for (Tuple3 ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); assert remainingEntries.isEmpty(); } } @ParameterizedTest @MethodSource("provideArgumentsPut") public void testAtPutValueAtGetValue(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMap(map -> map .at(null, key1).flatMap(v -> v.putValue(key2, value).doAfterTerminate(v::release)) .then(map.at(null, key1).flatMap(v -> v.getValue(null, key2).doAfterTerminate(v::release))) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(value).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testSetAndGetPrevious(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map .putValueAndGetPrevious(key, Map.of("error?", "error.")) .defaultIfEmpty(Map.of("nothing", "nothing")), map.putValueAndGetPrevious(key, value), map.putValueAndGetPrevious(key, value) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(Map.of("nothing", "nothing"), Map.of("error?", "error.")).expectNext(value).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsPut") public void testAtPutValueAndGetPrevious(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map .at(null, key1) .flatMap(v -> v .putValueAndGetPrevious(key2, "error?") .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .putValueAndGetPrevious(key2, value) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .putValueAndGetPrevious(key2, value) .doAfterTerminate(v::release) ) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext("error?", value).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testSetValueRemoveAndGetPrevious(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.removeAndGetPrevious(key), map.putValue(key, value).then(map.removeAndGetPrevious(key)), map.removeAndGetPrevious(key) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(value).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsPut") public void testAtPutValueRemoveAndGetPrevious(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map .at(null, key1) .flatMap(v -> v .putValue(key2, "error?") .then(v.removeAndGetPrevious(key2)) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .putValue(key2, value) .then(v.removeAndGetPrevious(key2)) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v.removeAndGetPrevious(key2) .doAfterTerminate(v::release) ) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext("error?", value).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testSetValueRemoveAndGetStatus(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.removeAndGetStatus(key), map.putValue(key, value).then(map.removeAndGetStatus(key)), map.removeAndGetStatus(key) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(false, true, false).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsPut") public void testAtPutValueRemoveAndGetStatus(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map .at(null, key1) .flatMap(v -> v .putValue(key2, "error?") .then(v.removeAndGetStatus(key2)) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .putValue(key2, value) .then(v.removeAndGetStatus(key2)) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v.removeAndGetStatus(key2) .doAfterTerminate(v::release) ) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(true, true, false).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testUpdate(UpdateMode updateMode, String key, Map value, boolean shouldFail) { if (updateMode != UpdateMode.ALLOW_UNSAFE && !isTestBadKeysEnabled()) { return; } var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.updateValue(key, old -> { assert old == null; return Map.of("error?", "error."); }), map.updateValue(key, false, old -> { assert Objects.equals(old, Map.of("error?", "error.")); return Map.of("error?", "error."); }), map.updateValue(key, true, old -> { assert Objects.equals(old, Map.of("error?", "error.")); return Map.of("error?", "error."); }), map.updateValue(key, true, old -> { assert Objects.equals(old, Map.of("error?", "error.")); return value; }), map.updateValue(key, true, old -> { assert Objects.equals(old, value); return value; }) ) .doAfterTerminate(map::release) ) )); if (updateMode != UpdateMode.ALLOW_UNSAFE || shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(true, false, false, true, false).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsPut") public void testAtUpdate(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { if (updateMode == UpdateMode.DISALLOW && !isTestBadKeysEnabled()) { return; } var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> prev) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> value) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> value) .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> null) .doAfterTerminate(v::release) ) ) .doAfterTerminate(map::release) ) )); if (updateMode == UpdateMode.DISALLOW || shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(false, true, false, true).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testUpdateGet(UpdateMode updateMode, String key, Map value, boolean shouldFail) { if (updateMode != UpdateMode.ALLOW_UNSAFE && !isTestBadKeysEnabled()) { return; } var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.updateValue(key, old -> { assert old == null; return Map.of("error?", "error."); }).then(map.getValue(null, key)), map.updateValue(key, false, old -> { assert Objects.equals(old, Map.of("error?", "error.")); return Map.of("error?", "error."); }).then(map.getValue(null, key)), map.updateValue(key, true, old -> { assert Objects.equals(old, Map.of("error?", "error.")); return Map.of("error?", "error."); }).then(map.getValue(null, key)), map.updateValue(key, true, old -> { assert Objects.equals(old, Map.of("error?", "error.")); return value; }).then(map.getValue(null, key)), map.updateValue(key, true, old -> { assert Objects.equals(old, value); return value; }).then(map.getValue(null, key)) ) .doAfterTerminate(map::release) ) )); if (updateMode != UpdateMode.ALLOW_UNSAFE || shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(Map.of("error?", "error."), Map.of("error?", "error."), Map.of("error?", "error."), value, value).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsPut") public void testAtUpdateGetValue(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { if (updateMode == UpdateMode.DISALLOW && !isTestBadKeysEnabled()) { return; } var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> prev) .then(v.getValue(null, key2)) .defaultIfEmpty("empty") .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> value) .then(v.getValue(null, key2)) .defaultIfEmpty("empty") .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> value) .then(v.getValue(null, key2)) .defaultIfEmpty("empty") .doAfterTerminate(v::release) ), map .at(null, key1) .flatMap(v -> v .updateValue(key2, prev -> null) .then(v.getValue(null, key2)) .defaultIfEmpty("empty") .doAfterTerminate(v::release) ) ) .doAfterTerminate(map::release) ) )); if (updateMode == UpdateMode.DISALLOW || shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext("empty", value, value, "empty").verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSet") public void testSetAndGetChanged(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.putValueAndGetChanged(key, Map.of("error?", "error.")).single(), map.putValueAndGetChanged(key, value).single(), map.putValueAndGetChanged(key, value).single(), map.remove(key), map.putValueAndGetChanged(key, Map.of("error?", "error.")).single() ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(true, true, false, true).verifyComplete(); } } private static Stream provideArgumentsSetMulti() { var goodKeys = Set.of(Set.of("12345", "67890"), Set.of()); Set> badKeys; if (isTestBadKeysEnabled()) { badKeys = Set.of(Set.of("", "12345"), Set.of("45678", "aaaa"), Set.of("aaaaaa", "capra")); } else { badKeys = Set.of(); } Set, Boolean>> keys = Stream.concat( goodKeys.stream().map(s -> Tuples.of(s, false)), badKeys.stream().map(s -> Tuples.of(s, true)) ).collect(Collectors.toSet()); var values = Set.of( Map.of("123456", "a", "234567", ""), Map.of("123456", "\0", "234567", "\0\0", "345678", BIG_STRING) ); return keys .stream() .map(keyTuple -> keyTuple.mapT1(ks -> Flux .zip(Flux.fromIterable(ks), Flux.fromIterable(values)) .collectMap(Tuple2::getT1, Tuple2::getT2) .block() )) .flatMap(entryTuple -> Arrays.stream(UpdateMode.values()).map(updateMode -> Tuples.of(updateMode, entryTuple.getT1(), entryTuple.getT2() ))) .map(fullTuple -> Arguments.of(fullTuple.getT1(), fullTuple.getT2(), fullTuple.getT3())); } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetMultiGetMulti(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), map.getMulti(null, Flux.fromIterable(entries.keySet())) ) .doAfterTerminate(map::release) ) .filter(k -> k.getValue().isPresent()) .map(k -> Map.entry(k.getKey(), k.getValue().orElseThrow())) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetAllValuesGetMulti(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> map .setAllValues(Flux.fromIterable(entries.entrySet())) .thenMany(map.getMulti(null, Flux.fromIterable(entries.keySet()))) .doAfterTerminate(map::release) ) .filter(k -> k.getValue().isPresent()) .map(k -> Map.entry(k.getKey(), k.getValue().orElseThrow())) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetAllValuesAndGetPrevious(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.setAllValuesAndGetPrevious(Flux.fromIterable(entries.entrySet())), map.setAllValuesAndGetPrevious(Flux.fromIterable(entries.entrySet())) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetGetMulti(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.set(entries).then(Mono.empty()), map.getMulti(null, Flux.fromIterable(entries.keySet())) ) .doAfterTerminate(map::release) ) .filter(k -> k.getValue().isPresent()) .map(k -> Map.entry(k.getKey(), k.getValue().orElseThrow())) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetAndGetStatus(UpdateMode updateMode, Map> entries, boolean shouldFail) { Step stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> { Mono removalMono; if (entries.isEmpty()) { removalMono = Mono.empty(); } else { removalMono = map.remove(entries.keySet().stream().findAny().orElseThrow()); } return Flux .concat( map.setAndGetChanged(entries).single(), map.setAndGetChanged(entries).single(), removalMono.then(Mono.empty()), map.setAndGetChanged(entries).single() ) .doAfterTerminate(map::release); }) )); if (shouldFail) { stpVer.verifyError(); } else { stpVer.expectNext(!entries.isEmpty(), false, !entries.isEmpty()).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetAndGetPrevious(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.setAndGetPrevious(entries), map.setAndGetPrevious(entries) ) .map(Map::entrySet) .concatMapIterable(list -> list) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetClearAndGetPreviousGet(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat(map.set(entries).then(Mono.empty()), map.clearAndGetPrevious(), map.get(null)) .map(Map::entrySet) .concatMapIterable(list -> list) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetMultiGetAllValues(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), map.getAllValues(null) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetMultiGet(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), map.get(null) .map(Map::entrySet) .flatMapIterable(list -> list) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetMultiGetAllStagesGet(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), map .getAllStages(null) .flatMap(stage -> stage .getValue() .get(null) .map(val -> Map.entry(stage.getKey(), val)) .doAfterTerminate(() -> stage.getValue().release()) ) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.verifyError(); } else { entries.forEach((k, v) -> remainingEntries.add(Map.entry(k, v))); for (Entry> ignored : remainingEntries) { stpVer = stpVer.expectNextMatches(remainingEntries::remove); } stpVer.verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetMultiIsEmpty(UpdateMode updateMode, Map> entries, boolean shouldFail) { Step stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.isEmpty(null), map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), map.isEmpty(null) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.expectNext(true).verifyError(); } else { stpVer.expectNext(true, entries.isEmpty()).verifyComplete(); } } @ParameterizedTest @MethodSource("provideArgumentsSetMulti") public void testSetMultiClear(UpdateMode updateMode, Map> entries, boolean shouldFail) { Step stpVer = StepVerifier .create(tempDb(db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( map.isEmpty(null), map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), map.isEmpty(null), map.clear().then(Mono.empty()), map.isEmpty(null) ) .doAfterTerminate(map::release) ) )); if (shouldFail) { stpVer.expectNext(true).verifyError(); } else { stpVer.expectNext(true, entries.isEmpty(), true).verifyComplete(); } } }