private FileSourceDto createDto(Consumer<FileSourceDto> modifier) { DbFileSources.Data sourceData = DbFileSources.Data.newBuilder().build(); byte[] data = FileSourceDto.encodeSourceData(sourceData); String dataHash = DigestUtils.md5Hex(data); FileSourceDto dto = new FileSourceDto() .setProjectUuid(PROJECT_UUID) .setFileUuid(FILE1_UUID) .setSrcHash("sourceHash") .setLineHashes(Collections.singletonList("lineHash")) .setDataHash(dataHash) .setRevision("rev-1") .setSourceData(sourceData) .setCreatedAt(PAST) .setUpdatedAt(PAST); modifier.accept(dto); return dto; }
@Test public void getSourceData_throws_ISE_with_id_fileUuid_and_projectUuid_in_message_when_data_cant_be_read() { long id = 12L; String fileUuid = "file uuid"; String projectUuid = "project uuid"; FileSourceDto underTest = new FileSourceDto() .setBinaryData(new byte[] {1, 2, 3, 4, 5}) .setId(id) .setFileUuid(fileUuid) .setProjectUuid(projectUuid); expectedException.expect(IllegalStateException.class); expectedException.expectMessage("Fail to decompress and deserialize source data [id=" + id + ",fileUuid=" + fileUuid + ",projectUuid=" + projectUuid + "]"); underTest.getSourceData(); }
private static FileSourceDto newFileSourceDto(ComponentDto file) { return new FileSourceDto() .setFileUuid(file.uuid()) .setProjectUuid(file.projectUuid()) .setDataHash("0263047cd758c68c27683625f072f010") .setLineHashes(of("8d7b3d6b83c0a517eac07e1aac94b773")) .setCreatedAt(System.currentTimeMillis()) .setUpdatedAt(System.currentTimeMillis()) .setRevision("123456789") .setSrcHash("123456"); } }
byte[] binaryData = FileSourceDto.encodeSourceData(lineData); String dataHash = DigestUtils.md5Hex(binaryData); String srcHash = fileSourceData.getSrcHash(); FileSourceDto dto = new FileSourceDto() .setProjectUuid(projectUuid) .setFileUuid(file.getUuid()) .setBinaryData(binaryData) .setSrcHash(srcHash) .setDataHash(dataHash) .setLineHashes(lineHashes) .setLineHashesVersion(lineHashesVersion) .setCreatedAt(system2.now()) .setUpdatedAt(system2.now()) .setRevision(computeRevision(latestChangeWithRevision)); dbClient.fileSourceDao().insert(session, dto); session.commit(); } else { boolean binaryDataUpdated = !dataHash.equals(previousDto.getDataHash()); boolean srcHashUpdated = !srcHash.equals(previousDto.getSrcHash()); String revision = computeRevision(latestChangeWithRevision); boolean revisionUpdated = !ObjectUtils.equals(revision, previousDto.getRevision()); boolean lineHashesVersionUpdated = previousDto.getLineHashesVersion() != lineHashesVersion; if (binaryDataUpdated || srcHashUpdated || revisionUpdated || lineHashesVersionUpdated) { previousDto .setBinaryData(binaryData) .setDataHash(dataHash) .setSrcHash(srcHash)
@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(dbSession, fileSourceDto); dbSession.commit(); }
@Test public void insert() { FileSourceDto expected = new FileSourceDto() .setProjectUuid("PRJ_UUID") .setFileUuid("FILE2_UUID") .setBinaryData("FILE2_BINARY_DATA".getBytes()) .setDataHash("FILE2_DATA_HASH") .setLineHashes(of("LINE1_HASH", "LINE2_HASH")) .setSrcHash("FILE2_HASH") .setCreatedAt(1500000000000L) .setUpdatedAt(1500000000001L) .setLineHashesVersion(1) .setRevision("123456789"); underTest.insert(dbSession, expected); dbSession.commit(); FileSourceDto fileSourceDto = underTest.selectByFileUuid(dbSession, 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()); }
private void insertFileWithData(ComponentDto file, DbFileSources.Data fileData) { db.getDbClient().fileSourceDao().insert(db.getSession(), new FileSourceDto() .setProjectUuid(file.projectUuid()) .setFileUuid(file.uuid()) .setSourceData(fileData)); db.commit(); }
dbClient.fileSourceDao().insert(dbTester.getSession(), new FileSourceDto() .setProjectUuid(PROJECT_UUID) .setFileUuid(FILE1_UUID) .setSrcHash("5b4bd9815cdb17b8ceae19eb1810c34c") .setLineHashes(Collections.singletonList("6438c669e0d0de98e6929c2cc0fac474")) .setDataHash("6cad150e3d065976c230cddc5a09efaa") .setSourceData(DbFileSources.Data.newBuilder() .addLines(DbFileSources.Line.newBuilder() .setLine(1) .build()) .build()) .setCreatedAt(past) .setUpdatedAt(past) .setRevision("rev-0")); dbTester.getSession().commit(); assertThat(fileSourceDto.getCreatedAt()).isEqualTo(past); assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW); assertThat(fileSourceDto.getRevision()).isEqualTo("rev-1"); verify(fileSourceDataWarnings).commitWarnings();
@Test public void update_to_no_line_hashes() { ImmutableList<String> lineHashes = of("a", "b", "c"); FileSourceDto fileSourceDto = new FileSourceDto() .setProjectUuid("Foo") .setFileUuid("Bar") .setLineHashes(lineHashes) .setCreatedAt(1500000000000L) .setUpdatedAt(1500000000001L); underTest.insert(dbSession, fileSourceDto); dbSession.commit(); FileSourceDto resBefore = underTest.selectByFileUuid(dbSession, fileSourceDto.getFileUuid()); assertThat(resBefore.getLineCount()).isEqualTo(lineHashes.size()); assertThat(resBefore.getLineHashes()).isEqualTo(lineHashes); fileSourceDto.setId(resBefore.getId()); fileSourceDto.setLineHashes(emptyList()); underTest.update(dbSession, fileSourceDto); dbSession.commit(); FileSourceDto res = underTest.selectByFileUuid(dbSession, fileSourceDto.getFileUuid()); assertThat(res.getLineHashes()).isEmpty(); assertThat(res.getLineCount()).isEqualTo(1); }
@Test public void selectSourceByFileUuid_reads_source_without_line_hashes() { FileSourceDto fileSourceDto = new FileSourceDto() .setProjectUuid("Foo") .setFileUuid("Bar") .setCreatedAt(1500000000000L) .setUpdatedAt(1500000000001L); underTest.insert(dbSession, fileSourceDto); dbSession.commit(); FileSourceDto res = underTest.selectByFileUuid(dbSession, fileSourceDto.getFileUuid()); assertThat(res.getLineCount()).isEqualTo(0); assertThat(res.getLineHashes()).isEmpty(); }
@Test public void persist_sources() { List<String> lineHashes = Arrays.asList("137f72c3708c6bd0de00a0e5a69c699b", "e6251bcf1a7dc3ba5e7933e325bbe605"); String sourceHash = "ee5a58024a155466b43bc559d953e018"; DbFileSources.Data fileSourceData = DbFileSources.Data.newBuilder() .addAllLines(Arrays.asList( DbFileSources.Line.newBuilder().setSource("line1").setLine(1).build(), DbFileSources.Line.newBuilder().setSource("line2").setLine(2).build())) .build(); when(fileSourceDataComputer.compute(fileComponent().build(), fileSourceDataWarnings)) .thenReturn(new FileSourceDataComputer.Data(fileSourceData, lineHashes, sourceHash, null)); underTest.execute(new TestComputationStepContext()); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); assertThat(fileSourceDto.getProjectUuid()).isEqualTo(PROJECT_UUID); assertThat(fileSourceDto.getFileUuid()).isEqualTo(FILE1_UUID); assertThat(fileSourceDto.getBinaryData()).isNotEmpty(); assertThat(fileSourceDto.getDataHash()).isNotEmpty(); assertThat(fileSourceDto.getLineHashesVersion()).isEqualTo(LineHashVersion.WITHOUT_SIGNIFICANT_CODE.getDbValue()); assertThat(fileSourceDto.getLineHashes()).isNotEmpty(); assertThat(fileSourceDto.getCreatedAt()).isEqualTo(NOW); assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW); DbFileSources.Data data = fileSourceDto.getSourceData(); assertThat(data.getLinesCount()).isEqualTo(2); assertThat(data.getLines(0).getLine()).isEqualTo(1); assertThat(data.getLines(0).getSource()).isEqualTo("line1"); assertThat(data.getLines(1).getLine()).isEqualTo(2); assertThat(data.getLines(1).getSource()).isEqualTo("line2"); verify(fileSourceDataWarnings).commitWarnings(); }
@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(); }
.setTestData(tests) .setUpdatedAt(now); dbClient.fileSourceDao().update(session, existingDto); } else { FileSourceDto newDto = new FileSourceDto() .setTestData(tests) .setFileUuid(componentUuid) .setProjectUuid(projectUuid) .setDataType(Type.TEST) .setCreatedAt(now) .setUpdatedAt(now); dbClient.fileSourceDao().insert(session, newDto);
@CheckForNull private FileSourceDto insertContentOfFileInDb(String uuid, @Nullable String[] content) { return dbTester.getDbClient().componentDao().selectByUuid(dbTester.getSession(), uuid) .map(file -> { SourceLineHashesComputer linesHashesComputer = new SourceLineHashesComputer(); if (content != null) { stream(content).forEach(linesHashesComputer::addLine); } FileSourceDto fileSourceDto = new FileSourceDto() .setFileUuid(file.uuid()) .setProjectUuid(file.projectUuid()) .setLineHashes(linesHashesComputer.getLineHashes()); dbTester.getDbClient().fileSourceDao().insert(dbTester.getSession(), fileSourceDto); dbTester.commit(); return fileSourceDto; }).orElse(null); }
@Test public void getSourceData_reads_Data_object_bigger_than_default_size_limit() { DbFileSources.Data build = createOver64MBDataStructure(); byte[] bytes = FileSourceDto.encodeSourceData(build); DbFileSources.Data data = new FileSourceDto().decodeSourceData(bytes); assertThat(data.getLinesCount()).isEqualTo(build.getLinesCount()); }
@Test public void update_sources_when_src_hash_is_missing() { dbClient.fileSourceDao().insert(dbTester.getSession(), createDto(dto -> dto.setSrcHash(null))); dbTester.getSession().commit(); DbFileSources.Data sourceData = DbFileSources.Data.newBuilder().build(); setComputedData(sourceData, Collections.singletonList("lineHash"), "newSourceHash", null); underTest.execute(new TestComputationStepContext()); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); assertThat(fileSourceDto.getCreatedAt()).isEqualTo(PAST); assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW); assertThat(fileSourceDto.getSrcHash()).isEqualTo("newSourceHash"); verify(fileSourceDataWarnings).commitWarnings(); }
@Test public void update_sources_when_revision_is_missing() { DbFileSources.Data sourceData = DbFileSources.Data.newBuilder() .addLines(DbFileSources.Line.newBuilder() .setLine(1) .setSource("line") .build()) .build(); dbClient.fileSourceDao().insert(dbTester.getSession(), createDto(dto -> dto.setRevision(null))); dbTester.getSession().commit(); Changeset changeset = Changeset.newChangesetBuilder().setDate(1L).setRevision("revision").build(); setComputedData(sourceData, Collections.singletonList("137f72c3708c6bd0de00a0e5a69c699b"), "29f25900140c94db38035128cb6de6a2", changeset); underTest.execute(new TestComputationStepContext()); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); assertThat(fileSourceDto.getCreatedAt()).isEqualTo(PAST); assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW); assertThat(fileSourceDto.getRevision()).isEqualTo("revision"); verify(fileSourceDataWarnings).commitWarnings(); }
private <E> Optional<Iterable<E>> getLines(DbSession dbSession, String fileUuid, int from, int toInclusive, Function<DbFileSources.Line, E> function) { verifyLine(from); checkArgument(toInclusive >= from, String.format("Line number must greater than or equal to %d, got %d", from, toInclusive)); FileSourceDto dto = dbClient.fileSourceDao().selectByFileUuid(dbSession, fileUuid); if (dto == null) { return Optional.empty(); } return Optional.of(dto.getSourceData().getLinesList().stream() .filter(line -> line.hasLine() && line.getLine() >= from) .limit((toInclusive - from) + 1L) .map(function) .collect(MoreCollectors.toList())); }
public Optional<DbScmInfo> getScmInfo(Component file) { Optional<String> uuid = getFileUUid(file); if (!uuid.isPresent()) { return Optional.empty(); } LOGGER.trace("Reading SCM info from DB for file '{}'", uuid.get()); try (DbSession dbSession = dbClient.openSession(false)) { FileSourceDto dto = dbClient.fileSourceDao().selectByFileUuid(dbSession, uuid.get()); if (dto == null) { return Optional.empty(); } return DbScmInfo.create(dto.getSourceData().getLinesList(), dto.getSrcHash()); } }
@Test public void persist_scm() { DbFileSources.Data dbData = DbFileSources.Data.newBuilder().addLines( DbFileSources.Line.newBuilder() .setScmAuthor("john") .setScmDate(123456789L) .setScmRevision("rev-1") .build()) .build(); setComputedData(dbData); underTest.execute(new TestComputationStepContext()); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData); assertThat(fileSourceDto.getRevision()).isNull(); verify(fileSourceDataWarnings).commitWarnings(); }