Add instrumentation of MappingCassandraEntityInformationClass

Author: gonzalotguerrero

client-java/instrumentation/pom.xml

@@ -67,6 +67,12 @@
             <version>${springboot.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-cassandra</artifactId>
+            <version>${springboot.version}</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>

client-java/instrumentation/src/main/java/org/evomaster/client/java/instrumentation/AdditionalInfo.java

@@ -118,6 +118,8 @@ public StatementDescription(String line, String method) {
 
     private final Set<MongoCollectionSchema> mongoCollectionSchemaData = new CopyOnWriteArraySet<>();
 
+    private final Set<CassandraTableSchema> cassandraTableSchemaData = new CopyOnWriteArraySet<>();
+
     public Set<ExecutedSqlCommand> getSqlInfoData(){
         return Collections.unmodifiableSet(executedSqlCommandData);
     }
@@ -150,6 +152,10 @@ public Set<MongoCollectionSchema> getMongoCollectionTypeData(){
         return Collections.unmodifiableSet(mongoCollectionSchemaData);
     }
 
+    public Set<CassandraTableSchema> getCassandraTableTypeData(){
+        return Collections.unmodifiableSet(cassandraTableSchemaData);
+    }
+
     public void addSqlInfo(ExecutedSqlCommand info){
         executedSqlCommandData.add(info);
     }
@@ -182,6 +188,10 @@ public void addMongoCollectionType(MongoCollectionSchema mongoCollectionSchema){
         mongoCollectionSchemaData.add(mongoCollectionSchema);
     }
 
+    public void addCassandraTableType(CassandraTableSchema cassandraTableSchema){
+        cassandraTableSchemaData.add(cassandraTableSchema);
+    }
+
     public Set<String> getParsedDtoNamesView(){
         return Collections.unmodifiableSet(parsedDtoNames);
     }

client-java/instrumentation/src/main/java/org/evomaster/client/java/instrumentation/CassandraTableSchema.java

@@ -0,0 +1,46 @@
+package org.evomaster.client.java.instrumentation;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * Schema of rows in a Cassandra table.
+ */
+public class CassandraTableSchema implements Serializable {
+    private final String tableName;
+    private final String tableSchema;
+
+    public CassandraTableSchema(String tableName, String tableSchema) {
+        this.tableName = tableName;
+        this.tableSchema = tableSchema;
+    }
+
+    public String getTableName() {
+        return tableName;
+    }
+
+    public String getTableSchema() {
+        return tableSchema;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        CassandraTableSchema that = (CassandraTableSchema) o;
+        return Objects.equals(tableName, that.tableName) && Objects.equals(tableSchema, that.tableSchema);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(tableName, tableSchema);
+    }
+
+    @Override
+    public String toString() {
+        return "CassandraTableSchema{" +
+                "tableName='" + tableName + '\'' +
+                ", tableSchema='" + tableSchema + '\'' +
+                '}';
+    }
+}

client-java/instrumentation/src/main/java/org/evomaster/client/java/instrumentation/coverage/methodreplacement/ReplacementList.java

@@ -54,6 +54,7 @@ public static List<MethodReplacementClass> getList() {
                     new LocalTimeClassReplacement(),
                     new LongClassReplacement(),
                     new MapClassReplacement(),
+                    new MappingCassandraEntityInformationClassReplacement(),
                     new MatcherClassReplacement(),
                     new MessageBodyReaderClassReplacement(),
                     new MethodClassReplacement(),

client-java/instrumentation/src/main/java/org/evomaster/client/java/instrumentation/coverage/methodreplacement/thirdpartyclasses/MappingCassandraEntityInformationClassReplacement.java

@@ -0,0 +1,82 @@
+package org.evomaster.client.java.instrumentation.coverage.methodreplacement.thirdpartyclasses;
+
+import org.evomaster.client.java.instrumentation.CassandraTableSchema;
+import org.evomaster.client.java.instrumentation.coverage.methodreplacement.Replacement;
+import org.evomaster.client.java.instrumentation.coverage.methodreplacement.ThirdPartyCast;
+import org.evomaster.client.java.instrumentation.coverage.methodreplacement.ThirdPartyMethodReplacementClass;
+import org.evomaster.client.java.instrumentation.object.ClassToSchema;
+import org.evomaster.client.java.instrumentation.shared.ReplacementCategory;
+import org.evomaster.client.java.instrumentation.shared.ReplacementType;
+import org.evomaster.client.java.instrumentation.staticstate.ExecutionTracer;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * When a Cassandra repository is created in Spring, a CqlSession is used under the hood.
+ * But information about the type of the repository's rows is not transferred to the session.
+ * That info is retained on Spring side.
+ * So the intention of this replacement is to retrieve that type info.
+ * This will allow us to create and insert rows of the correct type in the table (and the repository).
+ */
+public class MappingCassandraEntityInformationClassReplacement extends ThirdPartyMethodReplacementClass {
+    private static final MappingCassandraEntityInformationClassReplacement singleton = new MappingCassandraEntityInformationClassReplacement();
+    private static ThreadLocal<Object> instance = new ThreadLocal<>();
+
+    @Override
+    protected String getNameOfThirdPartyTargetClass() {
+        return "org.springframework.data.cassandra.repository.support.MappingCassandraEntityInformation";
+    }
+
+    public static Object consumeInstance() {
+        Object mappingCassandraEntityInformation = instance.get();
+        if (mappingCassandraEntityInformation == null) {
+            throw new IllegalStateException("No instance to consume");
+        }
+        instance.set(null);
+        return mappingCassandraEntityInformation;
+    }
+
+    private static void addInstance(Object x) {
+        Object mappingCassandraEntityInformation = instance.get();
+        if (mappingCassandraEntityInformation != null) {
+            throw new IllegalStateException("Previous instance was not consumed");
+        }
+        instance.set(x);
+    }
+
+    @Replacement(
+            replacingConstructor = true,
+            type = ReplacementType.TRACKER,
+            category = ReplacementCategory.CASSANDRA,
+            id = "constructorEntityConverter",
+            castTo = "org.springframework.data.cassandra.repository.support.MappingCassandraEntityInformation"
+    )
+    public static void MappingCassandraEntityInformation(
+            @ThirdPartyCast(actualType = "org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity") Object entity,
+            @ThirdPartyCast(actualType = "org.springframework.data.cassandra.core.convert.CassandraConverter") Object converter) {
+        handleMappingCassandraEntityInformationConstructor("constructorEntityConverter", Arrays.asList(entity, converter));
+    }
+
+    private static void handleMappingCassandraEntityInformationConstructor(String id, List<Object> args) {
+        Constructor original = getOriginalConstructor(singleton, id);
+
+        try {
+            Object mappingCassandraEntityInformation = original.newInstance(args.toArray());
+            addInstance(mappingCassandraEntityInformation);
+
+            Object tableNameId = mappingCassandraEntityInformation.getClass().getMethod("getTableName").invoke(mappingCassandraEntityInformation);
+            String tableName = (String) tableNameId.getClass().getMethod("asInternal").invoke(tableNameId);
+
+            Class<?> rowType = (Class<?>) mappingCassandraEntityInformation.getClass().getMethod("getJavaType").invoke(mappingCassandraEntityInformation);
+            String schema = ClassToSchema.getOrDeriveSchemaWithItsRef(rowType, true, Collections.emptyList());
+
+            ExecutionTracer.addCassandraTableType(new CassandraTableSchema(tableName, schema));
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

client-java/instrumentation/src/main/java/org/evomaster/client/java/instrumentation/staticstate/ExecutionTracer.java

@@ -478,6 +478,12 @@ public static void addMongoCollectionType(MongoCollectionSchema mongoCollectionS
         }
     }
 
+    public static void addCassandraTableType(CassandraTableSchema cassandraTableSchema){
+        if (!executingInitCassandra) {
+            getCurrentAdditionalInfo().addCassandraTableType(cassandraTableSchema);
+        }
+    }
+
 
     public static void markLastExecutedStatement(String lastLine, String lastMethod) {
         getCurrentAdditionalInfo().pushLastExecutedStatement(lastLine, lastMethod);

client-java/instrumentation/src/test/java/com/foo/somedifferentpackage/examples/methodreplacement/MappingCassandraEntityOperationsImpl.java

@@ -0,0 +1,13 @@
+package com.foo.somedifferentpackage.examples.methodreplacement;
+
+import org.evomaster.client.java.instrumentation.example.cassandra.MappingCassandraEntityOperations;
+import org.springframework.data.cassandra.core.convert.CassandraConverter;
+import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
+import org.springframework.data.cassandra.repository.support.MappingCassandraEntityInformation;
+
+public class MappingCassandraEntityOperationsImpl implements MappingCassandraEntityOperations {
+    @Override
+    public <T, ID> MappingCassandraEntityInformation<?, ?> callMappingCassandraEntityInformation(CassandraPersistentEntity<T> entity, CassandraConverter converter) {
+        return new MappingCassandraEntityInformation<>(entity, converter);
+    }
+}

client-java/instrumentation/src/test/java/org/evomaster/client/java/instrumentation/example/cassandra/MappingCassandraEntityInstrumentedTest.java

@@ -0,0 +1,60 @@
+package org.evomaster.client.java.instrumentation.example.cassandra;
+
+import com.datastax.oss.driver.api.core.CqlIdentifier;
+import com.foo.somedifferentpackage.examples.methodreplacement.MappingCassandraEntityOperationsImpl;
+import org.evomaster.client.java.instrumentation.InstrumentingClassLoader;
+import org.evomaster.client.java.instrumentation.staticstate.ExecutionTracer;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.data.cassandra.core.convert.CassandraConverter;
+import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
+import org.springframework.data.cassandra.repository.support.MappingCassandraEntityInformation;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+
+public class MappingCassandraEntityInstrumentedTest {
+
+    public static class SomeType {
+        public String someField;
+    }
+
+    protected MappingCassandraEntityOperations getInstance() throws Exception {
+
+        InstrumentingClassLoader cl = new InstrumentingClassLoader("com.foo");
+
+        return (MappingCassandraEntityOperations)
+                cl.loadClass(MappingCassandraEntityOperationsImpl.class.getName())
+                        .newInstance();
+    }
+
+    @BeforeEach
+    public void init(){
+        ExecutionTracer.reset();
+        assertEquals(0 , ExecutionTracer.getNumberOfObjectives());
+    }
+
+    @AfterEach
+    public void checkInstrumentation(){
+        assertTrue(ExecutionTracer.getNumberOfObjectives() > 0);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testConstructor() throws Exception {
+        MappingCassandraEntityOperations cassandraInstrumented = getInstance();
+
+        CassandraPersistentEntity<SomeType> entity = mock(CassandraPersistentEntity.class);
+        when(entity.getType()).thenReturn(SomeType.class);
+        when(entity.getTableName()).thenReturn(CqlIdentifier.fromCql("some_table"));
+
+        CassandraConverter converter = mock(CassandraConverter.class);
+
+        MappingCassandraEntityInformation<?, ?> mappingCassandraEntityInformation =
+                cassandraInstrumented.callMappingCassandraEntityInformation(entity, converter);
+        assertNotNull(mappingCassandraEntityInformation);
+    }
+}

client-java/instrumentation/src/test/java/org/evomaster/client/java/instrumentation/example/cassandra/MappingCassandraEntityOperations.java

@@ -0,0 +1,9 @@
+package org.evomaster.client.java.instrumentation.example.cassandra;
+
+import org.springframework.data.cassandra.core.convert.CassandraConverter;
+import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
+import org.springframework.data.cassandra.repository.support.MappingCassandraEntityInformation;
+
+public interface MappingCassandraEntityOperations {
+    <T, ID> MappingCassandraEntityInformation<?, ?> callMappingCassandraEntityInformation(CassandraPersistentEntity<T> entity, CassandraConverter converter);
+}