several tests with the same name SONAR-6255

several tests can have the same name. a uuid is introduced to have an identifier for the test.
coverage details are aggregated for all the tests with the same name.

2 files changed, 202 insertions, 95 deletions

diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java
index 9ff1a514184..8be0e1c5d2e 100644
--- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java
+++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java
@@ -20,16 +20,22 @@
 
 package org.sonar.server.computation.step;
 
+import com.google.common.base.Joiner;
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.CacheLoader;
 import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.HashBasedTable;
 import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Table;
 import org.apache.ibatis.session.ResultContext;
 import org.apache.ibatis.session.ResultHandler;
 import org.sonar.api.resources.Qualifiers;
 import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.Uuids;
+import org.sonar.api.utils.log.Logger;
+import org.sonar.api.utils.log.Loggers;
 import org.sonar.batch.protocol.output.BatchReport;
 import org.sonar.batch.protocol.output.BatchReportReader;
 import org.sonar.core.persistence.DbSession;
@@ -41,17 +47,20 @@ import org.sonar.server.computation.source.ReportIterator;
 import org.sonar.server.db.DbClient;
 import org.sonar.server.source.db.FileSourceDb;
 
-import javax.annotation.CheckForNull;
-
 import java.io.File;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ExecutionException;
 
 public class PersistTestsStep implements ComputationStep {
 
+  private static final Logger LOG = Loggers.get(PersistTestsStep.class);
+
   private final DbClient dbClient;
   private final System2 system;
 
@@ -74,6 +83,9 @@ public class PersistTestsStep implements ComputationStep {
 
       recursivelyProcessComponent(context, rootComponentRef);
       session.commit();
+      if (context.hasUnprocessedCoverageDetails) {
+        LOG.warn("Some coverage tests are not taken into account during analysis of project '{}'", computationContext.getProject().getKey());
+      }
     } finally {
       MyBatis.closeQuietly(session);
     }
@@ -82,7 +94,7 @@ public class PersistTestsStep implements ComputationStep {
   private void recursivelyProcessComponent(TestContext context, int componentRef) {
     BatchReportReader reportReader = context.reader;
     BatchReport.Component component = reportReader.readComponent(componentRef);
-    if (component.getIsTest() && reportReader.readTests(componentRef) != null) {
+    if (component.getIsTest()) {
       persistTestResults(component, context);
     }
 
@@ -92,8 +104,16 @@ public class PersistTestsStep implements ComputationStep {
   }
 
   private void persistTestResults(BatchReport.Component component, TestContext context) {
-    ListMultimap<String, FileSourceDb.Test.CoveredFile> coveredFilesByName = loadCoverageDetails(component.getRef(), context);
-    List<FileSourceDb.Test> tests = buildDbTests(component, context, coveredFilesByName);
+    Multimap<String, FileSourceDb.Test.Builder> testsByName = buildDbTests(context, component);
+    Table<String, String, FileSourceDb.Test.CoveredFile.Builder> coveredFilesByName = loadCoverageDetails(component.getRef(), context);
+    List<FileSourceDb.Test> tests = addCoveredFilesToTests(testsByName, coveredFilesByName);
+    if (checkIfThereAreUnprocessedCoverageDetails(testsByName, coveredFilesByName, component)) {
+      context.hasUnprocessedCoverageDetails = true;
+    }
+
+    if (tests.isEmpty()) {
+      return;
+    }
 
     FileSourceDto existingDto = context.existingFileSourcesByUuid.get(component.getUuid());
     long now = system.now();
@@ -116,53 +136,102 @@ public class PersistTestsStep implements ComputationStep {
     }
   }
 
-  private List<FileSourceDb.Test> buildDbTests(BatchReport.Component component, TestContext context, ListMultimap<String, FileSourceDb.Test.CoveredFile> coveredFilesByName) {
+  private boolean checkIfThereAreUnprocessedCoverageDetails(Multimap<String, FileSourceDb.Test.Builder> testsByName,
+    Table<String, String, FileSourceDb.Test.CoveredFile.Builder> coveredFilesByName,
+    BatchReport.Component component) {
+    Set<String> unprocessedCoverageDetailNames = new HashSet<>(coveredFilesByName.rowKeySet());
+    unprocessedCoverageDetailNames.removeAll(testsByName.keySet());
+    boolean hasUnprocessedCoverageDetails = !unprocessedCoverageDetailNames.isEmpty();
+    if (hasUnprocessedCoverageDetails) {
+      LOG.trace("The following test coverages for file '{}' have not been taken into account: {}", component.getPath(), Joiner.on(", ").join(unprocessedCoverageDetailNames));
+    }
+    return hasUnprocessedCoverageDetails;
+  }
+
+  private List<FileSourceDb.Test> addCoveredFilesToTests(Multimap<String, FileSourceDb.Test.Builder> testsByName,
+    Table<String, String, FileSourceDb.Test.CoveredFile.Builder> coveredFilesByName) {
     List<FileSourceDb.Test> tests = new ArrayList<>();
-    ReportIterator<BatchReport.Test> testIterator = new ReportIterator<>(context.reader.readTests(component.getRef()), BatchReport.Test.PARSER);
-    while (testIterator.hasNext()) {
-      BatchReport.Test batchTest = testIterator.next();
-      FileSourceDb.Test.Builder dbTest = FileSourceDb.Test.newBuilder();
-      dbTest.setType(batchTest.getType());
-      dbTest.setName(batchTest.getName());
-      if (batchTest.hasStacktrace()) {
-        dbTest.setStacktrace(batchTest.getStacktrace());
-      }
-      if (batchTest.hasStatus()) {
-        dbTest.setStatus(batchTest.getStatus());
-      }
-      if (batchTest.hasMsg()) {
-        dbTest.setMsg(batchTest.getMsg());
-      }
-      if (batchTest.hasExecutionTimeMs()) {
-        dbTest.setExecutionTimeMs(batchTest.getExecutionTimeMs());
+    for (FileSourceDb.Test.Builder test : testsByName.values()) {
+      Collection<FileSourceDb.Test.CoveredFile.Builder> coveredFiles = coveredFilesByName.row(test.getName()).values();
+      if (!coveredFiles.isEmpty()) {
+        for (FileSourceDb.Test.CoveredFile.Builder coveredFile : coveredFiles) {
+          test.addCoveredFile(coveredFile);
+        }
       }
-      List<FileSourceDb.Test.CoveredFile> coveredFiles = coveredFilesByName == null ? null : coveredFilesByName.get(batchTest.getName());
-      if (coveredFiles != null) {
-        dbTest.addAllCoveredFile(coveredFiles);
+      tests.add(test.build());
+    }
+
+    return tests;
+  }
+
+  private Multimap<String, FileSourceDb.Test.Builder> buildDbTests(TestContext context, BatchReport.Component component) {
+    Multimap<String, FileSourceDb.Test.Builder> tests = ArrayListMultimap.create();
+    File testsFile = context.reader.readTests(component.getRef());
+    if (testsFile == null) {
+      return tests;
+    }
+    ReportIterator<BatchReport.Test> testIterator = new ReportIterator<>(testsFile, BatchReport.Test.PARSER);
+    try {
+      while (testIterator.hasNext()) {
+        BatchReport.Test batchTest = testIterator.next();
+        FileSourceDb.Test.Builder dbTest = FileSourceDb.Test.newBuilder();
+        dbTest.setUuid(Uuids.create());
+        dbTest.setName(batchTest.getName());
+        if (batchTest.hasStacktrace()) {
+          dbTest.setStacktrace(batchTest.getStacktrace());
+        }
+        if (batchTest.hasStatus()) {
+          dbTest.setStatus(batchTest.getStatus());
+        }
+        if (batchTest.hasMsg()) {
+          dbTest.setMsg(batchTest.getMsg());
+        }
+        if (batchTest.hasDurationInMs()) {
+          dbTest.setExecutionTimeMs(batchTest.getDurationInMs());
+        }
+
+        tests.put(dbTest.getName(), dbTest);
       }
-      tests.add(dbTest.build());
+    } finally {
+      testIterator.close();
     }
 
     return tests;
   }
 
-  @CheckForNull
-  private ListMultimap<String, FileSourceDb.Test.CoveredFile> loadCoverageDetails(int testFileRef, TestContext context) {
+  /**
+   * returns a Table of (test name, main file uuid, covered file)
+   */
+  private Table<String, String, FileSourceDb.Test.CoveredFile.Builder> loadCoverageDetails(int testFileRef, TestContext context) {
+    Table<String, String, FileSourceDb.Test.CoveredFile.Builder> nameToCoveredFiles = HashBasedTable.create();
     File coverageDetailsFile = context.reader.readCoverageDetails(testFileRef);
     if (coverageDetailsFile == null) {
-      return null;
+      return nameToCoveredFiles;
     }
 
-    ListMultimap<String, FileSourceDb.Test.CoveredFile> nameToCoveredFiles = ArrayListMultimap.create();
     ReportIterator<BatchReport.CoverageDetail> coverageIterator = new ReportIterator<>(coverageDetailsFile, BatchReport.CoverageDetail.PARSER);
-    while (coverageIterator.hasNext()) {
-      BatchReport.CoverageDetail batchCoverageDetail = coverageIterator.next();
-      for (BatchReport.CoverageDetail.CoveredFile batchCoveredFile : batchCoverageDetail.getCoveredFileList()) {
-        FileSourceDb.Test.CoveredFile.Builder dbCoveredFile = FileSourceDb.Test.CoveredFile.newBuilder()
-          .setFileUuid(context.getUuid(batchCoveredFile.getFileRef()))
-          .addAllCoveredLine(batchCoveredFile.getCoveredLineList());
-        nameToCoveredFiles.put(batchCoverageDetail.getTestName(), dbCoveredFile.build());
+    try {
+      while (coverageIterator.hasNext()) {
+        BatchReport.CoverageDetail batchCoverageDetail = coverageIterator.next();
+        for (BatchReport.CoverageDetail.CoveredFile batchCoveredFile : batchCoverageDetail.getCoveredFileList()) {
+          String testName = batchCoverageDetail.getTestName();
+          String mainFileUuid = context.getUuid(batchCoveredFile.getFileRef());
+          FileSourceDb.Test.CoveredFile.Builder existingDbCoveredFile = nameToCoveredFiles.get(testName, mainFileUuid);
+          List<Integer> batchCoveredLines = batchCoveredFile.getCoveredLineList();
+          if (existingDbCoveredFile == null) {
+            FileSourceDb.Test.CoveredFile.Builder dbCoveredFile = FileSourceDb.Test.CoveredFile.newBuilder()
+              .setFileUuid(context.getUuid(batchCoveredFile.getFileRef()))
+              .addAllCoveredLine(batchCoveredLines);
+            nameToCoveredFiles.put(testName, mainFileUuid, dbCoveredFile);
+          } else {
+            List<Integer> remainingBatchCoveredLines = new ArrayList<>(batchCoveredLines);
+            remainingBatchCoveredLines.removeAll(existingDbCoveredFile.getCoveredLineList());
+            existingDbCoveredFile.addAllCoveredLine(batchCoveredLines);
+          }
+        }
       }
+    } finally {
+      coverageIterator.close();
     }
     return nameToCoveredFiles;
   }
@@ -178,6 +247,7 @@ public class PersistTestsStep implements ComputationStep {
     final BatchReportReader reader;
     final Cache<Integer, String> componentRefToUuidCache;
     final Map<String, FileSourceDto> existingFileSourcesByUuid;
+    boolean hasUnprocessedCoverageDetails = false;
 
     TestContext(ComputationContext context, DbSession session) {
       this.session = session;
@@ -187,6 +257,7 @@ public class PersistTestsStep implements ComputationStep {
         .maximumSize(500_000)
         .build(
           new CacheLoader<Integer, String>() {
+            @Override
             public String load(Integer key) {
               return reader.readComponent(key).getUuid();
             }
@@ -207,7 +278,7 @@ public class PersistTestsStep implements ComputationStep {
       try {
         return componentRefToUuidCache.get(fileRef);
       } catch (ExecutionException e) {
-        throw new IllegalStateException(String.format("Error while retrieving uuid of component file ref '%d'", fileRef));
+        throw new IllegalStateException(String.format("Error while retrieving uuid of component file ref '%d'", fileRef), e);
       }
     }
   }
diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java
index 1d91b26da9e..474b5f44527 100644
--- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java
+++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java
@@ -27,9 +27,10 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.sonar.api.utils.System2;
+import org.sonar.api.utils.log.LogTester;
+import org.sonar.api.utils.log.LoggerLevel;
 import org.sonar.batch.protocol.Constants;
 import org.sonar.batch.protocol.Constants.TestStatus;
-import org.sonar.batch.protocol.Constants.TestType;
 import org.sonar.batch.protocol.output.BatchReport;
 import org.sonar.batch.protocol.output.BatchReport.CoverageDetail;
 import org.sonar.batch.protocol.output.BatchReportReader;
@@ -38,7 +39,6 @@ import org.sonar.core.persistence.DbSession;
 import org.sonar.core.persistence.DbTester;
 import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.source.db.FileSourceDto;
-import org.sonar.server.component.ComponentTesting;
 import org.sonar.server.computation.ComputationContext;
 import org.sonar.server.db.DbClient;
 import org.sonar.server.source.db.FileSourceDao;
@@ -50,8 +50,10 @@ import java.util.Arrays;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
+import static org.sonar.server.component.ComponentTesting.newProjectDto;
 
 public class PersistTestsStepTest extends BaseStepTest {
   private static final String PROJECT_UUID = "PROJECT";
@@ -63,6 +65,8 @@ public class PersistTestsStepTest extends BaseStepTest {
   private static final String TEST_FILE_UUID_2 = "TEST-FILE-2";
   private static final String MAIN_FILE_UUID_1 = "MAIN-FILE-1";
   private static final String MAIN_FILE_UUID_2 = "MAIN-FILE-2";
+  private static final String TEST_FILE_PATH_1 = "TEST-PATH-1";
+  private static final String TEST_FILE_PATH_2 = "TEST-PATH-2";
 
   PersistTestsStep sut;
 
@@ -72,6 +76,9 @@ public class PersistTestsStepTest extends BaseStepTest {
   @ClassRule
   public static DbTester db = new DbTester();
 
+  @Rule
+  public LogTester log = new LogTester();
+
   File reportDir;
   DbSession session;
   DbClient dbClient;
@@ -106,9 +113,10 @@ public class PersistTestsStepTest extends BaseStepTest {
 
   @Test
   public void no_test_in_database_and_batch_report() throws Exception {
-    sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+    sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto()));
 
     assertThat(dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1)).isNull();
+    assertThat(log.logs()).isEmpty();
   }
 
   @Test
@@ -120,10 +128,10 @@ public class PersistTestsStepTest extends BaseStepTest {
     writer.writeTests(TEST_FILE_REF_1, batchTests);
     List<CoverageDetail> coverageDetails = Arrays.asList(
       newCoverageDetail(1, MAIN_FILE_REF_1)
-      );
+    );
     writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails);
 
-    sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+    sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
 
     FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
     assertThat(dto.getCreatedAt()).isEqualTo(now);
@@ -132,29 +140,20 @@ public class PersistTestsStepTest extends BaseStepTest {
     assertThat(dto.getFileUuid()).isEqualTo(TEST_FILE_UUID_1);
     assertThat(dto.getTestData()).hasSize(2);
 
-    FileSourceDb.Test test1 = dto.getTestData().get(0);
-    assertThat(test1.getName()).isEqualTo("name#1");
-    assertThat(test1.getCoveredFileCount()).isEqualTo(1);
-    assertThat(test1.getCoveredFile(0).getFileUuid()).isEqualTo(MAIN_FILE_UUID_1);
+    assertThat(dto.getTestData()).extracting("name", "coveredFileCount").containsOnly(
+      tuple("name#1", 1),
+      tuple("name#2", 0));
 
-    FileSourceDb.Test test2 = dto.getTestData().get(1);
-    assertThat(test2.getName()).isEqualTo("name#2");
-    assertThat(test2.getCoveredFileList()).isEmpty();
+    assertThat(log.logs()).isEmpty();
   }
 
   @Test
   public void insert_all_data_of_a_test() throws Exception {
     BatchReportWriter writer = new BatchReportWriter(reportDir);
-    List<BatchReport.Test> batchTests = Arrays.asList(
-      newTest(1)
-    );
-    writer.writeTests(TEST_FILE_REF_1, batchTests);
-    List<CoverageDetail> coverageDetails = Arrays.asList(
-      newCoverageDetail(1, MAIN_FILE_REF_1)
-    );
-    writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails);
+    writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newTest(1)));
+    writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail(1, MAIN_FILE_REF_1)));
 
-    sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+    sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
 
     FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
     assertThat(dto.getCreatedAt()).isEqualTo(now);
@@ -164,99 +163,134 @@ public class PersistTestsStepTest extends BaseStepTest {
     assertThat(dto.getTestData()).hasSize(1);
 
     FileSourceDb.Test test1 = dto.getTestData().get(0);
+    assertThat(test1.getUuid()).isNotEmpty();
     assertThat(test1.getName()).isEqualTo("name#1");
     assertThat(test1.getMsg()).isEqualTo("message#1");
     assertThat(test1.getStacktrace()).isEqualTo("stacktrace#1");
     assertThat(test1.getStatus()).isEqualTo(TestStatus.FAILURE);
-    assertThat(test1.getType()).isEqualTo(TestType.UT);
     assertThat(test1.getExecutionTimeMs()).isEqualTo(1_000);
     assertThat(test1.getCoveredFileCount()).isEqualTo(1);
-    assertThat(test1.getCoveredFile(0).getCoveredLineList()).containsExactly(1, 2, 3);
+    assertThat(test1.getCoveredFile(0).getCoveredLineList()).containsOnly(1, 2, 3);
     assertThat(test1.getCoveredFile(0).getFileUuid()).isEqualTo(MAIN_FILE_UUID_1);
   }
 
   @Test
   public void insert_tests_without_coverage_details() throws Exception {
     BatchReportWriter writer = new BatchReportWriter(reportDir);
-    List<BatchReport.Test> batchTests = Arrays.asList(
-      newTest(1), newTest(2)
-      );
+    List<BatchReport.Test> batchTests = Arrays.asList(newTest(1), newTest(2));
     writer.writeTests(TEST_FILE_REF_1, batchTests);
 
-    sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+    sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
 
     FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
     assertThat(dto.getFileUuid()).isEqualTo(TEST_FILE_UUID_1);
     List<FileSourceDb.Test> tests = dto.getTestData();
     assertThat(tests).hasSize(2);
     assertThat(tests.get(0).getCoveredFileList()).isEmpty();
+    assertThat(tests.get(0).getMsg()).isEqualTo("message#1");
+    assertThat(tests.get(1).getCoveredFileList()).isEmpty();
+  }
+
+  @Test
+  public void insert_coverage_details_not_taken_into_account() throws Exception {
+    BatchReportWriter writer = new BatchReportWriter(reportDir);
+    List<BatchReport.Test> batchTests = Arrays.asList(newTest(1));
+    writer.writeTests(TEST_FILE_REF_1, batchTests);
+    List<CoverageDetail> coverageDetails = Arrays.asList(newCoverageDetail(1, MAIN_FILE_REF_1), newCoverageDetail(2, MAIN_FILE_REF_2));
+    writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails);
+    writer.writeCoverageDetails(TEST_FILE_REF_2, coverageDetails);
+
+    sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+
+    assertThat(log.logs(LoggerLevel.WARN)).hasSize(1);
+    assertThat(log.logs(LoggerLevel.WARN).get(0)).isEqualTo("Some coverage tests are not taken into account during analysis of project 'KEY_PROJECT'");
+    assertThat(log.logs(LoggerLevel.TRACE)).hasSize(2);
+    assertThat(log.logs(LoggerLevel.TRACE).get(0)).isEqualTo("The following test coverages for file 'TEST-PATH-1' have not been taken into account: name#2");
+    assertThat(log.logs(LoggerLevel.TRACE).get(1)).startsWith("The following test coverages for file 'TEST-PATH-2' have not been taken into account: ");
+    assertThat(log.logs(LoggerLevel.TRACE).get(1)).contains("name#1", "name#2");
   }
 
   @Test
-  public void update_one_test() throws Exception {
+  public void aggregate_coverage_details() throws Exception {
+    BatchReportWriter writer = new BatchReportWriter(reportDir);
+    writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newTest(1)));
+    writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(
+      newCoverageDetailWithLines(1, MAIN_FILE_REF_1, 1, 3),
+      newCoverageDetailWithLines(1, MAIN_FILE_REF_1, 2, 4)));
+
+    sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+
+    FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
+    List<Integer> coveredLines = dto.getTestData().get(0).getCoveredFile(0).getCoveredLineList();
+    assertThat(coveredLines).containsOnly(1, 2, 3, 4);
+  }
+
+  @Test
+  public void update_existing_test() throws Exception {
     // ARRANGE
     dbClient.fileSourceDao().insert(session, new FileSourceDto()
       .setProjectUuid(PROJECT_UUID)
       .setFileUuid(TEST_FILE_UUID_1)
-      .setTestData(Arrays.asList(newDbTest(1)))
+      .setTestData(Arrays.asList(FileSourceDb.Test.newBuilder()
+        .setUuid("test-uuid-1")
+        .setName("name#1")
+        .setStatus(TestStatus.ERROR)
+        .setStacktrace("old-stacktrace#1")
+        .setMsg("old-message#1")
+        .setExecutionTimeMs(987_654_321L)
+        .build()))
       .setCreatedAt(100_000)
       .setUpdatedAt(100_000));
     session.commit();
     assertThat(dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1)).isNotNull();
+
     BatchReportWriter writer = new BatchReportWriter(reportDir);
-    List<BatchReport.Test> batchTests = Arrays.asList(
-      newTest(1), newTest(2)
-      );
-    writer.writeTests(TEST_FILE_REF_1, batchTests);
-    List<CoverageDetail> coverageDetails = Arrays.asList(
-      newCoverageDetail(1, MAIN_FILE_REF_1)
-      );
-    writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails);
+    BatchReport.Test newBatchTest = newTest(1);
+    writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newBatchTest));
+
+    CoverageDetail newCoverageDetail = newCoverageDetail(1, MAIN_FILE_REF_1);
+    writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail));
 
     // ACT
-    sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+    sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
 
     // ASSERT
     FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
     assertThat(dto.getCreatedAt()).isEqualTo(100_000);
     assertThat(dto.getUpdatedAt()).isEqualTo(now);
-    assertThat(dto.getTestData()).hasSize(2);
+    assertThat(dto.getTestData()).hasSize(1);
 
     FileSourceDb.Test test = dto.getTestData().get(0);
+    assertThat(test.getUuid()).isNotEqualTo("test-uuid-1");
     assertThat(test.getName()).isEqualTo("name#1");
-    assertThat(test.getMsg()).isEqualTo("message#1");
+    assertThat(test.getStatus()).isEqualTo(newBatchTest.getStatus());
+    assertThat(test.getMsg()).isEqualTo(newBatchTest.getMsg());
+    assertThat(test.getStacktrace()).isEqualTo(newBatchTest.getStacktrace());
+    assertThat(test.getExecutionTimeMs()).isEqualTo(newBatchTest.getDurationInMs());
     assertThat(test.getCoveredFileCount()).isEqualTo(1);
-    assertThat(test.getCoveredFile(0).getCoveredLineList()).containsExactly(1, 2, 3);
+    assertThat(test.getCoveredFile(0).getCoveredLineList()).containsOnly(1, 2, 3);
     assertThat(test.getCoveredFile(0).getFileUuid()).isEqualTo(MAIN_FILE_UUID_1);
   }
 
-  private FileSourceDb.Test newDbTest(int id) {
-    return FileSourceDb.Test.newBuilder()
-      .setName("name#" + id)
-      .setType(TestType.IT)
-      .setStatus(TestStatus.ERROR)
-      .setStacktrace("old-stacktrace#" + id)
-      .setMsg("old-message#" + id)
-      .setExecutionTimeMs(123_456_789L)
-      .build();
-  }
-
   private BatchReport.Test newTest(int id) {
     return BatchReport.Test.newBuilder()
-      .setType(TestType.UT)
       .setStatus(TestStatus.FAILURE)
       .setName("name#" + id)
       .setStacktrace("stacktrace#" + id)
       .setMsg("message#" + id)
-      .setExecutionTimeMs(1_000)
+      .setDurationInMs(1_000)
       .build();
   }
 
   private BatchReport.CoverageDetail newCoverageDetail(int id, int covered_file_ref) {
+    return newCoverageDetailWithLines(id, covered_file_ref, 1, 2, 3);
+  }
+
+  private BatchReport.CoverageDetail newCoverageDetailWithLines(int id, int covered_file_ref, Integer... lines) {
     return CoverageDetail.newBuilder()
       .setTestName("name#" + id)
       .addCoveredFile(CoverageDetail.CoveredFile.newBuilder()
-        .addAllCoveredLine(Arrays.asList(1, 2, 3))
+        .addAllCoveredLine(Arrays.asList(lines))
         .setFileRef(covered_file_ref)
         .build()
       )
@@ -287,12 +321,14 @@ public class PersistTestsStepTest extends BaseStepTest {
       .setIsTest(true)
       .setType(Constants.ComponentType.FILE)
       .setUuid(TEST_FILE_UUID_1)
+      .setPath(TEST_FILE_PATH_1)
       .build());
     writer.writeComponent(BatchReport.Component.newBuilder()
       .setRef(TEST_FILE_REF_2)
       .setIsTest(true)
       .setType(Constants.ComponentType.FILE)
       .setUuid(TEST_FILE_UUID_2)
+      .setPath(TEST_FILE_PATH_2)
       .build());
     writer.writeComponent(BatchReport.Component.newBuilder()
       .setRef(MAIN_FILE_REF_1)