}
// FIXME SONAR-11631 code below applies to the analysisVersion, not the project version, fix it
if (baseAnalysis != null) {
- return firstNonNull(baseAnalysis.getVersion(), DEFAULT_PROJECT_VERSION);
+ return firstNonNull(baseAnalysis.getCodePeriodVersion(), DEFAULT_PROJECT_VERSION);
}
return DEFAULT_PROJECT_VERSION;
}
String componentUuid = component.getUuid();
return new SnapshotDto()
.setUuid(snapshotUuid)
- .setVersion(component.getType() == Component.Type.PROJECT ? component.getProjectAttributes().getVersion() : null)
+ .setCodePeriodVersion(component.getType() == Component.Type.PROJECT ? component.getProjectAttributes().getVersion() : null)
.setComponentUuid(componentUuid)
.setLast(false)
.setStatus(SnapshotDto.STATUS_UNPROCESSED)
@Test
public void project_version_is_loaded_from_db_if_absent_from_report() {
- SnapshotDto baseAnalysis = new SnapshotDto().setVersion("6.5");
+ SnapshotDto baseAnalysis = new SnapshotDto().setCodePeriodVersion("6.5");
Component root = call(newBuilder()
.setType(PROJECT)
.build(), baseAnalysis, NO_SCM_BASE_PATH, NO_PROJECT_VERSION);
@Test
public void project_version_is_loaded_from_db_if_empty_report() {
- SnapshotDto baseAnalysis = new SnapshotDto().setVersion("6.5");
+ SnapshotDto baseAnalysis = new SnapshotDto().setCodePeriodVersion("6.5");
Component root = call(newBuilder()
.setType(PROJECT)
.build(), baseAnalysis, NO_SCM_BASE_PATH, NO_PROJECT_VERSION);
SnapshotDto analysis1 = dbTester.components()
.insertSnapshot(project, snapshot -> snapshot.setStatus(STATUS_UNPROCESSED).setCreatedAt(1226379600000L).setLast(false));// 2008-11-11
SnapshotDto analysis2 = dbTester.components().insertSnapshot(project,
- snapshot -> snapshot.setStatus(STATUS_PROCESSED).setVersion("not provided").setCreatedAt(1226379600000L).setLast(false));// 2008-11-29
+ snapshot -> snapshot.setStatus(STATUS_PROCESSED).setCodePeriodVersion("not provided").setCreatedAt(1226379600000L).setLast(false));// 2008-11-29
dbTester.events().insertEvent(newEvent(analysis1).setName("not provided").setCategory(CATEGORY_VERSION).setDate(analysis1.getCreatedAt()));
dbTester.events().insertEvent(newEvent(analysis2).setName("not provided").setCategory(CATEGORY_VERSION).setDate(analysis2.getCreatedAt()));
when(analysisMetadataHolder.getAnalysisDate()).thenReturn(november30th2008.getTime());
public void fail_with_MessageException_if_string_is_not_an_existing_version_event(String propertyValue) {
OrganizationDto organization = dbTester.organizations().insert();
ComponentDto project = dbTester.components().insertPrivateProject(organization);
- SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setVersion("0.9").setLast(false)); // 2008-11-11
- SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setVersion("1.0").setLast(false)); // 2008-11-12
- SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setVersion("1.1").setLast(false)); // 2008-11-20
- SnapshotDto analysis4 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227358680000L).setVersion("1.1").setLast(false)); // 2008-11-22
- SnapshotDto analysis5 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setVersion("1.1").setLast(true)); // 2008-11-29
+ SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setCodePeriodVersion("0.9").setLast(false)); // 2008-11-11
+ SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setCodePeriodVersion("1.0").setLast(false)); // 2008-11-12
+ SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-20
+ SnapshotDto analysis4 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227358680000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-22
+ SnapshotDto analysis5 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setCodePeriodVersion("1.1").setLast(true)); // 2008-11-29
dbTester.events().insertEvent(newEvent(analysis1).setName("0.9").setCategory(CATEGORY_VERSION).setDate(analysis1.getCreatedAt()));
dbTester.events().insertEvent(newEvent(analysis2).setName("1.0").setCategory(CATEGORY_VERSION).setDate(analysis2.getCreatedAt()));
dbTester.events().insertEvent(newEvent(analysis5).setName("1.1").setCategory(CATEGORY_VERSION).setDate(analysis4.getCreatedAt()));
public void feed_period_by_previous_version() {
OrganizationDto organization = dbTester.organizations().insert();
ComponentDto project = dbTester.components().insertPrivateProject(organization);
- SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setVersion("0.9").setLast(false)); // 2008-11-11
- SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setVersion("1.0").setLast(false)); // 2008-11-12
- SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setVersion("1.1").setLast(false)); // 2008-11-20
- SnapshotDto analysis4 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227358680000L).setVersion("1.1").setLast(false)); // 2008-11-22
- SnapshotDto analysis5 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setVersion("1.1").setLast(true)); // 2008-11-29
+ SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setCodePeriodVersion("0.9").setLast(false)); // 2008-11-11
+ SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setCodePeriodVersion("1.0").setLast(false)); // 2008-11-12
+ SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-20
+ SnapshotDto analysis4 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227358680000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-22
+ SnapshotDto analysis5 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setCodePeriodVersion("1.1").setLast(true)); // 2008-11-29
dbTester.events().insertEvent(newEvent(analysis1).setName("0.9").setCategory(CATEGORY_VERSION).setDate(analysis1.getCreatedAt()));
dbTester.events().insertEvent(newEvent(analysis2).setName("1.0").setCategory(CATEGORY_VERSION).setDate(analysis2.getCreatedAt()));
dbTester.events().insertEvent(newEvent(analysis5).setName("1.1").setCategory(CATEGORY_VERSION).setDate(analysis4.getCreatedAt()));
public void feed_period_by_previous_version_with_previous_version_deleted() {
OrganizationDto organization = dbTester.organizations().insert();
ComponentDto project = dbTester.components().insertPrivateProject(organization);
- SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setVersion("0.9").setLast(false)); // 2008-11-11
- SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setVersion("1.0").setLast(false)); // 2008-11-12
- SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setVersion("1.1").setLast(false)); // 2008-11-20
+ SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setCodePeriodVersion("0.9").setLast(false)); // 2008-11-11
+ SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setCodePeriodVersion("1.0").setLast(false)); // 2008-11-12
+ SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-20
dbTester.events().insertEvent(newEvent(analysis1).setName("0.9").setCategory(CATEGORY_VERSION));
// The "1.0" version was deleted from the history
dbTester.events().insertEvent(newEvent(analysis3).setName("1.1").setCategory(CATEGORY_VERSION));
public void feed_period_by_previous_version_with_first_analysis_when_no_previous_version_found() {
OrganizationDto organization = dbTester.organizations().insert();
ComponentDto project = dbTester.components().insertPrivateProject(organization);
- SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setVersion("1.1").setLast(false)); // 2008-11-11
- SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setVersion("1.1").setLast(true)); // 2008-11-29
+ SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-11
+ SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setCodePeriodVersion("1.1").setLast(true)); // 2008-11-29
dbTester.events().insertEvent(newEvent(analysis2).setName("1.1").setCategory(CATEGORY_VERSION));
when(system2Mock.now()).thenReturn(november30th2008.getTime());
when(analysisMetadataHolder.isFirstAnalysis()).thenReturn(false);
public void feed_period_by_previous_version_with_first_analysis_when_previous_snapshot_is_the_last_one() {
OrganizationDto organization = dbTester.organizations().insert();
ComponentDto project = dbTester.components().insertPrivateProject(organization);
- SnapshotDto analysis = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setVersion("0.9").setLast(true)); // 2008-11-11
+ SnapshotDto analysis = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setCodePeriodVersion("0.9").setLast(true)); // 2008-11-11
dbTester.events().insertEvent(newEvent(analysis).setName("0.9").setCategory(CATEGORY_VERSION));
when(system2Mock.now()).thenReturn(november30th2008.getTime());
when(analysisMetadataHolder.isFirstAnalysis()).thenReturn(false);
public void feed_period_by_version() {
OrganizationDto organization = dbTester.organizations().insert();
ComponentDto project = dbTester.components().insertPrivateProject(organization);
- SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setVersion("0.9").setLast(false)); // 2008-11-11
- SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setVersion("1.0").setLast(false)); // 2008-11-12
- SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setVersion("1.1").setLast(false)); // 2008-11-20
- SnapshotDto analysis4 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227358680000L).setVersion("1.1").setLast(false)); // 2008-11-22
- SnapshotDto analysis5 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setVersion("1.1").setLast(true)); // 2008-11-29
+ SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setCodePeriodVersion("0.9").setLast(false)); // 2008-11-11
+ SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226494680000L).setCodePeriodVersion("1.0").setLast(false)); // 2008-11-12
+ SnapshotDto analysis3 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227157200000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-20
+ SnapshotDto analysis4 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227358680000L).setCodePeriodVersion("1.1").setLast(false)); // 2008-11-22
+ SnapshotDto analysis5 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1227934800000L).setCodePeriodVersion("1.1").setLast(true)); // 2008-11-29
dbTester.events().insertEvent(newEvent(analysis1).setName("0.9").setCategory(CATEGORY_VERSION));
dbTester.events().insertEvent(newEvent(analysis2).setName("1.0").setCategory(CATEGORY_VERSION));
dbTester.events().insertEvent(newEvent(analysis5).setName("1.1").setCategory(CATEGORY_VERSION));
public void feed_period_by_version_with_only_one_existing_version() {
OrganizationDto organization = dbTester.organizations().insert();
ComponentDto project = dbTester.components().insertPrivateProject(organization);
- SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setVersion("0.9").setLast(true)); // 2008-11-11
+ SnapshotDto analysis1 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setCreatedAt(1226379600000L).setCodePeriodVersion("0.9").setLast(true)); // 2008-11-11
dbTester.events().insertEvent(newEvent(analysis1).setName("0.9").setCategory(CATEGORY_VERSION));
when(system2Mock.now()).thenReturn(november30th2008.getTime());
when(analysisMetadataHolder.isFirstAnalysis()).thenReturn(false);
SnapshotDto projectSnapshot = getUnprocessedSnapshot(projectDto.uuid());
assertThat(projectSnapshot.getUuid()).isEqualTo(ANALYSIS_UUID);
assertThat(projectSnapshot.getComponentUuid()).isEqualTo(project.getUuid());
- assertThat(projectSnapshot.getVersion()).isEqualTo("1.0");
+ assertThat(projectSnapshot.getCodePeriodVersion()).isEqualTo("1.0");
assertThat(projectSnapshot.getLast()).isFalse();
assertThat(projectSnapshot.getStatus()).isEqualTo("U");
assertThat(projectSnapshot.getCreatedAt()).isEqualTo(analysisDate);
SnapshotDto viewSnapshot = getUnprocessedSnapshot(viewDto.uuid());
assertThat(viewSnapshot.getUuid()).isEqualTo(ANALYSIS_UUID);
assertThat(viewSnapshot.getComponentUuid()).isEqualTo(view.getUuid());
- assertThat(viewSnapshot.getVersion()).isNull();
+ assertThat(viewSnapshot.getCodePeriodVersion()).isNull();
assertThat(viewSnapshot.getLast()).isFalse();
assertThat(viewSnapshot.getStatus()).isEqualTo("U");
assertThat(viewSnapshot.getCreatedAt()).isEqualTo(analysisDate);
*/
public static final String STATUS_UNPROCESSED = "U";
public static final String STATUS_PROCESSED = "P";
- public static final int MAX_VERSION_LENGTH = 100;
+ private static final int MAX_VERSION_LENGTH = 100;
private Long id;
private String uuid;
private String status = STATUS_UNPROCESSED;
private Integer purgeStatus;
private Boolean last;
- private String version;
+ private String codePeriodVersion;
private String periodMode;
private String periodParam;
private Long periodDate;
* Version is only available on projects and modules
*/
@CheckForNull
- public String getVersion() {
- return version;
+ public String getCodePeriodVersion() {
+ return codePeriodVersion;
}
- public SnapshotDto setVersion(@Nullable String version) {
- if (version != null) {
- checkArgument(version.length() <= MAX_VERSION_LENGTH,
- "Event name length (%s) is longer than the maximum authorized (%s). '%s' was provided.", version.length(), MAX_VERSION_LENGTH, version);
+ public SnapshotDto setCodePeriodVersion(@Nullable String codePeriodVersion) {
+ if (codePeriodVersion != null) {
+ checkArgument(codePeriodVersion.length() <= MAX_VERSION_LENGTH,
+ "Event name length (%s) is longer than the maximum authorized (%s). '%s' was provided.", codePeriodVersion.length(), MAX_VERSION_LENGTH, codePeriodVersion);
}
- this.version = version;
+ this.codePeriodVersion = codePeriodVersion;
return this;
}
/**
* Used by MyBatis
*/
- private void setRawVersion(@Nullable String version) {
- this.version = version;
+ private void setRawCodePeriodVersion(@Nullable String codePeriodVersion) {
+ this.codePeriodVersion = codePeriodVersion;
}
public SnapshotDto setPeriodMode(@Nullable String p) {
Objects.equals(status, that.status) &&
Objects.equals(purgeStatus, that.purgeStatus) &&
Objects.equals(last, that.last) &&
- Objects.equals(version, that.version) &&
+ Objects.equals(codePeriodVersion, that.codePeriodVersion) &&
Objects.equals(periodMode, that.periodMode) &&
Objects.equals(periodParam, that.periodParam) &&
Objects.equals(periodDate, that.periodDate);
@Override
public int hashCode() {
- return Objects.hash(id, uuid, componentUuid, createdAt, buildDate, status, purgeStatus, last, version, periodMode, periodParam, periodDate);
+ return Objects.hash(id, uuid, componentUuid, createdAt, buildDate, status, purgeStatus, last, codePeriodVersion, periodMode, periodParam, periodDate);
}
@Override
", status='" + status + '\'' +
", purgeStatus=" + purgeStatus +
", last=" + last +
- ", version='" + version + '\'' +
+ ", codePeriodVersion='" + codePeriodVersion + '\'' +
", periodMode='" + periodMode + '\'' +
", periodParam='" + periodParam + '\'' +
", periodDate=" + periodDate +
private Long createdAfter;
private Long createdBefore;
private String status;
- private String version;
+ private String codePeriodVersion;
private Boolean isLast;
private String sortField;
private String sortOrder;
}
@CheckForNull
- public String getVersion() {
- return version;
+ public String getCodePeriodVersion() {
+ return codePeriodVersion;
}
- public SnapshotQuery setVersion(@Nullable String version) {
- this.version = version;
+ public SnapshotQuery setCodePeriodVersion(@Nullable String codePeriodVersion) {
+ this.codePeriodVersion = codePeriodVersion;
return this;
}
s.status as status,
s.purge_status as purgeStatus,
s.islast as last,
- s.version as rawVersion,
+ s.version as rawCodePeriodVersion,
s.period1_mode as periodMode,
s.period1_param as periodParam,
s.period1_date as periodDate
<if test="query.status != null">
AND s.status=#{query.status,jdbcType=VARCHAR}
</if>
- <if test="query.version != null">
- AND s.version=#{query.version,jdbcType=VARCHAR}
+ <if test="query.codePeriodVersion != null">
+ AND s.version=#{query.codePeriodVersion,jdbcType=VARCHAR}
</if>
<if test="query.isLast != null">
AND s.islast=#{query.isLast}
<update id="update" parameterType="Snapshot">
update snapshots
- set version = #{version, jdbcType=VARCHAR},
+ set version = #{codePeriodVersion, jdbcType=VARCHAR},
status = #{status, jdbcType=VARCHAR}
where uuid = #{uuid,jdbcType=VARCHAR}
</update>
#{status, jdbcType=VARCHAR},
#{purgeStatus, jdbcType=INTEGER},
#{last, jdbcType=BOOLEAN},
- #{version, jdbcType=VARCHAR},
+ #{codePeriodVersion, jdbcType=VARCHAR},
#{periodMode, jdbcType=VARCHAR},
#{periodParam, jdbcType=VARCHAR},
#{periodDate, jdbcType=BIGINT})
.setPeriodMode("days")
.setPeriodParam("30")
.setPeriodDate(1500000000001L)
- .setVersion("2.1-SNAPSHOT")
+ .setCodePeriodVersion("2.1-SNAPSHOT")
.setBuildDate(1500000000006L)
.setCreatedAt(1403042400000L));
assertThat(result.getStatus()).isEqualTo("P");
assertThat(result.getLast()).isTrue();
assertThat(result.getPurgeStatus()).isEqualTo(1);
- assertThat(result.getVersion()).isEqualTo("2.1-SNAPSHOT");
+ assertThat(result.getCodePeriodVersion()).isEqualTo("2.1-SNAPSHOT");
assertThat(result.getPeriodMode()).isEqualTo("days");
assertThat(result.getPeriodModeParameter()).isEqualTo("30");
assertThat(result.getPeriodDate()).isEqualTo(1500000000001L);
assertThat(result.getBuildDate()).isEqualTo(1500000000006L);
assertThat(result.getCreatedAt()).isEqualTo(1403042400000L);
- assertThat(result.getVersion()).isEqualTo("2.1-SNAPSHOT");
+ assertThat(result.getCodePeriodVersion()).isEqualTo("2.1-SNAPSHOT");
assertThat(underTest.selectByUuid(db.getSession(), "DOES_NOT_EXIST").isPresent()).isFalse();
}
.setPeriodMode("days")
.setPeriodParam("30")
.setPeriodDate(1500000000001L)
- .setVersion("2.1-SNAPSHOT")
+ .setCodePeriodVersion("2.1-SNAPSHOT")
.setBuildDate(1500000000006L)
.setCreatedAt(1403042400000L));
assertThat(dto.getPeriodDate()).isEqualTo(1500000000001L);
assertThat(dto.getBuildDate()).isEqualTo(1500000000006L);
assertThat(dto.getCreatedAt()).isEqualTo(1403042400000L);
- assertThat(dto.getVersion()).isEqualTo("2.1-SNAPSHOT");
+ assertThat(dto.getCodePeriodVersion()).isEqualTo("2.1-SNAPSHOT");
}
db.commit();
analysis
.setComponentUuid("P42")
- .setVersion("5.6.3")
+ .setCodePeriodVersion("5.6.3")
.setStatus(STATUS_UNPROCESSED);
underTest.update(dbSession, analysis);
SnapshotDto result = underTest.selectByUuid(dbSession, "A1").get();
- assertThat(result.getVersion()).isEqualTo("5.6.3");
+ assertThat(result.getCodePeriodVersion()).isEqualTo("5.6.3");
assertThat(result.getStatus()).isEqualTo(STATUS_UNPROCESSED);
assertThat(result.getComponentUuid()).isEqualTo("P1");
}
db.commit();
assertThat(underTest.selectByUuid(dbSession, analysis.getUuid())
- .map(SnapshotDto::getVersion))
+ .map(SnapshotDto::getCodePeriodVersion))
.contains(tooLongVersion);
}
.setStatus("P")
.setLast(true)
.setPurgeStatus(1)
- .setVersion("2.1-SNAPSHOT")
+ .setCodePeriodVersion("2.1-SNAPSHOT")
.setPeriodMode("days1")
.setPeriodParam("30")
.setPeriodDate(1_500_000_000_001L)
.setBuildDate(parseDate("2014-07-02").getTime())
.setComponentUuid("uuid_21")
.setLast(true)
- .setVersion("1.0")
+ .setCodePeriodVersion("1.0")
.setPeriodMode("mode1")
.setPeriodParam("param1")
.setPeriodDate(parseDate("2014-06-01").getTime());
assertThat(snapshotDto.getBuildDate()).isEqualTo(parseDate("2014-07-02").getTime());
assertThat(snapshotDto.getComponentUuid()).isEqualTo("uuid_21");
assertThat(snapshotDto.getLast()).isTrue();
- assertThat(snapshotDto.getVersion()).isEqualTo("1.0");
+ assertThat(snapshotDto.getCodePeriodVersion()).isEqualTo("1.0");
assertThat(snapshotDto.getPeriodMode()).isEqualTo("mode1");
assertThat(snapshotDto.getPeriodModeParameter()).isEqualTo("param1");
assertThat(snapshotDto.getPeriodDate()).isEqualTo(parseDate("2014-06-01").getTime());
@Test
public void fail_if_version_name_is_longer_then_100_characters() {
SnapshotDto snapshotDto = new SnapshotDto();
- snapshotDto.setVersion(null);
- snapshotDto.setVersion("1.0");
- snapshotDto.setVersion(repeat("a", 100));
+ snapshotDto.setCodePeriodVersion(null);
+ snapshotDto.setCodePeriodVersion("1.0");
+ snapshotDto.setCodePeriodVersion(repeat("a", 100));
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Event name length (101) is longer than the maximum authorized (100). " +
"'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' was provided.");
- snapshotDto.setVersion(repeat("a", 101));
+ snapshotDto.setCodePeriodVersion(repeat("a", 101));
}
}
.setComponentUuid("abcd")
.setIsLast(true)
.setStatus("P")
- .setVersion("1.0")
+ .setCodePeriodVersion("1.0")
.setCreatedAfter(10L)
.setCreatedBefore(20L)
.setSort(BY_DATE, ASC);
assertThat(query.getComponentUuid()).isEqualTo("abcd");
assertThat(query.getIsLast()).isTrue();
assertThat(query.getStatus()).isEqualTo("P");
- assertThat(query.getVersion()).isEqualTo("1.0");
+ assertThat(query.getCodePeriodVersion()).isEqualTo("1.0");
assertThat(query.getCreatedAfter()).isEqualTo(10L);
assertThat(query.getCreatedBefore()).isEqualTo(20L);
assertThat(query.getSortField()).isEqualTo("created_at");
analysis -> {
wsComponent.setAnalysisDate(formatDateTime(analysis.getCreatedAt()));
ofNullable(analysis.getPeriodDate()).ifPresent(leak -> wsComponent.setLeakPeriodDate(formatDateTime(leak)));
- ofNullable(analysis.getVersion()).ifPresent(wsComponent::setVersion);
+ ofNullable(analysis.getCodePeriodVersion()).ifPresent(wsComponent::setVersion);
});
if (QUALIFIERS_WITH_VISIBILITY.contains(dto.qualifier())) {
wsComponent.setVisibility(Visibility.getLabel(dto.isPrivate()));
private EventDto insertDbEvent(DbSession dbSession, CreateEventRequest request, SnapshotDto analysis) {
EventDto dbEvent = dbClient.eventDao().insert(dbSession, toDbEvent(request, analysis));
if (VERSION.equals(request.getCategory())) {
- analysis.setVersion(request.getName());
+ analysis.setCodePeriodVersion(request.getName());
dbClient.snapshotDao().update(dbSession, analysis);
}
dbSession.commit();
SnapshotDto analysis = dbClient.snapshotDao().selectByUuid(dbSession, dbEvent.getAnalysisUuid())
.orElseThrow(() -> new IllegalStateException(format("Analysis '%s' not found", dbEvent.getAnalysisUuid())));
checkArgument(!analysis.getLast(), "Cannot delete the version event of last analysis");
- analysis.setVersion(null);
+ analysis.setCodePeriodVersion(null);
dbClient.snapshotDao().update(dbSession, analysis);
}
dbClient.eventDao().delete(dbSession, dbEvent.getUuid());
dbClient.eventDao().update(dbSession, event.getUuid(), event.getName(), event.getDescription());
if (VERSION.getLabel().equals(event.getCategory())) {
SnapshotDto analysis = getAnalysis(dbSession, event);
- analysis.setVersion(event.getName());
+ analysis.setCodePeriodVersion(event.getName());
dbClient.snapshotDao().update(dbSession, analysis);
}
dbSession.commit();
List<Page> pages = pageRepository.getComponentPages(false, component.qualifier());
writeExtensions(json, component, pages);
if (analysis != null) {
- json.prop("version", analysis.getVersion())
+ json.prop("version", analysis.getCodePeriodVersion())
.prop("analysisDate", formatDateTime(new Date(analysis.getCreatedAt())));
}
}
ComponentDto module = db.components().insertComponent(newModuleDto(project));
ComponentDto directory = db.components().insertComponent(newDirectory(module, "dir"));
ComponentDto file = db.components().insertComponent(newFileDto(directory));
- db.components().insertSnapshot(project, s -> s.setVersion("1.1"));
+ db.components().insertSnapshot(project, s -> s.setCodePeriodVersion("1.1"));
userSession.addProjectPermission(USER, project);
ShowWsResponse response = newRequest(null, file.getDbKey());
ComponentDto module = db.components().insertComponent(newModuleDto(branch));
ComponentDto directory = db.components().insertComponent(newDirectory(module, "dir"));
ComponentDto file = db.components().insertComponent(newFileDto(directory));
- db.components().insertSnapshot(branch, s -> s.setVersion("1.1"));
+ db.components().insertSnapshot(branch, s -> s.setCodePeriodVersion("1.1"));
ShowWsResponse response = ws.newRequest()
.setParam(PARAM_COMPONENT, file.getKey())
ComponentDto module = db.components().insertComponent(newModuleDto(branch));
ComponentDto directory = db.components().insertComponent(newDirectory(module, "dir"));
ComponentDto file = db.components().insertComponent(newFileDto(directory));
- db.components().insertSnapshot(branch, s -> s.setVersion("1.1"));
+ db.components().insertSnapshot(branch, s -> s.setCodePeriodVersion("1.1"));
ShowWsResponse response = ws.newRequest()
.setParam(PARAM_COMPONENT, file.getKey())
.setQualifier(Qualifiers.PROJECT)
.setTagsString("language, plugin"));
db.components().insertSnapshot(project, snapshot -> snapshot
- .setVersion("1.1")
+ .setCodePeriodVersion("1.1")
.setCreatedAt(parseDateTime("2017-03-01T11:39:03+0100").getTime())
.setPeriodDate(parseDateTime("2017-01-01T11:39:03+0100").getTime()));
ComponentDto directory = newDirectory(project, "AVIF-FfgA3Ax6PH2efPF", "src/main/java/com/sonarsource/markdown/impl")
call(VERSION.name(), "5.6.3", analysis.getUuid());
Optional<SnapshotDto> newAnalysis = dbClient.snapshotDao().selectByUuid(dbSession, analysis.getUuid());
- assertThat(newAnalysis.get().getVersion()).isEqualTo("5.6.3");
+ assertThat(newAnalysis.get().getCodePeriodVersion()).isEqualTo("5.6.3");
}
@Test
CreateEventResponse result = call(OTHER.name(), "Project Import", analysis.getUuid());
SnapshotDto newAnalysis = dbClient.snapshotDao().selectByUuid(dbSession, analysis.getUuid()).get();
- assertThat(analysis.getVersion()).isEqualTo(newAnalysis.getVersion());
+ assertThat(analysis.getCodePeriodVersion()).isEqualTo(newAnalysis.getCodePeriodVersion());
ProjectAnalyses.Event wsEvent = result.getEvent();
assertThat(wsEvent.getKey()).isNotEmpty();
assertThat(wsEvent.getCategory()).isEqualTo(OTHER.name());
@Test
public void delete_version_event() {
ComponentDto project = db.components().insertPrivateProject();
- SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setVersion("5.6.3").setLast(false));
+ SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setCodePeriodVersion("5.6.3").setLast(false));
db.events().insertEvent(newEvent(analysis).setUuid("E1").setCategory(VERSION.getLabel()));
logInAsProjectAdministrator(project);
call("E1");
SnapshotDto newAnalysis = dbClient.snapshotDao().selectByUuid(dbSession, analysis.getUuid()).get();
- assertThat(newAnalysis.getVersion()).isNull();
+ assertThat(newAnalysis.getCodePeriodVersion()).isNull();
}
@Test
public void fail_if_version_for_last_analysis() {
ComponentDto project = db.components().insertPrivateProject();
- SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setVersion("5.6.3").setLast(true));
+ SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setCodePeriodVersion("5.6.3").setLast(true));
db.events().insertEvent(newEvent(analysis).setUuid("E1").setCategory(VERSION.getLabel()));
logInAsProjectAdministrator(project);
call("E1", "6.3");
SnapshotDto updatedAnalysis = dbClient.snapshotDao().selectByUuid(dbSession, analysis.getUuid()).get();
- assertThat(updatedAnalysis.getVersion()).isEqualTo("6.3");
+ assertThat(updatedAnalysis.getCodePeriodVersion()).isEqualTo("6.3");
}
@Test
call("E1", "6.3");
SnapshotDto updatedAnalysis = dbClient.snapshotDao().selectByUuid(dbSession, analysis.getUuid()).get();
- assertThat(updatedAnalysis.getVersion()).isEqualTo("5.6");
+ assertThat(updatedAnalysis.getCodePeriodVersion()).isEqualTo("5.6");
}
@Test
private SnapshotDto createAnalysisAndLogInAsProjectAdministrator(String version) {
ComponentDto project = db.components().insertPrivateProject();
- SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setVersion(version));
+ SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setCodePeriodVersion(version));
logInAsProjectAdministrator(project);
return analysis;
}
ComponentDto project = insertOrganizationAndProject();
db.components().insertSnapshot(project, snapshot -> snapshot
.setCreatedAt(parseDateTime("2015-04-22T11:44:00+0200").getTime())
- .setVersion("3.14"));
+ .setCodePeriodVersion("3.14"));
userSession.addProjectPermission(UserRole.USER, project);
init();
componentDbTester.insertComponent(project);
SnapshotDto analysis = newAnalysis(project)
.setCreatedAt(parseDateTime("2016-12-06T11:44:00+0200").getTime())
- .setVersion("6.3")
+ .setCodePeriodVersion("6.3")
.setLast(true);
componentDbTester.insertSnapshot(analysis);
when(resourceTypes.get(project.qualifier())).thenReturn(DefaultResourceTypes.get().getRootType());