@VisibleForTesting @CheckForNull Date maxLiveDateOfClosedIssues(Date now) { if (maxAgeInDaysOfClosedIssues > 0) { return DateUtils.addDays(now, -maxAgeInDaysOfClosedIssues); } // delete all closed issues return null; } }
public Optional<Date> maxLiveDateOfInactiveShortLivingBranches() { return maxAgeInDaysOfInactiveShortLivingBranches.map(age -> DateUtils.addDays(new Date(system2.now()), -age)); }
/** * Return the datetime if @param stringDate is a datetime, date + 1 day if stringDate is a date. * So '2016-09-01' would return a date equivalent to '2016-09-02T00:00:00+0000' in GMT (Warning: relies on default timezone!) * * @return the datetime, {@code null} if stringDate is null * @throws IllegalArgumentException if stringDate is not a correctly formed date or datetime * @see #parseDateOrDateTime(String) * @since 6.1 */ @CheckForNull public static Date parseEndingDateOrDateTime(@Nullable String stringDate) { if (stringDate == null) { return null; } Date date = parseDateTimeQuietly(stringDate); if (date != null) { return date; } date = parseDateQuietly(stringDate); checkArgument(date != null, "Date '%s' cannot be parsed as either a date or date+time", stringDate); return addDays(date, 1); }
@Override public void start() { try (DbSession dbSession = dbClient.openSession(false)) { Date sixMonthsAgo = DateUtils.addDays(new Date(system2.now()), -180); LOGGER.info("Delete the Compute Engine tasks created before {}", sixMonthsAgo.getTime()); Set<String> ceActivityUuids = dbClient.ceActivityDao().selectOlderThan(dbSession, sixMonthsAgo.getTime()) .stream() .map(CeActivityDto::getUuid) .collect(toSet()); dbClient.ceActivityDao().deleteByUuids(dbSession, ceActivityUuids); dbClient.ceTaskCharacteristicsDao().deleteByTaskUuids(dbSession, ceActivityUuids); dbClient.ceTaskInputDao().deleteByUuids(dbSession, ceActivityUuids); Date fourWeeksAgo = DateUtils.addDays(new Date(system2.now()), -28); LOGGER.info("Delete the Scanner contexts tasks created before {}", fourWeeksAgo.getTime()); Set<String> scannerContextUuids = dbClient.ceScannerContextDao().selectOlderThan(dbSession, fourWeeksAgo.getTime()); dbClient.ceScannerContextDao().deleteByUuids( dbSession, concat(ceActivityUuids.stream(), scannerContextUuids.stream()).collect(toSet())); dbSession.commit(); } }
private Optional<Period> resolveByDays(DbSession dbSession, String projectUuid, Integer days, String propertyValue) { checkPeriodProperty(days > 0, propertyValue, "number of days is <= 0"); long analysisDate = analysisMetadataHolder.getAnalysisDate(); List<SnapshotDto> snapshots = dbClient.snapshotDao().selectAnalysesByQuery(dbSession, createCommonQuery(projectUuid).setCreatedBefore(analysisDate).setSort(BY_DATE, ASC)); ensureNotOnFirstAnalysis(!snapshots.isEmpty()); Instant targetDate = DateUtils.addDays(Instant.ofEpochMilli(analysisDate), -days); LOG.debug("Resolving new code period by {} days: {}", days, supplierToString(() -> logDate(targetDate))); SnapshotDto snapshot = findNearestSnapshotToTargetDate(snapshots, targetDate); return Optional.of(newPeriod(LEAK_PERIOD_MODE_DAYS, String.valueOf((int) days), snapshot)); }
@Test public void should_have_empty_branch_purge_date() { PurgeConfiguration conf = new PurgeConfiguration(new IdUuidPair(1L, "1"), emptyList(), 30, Optional.of(10), System2.INSTANCE, emptyList()); assertThat(conf.maxLiveDateOfInactiveShortLivingBranches()).isNotEmpty(); long tenDaysAgo = DateUtils.addDays(new Date(System2.INSTANCE.now()), -10).getTime(); assertThat(conf.maxLiveDateOfInactiveShortLivingBranches().get().getTime()).isBetween(tenDaysAgo - 5000, tenDaysAgo + 5000); }
@Test public void is_last_snapshot_when_previous_snapshot_is_older() { Date today = new Date(); Date yesterday = DateUtils.addDays(today, -1); SnapshotDto snapshot = defaultSnapshot().setCreatedAt(today.getTime()); SnapshotDto previousLastSnapshot = defaultSnapshot().setCreatedAt(yesterday.getTime()); boolean isLast = SnapshotDao.isLast(snapshot, previousLastSnapshot); assertThat(isLast).isTrue(); }
@Test public void is_not_last_snapshot_when_previous_snapshot_is_newer() { Date today = new Date(); Date yesterday = DateUtils.addDays(today, -1); SnapshotDto snapshot = defaultSnapshot().setCreatedAt(yesterday.getTime()); SnapshotDto previousLastSnapshot = defaultSnapshot().setCreatedAt(today.getTime()); boolean isLast = SnapshotDao.isLast(snapshot, previousLastSnapshot); assertThat(isLast).isFalse(); }
private static FieldDiffs newToClosedDiffsWithLine(Date creationDate, @Nullable Integer oldLineValue) { FieldDiffs fieldDiffs = new FieldDiffs().setCreationDate(addDays(creationDate, -5)) .setDiff("status", randomNonCloseStatus(), STATUS_CLOSED); if (oldLineValue != null) { fieldDiffs.setDiff("line", oldLineValue, ""); } return fieldDiffs; }
@Test public void delete_files_and_directories() { MapSettings settings = new MapSettings(new PropertyDefinitions(PurgeProperties.all())); settings.setProperty(PurgeConstants.DAYS_BEFORE_DELETING_CLOSED_ISSUES, 5); Date now = new Date(); PurgeConfiguration underTest = PurgeConfiguration.newDefaultPurgeConfiguration(settings.asConfig(), new IdUuidPair(42L, "any-uuid"), emptyList()); assertThat(underTest.getScopesWithoutHistoricalData()) .containsExactlyInAnyOrder(Scopes.DIRECTORY, Scopes.FILE); assertThat(underTest.maxLiveDateOfClosedIssues(now)).isEqualTo(DateUtils.addDays(now, -5)); } }
OrganizationDto organizationDto = newOrganizationDto(); ComponentDto project1 = newPrivateProjectDto(organizationDto); IssueDoc project1Issue1 = newDoc(project1).setFuncCreationDate(addDays(now, -10)); IssueDoc project1Issue2 = newDoc(project1).setFuncCreationDate(addDays(now, -20)); ComponentDto project2 = newPrivateProjectDto(organizationDto); IssueDoc project2Issue1 = newDoc(project2).setFuncCreationDate(addDays(now, -15)); IssueDoc project2Issue2 = newDoc(project2).setFuncCreationDate(addDays(now, -30)); indexIssues(project1Issue1, project1Issue2, project2Issue1, project2Issue2); .createdAfterByProjectUuids(ImmutableMap.of(project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -15), true))), project1Issue1.key()); project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -14), true), project2.uuid(), new IssueQuery.PeriodStart(addDays(now, -25), true))), project1Issue1.key(), project2Issue1.key()); project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -30), true))), project1Issue1.key(), project1Issue2.key()); project1.uuid(), new IssueQuery.PeriodStart(addDays(now, -5), true), project2.uuid(), new IssueQuery.PeriodStart(addDays(now, -5), true))));
private void loadClosedIssues_returns_only_closed_issues_with_close_date_is_from_30_days_ago(ComponentIssuesLoader underTest) { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto project = dbTester.components().insertPublicProject(organization); ComponentDto file = dbTester.components().insertComponent(ComponentTesting.newFileDto(project)); RuleDefinitionDto rule = dbTester.rules().insert(t -> t.setType(RuleType.CODE_SMELL)); Date[] issueDates = new Date[] { addDays(NOW, -10), addDays(NOW, -31), addDays(NOW, -30), DATE_LIMIT_30_DAYS_BACK_MIDNIGHT, addDays(NOW, -29), addDays(NOW, -60), }; IssueDto[] issues = Arrays.stream(issueDates) .map(issueDate -> { IssueDto closedIssue = dbTester.issues().insert(rule, project, file, t -> t.setStatus(STATUS_CLOSED).setIssueCloseDate(issueDate).setIsFromHotspot(false)); dbTester.issues().insertFieldDiffs(closedIssue, newToClosedDiffsWithLine(issueDate, 10)); return closedIssue; }) .toArray(IssueDto[]::new); when(system2.now()).thenReturn(NOW.getTime()); List<DefaultIssue> defaultIssues = underTest.loadClosedIssues(file.uuid()); assertThat(defaultIssues) .extracting(DefaultIssue::key) .containsOnly(issues[0].getKey(), issues[2].getKey(), issues[3].getKey(), issues[4].getKey()); }
@Test public void loadClosedIssues_returns_single_DefaultIssue_by_issue_based_on_first_row() { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto project = dbTester.components().insertPublicProject(organization); ComponentDto file = dbTester.components().insertComponent(ComponentTesting.newFileDto(project)); RuleDefinitionDto rule = dbTester.rules().insert(t -> t.setType(RuleType.CODE_SMELL)); Date issueDate = addDays(NOW, -10); IssueDto issue = dbTester.issues().insert(rule, project, file, t -> t.setStatus(STATUS_CLOSED).setIssueCloseDate(issueDate).setIsFromHotspot(false)); dbTester.issues().insertFieldDiffs(issue, newToClosedDiffsWithLine(issueDate, 10)); dbTester.issues().insertFieldDiffs(issue, newToClosedDiffsWithLine(addDays(issueDate, 3), 20)); dbTester.issues().insertFieldDiffs(issue, newToClosedDiffsWithLine(addDays(issueDate, 1), 30)); when(system2.now()).thenReturn(NOW.getTime()); ComponentIssuesLoader underTest = newComponentIssuesLoader(newEmptySettings()); List<DefaultIssue> defaultIssues = underTest.loadClosedIssues(file.uuid()); assertThat(defaultIssues).hasSize(1); assertThat(defaultIssues.iterator().next().getLine()).isEqualTo(20); }
@Test public void leak_period_start_date_is_exclusive() { long leakPeriodStart = addDays(new Date(), -14).getTime(); ComponentDto project = db.components().insertPublicProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); SnapshotDto analysis = db.components().insertSnapshot(project, s -> s.setPeriodDate(leakPeriodStart)); SearchRequest request = new SearchRequest() .setComponentUuids(Collections.singletonList(file.uuid())) .setOnComponentOnly(true) .setSinceLeakPeriod(true); IssueQuery query = underTest.create(request); assertThat(query.componentUuids()).containsOnly(file.uuid()); assertThat(query.createdAfter().date()).isEqualTo(new Date(leakPeriodStart)); assertThat(query.createdAfter().inclusive()).isFalse(); }
@Test public void loadClosedIssues_returns_single_DefaultIssue_with_null_line_if_first_row_has_no_line_diff() { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto project = dbTester.components().insertPublicProject(organization); ComponentDto file = dbTester.components().insertComponent(ComponentTesting.newFileDto(project)); RuleDefinitionDto rule = dbTester.rules().insert(t -> t.setType(RuleType.CODE_SMELL)); Date issueDate = addDays(NOW, -10); IssueDto issue = dbTester.issues().insert(rule, project, file, t -> t.setStatus(STATUS_CLOSED).setIssueCloseDate(issueDate).setIsFromHotspot(false)); dbTester.issues().insertFieldDiffs(issue, newToClosedDiffsWithLine(issueDate, 10)); dbTester.issues().insertFieldDiffs(issue, newToClosedDiffsWithLine(addDays(issueDate, 2), null)); dbTester.issues().insertFieldDiffs(issue, newToClosedDiffsWithLine(addDays(issueDate, 1), 30)); when(system2.now()).thenReturn(NOW.getTime()); ComponentIssuesLoader underTest = newComponentIssuesLoader(newEmptySettings()); List<DefaultIssue> defaultIssues = underTest.loadClosedIssues(file.uuid()); assertThat(defaultIssues).hasSize(1); assertThat(defaultIssues.iterator().next().getLine()).isNull(); }
@Test @UseDataProvider("closedIssuesSupportedRuleTypes") public void scrollClosedByComponentUuid_does_not_return_row_for_status_change_from_close(RuleType ruleType) { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto component = randomComponent(organization); IssueDto issue = insertNewClosedIssue(component, ruleType); Date date = new Date(); IssueChangeDto changes[] = new IssueChangeDto[] { insertToClosedDiff(issue, DateUtils.addDays(date, -10), Issue.STATUS_CLOSED, Issue.STATUS_REOPENED), insertToClosedDiff(issue, DateUtils.addDays(date, -60)), insertToClosedDiff(issue, date), insertToClosedDiff(issue, DateUtils.addDays(date, -5)) }; RecorderResultHandler resultHandler = new RecorderResultHandler(); underTest.scrollClosedByComponentUuid(component.uuid(), NO_FILTERING_ON_CLOSE_DATE, resultHandler); assertThat(resultHandler.issues) .hasSize(3) .extracting(IssueDto::getKey, t -> t.getClosedChangeData().get()) .containsExactly( tuple(issue.getKey(), changes[2].getChangeData()), tuple(issue.getKey(), changes[3].getChangeData()), tuple(issue.getKey(), changes[1].getChangeData())); }
@Test @UseDataProvider("closedIssuesSupportedRuleTypes") public void scrollClosedByComponentUuid_return_one_row_per_status_diff_to_CLOSED_sorted_by_most_recent_creation_date_first(RuleType ruleType) { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto component = randomComponent(organization); IssueDto issue = insertNewClosedIssue(component, ruleType); Date date = new Date(); IssueChangeDto changes[] = new IssueChangeDto[] { insertToClosedDiff(issue, DateUtils.addDays(date, -10)), insertToClosedDiff(issue, DateUtils.addDays(date, -60)), insertToClosedDiff(issue, date), insertToClosedDiff(issue, DateUtils.addDays(date, -5)) }; RecorderResultHandler resultHandler = new RecorderResultHandler(); underTest.scrollClosedByComponentUuid(component.uuid(), NO_FILTERING_ON_CLOSE_DATE, resultHandler); assertThat(resultHandler.issues) .hasSize(4) .extracting(IssueDto::getKey, t -> t.getClosedChangeData().get()) .containsExactly( tuple(issue.getKey(), changes[2].getChangeData()), tuple(issue.getKey(), changes[3].getChangeData()), tuple(issue.getKey(), changes[0].getChangeData()), tuple(issue.getKey(), changes[1].getChangeData())); }
@Test public void application_search_project_issues_on_leak() { Date now = new Date(); ComponentDto project1 = db.components().insertPublicProject(); SnapshotDto analysis1 = db.components().insertSnapshot(project1, s -> s.setPeriodDate(addDays(now, -14).getTime())); ComponentDto project2 = db.components().insertPublicProject(); SnapshotDto analysis2 = db.components().insertSnapshot(project2, s -> s.setPeriodDate(null)); ComponentDto project3 = db.components().insertPublicProject(); ComponentDto application = db.components().insertApplication(db.getDefaultOrganization()); db.components().insertComponents(newProjectCopy("PC1", project1, application)); db.components().insertComponents(newProjectCopy("PC2", project2, application)); db.components().insertComponents(newProjectCopy("PC3", project3, application)); userSession.registerComponents(application, project1, project2, project3); IssueQuery result = underTest.create(new SearchRequest() .setComponentUuids(singletonList(application.uuid())) .setSinceLeakPeriod(true)); assertThat(result.createdAfterByProjectUuids()).hasSize(1); assertThat(result.createdAfterByProjectUuids().get(project1.uuid()).date().getTime()).isEqualTo(analysis1.getPeriodDate()); assertThat(result.createdAfterByProjectUuids().get(project1.uuid()).inclusive()).isFalse(); assertThat(result.viewUuids()).containsExactlyInAnyOrder(application.uuid()); }
@Test public void loadClosedIssues_returns_only_closed_issues_with_close_date() { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto project = dbTester.components().insertPublicProject(organization); ComponentDto file = dbTester.components().insertComponent(ComponentTesting.newFileDto(project)); RuleDefinitionDto rule = dbTester.rules().insert(t -> t.setType(RuleType.CODE_SMELL)); Date issueDate = addDays(NOW, -10); IssueDto closedIssue = dbTester.issues().insert(rule, project, file, t -> t.setStatus(STATUS_CLOSED).setIssueCloseDate(issueDate).setIsFromHotspot(false)); dbTester.issues().insertFieldDiffs(closedIssue, newToClosedDiffsWithLine(issueDate, 10)); IssueDto issueNoCloseDate = dbTester.issues().insert(rule, project, file, t -> t.setStatus(STATUS_CLOSED).setIsFromHotspot(false)); dbTester.issues().insertFieldDiffs(issueNoCloseDate, newToClosedDiffsWithLine(issueDate, 10)); when(system2.now()).thenReturn(NOW.getTime()); ComponentIssuesLoader underTest = newComponentIssuesLoader(newEmptySettings()); List<DefaultIssue> defaultIssues = underTest.loadClosedIssues(file.uuid()); assertThat(defaultIssues) .extracting(DefaultIssue::key) .containsOnly(closedIssue.getKey()); }
@Test public void search_with_more_recent_analysis() { long yesterday = DateUtils.addDays(new Date(), -1).getTime(); ComponentDto project = db.components().insertPrivateProject(); UserDto userAuthenticated = db.users().insertUser(); userSession.logIn(userAuthenticated).addProjectPermission(ADMIN, project); UserDto userMeasureCreator = db.users().insertUser(); MetricDto metric = db.measures().insertMetric(m -> m.setUserManaged(true).setValueType(STRING.name())); CustomMeasureDto customMeasure = db.measures().insertCustomMeasure(userMeasureCreator, project, metric, m -> m.setCreatedAt(yesterday).setUpdatedAt(yesterday)); db.components().insertSnapshot(project); String response = ws.newRequest() .setParam(SearchAction.PARAM_PROJECT_ID, project.uuid()) .execute() .getInput(); assertJson(response).isSimilarTo("{\n" + " \"customMeasures\": [\n" + " {\n" + " \"id\": \"" + customMeasure.getId() + "\",\n" + " \"value\": \"" + customMeasure.getTextValue() + "\",\n" + " \"pending\": false\n" + " },\n" + " ]\n" + "}"); }