*/
package org.sonar.db.source;
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.InvalidProtocolBufferException;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.io.IOUtils;
import org.sonar.db.protobuf.DbFileSources;
+import static com.google.common.base.Splitter.on;
import static java.lang.String.format;
public class FileSourceDto {
private static final String SIZE_LIMIT_EXCEEDED_EXCEPTION_MESSAGE = "Protocol message was too large. May be malicious. " +
"Use CodedInputStream.setSizeLimit() to increase the size limit.";
+ private static final Joiner LINE_RETURN_JOINER = Joiner.on('\n');
+ public static final Splitter LINES_HASHES_SPLITTER = on('\n');
+ public static final int LINE_COUNT_NOT_POPULATED = -1;
private Long id;
private String projectUuid;
private long createdAt;
private long updatedAt;
private String lineHashes;
+ /**
+ * When {@code line_count} column has been added, it's been populated with value {@link #LINE_COUNT_NOT_POPULATED -1},
+ * which implies all existing files sources have this value at the time SonarQube is upgraded.
+ * <p>
+ * Column {@code line_count} is populated with the correct value from every new files and for existing files as the
+ * project they belong to is analyzed for the first time after the migration.
+ * <p>
+ * Method {@link #getLineCount()} hides this migration-only-related complexity by either returning the value
+ * of column {@code line_count} when its been populated, or computed the returned value from the value of column
+ * {@code line_hashes}.
+ */
+ private int lineCount = LINE_COUNT_NOT_POPULATED;
private String srcHash;
- private byte[] binaryData;
+ private byte[] binaryData = new byte[0];
private String dataType;
private String dataHash;
private String revision;
return this;
}
- @CheckForNull
- public String getLineHashes() {
+ /** Used by MyBatis */
+ public String getRawLineHashes() {
return lineHashes;
}
- public FileSourceDto setLineHashes(@Nullable String lineHashes) {
+ public void setRawLineHashes(@Nullable String lineHashes) {
this.lineHashes = lineHashes;
+ }
+
+ public List<String> getLineHashes() {
+ if (lineHashes == null) {
+ return Collections.emptyList();
+ }
+ return LINES_HASHES_SPLITTER.splitToList(lineHashes);
+ }
+
+ /**
+ * @return the value of column {@code line_count} if populated, otherwise the size of {@link #getLineHashes()}.
+ */
+ public int getLineCount() {
+ if (lineCount == LINE_COUNT_NOT_POPULATED) {
+ return getLineHashes().size();
+ }
+ return lineCount;
+ }
+
+ public FileSourceDto setLineHashes(@Nullable List<String> lineHashes) {
+ if (lineHashes == null) {
+ this.lineHashes = null;
+ this.lineCount = 0;
+ } else if (lineHashes.isEmpty()) {
+ this.lineHashes = null;
+ this.lineCount = 1;
+ } else {
+ this.lineHashes = LINE_RETURN_JOINER.join(lineHashes);
+ this.lineCount = lineHashes.size();
+ }
return this;
}
<mapper namespace="org.sonar.db.source.FileSourceMapper">
<select id="select" parameterType="map" resultType="org.sonar.db.source.FileSourceDto">
- SELECT id, project_uuid as projectUuid, file_uuid as fileUuid, created_at as createdAt, updated_at as updatedAt,
- binary_data as binaryData, line_hashes as lineHashes, data_hash as dataHash, src_hash as srcHash, data_type as
- dataType, revision, line_hashes_version as lineHashesVersion
- FROM file_sources
- WHERE file_uuid = #{fileUuid} and data_type = #{dataType}
+ select
+ id,
+ project_uuid as projectUuid,
+ file_uuid as fileUuid,
+ created_at as createdAt,
+ updated_at as updatedAt,
+ binary_data as binaryData,
+ line_hashes as rawLineHashes,
+ line_hashes_version as lineHashesVersion,
+ line_count as lineCount,
+ data_hash as dataHash,
+ src_hash as srcHash,
+ data_type as
+ dataType,
+ revision
+ from
+ file_sources
+ where
+ file_uuid = #{fileUuid}
+ and data_type = #{dataType}
</select>
<select id="selectHashesForProject" parameterType="map" resultType="org.sonar.db.source.FileSourceDto">
</select>
<select id="selectLineHashesVersion" parameterType="map" resultType="Integer">
- SELECT line_hashes_version
+ SELECT line_hashes_version
FROM file_sources
WHERE file_uuid = #{fileUuid,jdbcType=VARCHAR} and data_type=#{dataType,jdbcType=VARCHAR}
</select>
<insert id="insert" parameterType="org.sonar.db.source.FileSourceDto" useGeneratedKeys="false">
- INSERT INTO file_sources (project_uuid, file_uuid, created_at, updated_at, binary_data, line_hashes, data_hash,
- src_hash, data_type, revision, line_hashes_version)
- VALUES (#{projectUuid,jdbcType=VARCHAR}, #{fileUuid,jdbcType=VARCHAR}, #{createdAt,jdbcType=BIGINT},
- #{updatedAt,jdbcType=BIGINT}, #{binaryData,jdbcType=BLOB}, #{lineHashes,jdbcType=CLOB},
- #{dataHash,jdbcType=VARCHAR}, #{srcHash,jdbcType=VARCHAR},#{dataType,jdbcType=VARCHAR},
- #{revision,jdbcType=VARCHAR}, #{lineHashesVersion,jdbcType=INTEGER})
+ insert into file_sources
+ (
+ project_uuid,
+ file_uuid,
+ created_at,
+ updated_at,
+ binary_data,
+ line_hashes,
+ line_hashes_version,
+ line_count,
+ data_hash,
+ src_hash,
+ data_type,
+ revision
+ )
+ values
+ (
+ #{projectUuid,jdbcType=VARCHAR},
+ #{fileUuid,jdbcType=VARCHAR},
+ #{createdAt,jdbcType=BIGINT},
+ #{updatedAt,jdbcType=BIGINT},
+ #{binaryData,jdbcType=BLOB},
+ #{rawLineHashes,jdbcType=CLOB},
+ #{lineHashesVersion,jdbcType=INTEGER},
+ #{lineCount,jdbcType=INTEGER},
+ #{dataHash,jdbcType=VARCHAR},
+ #{srcHash,jdbcType=VARCHAR},
+ #{dataType,jdbcType=VARCHAR},
+ #{revision,jdbcType=VARCHAR}
+ )
</insert>
<update id="update" parameterType="org.sonar.db.source.FileSourceDto" useGeneratedKeys="false">
- UPDATE file_sources SET
- updated_at = #{updatedAt,jdbcType=BIGINT},
- binary_data = #{binaryData,jdbcType=BLOB},
- line_hashes = #{lineHashes,jdbcType=CLOB},
- data_hash = #{dataHash,jdbcType=VARCHAR},
- src_hash = #{srcHash,jdbcType=VARCHAR},
- revision = #{revision,jdbcType=VARCHAR},
- line_hashes_version = #{lineHashesVersion,jdbcType=INTEGER}
- WHERE id = #{id}
+ update
+ file_sources
+ set
+ updated_at = #{updatedAt,jdbcType=BIGINT},
+ binary_data = #{binaryData,jdbcType=BLOB},
+ line_hashes = #{rawLineHashes,jdbcType=CLOB},
+ line_hashes_version = #{lineHashesVersion,jdbcType=INTEGER},
+ line_count = #{lineCount,jdbcType=INTEGER},
+ data_hash = #{dataHash,jdbcType=VARCHAR},
+ src_hash = #{srcHash,jdbcType=VARCHAR},
+ revision = #{revision,jdbcType=VARCHAR}
+ where
+ id = #{id}
</update>
</mapper>
*/
package org.sonar.db.source;
+import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.io.Reader;
import java.util.function.Consumer;
import org.sonar.db.DbTester;
import org.sonar.db.source.FileSourceDto.Type;
+import static com.google.common.collect.ImmutableList.of;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
@Test
public void insert() {
- dbTester.prepareDbUnit(getClass(), "shared.xml");
-
- underTest.insert(session, new FileSourceDto()
+ FileSourceDto expected = new FileSourceDto()
.setProjectUuid("PRJ_UUID")
.setFileUuid("FILE2_UUID")
.setBinaryData("FILE2_BINARY_DATA".getBytes())
.setDataHash("FILE2_DATA_HASH")
- .setLineHashes("LINE1_HASH\\nLINE2_HASH")
+ .setLineHashes(of("LINE1_HASH", "LINE2_HASH"))
.setSrcHash("FILE2_HASH")
.setDataType(Type.SOURCE)
.setCreatedAt(1500000000000L)
.setUpdatedAt(1500000000001L)
.setLineHashesVersion(1)
- .setRevision("123456789"));
+ .setRevision("123456789");
+ underTest.insert(session, expected);
+ session.commit();
+
+ FileSourceDto fileSourceDto = underTest.selectSourceByFileUuid(session, expected.getFileUuid());
+
+ assertThat(fileSourceDto.getProjectUuid()).isEqualTo(expected.getProjectUuid());
+ assertThat(fileSourceDto.getFileUuid()).isEqualTo(expected.getFileUuid());
+ assertThat(fileSourceDto.getBinaryData()).isEqualTo(expected.getBinaryData());
+ assertThat(fileSourceDto.getDataHash()).isEqualTo(expected.getDataHash());
+ assertThat(fileSourceDto.getRawLineHashes()).isEqualTo(expected.getRawLineHashes());
+ assertThat(fileSourceDto.getLineHashes()).isEqualTo(expected.getLineHashes());
+ assertThat(fileSourceDto.getLineCount()).isEqualTo(expected.getLineCount());
+ assertThat(fileSourceDto.getSrcHash()).isEqualTo(expected.getSrcHash());
+ assertThat(fileSourceDto.getCreatedAt()).isEqualTo(expected.getCreatedAt());
+ assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(expected.getUpdatedAt());
+ assertThat(fileSourceDto.getRevision()).isEqualTo(expected.getRevision());
+ }
+
+ @Test
+ public void insert_does_not_fail_on_FileSourceDto_with_only_non_nullable_data() {
+ FileSourceDto fileSourceDto = new FileSourceDto()
+ .setProjectUuid("Foo")
+ .setFileUuid("Bar")
+ .setCreatedAt(1500000000000L)
+ .setUpdatedAt(1500000000001L);
+ underTest.insert(session, fileSourceDto);
+ session.commit();
+ }
+
+ @Test
+ public void selectSourceByFileUuid_reads_source_without_line_hashes() {
+ FileSourceDto fileSourceDto = new FileSourceDto()
+ .setProjectUuid("Foo")
+ .setFileUuid("Bar")
+ .setDataType(Type.SOURCE)
+ .setCreatedAt(1500000000000L)
+ .setUpdatedAt(1500000000001L);
+ underTest.insert(session, fileSourceDto);
+ session.commit();
+
+ FileSourceDto res = underTest.selectSourceByFileUuid(session, fileSourceDto.getFileUuid());
+
+ assertThat(res.getLineCount()).isEqualTo(0);
+ assertThat(res.getLineHashes()).isEmpty();
+ }
+
+ @Test
+ public void selectTest_reads_test_without_line_hashes() {
+ FileSourceDto fileSourceDto = new FileSourceDto()
+ .setProjectUuid("Foo")
+ .setFileUuid("Bar")
+ .setDataType(Type.TEST)
+ .setCreatedAt(1500000000000L)
+ .setUpdatedAt(1500000000001L);
+ underTest.insert(session, fileSourceDto);
session.commit();
- dbTester.assertDbUnitTable(getClass(), "insert-result.xml", "file_sources",
- "project_uuid", "file_uuid", "data_hash", "line_hashes", "src_hash", "created_at", "updated_at", "data_type", "revision", "line_hashes_version");
+ FileSourceDto res = underTest.selectTestByFileUuid(session, fileSourceDto.getFileUuid());
+
+ assertThat(res.getLineCount()).isEqualTo(0);
+ assertThat(res.getLineHashes()).isEmpty();
}
@Test
.setFileUuid("FILE2_UUID")
.setBinaryData("FILE2_BINARY_DATA".getBytes())
.setDataHash("FILE2_DATA_HASH")
- .setLineHashes("hashes")
+ .setLineHashes(singletonList("hashes"))
.setSrcHash("FILE2_HASH")
.setDataType(Type.SOURCE)
.setCreatedAt(1500000000000L)
.setFileUuid("FILE2_UUID")
.setBinaryData("FILE2_BINARY_DATA".getBytes())
.setDataHash("FILE2_DATA_HASH")
- .setLineHashes("hashes")
+ .setLineHashes(singletonList("hashes"))
.setSrcHash("FILE2_HASH")
.setDataType(Type.SOURCE)
.setCreatedAt(1500000000000L)
.setBinaryData("updated data".getBytes())
.setDataHash("NEW_DATA_HASH")
.setSrcHash("NEW_FILE_HASH")
- .setLineHashes("NEW_LINE_HASHES")
+ .setLineHashes(singletonList("NEW_LINE_HASHES"))
.setDataType(Type.SOURCE)
.setUpdatedAt(1500000000002L)
.setLineHashesVersion(1)
"data_hash", "line_hashes", "src_hash", "created_at", "updated_at", "data_type", "revision", "line_hashes_version");
}
+ @Test
+ public void update_to_no_line_hashes() {
+ ImmutableList<String> lineHashes = of("a", "b", "c");
+ FileSourceDto fileSourceDto = new FileSourceDto()
+ .setProjectUuid("Foo")
+ .setFileUuid("Bar")
+ .setDataType(Type.SOURCE)
+ .setLineHashes(lineHashes)
+ .setCreatedAt(1500000000000L)
+ .setUpdatedAt(1500000000001L);
+ underTest.insert(session, fileSourceDto);
+ session.commit();
+
+ FileSourceDto resBefore = underTest.selectSourceByFileUuid(session, fileSourceDto.getFileUuid());
+ assertThat(resBefore.getLineCount()).isEqualTo(lineHashes.size());
+ assertThat(resBefore.getLineHashes()).isEqualTo(lineHashes);
+
+ fileSourceDto.setId(resBefore.getId());
+ fileSourceDto.setLineHashes(emptyList());
+ underTest.update(session, fileSourceDto);
+ session.commit();
+
+ FileSourceDto res = underTest.selectSourceByFileUuid(session, fileSourceDto.getFileUuid());
+ assertThat(res.getLineHashes()).isEmpty();
+ assertThat(res.getLineCount()).isEqualTo(1);
+ }
+
private static class ReaderToStringConsumer implements Consumer<Reader> {
String result = null;
*/
package org.sonar.db.source;
+import com.google.common.base.Joiner;
import java.util.Arrays;
+import java.util.Collections;
import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
}
return dataBuilder.build();
}
+
+ @Test
+ public void new_FileSourceDto_as_lineCount_0_and_rawLineHashes_to_null() {
+ FileSourceDto underTest = new FileSourceDto();
+
+ assertThat(underTest.getLineCount()).isZero();
+ assertThat(underTest.getLineHashes()).isEmpty();
+ assertThat(underTest.getRawLineHashes()).isNull();
+ }
+
+ @Test
+ public void setLineHashes_null_sets_lineCount_to_0_and_rawLineHashes_to_null() {
+ FileSourceDto underTest = new FileSourceDto();
+ underTest.setLineHashes(null);
+
+ assertThat(underTest.getLineCount()).isZero();
+ assertThat(underTest.getLineHashes()).isEmpty();
+ assertThat(underTest.getRawLineHashes()).isNull();
+ }
+
+ @Test
+ public void setLineHashes_empty_sets_lineCount_to_1_and_rawLineHashes_to_null() {
+ FileSourceDto underTest = new FileSourceDto();
+ underTest.setLineHashes(Collections.emptyList());
+
+ assertThat(underTest.getLineCount()).isEqualTo(1);
+ assertThat(underTest.getLineHashes()).isEmpty();
+ assertThat(underTest.getRawLineHashes()).isNull();
+ }
+
+ @Test
+ public void setLineHashes_sets_lineCount_to_size_of_list_and_rawLineHashes_to_join_by_line_return() {
+ FileSourceDto underTest = new FileSourceDto();
+ int expected = 1 + new Random().nextInt(96);
+ List<String> lineHashes = IntStream.range(0, expected).mapToObj(String::valueOf).collect(Collectors.toList());
+ underTest.setLineHashes(lineHashes);
+
+ assertThat(underTest.getLineCount()).isEqualTo(expected);
+ assertThat(underTest.getRawLineHashes()).isEqualTo(Joiner.on('\n').join(lineHashes));
+ }
}
import java.util.Arrays;
import java.util.Date;
+import java.util.Random;
import java.util.function.Consumer;
+import java.util.stream.IntStream;
import org.apache.commons.lang.math.RandomUtils;
+import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.protobuf.DbFileSources;
.setFileUuid(file.uuid())
.setSrcHash(randomAlphanumeric(50))
.setDataHash(randomAlphanumeric(50))
- .setLineHashes(randomAlphanumeric(50))
+ .setLineHashes(IntStream.range(0, new Random().nextInt(21)).mapToObj(String::valueOf).collect(MoreCollectors.toList()))
.setRevision(randomAlphanumeric(100))
.setSourceData(newRandomData(3).build())
.setCreatedAt(new Date().getTime())
+++ /dev/null
-<dataset>
-
- <file_sources id="101" project_uuid="PRJ_UUID" file_uuid="FILE1_UUID"
- binary_data="abcde" data_hash="hash"
- line_hashes="ABC\nDEF\nGHI"
- src_hash="FILE_HASH" revision="123456789"
- created_at="1500000000000" updated_at="1500000000000" data_type="SOURCE"
- line_hashes_version="[null]" />
-
-
- <file_sources id="102" project_uuid="PRJ_UUID" file_uuid="FILE2_UUID"
- binary_data="[ignore]"
- data_hash="FILE2_DATA_HASH"
- line_hashes="LINE1_HASH\nLINE2_HASH"
- src_hash="FILE2_HASH" revision="123456789"
- created_at="1500000000000" updated_at="1500000000001" data_type="SOURCE"
- line_hashes_version="1" />
-
-</dataset>
import org.sonar.server.computation.task.projectanalysis.source.SourceLinesHashRepository;
import org.sonar.server.computation.task.step.ComputationStep;
-import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.base.Splitter.on;
import static com.google.common.collect.FluentIterable.from;
import static java.util.Arrays.asList;
if (fileSourceDto == null) {
return null;
}
- String lineHashes = firstNonNull(fileSourceDto.getLineHashes(), "");
- return new File(dbComponent.getPath(), LINES_HASHES_SPLITTER.splitToList(lineHashes));
+ return new File(dbComponent.getPath(), fileSourceDto.getLineHashes());
}
private static void printIfDebug(ScoreMatrix scoreMatrix) {
read(fileSourceBuilder, currentLine, linesIterator.next(), linesIterator.hasNext());
}
- return new Data(fileSourceBuilder.build(), LINE_RETURN_JOINER.join(lineHashesComputer.getResult()), sourceHashComputer.getHash());
+ return new Data(fileSourceBuilder.build(), lineHashesComputer.getResult(), sourceHashComputer.getHash());
}
private void read(DbFileSources.Data.Builder fileSourceBuilder, int currentLine, String lineSource, boolean hasNextLine) {
public static class Data {
private final DbFileSources.Data fileSourceData;
- private final String lineHashes;
+ private final List<String> lineHashes;
private final String srcHash;
- private Data(DbFileSources.Data fileSourceData, String lineHashes, String srcHash) {
+ private Data(DbFileSources.Data fileSourceData, List<String> lineHashes, String srcHash) {
this.fileSourceData = fileSourceData;
this.lineHashes = lineHashes;
this.srcHash = srcHash;
return srcHash;
}
- public String getLineHashes() {
+ public List<String> getLineHashes() {
return lineHashes;
}
byte[] data = FileSourceDto.encodeSourceData(fileData);
String dataHash = DigestUtils.md5Hex(data);
String srcHash = fileSourceData.getSrcHash();
- String lineHashes = fileSourceData.getLineHashes();
+ List<String> lineHashes = fileSourceData.getLineHashes();
+ Integer lineHashesVersion = sourceLinesHash.getLineHashesVersion(file);
FileSourceDto previousDto = previousFileSourcesByUuid.get(file.getUuid());
- int lineHashesVersion = sourceLinesHash.getLineHashesVersion(file);
if (previousDto == null) {
FileSourceDto dto = new FileSourceDto()
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.tester.UserSessionRule;
+import static com.google.common.collect.ImmutableList.of;
import static java.lang.String.format;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.entry;
.setFileUuid(file.uuid())
.setProjectUuid(file.projectUuid())
.setDataHash("0263047cd758c68c27683625f072f010")
- .setLineHashes("8d7b3d6b83c0a517eac07e1aac94b773")
+ .setLineHashes(of("8d7b3d6b83c0a517eac07e1aac94b773"))
.setCreatedAt(System.currentTimeMillis())
.setUpdatedAt(System.currentTimeMillis())
.setDataType(FileSourceDto.Type.SOURCE)
import org.sonar.server.computation.task.projectanalysis.component.TreeRootHolderRule;
import org.sonar.server.computation.task.projectanalysis.source.SourceLinesHashRepository;
-import static com.google.common.base.Joiner.on;
import static java.util.Arrays.stream;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
FileSourceDto fileSourceDto = new FileSourceDto()
.setFileUuid(file.uuid())
.setProjectUuid(file.projectUuid())
- .setLineHashes(on('\n').join(linesHashesComputer.getLineHashes()))
+ .setLineHashes(linesHashesComputer.getLineHashes())
.setDataType(FileSourceDto.Type.SOURCE);
dbTester.getDbClient().fileSourceDao().insert(dbTester.getSession(), fileSourceDto);
dbTester.commit();
lineHashesComputer);
ComputeFileSourceData.Data data = computeFileSourceData.compute();
- assertThat(data.getLineHashes()).isEqualTo("137f72c3708c6bd0de00a0e5a69c699b");
+ assertThat(data.getLineHashes()).containsOnly("137f72c3708c6bd0de00a0e5a69c699b");
assertThat(data.getSrcHash()).isEqualTo("137f72c3708c6bd0de00a0e5a69c699b");
assertThat(data.getFileSourceData().getLinesList()).hasSize(1);
assertThat(data.getFileSourceData().getLines(0).getHighlighting()).isEqualTo("h-1");
lineHashesComputer);
ComputeFileSourceData.Data data = computeFileSourceData.compute();
- assertThat(data.getLineHashes()).isEqualTo("137f72c3708c6bd0de00a0e5a69c699b\ne6251bcf1a7dc3ba5e7933e325bbe605");
+ assertThat(data.getLineHashes()).containsOnly("137f72c3708c6bd0de00a0e5a69c699b", "e6251bcf1a7dc3ba5e7933e325bbe605");
assertThat(data.getSrcHash()).isEqualTo("ee5a58024a155466b43bc559d953e018");
assertThat(data.getFileSourceData().getLinesList()).hasSize(2);
assertThat(data.getFileSourceData().getLines(0).getHighlighting()).isEqualTo("h-1");
import com.google.common.collect.Lists;
import java.util.Arrays;
+import java.util.List;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.server.computation.task.projectanalysis.source.SourceLinesRepositoryRule;
import org.sonar.server.computation.task.step.ComputationStep;
+import static com.google.common.collect.ImmutableList.of;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSourceByFileUuid(session, FILE1_UUID);
- assertThat(fileSourceDto.getLineHashes()).isEqualTo("137f72c3708c6bd0de00a0e5a69c699b\ne6251bcf1a7dc3ba5e7933e325bbe605");
+ assertThat(fileSourceDto.getLineHashes()).containsExactly("137f72c3708c6bd0de00a0e5a69c699b", "e6251bcf1a7dc3ba5e7933e325bbe605");
assertThat(fileSourceDto.getSrcHash()).isEqualTo("ee5a58024a155466b43bc559d953e018");
}
// Existing sources
long past = 150000L;
String srcHash = "137f72c3708c6bd0de00a0e5a69c699b";
- String lineHashes = "137f72c3708c6bd0de00a0e5a69c699b";
+ List<String> lineHashes = of("137f72c3708c6bd0de00a0e5a69c699b");
String dataHash = "29f25900140c94db38035128cb6de6a2";
dbClient.fileSourceDao().insert(dbTester.getSession(), new FileSourceDto()
.setFileUuid(FILE1_UUID)
.setDataType(Type.SOURCE)
.setSrcHash("5b4bd9815cdb17b8ceae19eb1810c34c")
- .setLineHashes("6438c669e0d0de98e6929c2cc0fac474\n")
+ .setLineHashes(of("6438c669e0d0de98e6929c2cc0fac474", ""))
.setDataHash("6cad150e3d065976c230cddc5a09efaa")
.setSourceData(DbFileSources.Data.newBuilder()
.addLines(DbFileSources.Line.newBuilder()
.setFileUuid(FILE1_UUID)
.setDataType(Type.SOURCE)
// Source hash is missing, update will be made
- .setLineHashes("137f72c3708c6bd0de00a0e5a69c699b")
+ .setLineHashes(of("137f72c3708c6bd0de00a0e5a69c699b"))
.setDataHash("29f25900140c94db38035128cb6de6a2")
.setSourceData(DbFileSources.Data.newBuilder()
.addLines(DbFileSources.Line.newBuilder()
.setFileUuid(FILE1_UUID)
.setDataType(Type.SOURCE)
.setSrcHash("137f72c3708c6bd0de00a0e5a69c699b")
- .setLineHashes("137f72c3708c6bd0de00a0e5a69c699b")
+ .setLineHashes(of("137f72c3708c6bd0de00a0e5a69c699b"))
.setDataHash("8e84c0d961cfe364e43833c4cc4ddef5")
// Revision is missing, update will be made
.setSourceData(DbFileSources.Data.newBuilder()
.setFileUuid(FILE1_UUID)
.setDataType(Type.SOURCE)
.setSrcHash("137f72c3708c6bd0de00a0e5a69c699b")
- .setLineHashes("137f72c3708c6bd0de00a0e5a69c699b")
+ .setLineHashes(of("137f72c3708c6bd0de00a0e5a69c699b"))
.setDataHash("8e84c0d961cfe364e43833c4cc4ddef5")
// Revision is missing, update will be made
.setSourceData(DbFileSources.Data.newBuilder()
file_uuid="CDEF"
binary_data=""
data_hash="hash"
+ line_count="1"
line_hashes="987654"
src_hash="12345"
created_at="1414597442000"
file_uuid="CDEF"
binary_data=""
data_hash="[null]"
+ line_count="0"
line_hashes="[null]"
src_hash="[null]"
created_at="1414597442000"
file_uuid="CDEF"
binary_data=""
data_hash="hash"
+ line_count="1"
line_hashes="987654"
src_hash="12345"
created_at="1414597442000"
<dataset>
- <file_sources id="1" project_uuid="PROJECT_UUID" file_uuid="FILE_UUID" created_at="1416238020000" updated_at="1416239042000"
- binary_data="" data_hash="" data_type="TEST" />
+ <file_sources id="1"
+ project_uuid="PROJECT_UUID"
+ file_uuid="FILE_UUID"
+ line_count="0"
+ created_at="1416238020000"
+ updated_at="1416239042000"
+ binary_data=""
+ data_hash=""
+ data_type="TEST"
+ />
</dataset>
<dataset>
- <file_sources id="1" project_uuid="P1" file_uuid="F1" created_at="1416238020000" updated_at="1416239042000"
- binary_data="" data_hash="" data_type="TEST"/>
+ <file_sources id="1"
+ project_uuid="P1"
+ file_uuid="F1"
+ created_at="1416238020000"
+ updated_at="1416239042000"
+ line_count="0"
+ binary_data=""
+ data_hash=""
+ data_type="TEST"/>
- <file_sources id="2" project_uuid="P2" file_uuid="F2" created_at="1416238020000" updated_at="1416239042000"
- binary_data="" data_hash="" data_type="TEST"/>
+ <file_sources id="2"
+ project_uuid="P2"
+ file_uuid="F2"
+ created_at="1416238020000"
+ updated_at="1416239042000"
+ line_count="0"
+ binary_data=""
+ data_hash=""
+ data_type="TEST"/>
</dataset>
<dataset>
- <file_sources id="1" project_uuid="P1" file_uuid="F1" created_at="1416238020000" updated_at="1416239042000"
- binary_data="" data_hash="" data_type="TEST"/>
+ <file_sources id="1"
+ project_uuid="P1"
+ file_uuid="F1"
+ created_at="1416238020000"
+ updated_at="1416239042000"
+ line_count="0"
+ binary_data=""
+ data_hash=""
+ data_type="TEST"/>
- <file_sources id="2" project_uuid="P1" file_uuid="F2" created_at="1416238020000" updated_at="1300000000000"
- binary_data="" data_hash="" data_type="TEST"/>
+ <file_sources id="2"
+ project_uuid="P1"
+ file_uuid="F2"
+ created_at="1416238020000"
+ updated_at="1300000000000"
+ line_count="0"
+ binary_data=""
+ data_hash=""
+ data_type="TEST"/>
</dataset>
<dataset>
- <file_sources id="1" project_uuid="P1" file_uuid="F1" created_at="1416238020000" updated_at="1416239042000"
- binary_data="" data_hash="" data_type="TEST"/>
+ <file_sources id="1"
+ project_uuid="P1"
+ file_uuid="F1"
+ created_at="1416238020000"
+ updated_at="1416239042000"
+ line_count="0"
+ binary_data=""
+ data_hash=""
+ data_type="TEST"/>
</dataset>
projects / sonarqube.git / commitdiff