Redis data generation.

client-java/controller-api/src/main/java/org/evomaster/client/java/controller/api/ControllerConstants.java

@@ -30,6 +30,8 @@ public class ControllerConstants {
 
     public static final String MONGO_INSERTION = "/mongoInsertion";
 
+    public static final String REDIS_INSERTION = "/redisInsertion";
+
     public static final String POST_SEARCH_ACTION = "/postSearchAction";
 
     public static final String DERIVE_PARAMS = "/deriveParams";

client-java/controller-api/src/main/java/org/evomaster/client/java/controller/api/dto/ExtraHeuristicsDto.java

@@ -1,5 +1,6 @@
 package org.evomaster.client.java.controller.api.dto;
 
+import org.evomaster.client.java.controller.api.dto.database.execution.RedisExecutionsDto;
 import org.evomaster.client.java.controller.api.dto.database.execution.SqlExecutionsDto;
 import org.evomaster.client.java.controller.api.dto.database.execution.MongoExecutionsDto;
 import java.util.ArrayList;
@@ -21,4 +22,6 @@ public class ExtraHeuristicsDto {
     public SqlExecutionsDto sqlSqlExecutionsDto;
 
     public MongoExecutionsDto mongoExecutionsDto;
+
+    public RedisExecutionsDto redisExecutionsDto;
 }

client-java/controller-api/src/main/java/org/evomaster/client/java/controller/api/dto/database/execution/RedisExecutionsDto.java

@@ -0,0 +1,12 @@
+package org.evomaster.client.java.controller.api.dto.database.execution;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RedisExecutionsDto {
+
+    public RedisExecutionsDto() {}
+
+    public List<RedisFailedCommand> failedCommands = new ArrayList<>();
+}

client-java/controller-api/src/main/java/org/evomaster/client/java/controller/api/dto/database/execution/RedisFailedCommand.java

@@ -0,0 +1,19 @@
+package org.evomaster.client.java.controller.api.dto.database.execution;
+
+public class RedisFailedCommand {
+    public String command;
+    public String type;
+    public String key;
+
+    public RedisFailedCommand() {}
+
+    public RedisFailedCommand(String command, String key, String type) {
+        this.command = command;
+        this.key = key;
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+}

client-java/controller-api/src/main/java/org/evomaster/client/java/controller/api/dto/database/operations/RedisDatabaseCommandDto.java

@@ -0,0 +1,8 @@
+package org.evomaster.client.java.controller.api.dto.database.operations;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RedisDatabaseCommandDto {
+    public List<RedisInsertionDto> insertions = new ArrayList<>();
+}

client-java/controller-api/src/main/java/org/evomaster/client/java/controller/api/dto/database/operations/RedisInsertionDto.java

@@ -0,0 +1,13 @@
+package org.evomaster.client.java.controller.api.dto.database.operations;
+
+public class RedisInsertionDto {
+
+    /** The Redis key.*/
+    public String key;
+
+    /** The serialized value to set for that key. */
+    public String value;
+
+    /** Keyspace index, default 0. */
+    public int keyspace = 0;
+}

client-java/controller-api/src/main/java/org/evomaster/client/java/controller/api/dto/database/operations/RedisInsertionResultsDto.java

@@ -0,0 +1,10 @@
+package org.evomaster.client.java.controller.api.dto.database.operations;
+
+import java.util.List;
+
+public class RedisInsertionResultsDto {
+
+    public RedisInsertionResultsDto() {}
+
+    public List<Boolean> executionResults;
+}

client-java/controller/src/main/java/org/evomaster/client/java/controller/EmbeddedSutController.java

@@ -114,6 +114,11 @@ public final void setExecutingInitMongo(boolean executingInitMongo) {
         ExecutionTracer.setExecutingInitMongo(executingInitMongo);
     }
 
+    @Override
+    public final void setExecutingInitRedis(boolean executingInitRedis) {
+        ExecutionTracer.setExecutingInitRedis(executingInitRedis);
+    }
+
     @Override
     public final void setExecutingAction(boolean executingAction){
         ExecutionTracer.setExecutingAction(executingAction);

client-java/controller/src/main/java/org/evomaster/client/java/controller/ExternalSutController.java

@@ -522,6 +522,14 @@ public final void setExecutingInitMongo(boolean executingInitMongo) {
         ExecutionTracer.setExecutingInitMongo(executingInitMongo);
     }
 
+    @Override
+    public final void setExecutingInitRedis(boolean executingInitRedis) {
+        checkInstrumentation();
+        serverController.setExecutingInitMongo(executingInitRedis);
+        // sync executingInitMongo on the local ExecutionTracer
+        ExecutionTracer.setExecutingInitMongo(executingInitRedis);
+    }
+
     @Override
     public final void setExecutingAction(boolean executingAction){
         checkInstrumentation();

client-java/controller/src/main/java/org/evomaster/client/java/controller/SutHandler.java

@@ -1,9 +1,6 @@
 package org.evomaster.client.java.controller;
 
-import org.evomaster.client.java.controller.api.dto.database.operations.InsertionDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.InsertionResultsDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.MongoInsertionDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.MongoInsertionResultsDto;
+import org.evomaster.client.java.controller.api.dto.database.operations.*;
 import org.evomaster.client.java.controller.api.dto.problem.rpc.ScheduleTaskInvocationResultDto;
 import org.evomaster.client.java.controller.redis.ReflectionBasedRedisClient;
 import org.evomaster.client.java.sql.DbCleaner;
@@ -91,6 +88,8 @@ default void setupForGeneratedTest(){}
 
     MongoInsertionResultsDto execInsertionsIntoMongoDatabase(List<MongoInsertionDto> insertions);
 
+    RedisInsertionResultsDto execInsertionsIntoRedisDatabase(List<RedisInsertionDto> insertions);
+
     /**
      * <p>
      * return an instance of a client of an RPC service.

client-java/controller/src/main/java/org/evomaster/client/java/controller/internal/EMController.java

@@ -3,10 +3,7 @@
 import org.evomaster.client.java.controller.api.ControllerConstants;
 import org.evomaster.client.java.controller.api.Formats;
 import org.evomaster.client.java.controller.api.dto.*;
-import org.evomaster.client.java.controller.api.dto.database.operations.DatabaseCommandDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.InsertionResultsDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.MongoDatabaseCommandDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.MongoInsertionResultsDto;
+import org.evomaster.client.java.controller.api.dto.database.operations.*;
 import org.evomaster.client.java.controller.api.dto.problem.*;
 import org.evomaster.client.java.controller.api.dto.problem.param.DeriveParamResponseDto;
 import org.evomaster.client.java.controller.api.dto.problem.param.DerivedParamChangeReqDto;
@@ -15,6 +12,8 @@
 import org.evomaster.client.java.controller.api.dto.problem.rpc.ScheduleTaskInvocationsResult;
 import org.evomaster.client.java.controller.mongo.MongoScriptRunner;
 import org.evomaster.client.java.controller.problem.*;
+import org.evomaster.client.java.controller.redis.RedisCommandExecutor;
+import org.evomaster.client.java.controller.redis.ReflectionBasedRedisClient;
 import org.evomaster.client.java.sql.QueryResult;
 import org.evomaster.client.java.sql.SqlScriptRunner;
 import org.evomaster.client.java.controller.problem.rpc.schema.LocalAuthSetupSchema;
@@ -928,4 +927,57 @@ public Response executeMongoInsertion(MongoDatabaseCommandDto dto, @Context Http
             sutController.setExecutingInitMongo(false);
         }
     }
+
+    @Path(ControllerConstants.REDIS_INSERTION)
+    @Consumes(Formats.JSON_V1)
+    @POST
+    public Response executeRedisInsertion(
+            RedisDatabaseCommandDto dto,
+            @Context HttpServletRequest httpServletRequest) {
+
+        assert trackRequestSource(httpServletRequest);
+
+        try {
+            sutController.setExecutingInitRedis(true);
+
+            ReflectionBasedRedisClient connection =
+                    noKillSwitch(sutController::getRedisConnection);
+
+            if (connection == null) {
+                String msg = "No active Redis connection";
+                SimpleLogger.warn(msg);
+                return Response.status(400)
+                        .entity(WrappedResponseDto.withError(msg)).build();
+            }
+
+            if (dto.insertions == null || dto.insertions.isEmpty()) {
+                String msg = "No input command";
+                SimpleLogger.warn(msg);
+                return Response.status(400)
+                        .entity(WrappedResponseDto.withError(msg)).build();
+            }
+
+            RedisInsertionResultsDto redisResultsDto;
+            try {
+                redisResultsDto = RedisCommandExecutor.executeInsert(
+                        connection, dto.insertions);
+            } catch (Exception e) {
+                String msg = "Failed to execute Redis command: " + e.getMessage();
+                SimpleLogger.warn(msg);
+                return Response.status(400)
+                        .entity(WrappedResponseDto.withError(msg)).build();
+            }
+
+            return Response.status(200)
+                    .entity(WrappedResponseDto.withData(redisResultsDto)).build();
+
+        } catch (RuntimeException e) {
+            String msg = "Thrown exception: " + e.getMessage();
+            SimpleLogger.error(msg, e);
+            return Response.status(500)
+                    .entity(WrappedResponseDto.withError(msg)).build();
+        } finally {
+            sutController.setExecutingInitRedis(false);
+        }
+    }
 }

client-java/controller/src/main/java/org/evomaster/client/java/controller/internal/SutController.java

@@ -17,10 +17,7 @@
 import org.evomaster.client.java.controller.api.dto.constraint.ElementConstraintsDto;
 import org.evomaster.client.java.controller.api.dto.database.execution.SqlExecutionsDto;
 import org.evomaster.client.java.controller.api.dto.database.execution.SqlExecutionLogDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.InsertionDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.InsertionResultsDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.MongoInsertionDto;
-import org.evomaster.client.java.controller.api.dto.database.operations.MongoInsertionResultsDto;
+import org.evomaster.client.java.controller.api.dto.database.operations.*;
 import org.evomaster.client.java.controller.api.dto.database.schema.DbInfoDto;
 import org.evomaster.client.java.controller.api.dto.database.schema.ExtraConstraintsDto;
 import org.evomaster.client.java.controller.api.dto.MockDatabaseDto;
@@ -30,6 +27,7 @@
 import org.evomaster.client.java.controller.api.dto.problem.rpc.RPCTestDto;
 import org.evomaster.client.java.controller.internal.db.OpenSearchHandler;
 import org.evomaster.client.java.controller.internal.db.redis.RedisHandler;
+import org.evomaster.client.java.controller.redis.RedisCommandExecutor;
 import org.evomaster.client.java.controller.redis.ReflectionBasedRedisClient;
 import org.evomaster.client.java.sql.DbCleaner;
 import org.evomaster.client.java.sql.SqlScriptRunner;
@@ -299,6 +297,17 @@ public MongoInsertionResultsDto execInsertionsIntoMongoDatabase(List<MongoInsert
         }
     }
 
+    @Override
+    public RedisInsertionResultsDto execInsertionsIntoRedisDatabase(
+            List<RedisInsertionDto> insertions) {
+
+        ReflectionBasedRedisClient connection = getRedisConnection();
+        if (connection == null) {
+            throw new IllegalStateException("No connection to Redis");
+        }
+        return RedisCommandExecutor.executeInsert(connection, insertions);
+    }
+
     public int getActionIndex(){
         return actionIndex;
     }
@@ -379,6 +388,7 @@ public final boolean doEmploySmartDbClean(){
     public final void resetExtraHeuristics() {
         sqlHandler.reset();
         mongoHandler.reset();
+        redisHandler.reset();
     }
 
     /**
@@ -548,7 +558,7 @@ public final void computeOpenSearchHeuristics(ExtraHeuristicsDto dto, List<Addit
     }
 
     public final void computeRedisHeuristics(ExtraHeuristicsDto dto, List<AdditionalInfo> additionalInfoList){
-        if(redisHandler.isCalculateHeuristics()){
+        if (redisHandler.isCalculateHeuristics()) {
             if(!additionalInfoList.isEmpty()) {
                 AdditionalInfo last = additionalInfoList.get(additionalInfoList.size() - 1);
                 last.getRedisCommandData().forEach(it -> {
@@ -573,6 +583,10 @@ public final void computeRedisHeuristics(ExtraHeuristicsDto dto, List<Additional
                          ))
                     .forEach(h -> dto.heuristics.add(h));
         }
+
+        if (redisHandler.isExtractRedisExecution()) {
+            dto.redisExecutionsDto = redisHandler.getExecutionDto();
+        }
     }
 
     /**
@@ -1609,6 +1623,8 @@ public abstract List<TargetInfo> getTargetInfos(Collection<Integer> ids,
 
     public abstract void setExecutingInitMongo(boolean executingInitMongo);
 
+    public abstract void setExecutingInitRedis(boolean executingInitRedis);
+
     public abstract void setExecutingAction(boolean executingAction);
 
 

client-java/controller/src/main/java/org/evomaster/client/java/controller/internal/db/redis/RedisHandler.java

@@ -1,5 +1,7 @@
 package org.evomaster.client.java.controller.internal.db.redis;
 
+import org.evomaster.client.java.controller.api.dto.database.execution.RedisExecutionsDto;
+import org.evomaster.client.java.controller.api.dto.database.execution.RedisFailedCommand;
 import org.evomaster.client.java.controller.internal.TaintHandlerExecutionTracer;
 import org.evomaster.client.java.controller.redis.RedisKeyValueStore;
 import org.evomaster.client.java.controller.redis.ReflectionBasedRedisClient;
@@ -27,11 +29,21 @@ public class RedisHandler {
      */
     private final List<RedisCommandEvaluation> evaluatedRedisCommands = new ArrayList<>();
 
+    /**
+     * Commands that have a non-zero positive distance.
+     */
+    private final List<RedisFailedCommand> failedCommands = new ArrayList<>();
+
     /**
      * Whether to calculate heuristics based on execution or not
      */
     private volatile boolean calculateHeuristics;
 
+    /**
+     * Whether to use execution's info or not
+     */
+    private volatile boolean extractRedisExecution;
+
     /**
      * The client must be created given both host and port for Redis DB.
      */
@@ -46,13 +58,28 @@ public class RedisHandler {
     public RedisHandler() {
         operations = new ArrayList<>();
         calculateHeuristics = true;
+        extractRedisExecution = true;
     }
 
     public void reset() {
         operations.clear();
         evaluatedRedisCommands.clear();
     }
 
+    public boolean isExtractRedisExecution() {
+        return extractRedisExecution;
+    }
+
+    public void setExtractRedisExecution(boolean extractRedisExecution) {
+        this.extractRedisExecution = extractRedisExecution;
+    }
+
+    public RedisExecutionsDto getExecutionDto() {
+        RedisExecutionsDto dto = new RedisExecutionsDto();
+        dto.failedCommands.addAll(failedCommands);
+        return dto;
+    }
+
     public boolean isCalculateHeuristics() {
         return calculateHeuristics;
     }
@@ -71,12 +98,28 @@ public List<RedisCommandEvaluation> getEvaluatedRedisCommands() {
             .forEach(redisCommand -> {
                 RedisDistanceWithMetrics distanceWithMetrics = computeDistance(redisCommand, redisClient);
                 evaluatedRedisCommands.add(new RedisCommandEvaluation(redisCommand, distanceWithMetrics));
-        });
+                registerFailedCommand(redisCommand, distanceWithMetrics.getDistance());
+            });
         operations.clear();
 
         return evaluatedRedisCommands;
     }
 
+    private void registerFailedCommand(RedisCommand redisCommand, double distance) {
+        if (distance > 0 &&
+            redisCommand.getType().getLabel().equals("get")) {
+            //For this first iteration we'll only work on GET commands.
+            failedCommands.add(createFailedCommand(redisCommand));
+        }
+    }
+
+    private RedisFailedCommand createFailedCommand(RedisCommand redisCommand) {
+        return new RedisFailedCommand(
+                redisCommand.getType().getLabel().toUpperCase(),
+                redisCommand.extractArgs().get(0),
+                redisCommand.getType().getDataType());
+    }
+
     private RedisDistanceWithMetrics computeDistance(RedisCommand redisCommand, ReflectionBasedRedisClient redisClient) {
         RedisCommand.RedisCommandType type = redisCommand.getType();
         try {