diff --git a/client-java/controller/src/main/java/org/evomaster/client/java/controller/internal/db/redis/RedisHandler.java b/client-java/controller/src/main/java/org/evomaster/client/java/controller/internal/db/redis/RedisHandler.java index e41df05736..e28f9ba004 100644 --- a/client-java/controller/src/main/java/org/evomaster/client/java/controller/internal/db/redis/RedisHandler.java +++ b/client-java/controller/src/main/java/org/evomaster/client/java/controller/internal/db/redis/RedisHandler.java @@ -3,7 +3,7 @@ import org.evomaster.client.java.controller.internal.TaintHandlerExecutionTracer; import org.evomaster.client.java.controller.redis.ReflectionBasedRedisClient; import org.evomaster.client.java.controller.redis.RedisHeuristicsCalculator; -import org.evomaster.client.java.controller.redis.RedisInfo; +import org.evomaster.client.java.controller.redis.RedisValueData; import org.evomaster.client.java.instrumentation.RedisCommand; import org.evomaster.client.java.utils.SimpleLogger; @@ -82,35 +82,35 @@ private RedisDistanceWithMetrics computeDistance(RedisCommand redisCommand, Refl switch (type) { case KEYS: case EXISTS: { - List redisInfo = createRedisInfoForAllKeys(redisClient); - return calculator.computeDistance(redisCommand, redisInfo); + Map redisValueData = createRedisInfoForAllKeys(redisClient); + return calculator.computeDistance(redisCommand, redisValueData); } case GET: { - List redisInfo = createRedisInfoForKeysByType(REDIS_STRING_TYPE, redisClient); - return calculator.computeDistance(redisCommand, redisInfo); + Map redisValueData = createRedisInfoForKeysByType(REDIS_STRING_TYPE, redisClient); + return calculator.computeDistance(redisCommand, redisValueData); } case HGET: { String field = redisCommand.extractArgs().get(1); - List redisInfo = createRedisInfoForKeysByField(field, redisClient); - return calculator.computeDistance(redisCommand, redisInfo); + Map redisValueData = createRedisInfoForKeysByField(redisClient); + return calculator.computeDistance(redisCommand, redisValueData); } case HGETALL: { - List redisInfo = createRedisInfoForKeysByType(REDIS_HASH_TYPE, redisClient); - return calculator.computeDistance(redisCommand, redisInfo); + Map redisValueData = createRedisInfoForKeysByType(REDIS_HASH_TYPE, redisClient); + return calculator.computeDistance(redisCommand, redisValueData); } case SMEMBERS: { - List redisInfo = createRedisInfoForKeysByType(REDIS_SET_TYPE, redisClient); - return calculator.computeDistance(redisCommand, redisInfo); + Map redisValueData = createRedisInfoForKeysByType(REDIS_SET_TYPE, redisClient); + return calculator.computeDistance(redisCommand, redisValueData); } case SINTER: { List keys = redisCommand.extractArgs(); - List redisInfo = createRedisInfoForIntersection(keys, redisClient); - return calculator.computeDistance(redisCommand, redisInfo); + Map redisValueData = createRedisInfoForIntersection(keys, redisClient); + return calculator.computeDistance(redisCommand, redisValueData); } default: @@ -122,34 +122,36 @@ private RedisDistanceWithMetrics computeDistance(RedisCommand redisCommand, Refl } } - private List createRedisInfoForIntersection(List keys, ReflectionBasedRedisClient redisClient) { - List redisData = new ArrayList<>(); - keys.forEach( - key -> redisData.add(new RedisInfo(key, redisClient.getType(key), redisClient.getSetMembers(key)) + private Map createRedisInfoForIntersection(List commandKeys, ReflectionBasedRedisClient redisClient) { + Set keySet = redisClient.getKeysByType(REDIS_SET_TYPE); + + Map redisData = new HashMap<>(); + keySet.forEach( + key -> redisData.put(key, new RedisValueData(redisClient.getSetMembers(key)) )); return redisData; } - private List createRedisInfoForAllKeys(ReflectionBasedRedisClient redisClient) { + private Map createRedisInfoForAllKeys(ReflectionBasedRedisClient redisClient) { Set keys = redisClient.getAllKeys(); - List redisData = new ArrayList<>(); + Map redisData = new HashMap<>(); keys.forEach( - key -> redisData.add(new RedisInfo(key)) + key -> redisData.put(key, null) ); return redisData; } - private List createRedisInfoForKeysByType(String type, ReflectionBasedRedisClient redisClient) { + private Map createRedisInfoForKeysByType(String type, ReflectionBasedRedisClient redisClient) { Set keys = redisClient.getKeysByType(type); - List redisData = new ArrayList<>(); - keys.forEach(key -> redisData.add(new RedisInfo(key))); + Map redisData = new HashMap<>(); + keys.forEach(key -> redisData.put(key, null)); return redisData; } - private List createRedisInfoForKeysByField(String field, ReflectionBasedRedisClient redisClient) { + private Map createRedisInfoForKeysByField(ReflectionBasedRedisClient redisClient) { Set keys = redisClient.getKeysByType(REDIS_HASH_TYPE); - List redisData = new ArrayList<>(); - keys.forEach(key -> redisData.add(new RedisInfo(key, redisClient.getHashFields(key)))); + Map redisData = new HashMap<>(); + keys.forEach(key -> redisData.put(key, new RedisValueData(redisClient.getHashFields(key)))); return redisData; } diff --git a/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisHeuristicsCalculator.java b/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisHeuristicsCalculator.java index 18e3910692..d27dbc0991 100644 --- a/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisHeuristicsCalculator.java +++ b/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisHeuristicsCalculator.java @@ -9,6 +9,7 @@ import org.evomaster.client.java.utils.SimpleLogger; import java.util.*; +import java.util.stream.Collectors; import static org.evomaster.client.java.controller.redis.RedisUtils.redisPatternToRegex; @@ -31,16 +32,17 @@ public RedisHeuristicsCalculator(TaintHandler taintHandler) { * Dispatches the computation based on the command keyword (type). * * @param redisCommand Redis command. - * @param redisInfo Redis data in a generic structure. + * @param redisValueData Redis data in a generic structure. * @return RedisDistanceWithMetrics */ - public RedisDistanceWithMetrics computeDistance(RedisCommand redisCommand, List redisInfo) { + public RedisDistanceWithMetrics computeDistance(RedisCommand redisCommand, + Map redisValueData) { RedisCommand.RedisCommandType type = redisCommand.getType(); try { switch (type) { case KEYS: { String pattern = redisCommand.extractArgs().get(0); - return calculateDistanceForPattern(pattern, redisInfo); + return calculateDistanceForPattern(pattern, redisValueData); } case EXISTS: @@ -48,17 +50,17 @@ public RedisDistanceWithMetrics computeDistance(RedisCommand redisCommand, List< case HGETALL: case SMEMBERS: { String target = redisCommand.extractArgs().get(0); - return calculateDistanceForKeyMatch(target, redisInfo); + return calculateDistanceForKeyMatch(target, redisValueData); } case HGET: { String key = redisCommand.extractArgs().get(0); String field = redisCommand.extractArgs().get(1); - return calculateDistanceForFieldInHash(key, field, redisInfo); + return calculateDistanceForFieldInHash(key, field, redisValueData); } case SINTER: { - return calculateDistanceForIntersection(redisInfo); + return calculateDistanceForIntersection(redisCommand.extractArgs(), redisValueData); } default: @@ -79,7 +81,7 @@ public RedisDistanceWithMetrics computeDistance(RedisCommand redisCommand, List< */ private RedisDistanceWithMetrics calculateDistanceForPattern( String pattern, - List keys) { + Map keys) { double minDist = MAX_REDIS_DISTANCE; int eval = 0; String regex; @@ -89,8 +91,7 @@ private RedisDistanceWithMetrics calculateDistanceForPattern( SimpleLogger.uniqueWarn("Invalid Redis pattern. Cannot compute regex for: " + pattern); return new RedisDistanceWithMetrics(MAX_REDIS_DISTANCE, 0); } - for (RedisInfo k : keys) { - String key = k.getKey(); + for (String key : keys.keySet()) { double d = TruthnessUtils.normalizeValue( RegexDistanceUtils.getStandardDistance(key, regex)); if (taintHandler != null) { @@ -113,7 +114,7 @@ private RedisDistanceWithMetrics calculateDistanceForPattern( */ private RedisDistanceWithMetrics calculateDistanceForKeyMatch( String targetKey, - List candidateKeys + Map candidateKeys ) { if (candidateKeys.isEmpty()) { return new RedisDistanceWithMetrics(MAX_REDIS_DISTANCE, 0); @@ -122,9 +123,8 @@ private RedisDistanceWithMetrics calculateDistanceForKeyMatch( double minDist = MAX_REDIS_DISTANCE; int evaluated = 0; - for (RedisInfo k : candidateKeys) { + for (String key : candidateKeys.keySet()) { try { - String key = k.getKey(); long rawDist = DistanceHelper.getLeftAlignmentDistance(targetKey, key); double normDist = TruthnessUtils.normalizeValue(rawDist); if (taintHandler != null) { @@ -137,7 +137,7 @@ private RedisDistanceWithMetrics calculateDistanceForKeyMatch( return new RedisDistanceWithMetrics(0, evaluated); } } catch (Exception ex) { - SimpleLogger.uniqueWarn("Failed to compute distance for key " + k + ": " + ex.getMessage()); + SimpleLogger.uniqueWarn("Failed to compute distance for key " + key + ": " + ex.getMessage()); } } @@ -154,7 +154,7 @@ private RedisDistanceWithMetrics calculateDistanceForKeyMatch( private RedisDistanceWithMetrics calculateDistanceForFieldInHash( String targetKey, String targetField, - List keys + Map keys ) { if (keys.isEmpty()) { return new RedisDistanceWithMetrics(MAX_REDIS_DISTANCE, 0); @@ -163,11 +163,10 @@ private RedisDistanceWithMetrics calculateDistanceForFieldInHash( double minDist = MAX_REDIS_DISTANCE; int evaluated = 0; - for (RedisInfo k : keys) { + for (String key : keys.keySet()) { try { - String key = k.getKey(); long keyDist = DistanceHelper.getLeftAlignmentDistance(targetKey, key); - double fieldDist = calculateDistanceForField(targetField, k.getFields().keySet()); + double fieldDist = calculateDistanceForField(targetField, keys.get(key).getFields().keySet()); double combined = TruthnessUtils.normalizeValue(keyDist + fieldDist); if (taintHandler != null) { taintHandler.handleTaintForStringEquals(targetKey, key, false); @@ -179,7 +178,7 @@ private RedisDistanceWithMetrics calculateDistanceForFieldInHash( return new RedisDistanceWithMetrics(0, evaluated); } } catch (Exception ex) { - SimpleLogger.uniqueWarn("Failed HGET distance on " + k + ": " + ex.getMessage()); + SimpleLogger.uniqueWarn("Failed HGET distance on " + key + ": " + ex.getMessage()); } } @@ -216,37 +215,72 @@ private double calculateDistanceForField(String targetField, Set fields) /** * Computes the distance of a given intersection considering the keys for the given sets. + * Distance would be a function considering whether the keys are valid sets existing in Redis + * and whether the successive intersections return elements in common. * - * @param keys Set keys for the intersection + * @param commandArgs List of keys for the intersection + * @param storedKeys Set keys stored in Redis * @return RedisDistanceWithMetrics */ private RedisDistanceWithMetrics calculateDistanceForIntersection( - List keys + List commandArgs, + Map storedKeys ) { - if (keys == null || keys.isEmpty()) { + if (storedKeys == null || storedKeys.isEmpty()) { return new RedisDistanceWithMetrics(MAX_REDIS_DISTANCE, 0); } + return new RedisDistanceWithMetrics(TruthnessUtils.normalizeValue( + computeDistanceForKeysInArgs(commandArgs, storedKeys) + computeIntersectionDistanceForArgs(commandArgs, storedKeys) + ), storedKeys.size()); + } + + /** + * Computes the distance for the list of keys of each one existing in Redis. + * + * @param commandArgs List of keys for the intersection + * @param storedKeys Set keys stored in Redis + * @return RedisDistanceWithMetrics + */ + private double computeDistanceForKeysInArgs( + List commandArgs, + Map storedKeys + ) { + int numberOfCommandKeys = commandArgs.size(); + double sum = 0d; + for (String arg : commandArgs) { + sum += calculateDistanceForKeyMatch(arg, storedKeys).getDistance(); + } + return sum / numberOfCommandKeys; + } + + /** + * Computes the distance of a given intersection considering the keys present in the command args. + * + * @param commandArgs List of keys for the intersection + * @param storedSets Set keys stored in Redis + * @return RedisDistanceWithMetrics + */ + private double computeIntersectionDistanceForArgs( + List commandArgs, + Map storedSets + ) { + + List> membersInCommandArgsSets = commandArgs.stream() + .map(key -> storedSets.getOrDefault(key, new RedisValueData(new HashSet<>())).getMembers()) + .collect(Collectors.toList()); + double total = 0d; - int evaluated = 0; Set currentIntersection = null; - for (int i = 0; i < keys.size(); i++) { - RedisInfo k = keys.get(i); - String type = k.getType(); - if (!"set".equalsIgnoreCase(type)) { - return new RedisDistanceWithMetrics(MAX_REDIS_DISTANCE, evaluated); - } - - Set set = k.getMembers(); - if (set == null) set = Collections.emptySet(); + for (int i = 0; i < membersInCommandArgsSets.size(); i++) { + Set set = membersInCommandArgsSets.get(i); if (i == 0) { currentIntersection = new HashSet<>(set); double d0 = currentIntersection.isEmpty() ? MAX_REDIS_DISTANCE : 0d; total += d0; - evaluated++; } else { Set newIntersection = new HashSet<>(currentIntersection); newIntersection.retainAll(set); @@ -256,12 +290,11 @@ private RedisDistanceWithMetrics calculateDistanceForIntersection( : 0d; total += di; - evaluated++; currentIntersection = newIntersection; } } - return new RedisDistanceWithMetrics(total / keys.size(), evaluated); + return total / membersInCommandArgsSets.size(); } /** diff --git a/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisInfo.java b/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisValueData.java similarity index 58% rename from client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisInfo.java rename to client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisValueData.java index df3f531d6d..85b39c1713 100644 --- a/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisInfo.java +++ b/client-java/controller/src/main/java/org/evomaster/client/java/controller/redis/RedisValueData.java @@ -8,34 +8,18 @@ * Hence, RedisHeuristicCalculator will be decoupled from Redis. * There'll be no need to call Redis to calculate distances. */ -public class RedisInfo { - private String key; - private String type; +public class RedisValueData { private Map fields; private Set members; - public RedisInfo(String key) { - this.key = key; - } - - public RedisInfo(String key, Map fields) { - this.key = key; + public RedisValueData(Map fields) { this.fields = fields; } - public RedisInfo(String key, String type, Set members) { - this.key = key; - this.type = type; + public RedisValueData(Set members) { this.members = members; } - public String getKey() { - return key; - } - - public String getType() { - return type; - } public Set getMembers() { return members; diff --git a/client-java/controller/src/test/java/org/evomaster/client/java/controller/internal/db/redis/RedisHeuristicsCalculatorTest.java b/client-java/controller/src/test/java/org/evomaster/client/java/controller/internal/db/redis/RedisHeuristicsCalculatorTest.java index 3ef2045220..56fd9c533d 100644 --- a/client-java/controller/src/test/java/org/evomaster/client/java/controller/internal/db/redis/RedisHeuristicsCalculatorTest.java +++ b/client-java/controller/src/test/java/org/evomaster/client/java/controller/internal/db/redis/RedisHeuristicsCalculatorTest.java @@ -1,7 +1,7 @@ package org.evomaster.client.java.controller.internal.db.redis; import org.evomaster.client.java.controller.redis.RedisHeuristicsCalculator; -import org.evomaster.client.java.controller.redis.RedisInfo; +import org.evomaster.client.java.controller.redis.RedisValueData; import org.evomaster.client.java.instrumentation.RedisCommand; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -28,12 +28,12 @@ void testKeysPatternExactMatch() { 5 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("user:1")); - redisInfoList.add(new RedisInfo("user:2")); - redisInfoList.add(new RedisInfo("other")); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("user:1", null); + redisValueDataList.put("user:2", null); + redisValueDataList.put("other", null); - RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisInfoList); + RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisValueDataList); assertEquals(0.0, result.getDistance(), 1e-6, "Pattern 'user*' should fully match 'user:1' and 'user:2'"); } @@ -47,11 +47,11 @@ void testKeysPatternNoMatch() { 5 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("user:1")); - redisInfoList.add(new RedisInfo("user:2")); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("user:1", null); + redisValueDataList.put("user:2", null); - RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisInfoList); + RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisValueDataList); assertEquals(1.0, result.getDistance(), 0.1, "Pattern with no matches should yield max distance 1"); assertEquals(2, result.getNumberOfEvaluatedKeys()); } @@ -72,12 +72,12 @@ void testExistsCommandSimilarity() { 5 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("user:1")); - redisInfoList.add(new RedisInfo("user:2")); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("user:1", null); + redisValueDataList.put("user:2", null); - RedisDistanceWithMetrics dClose = calculator.computeDistance(closeKey, redisInfoList); - RedisDistanceWithMetrics dFar = calculator.computeDistance(farKey, redisInfoList); + RedisDistanceWithMetrics dClose = calculator.computeDistance(closeKey, redisValueDataList); + RedisDistanceWithMetrics dFar = calculator.computeDistance(farKey, redisValueDataList); assertTrue(dClose.getDistance() < dFar.getDistance(), "Closer key should have smaller distance."); @@ -92,11 +92,11 @@ void testHGetFieldExists() { 3 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("profile", Collections.singletonMap("name", "John"))); - redisInfoList.add(new RedisInfo("users", Collections.emptyMap())); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("profile", new RedisValueData(Collections.singletonMap("name", "John"))); + redisValueDataList.put("users", new RedisValueData(Collections.emptyMap())); - RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisInfoList); + RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisValueDataList); assertEquals(0.0, result.getDistance(), 1e-6, "Field 'name' exists, so distance must be 0"); @@ -112,10 +112,10 @@ void testHGetFieldNotExists() { 3 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("profile", Collections.emptyMap())); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("profile", new RedisValueData(Collections.emptyMap())); - RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisInfoList); + RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisValueDataList); assertTrue(result.getDistance() > 0.0, "Missing field should yield positive distance"); assertTrue(result.getNumberOfEvaluatedKeys() >= 1); @@ -142,12 +142,12 @@ void testHGetFieldDistance() { 3 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("profile", Collections.singletonMap("height", "175"))); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("profile", new RedisValueData(Collections.singletonMap("height", "175"))); - RedisDistanceWithMetrics resultLower = calculator.computeDistance(lowerDistanceCmd, redisInfoList); - RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisInfoList); - RedisDistanceWithMetrics resultGreater = calculator.computeDistance(greaterDistanceCmd, redisInfoList); + RedisDistanceWithMetrics resultLower = calculator.computeDistance(lowerDistanceCmd, redisValueDataList); + RedisDistanceWithMetrics result = calculator.computeDistance(cmd, redisValueDataList); + RedisDistanceWithMetrics resultGreater = calculator.computeDistance(greaterDistanceCmd, redisValueDataList); assertTrue(resultLower.getDistance() < result.getDistance(), "Closer target field should yield lower distance"); @@ -171,11 +171,11 @@ void testSInterSetsIntersectionAndNoIntersection() { 1 ); - List redisInfoListIntersection = new ArrayList<>(); - redisInfoListIntersection.add(new RedisInfo("setA", "set", new HashSet<>(Arrays.asList("a", "b", "c")))); - redisInfoListIntersection.add(new RedisInfo("setB", "set", new HashSet<>(Arrays.asList("b", "c", "d")))); + Map redisValueDataListIntersection = new HashMap<>(); + redisValueDataListIntersection.put("setA", new RedisValueData(new HashSet<>(Arrays.asList("a", "b", "c")))); + redisValueDataListIntersection.put("setB", new RedisValueData(new HashSet<>(Arrays.asList("b", "c", "d")))); - RedisDistanceWithMetrics dIntersect = calculator.computeDistance(cmdIntersect, redisInfoListIntersection); + RedisDistanceWithMetrics dIntersect = calculator.computeDistance(cmdIntersect, redisValueDataListIntersection); assertEquals(0.0, dIntersect.getDistance(), "Set intersection distance equals 0.0 when sets share members."); @@ -187,11 +187,11 @@ void testSInterSetsIntersectionAndNoIntersection() { 1 ); - List redisInfoListNoIntersection = new ArrayList<>(); - redisInfoListNoIntersection.add(new RedisInfo("setC", "set", new HashSet<>(Arrays.asList("a", "b")))); - redisInfoListNoIntersection.add(new RedisInfo("setD", "set", new HashSet<>(Arrays.asList("c", "d")))); + Map redisValueDataListNoIntersection = new HashMap<>(); + redisValueDataListNoIntersection.put("setC", new RedisValueData(new HashSet<>(Arrays.asList("a", "b")))); + redisValueDataListNoIntersection.put("setD", new RedisValueData(new HashSet<>(Arrays.asList("c", "d")))); - RedisDistanceWithMetrics dNoIntersect = calculator.computeDistance(cmdNoIntersect, redisInfoListNoIntersection); + RedisDistanceWithMetrics dNoIntersect = calculator.computeDistance(cmdNoIntersect, redisValueDataListNoIntersection); assertTrue(dNoIntersect.getDistance() > 0.0, "With disjoint sets, distance must be greater than zero."); @@ -206,11 +206,11 @@ void testSInterSetsIntersectionAndNoIntersection() { 1 ); - List redisInfoListGreaterDisjoint = new ArrayList<>(); - redisInfoListGreaterDisjoint.add(new RedisInfo("setC", "set", new HashSet<>(Arrays.asList("a", "b")))); - redisInfoListGreaterDisjoint.add(new RedisInfo("setD", "set", new HashSet<>(Arrays.asList("y", "z")))); + Map redisValueDataListGreaterDisjoint = new HashMap<>(); + redisValueDataListGreaterDisjoint.put("setC", new RedisValueData(new HashSet<>(Arrays.asList("a", "b")))); + redisValueDataListGreaterDisjoint.put("setD", new RedisValueData(new HashSet<>(Arrays.asList("y", "z")))); - RedisDistanceWithMetrics dNoIntersectFarDistance = calculator.computeDistance(cmdNoIntersectFarDistance, redisInfoListGreaterDisjoint); + RedisDistanceWithMetrics dNoIntersectFarDistance = calculator.computeDistance(cmdNoIntersectFarDistance, redisValueDataListGreaterDisjoint); assertTrue(dNoIntersectFarDistance.getDistance() > 0.0, "With disjoint sets, distance must be greater than zero."); @@ -231,23 +231,23 @@ void testSInterSeveralSets() { 1 ); - List redisInfoListLessDistance = new ArrayList<>(); - redisInfoListLessDistance.add(new RedisInfo("setA", "set", new HashSet<>(Arrays.asList("a", "b", "c")))); - redisInfoListLessDistance.add(new RedisInfo("setB", "set", new HashSet<>(Arrays.asList("b", "c")))); - redisInfoListLessDistance.add(new RedisInfo("setC", "set", new HashSet<>(Arrays.asList("c", "d")))); - redisInfoListLessDistance.add(new RedisInfo("setD", "set", new HashSet<>(Arrays.asList("d", "e")))); + Map redisValueDataListLessDistance = new HashMap<>(); + redisValueDataListLessDistance.put("setA", new RedisValueData(new HashSet<>(Arrays.asList("a", "b", "c")))); + redisValueDataListLessDistance.put("setB", new RedisValueData(new HashSet<>(Arrays.asList("b", "c")))); + redisValueDataListLessDistance.put("setC", new RedisValueData(new HashSet<>(Arrays.asList("c", "d")))); + redisValueDataListLessDistance.put("setD", new RedisValueData(new HashSet<>(Arrays.asList("d", "e")))); - RedisDistanceWithMetrics dIntersectLessDistance = calculator.computeDistance(cmdIntersect, redisInfoListLessDistance); + RedisDistanceWithMetrics dIntersectLessDistance = calculator.computeDistance(cmdIntersect, redisValueDataListLessDistance); assertTrue(dIntersectLessDistance.getDistance() > 0.0, "With disjoint sets, distance must be greater than zero."); - List redisInfoListMoreDistance = new ArrayList<>(); - redisInfoListMoreDistance.add(new RedisInfo("setA", "set", new HashSet<>(Arrays.asList("a", "b", "c")))); - redisInfoListMoreDistance.add(new RedisInfo("setB", "set", new HashSet<>(Arrays.asList("b", "c")))); - redisInfoListMoreDistance.add(new RedisInfo("setC", "set", new HashSet<>(Arrays.asList("d", "e")))); - redisInfoListMoreDistance.add(new RedisInfo("setD", "set", new HashSet<>(Arrays.asList("f", "g")))); + Map redisValueDataListMoreDistance = new HashMap<>(); + redisValueDataListMoreDistance.put("setA", new RedisValueData(new HashSet<>(Arrays.asList("a", "b", "c")))); + redisValueDataListMoreDistance.put("setB", new RedisValueData(new HashSet<>(Arrays.asList("b", "c")))); + redisValueDataListMoreDistance.put("setC", new RedisValueData(new HashSet<>(Arrays.asList("d", "e")))); + redisValueDataListMoreDistance.put("setD", new RedisValueData(new HashSet<>(Arrays.asList("f", "g")))); - RedisDistanceWithMetrics dIntersectMoreDistance = calculator.computeDistance(cmdIntersect, redisInfoListMoreDistance); + RedisDistanceWithMetrics dIntersectMoreDistance = calculator.computeDistance(cmdIntersect, redisValueDataListMoreDistance); assertTrue(dIntersectMoreDistance.getDistance() > 0.0, "With disjoint sets, distance must be greater than zero."); @@ -270,13 +270,13 @@ void testSMembersSimilarity() { 2 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("user:setA")); - redisInfoList.add(new RedisInfo("user:setB")); - redisInfoList.add(new RedisInfo("profile:set")); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("user:setA", null); + redisValueDataList.put("user:setB", null); + redisValueDataList.put("profile:set", null); - double dSimilar = calculator.computeDistance(similar, redisInfoList).getDistance(); - double dDifferent = calculator.computeDistance(different, redisInfoList).getDistance(); + double dSimilar = calculator.computeDistance(similar, redisValueDataList).getDistance(); + double dDifferent = calculator.computeDistance(different, redisValueDataList).getDistance(); assertTrue(dSimilar < dDifferent, "SMEMBERS with similar keys should yield smaller distance"); @@ -298,13 +298,13 @@ void testGetCommandSimilarity() { 1 ); - List redisInfoList = new ArrayList<>(); - redisInfoList.add(new RedisInfo("session:1235")); - redisInfoList.add(new RedisInfo("config")); - redisInfoList.add(new RedisInfo("log")); + Map redisValueDataList = new HashMap<>(); + redisValueDataList.put("session:1235", null); + redisValueDataList.put("config", null); + redisValueDataList.put("log", null); - double dSimilar = calculator.computeDistance(similar, redisInfoList).getDistance(); - double dDifferent = calculator.computeDistance(different, redisInfoList).getDistance(); + double dSimilar = calculator.computeDistance(similar, redisValueDataList).getDistance(); + double dDifferent = calculator.computeDistance(different, redisValueDataList).getDistance(); assertTrue(dSimilar < dDifferent, "GET with similar keys should yield smaller distance"); diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findhash/RedisLettuceFindHashApp.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findhash/RedisLettuceFindHashApp.java new file mode 100644 index 0000000000..e20a1ca80d --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findhash/RedisLettuceFindHashApp.java @@ -0,0 +1,20 @@ +package com.redis.lettuce.findhash; + +import com.redis.SwaggerConfiguration; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration; +import springfox.documentation.swagger2.annotations.EnableSwagger2; + +@EnableSwagger2 +@SpringBootApplication(exclude = SecurityAutoConfiguration.class) +public class RedisLettuceFindHashApp extends SwaggerConfiguration { + public RedisLettuceFindHashApp() { + super("redislettucefindhash"); + } + + public static void main(String[] args) { + SpringApplication.run(RedisLettuceFindHashApp.class, args); + } + +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findhash/RedisLettuceFindHashRest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findhash/RedisLettuceFindHashRest.java new file mode 100644 index 0000000000..83cef82123 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findhash/RedisLettuceFindHashRest.java @@ -0,0 +1,56 @@ +package com.redis.lettuce.findhash; + +import io.lettuce.core.RedisClient; +import io.lettuce.core.api.StatefulRedisConnection; +import io.lettuce.core.api.sync.RedisCommands; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.PostConstruct; +import javax.annotation.PreDestroy; +import java.util.List; +import java.util.Set; + +@RestController +@RequestMapping(path = "/redislettucefindhash") +public class RedisLettuceFindHashRest { + + private RedisClient redisClient; + private StatefulRedisConnection connection; + private RedisCommands sync; + + @PostConstruct + public void init() { + String redisHost = System.getProperty("spring.redis.host", "localhost"); + String redisPort = System.getProperty("spring.redis.port", "6379"); + String redisUri = "redis://" + redisHost + ":" + redisPort; + redisClient = RedisClient.create(redisUri); + connection = redisClient.connect(); + sync = connection.sync(); + } + + @PreDestroy + public void shutdown() { + connection.close(); + redisClient.shutdown(); + } + + @PostMapping("/hash/{key}/{field}") + public ResponseEntity saveHash(@PathVariable String key, @PathVariable String field) { + sync.hset(key, field, "value"); + return ResponseEntity.status(200).build(); + } + + @GetMapping("/findHash/{key}") + public ResponseEntity findHash(@PathVariable String key) { + String result = sync.hget(key, "field"); + if (result != null) { + return ResponseEntity.status(200).build(); + } else { + return ResponseEntity.status(404).build(); + } + } + +} + + diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/RedisLettuceApp.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findkey/RedisLettuceFindKeyApp.java similarity index 65% rename from core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/RedisLettuceApp.java rename to core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findkey/RedisLettuceFindKeyApp.java index 428beea34b..dff20195d0 100644 --- a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/RedisLettuceApp.java +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findkey/RedisLettuceFindKeyApp.java @@ -1,4 +1,4 @@ -package com.redis.lettuce; +package com.redis.lettuce.findkey; import com.redis.SwaggerConfiguration; import org.springframework.boot.SpringApplication; @@ -8,13 +8,13 @@ @EnableSwagger2 @SpringBootApplication(exclude = SecurityAutoConfiguration.class) -public class RedisLettuceApp extends SwaggerConfiguration { - public RedisLettuceApp() { - super("redislettuce"); +public class RedisLettuceFindKeyApp extends SwaggerConfiguration { + public RedisLettuceFindKeyApp() { + super("redislettucefindkey"); } public static void main(String[] args) { - SpringApplication.run(RedisLettuceApp.class, args); + SpringApplication.run(RedisLettuceFindKeyApp.class, args); } } diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/RedisLettuceController.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findkey/RedisLettuceFindKeyRest.java similarity index 90% rename from core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/RedisLettuceController.java rename to core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findkey/RedisLettuceFindKeyRest.java index cf7756fad8..fa723c7d67 100644 --- a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/RedisLettuceController.java +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findkey/RedisLettuceFindKeyRest.java @@ -1,4 +1,4 @@ -package com.redis.lettuce; +package com.redis.lettuce.findkey; import io.lettuce.core.api.sync.RedisCommands; import io.lettuce.core.api.StatefulRedisConnection; @@ -8,10 +8,12 @@ import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; +import java.util.List; +import java.util.Set; @RestController -@RequestMapping(path = "/redislettuce") -public class RedisLettuceController { +@RequestMapping(path = "/redislettucefindkey") +public class RedisLettuceFindKeyRest { private RedisClient redisClient; private StatefulRedisConnection connection; @@ -48,6 +50,7 @@ public ResponseEntity findKey(@PathVariable String key) { return ResponseEntity.status(404).build(); } } + } diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findpattern/RedisLettuceFindPatternApp.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findpattern/RedisLettuceFindPatternApp.java new file mode 100644 index 0000000000..96b1da131d --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findpattern/RedisLettuceFindPatternApp.java @@ -0,0 +1,20 @@ +package com.redis.lettuce.findpattern; + +import com.redis.SwaggerConfiguration; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration; +import springfox.documentation.swagger2.annotations.EnableSwagger2; + +@EnableSwagger2 +@SpringBootApplication(exclude = SecurityAutoConfiguration.class) +public class RedisLettuceFindPatternApp extends SwaggerConfiguration { + public RedisLettuceFindPatternApp() { + super("redislettucefindpattern"); + } + + public static void main(String[] args) { + SpringApplication.run(RedisLettuceFindPatternApp.class, args); + } + +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findpattern/RedisLettuceFindPatternRest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findpattern/RedisLettuceFindPatternRest.java new file mode 100644 index 0000000000..1c7d0fe0ae --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/findpattern/RedisLettuceFindPatternRest.java @@ -0,0 +1,57 @@ +package com.redis.lettuce.findpattern; + +import io.lettuce.core.RedisClient; +import io.lettuce.core.api.StatefulRedisConnection; +import io.lettuce.core.api.sync.RedisCommands; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.PostConstruct; +import javax.annotation.PreDestroy; +import java.util.List; +import java.util.Set; + +@RestController +@RequestMapping(path = "/redislettucefindpattern") +public class RedisLettuceFindPatternRest { + + private RedisClient redisClient; + private StatefulRedisConnection connection; + private RedisCommands sync; + + @PostConstruct + public void init() { + String redisHost = System.getProperty("spring.redis.host", "localhost"); + String redisPort = System.getProperty("spring.redis.port", "6379"); + String redisUri = "redis://" + redisHost + ":" + redisPort; + redisClient = RedisClient.create(redisUri); + connection = redisClient.connect(); + sync = connection.sync(); + } + + @PreDestroy + public void shutdown() { + connection.close(); + redisClient.shutdown(); + } + + @PostMapping("/string/{key}") + public ResponseEntity saveData(@PathVariable String key) { + sync.set(key, "value"); + return ResponseEntity.status(200).build(); + } + + @GetMapping("/findPattern") + public ResponseEntity findPattern() { + + List keys = sync.keys("som[3e]-key-?-*"); + if (keys != null && !keys.isEmpty()) { + return ResponseEntity.status(200).build(); + } else { + return ResponseEntity.status(404).build(); + } + } + +} + + diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setintersection/RedisLettuceSetIntersectionApp.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setintersection/RedisLettuceSetIntersectionApp.java new file mode 100644 index 0000000000..a72810af90 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setintersection/RedisLettuceSetIntersectionApp.java @@ -0,0 +1,20 @@ +package com.redis.lettuce.setintersection; + +import com.redis.SwaggerConfiguration; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration; +import springfox.documentation.swagger2.annotations.EnableSwagger2; + +@EnableSwagger2 +@SpringBootApplication(exclude = SecurityAutoConfiguration.class) +public class RedisLettuceSetIntersectionApp extends SwaggerConfiguration { + public RedisLettuceSetIntersectionApp() { + super("redislettucesetintersection"); + } + + public static void main(String[] args) { + SpringApplication.run(RedisLettuceSetIntersectionApp.class, args); + } + +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setintersection/RedisLettuceSetIntersectionRest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setintersection/RedisLettuceSetIntersectionRest.java new file mode 100644 index 0000000000..e3f43ba94e --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setintersection/RedisLettuceSetIntersectionRest.java @@ -0,0 +1,59 @@ +package com.redis.lettuce.setintersection; + +import io.lettuce.core.RedisClient; +import io.lettuce.core.api.StatefulRedisConnection; +import io.lettuce.core.api.sync.RedisCommands; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.PostConstruct; +import javax.annotation.PreDestroy; +import java.util.Set; + +@RestController +@RequestMapping(path = "/redislettucesetintersection") +public class RedisLettuceSetIntersectionRest { + + private RedisClient redisClient; + private StatefulRedisConnection connection; + private RedisCommands sync; + + @PostConstruct + public void init() { + String redisHost = System.getProperty("spring.redis.host", "localhost"); + String redisPort = System.getProperty("spring.redis.port", "6379"); + String redisUri = "redis://" + redisHost + ":" + redisPort; + redisClient = RedisClient.create(redisUri); + connection = redisClient.connect(); + sync = connection.sync(); + } + + @PreDestroy + public void shutdown() { + connection.close(); + redisClient.shutdown(); + } + + @PostMapping("/set/{key}/{member}") + public ResponseEntity saveSetMember(@PathVariable String key, @PathVariable String member) { + try{ + sync.sadd(key, member); + } catch (Exception e) { + return ResponseEntity.status(400).build(); + } + return ResponseEntity.status(200).build(); + } + + @GetMapping("/set/variable-intersection/{set1}/{set2}") + public ResponseEntity getIntersection(@PathVariable String set1, @PathVariable String set2) { + Set result = sync.sinter(set1, set2); + if (result != null && !result.isEmpty()) { + return ResponseEntity.status(200).build(); + } else { + return ResponseEntity.status(404).build(); + } + } + +} + + diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setmembers/RedisLettuceSetMembersApp.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setmembers/RedisLettuceSetMembersApp.java new file mode 100644 index 0000000000..3d9a0a3a24 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setmembers/RedisLettuceSetMembersApp.java @@ -0,0 +1,20 @@ +package com.redis.lettuce.setmembers; + +import com.redis.SwaggerConfiguration; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration; +import springfox.documentation.swagger2.annotations.EnableSwagger2; + +@EnableSwagger2 +@SpringBootApplication(exclude = SecurityAutoConfiguration.class) +public class RedisLettuceSetMembersApp extends SwaggerConfiguration { + public RedisLettuceSetMembersApp() { + super("redislettucesetmembers"); + } + + public static void main(String[] args) { + SpringApplication.run(RedisLettuceSetMembersApp.class, args); + } + +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setmembers/RedisLettuceSetMembersRest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setmembers/RedisLettuceSetMembersRest.java new file mode 100644 index 0000000000..e8f529dc93 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/main/java/com/redis/lettuce/setmembers/RedisLettuceSetMembersRest.java @@ -0,0 +1,59 @@ +package com.redis.lettuce.setmembers; + +import io.lettuce.core.RedisClient; +import io.lettuce.core.api.StatefulRedisConnection; +import io.lettuce.core.api.sync.RedisCommands; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.PostConstruct; +import javax.annotation.PreDestroy; +import java.util.Set; + +@RestController +@RequestMapping(path = "/redislettucesetmembers") +public class RedisLettuceSetMembersRest { + + private RedisClient redisClient; + private StatefulRedisConnection connection; + private RedisCommands sync; + + @PostConstruct + public void init() { + String redisHost = System.getProperty("spring.redis.host", "localhost"); + String redisPort = System.getProperty("spring.redis.port", "6379"); + String redisUri = "redis://" + redisHost + ":" + redisPort; + redisClient = RedisClient.create(redisUri); + connection = redisClient.connect(); + sync = connection.sync(); + } + + @PreDestroy + public void shutdown() { + connection.close(); + redisClient.shutdown(); + } + + @PostMapping("/set/{key}/{member}") + public ResponseEntity saveSetMember(@PathVariable String key, @PathVariable String member) { + try{ + sync.sadd(key, member); + } catch (Exception e) { + return ResponseEntity.status(400).build(); + } + return ResponseEntity.status(200).build(); + } + + @GetMapping("/set/members/{key}") + public ResponseEntity getMembers(@PathVariable String key) { + Set result = sync.smembers(key); + if (result != null && !result.isEmpty()) { + return ResponseEntity.status(200).build(); + } else { + return ResponseEntity.status(404).build(); + } + } + +} + + diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/RedisLettuceAppController.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/RedisLettuceAppController.java deleted file mode 100644 index 4e9134ce4f..0000000000 --- a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/RedisLettuceAppController.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.foo.spring.rest.redis.lettuce; - -import com.foo.spring.rest.redis.RedisController; -import com.redis.lettuce.RedisLettuceApp; - -public class RedisLettuceAppController extends RedisController { - public RedisLettuceAppController() { - super("lettuce", RedisLettuceApp.class); - } - - @Override - public String getPackagePrefixesToCover() { - return "com.redis.lettuce"; - } -} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findhash/RedisLettuceFindHashController.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findhash/RedisLettuceFindHashController.java new file mode 100644 index 0000000000..0dd5223b2b --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findhash/RedisLettuceFindHashController.java @@ -0,0 +1,15 @@ +package com.foo.spring.rest.redis.lettuce.findhash; + +import com.foo.spring.rest.redis.RedisController; +import com.redis.lettuce.findhash.RedisLettuceFindHashApp; + +public class RedisLettuceFindHashController extends RedisController { + public RedisLettuceFindHashController() { + super("lettuce", RedisLettuceFindHashApp.class); + } + + @Override + public String getPackagePrefixesToCover() { + return "com.redis.lettuce.findhash"; + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findkey/RedisLettuceFindKeyController.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findkey/RedisLettuceFindKeyController.java new file mode 100644 index 0000000000..19473d0133 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findkey/RedisLettuceFindKeyController.java @@ -0,0 +1,15 @@ +package com.foo.spring.rest.redis.lettuce.findkey; + +import com.foo.spring.rest.redis.RedisController; +import com.redis.lettuce.findkey.RedisLettuceFindKeyApp; + +public class RedisLettuceFindKeyController extends RedisController { + public RedisLettuceFindKeyController() { + super("lettuce", RedisLettuceFindKeyApp.class); + } + + @Override + public String getPackagePrefixesToCover() { + return "com.redis.lettuce.findkey"; + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findpattern/RedisLettuceFindPatternController.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findpattern/RedisLettuceFindPatternController.java new file mode 100644 index 0000000000..eb74279dca --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/findpattern/RedisLettuceFindPatternController.java @@ -0,0 +1,15 @@ +package com.foo.spring.rest.redis.lettuce.findpattern; + +import com.foo.spring.rest.redis.RedisController; +import com.redis.lettuce.findpattern.RedisLettuceFindPatternApp; + +public class RedisLettuceFindPatternController extends RedisController { + public RedisLettuceFindPatternController() { + super("lettuce", RedisLettuceFindPatternApp.class); + } + + @Override + public String getPackagePrefixesToCover() { + return "com.redis.lettuce.findpattern"; + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/setintersection/RedisLettuceSetIntersectionController.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/setintersection/RedisLettuceSetIntersectionController.java new file mode 100644 index 0000000000..95f012073c --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/setintersection/RedisLettuceSetIntersectionController.java @@ -0,0 +1,15 @@ +package com.foo.spring.rest.redis.lettuce.setintersection; + +import com.foo.spring.rest.redis.RedisController; +import com.redis.lettuce.setintersection.RedisLettuceSetIntersectionApp; + +public class RedisLettuceSetIntersectionController extends RedisController { + public RedisLettuceSetIntersectionController() { + super("lettuce", RedisLettuceSetIntersectionApp.class); + } + + @Override + public String getPackagePrefixesToCover() { + return "com.redis.lettuce.setintersection"; + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/setmembers/RedisLettuceSetMembersController.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/setmembers/RedisLettuceSetMembersController.java new file mode 100644 index 0000000000..18c058ca8c --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/com/foo/spring/rest/redis/lettuce/setmembers/RedisLettuceSetMembersController.java @@ -0,0 +1,15 @@ +package com.foo.spring.rest.redis.lettuce.setmembers; + +import com.foo.spring.rest.redis.RedisController; +import com.redis.lettuce.setmembers.RedisLettuceSetMembersApp; + +public class RedisLettuceSetMembersController extends RedisController { + public RedisLettuceSetMembersController() { + super("lettuce", RedisLettuceSetMembersApp.class); + } + + @Override + public String getPackagePrefixesToCover() { + return "com.redis.lettuce.setmembers"; + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/RedisControllerTest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/RedisControllerTest.java index 78dd8a04cb..9f62093749 100644 --- a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/RedisControllerTest.java +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/RedisControllerTest.java @@ -1,14 +1,14 @@ package org.evomaster.e2etests.spring.rest.redis; import com.foo.spring.rest.redis.RedisController; -import com.foo.spring.rest.redis.lettuce.RedisLettuceAppController; +import com.foo.spring.rest.redis.lettuce.findkey.RedisLettuceFindKeyController; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertTrue; public class RedisControllerTest { @Test public void testCanStartSut() { - RedisController controller = new RedisLettuceAppController(); + RedisController controller = new RedisLettuceFindKeyController(); controller.startSut(); assertTrue(controller.isSutRunning()); } diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findhash/RedisLettuceFindHashEMTest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findhash/RedisLettuceFindHashEMTest.java new file mode 100644 index 0000000000..0d8f6ebe18 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findhash/RedisLettuceFindHashEMTest.java @@ -0,0 +1,46 @@ +package org.evomaster.e2etests.spring.rest.redis.lettuce.findhash; + +import com.foo.spring.rest.redis.lettuce.findhash.RedisLettuceFindHashController; +import org.evomaster.core.EMConfig; +import org.evomaster.core.problem.rest.data.HttpVerb; +import org.evomaster.core.problem.rest.data.RestIndividual; +import org.evomaster.core.search.Solution; +import org.evomaster.e2etests.utils.RestTestBase; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; + +public class RedisLettuceFindHashEMTest extends RestTestBase { + + @BeforeAll + public static void initClass() throws Exception { + + EMConfig config = new EMConfig(); + config.setInstrumentMR_REDIS(true); + RestTestBase.initClass(new RedisLettuceFindHashController(), config); + } + + @Test + public void testFindHashEM() throws Throwable { + + runTestHandlingFlakyAndCompilation( + "RedisLettuceFindHashEM", + "org.foo.spring.rest.redis.RedisLettuceFindHashEM", + 1000, + true, + (args) -> { + setOption(args, "heuristicsForRedis", "true"); + setOption(args, "instrumentMR_REDIS", "true"); + + Solution solution = initAndRun(args); + + assertFalse(solution.getIndividuals().isEmpty()); + assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/redislettucefindhash/hash/{key}/{field}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 200, "/redislettucefindhash/findHash/{key}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 404, "/redislettucefindhash/findHash/{key}", null); + }, + 3); + + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/RedisLettuceEMTest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findkey/RedisLettuceFindKeyEMTest.java similarity index 66% rename from core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/RedisLettuceEMTest.java rename to core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findkey/RedisLettuceFindKeyEMTest.java index 257467fd75..0b74df6406 100644 --- a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/RedisLettuceEMTest.java +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findkey/RedisLettuceFindKeyEMTest.java @@ -1,6 +1,6 @@ -package org.evomaster.e2etests.spring.rest.redis.lettuce; +package org.evomaster.e2etests.spring.rest.redis.lettuce.findkey; -import com.foo.spring.rest.redis.lettuce.RedisLettuceAppController; +import com.foo.spring.rest.redis.lettuce.findkey.RedisLettuceFindKeyController; import org.evomaster.core.EMConfig; import org.evomaster.core.problem.rest.data.HttpVerb; import org.evomaster.core.problem.rest.data.RestIndividual; @@ -11,22 +11,22 @@ import static org.junit.jupiter.api.Assertions.*; -public class RedisLettuceEMTest extends RestTestBase { +public class RedisLettuceFindKeyEMTest extends RestTestBase { @BeforeAll public static void initClass() throws Exception { EMConfig config = new EMConfig(); config.setInstrumentMR_REDIS(true); - RestTestBase.initClass(new RedisLettuceAppController(), config); + RestTestBase.initClass(new RedisLettuceFindKeyController(), config); } @Test - public void testRunEM() throws Throwable { + public void testFindKeyEM() throws Throwable { runTestHandlingFlakyAndCompilation( - "RedisLettuceEM", - "org.foo.spring.rest.redis.RedisLettuceEM", + "RedisLettuceFindKeyEM", + "org.foo.spring.rest.redis.RedisLettuceFindKeyEM", 1000, true, (args) -> { @@ -36,9 +36,9 @@ public void testRunEM() throws Throwable { Solution solution = initAndRun(args); assertFalse(solution.getIndividuals().isEmpty()); - assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/redislettuce/string/{key}", null); - assertHasAtLeastOne(solution, HttpVerb.GET, 200, "/redislettuce/findKey/{key}", null); - assertHasAtLeastOne(solution, HttpVerb.GET, 404, "/redislettuce/findKey/{key}", null); + assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/redislettucefindkey/string/{key}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 200, "/redislettucefindkey/findKey/{key}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 404, "/redislettucefindkey/findKey/{key}", null); }, 3); diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findpattern/RedisLettuceFindPatternEMTest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findpattern/RedisLettuceFindPatternEMTest.java new file mode 100644 index 0000000000..4f7da484b8 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/findpattern/RedisLettuceFindPatternEMTest.java @@ -0,0 +1,46 @@ +package org.evomaster.e2etests.spring.rest.redis.lettuce.findpattern; + +import com.foo.spring.rest.redis.lettuce.findpattern.RedisLettuceFindPatternController; +import org.evomaster.core.EMConfig; +import org.evomaster.core.problem.rest.data.HttpVerb; +import org.evomaster.core.problem.rest.data.RestIndividual; +import org.evomaster.core.search.Solution; +import org.evomaster.e2etests.utils.RestTestBase; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; + +public class RedisLettuceFindPatternEMTest extends RestTestBase { + + @BeforeAll + public static void initClass() throws Exception { + + EMConfig config = new EMConfig(); + config.setInstrumentMR_REDIS(true); + RestTestBase.initClass(new RedisLettuceFindPatternController(), config); + } + + @Test + public void testFindPatternEM() throws Throwable { + + runTestHandlingFlakyAndCompilation( + "RedisLettuceFindPatternEM", + "org.foo.spring.rest.redis.RedisLettuceFindPatternEM", + 1000, + true, + (args) -> { + setOption(args, "heuristicsForRedis", "true"); + setOption(args, "instrumentMR_REDIS", "true"); + + Solution solution = initAndRun(args); + + assertFalse(solution.getIndividuals().isEmpty()); + assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/redislettucefindpattern/string/{key}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 200, "/redislettucefindpattern/findPattern", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 404, "/redislettucefindpattern/findPattern", null); + }, + 3); + + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/setintersection/RedisLettuceSetIntersectionEMTest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/setintersection/RedisLettuceSetIntersectionEMTest.java new file mode 100644 index 0000000000..64dee7c74b --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/setintersection/RedisLettuceSetIntersectionEMTest.java @@ -0,0 +1,47 @@ +package org.evomaster.e2etests.spring.rest.redis.lettuce.setintersection; + +import com.foo.spring.rest.redis.lettuce.setintersection.RedisLettuceSetIntersectionController; +import org.evomaster.core.EMConfig; +import org.evomaster.core.problem.rest.data.HttpVerb; +import org.evomaster.core.problem.rest.data.RestIndividual; +import org.evomaster.core.search.Solution; +import org.evomaster.e2etests.utils.RestTestBase; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; + +public class RedisLettuceSetIntersectionEMTest extends RestTestBase { + + @BeforeAll + public static void initClass() throws Exception { + + EMConfig config = new EMConfig(); + config.setInstrumentMR_REDIS(true); + RestTestBase.initClass(new RedisLettuceSetIntersectionController(), config); + } + + @Test + public void testSetIntersectionEM() throws Throwable { + + runTestHandlingFlakyAndCompilation( + "RedisLettuceSetIntersectionEM", + "org.foo.spring.rest.redis.RedisLettuceSetIntersectionEM", + 2000, + true, + (args) -> { + setOption(args, "heuristicsForRedis", "true"); + setOption(args, "instrumentMR_REDIS", "true"); + + Solution solution = initAndRun(args); + + assertFalse(solution.getIndividuals().isEmpty()); + assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/redislettucesetintersection/set/{key}/{member}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 200, "/redislettucesetintersection/set/variable-intersection/{set1}/{set2}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 404, "/redislettucesetintersection/set/variable-intersection/{set1}/{set2}", null); + + }, + 6); + + } +} diff --git a/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/setmembers/RedisLettuceSetMembersEMTest.java b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/setmembers/RedisLettuceSetMembersEMTest.java new file mode 100644 index 0000000000..c1f5878fd8 --- /dev/null +++ b/core-tests/e2e-tests/spring/spring-rest-redis/src/test/java/org/evomaster/e2etests/spring/rest/redis/lettuce/setmembers/RedisLettuceSetMembersEMTest.java @@ -0,0 +1,47 @@ +package org.evomaster.e2etests.spring.rest.redis.lettuce.setmembers; + +import com.foo.spring.rest.redis.lettuce.setmembers.RedisLettuceSetMembersController; +import org.evomaster.core.EMConfig; +import org.evomaster.core.problem.rest.data.HttpVerb; +import org.evomaster.core.problem.rest.data.RestIndividual; +import org.evomaster.core.search.Solution; +import org.evomaster.e2etests.utils.RestTestBase; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; + +public class RedisLettuceSetMembersEMTest extends RestTestBase { + + @BeforeAll + public static void initClass() throws Exception { + + EMConfig config = new EMConfig(); + config.setInstrumentMR_REDIS(true); + RestTestBase.initClass(new RedisLettuceSetMembersController(), config); + } + + @Test + public void testSetMembersEM() throws Throwable { + + runTestHandlingFlakyAndCompilation( + "RedisLettuceSetMembersEM", + "org.foo.spring.rest.redis.RedisLettuceSetMembersEM", + 1000, + true, + (args) -> { + setOption(args, "heuristicsForRedis", "true"); + setOption(args, "instrumentMR_REDIS", "true"); + + Solution solution = initAndRun(args); + + assertFalse(solution.getIndividuals().isEmpty()); + assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/redislettucesetmembers/set/{key}/{member}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 200, "/redislettucesetmembers/set/members/{key}", null); + assertHasAtLeastOne(solution, HttpVerb.GET, 404, "/redislettucesetmembers/set/members/{key}", null); + + }, + 3); + + } +}