@Test @UseDataProvider("allStatusesLeadingToClosed") public void automatically_reopen_closed_issue_to_most_recent_previous_status_from_changelog(String previousStatus) { DefaultIssue[] issues = Arrays.stream(SUPPORTED_RESOLUTIONS_FOR_UNCLOSING) .map(resolution -> { DefaultIssue issue = newClosedIssue(resolution); Date now = new Date(); addStatusChange(issue, addDays(now, -60), STATUS_OPEN, STATUS_CONFIRMED); addStatusChange(issue, addDays(now, -10), STATUS_CONFIRMED, previousStatus); setStatusPreviousToClosed(issue, previousStatus); return issue; }) .toArray(DefaultIssue[]::new); Date now = new Date(); workflow.start(); Arrays.stream(issues).forEach(issue -> { workflow.doAutomaticTransition(issue, IssueChangeContext.createScan(now)); assertThat(issue.status()).isEqualTo(previousStatus); assertThat(issue.updateDate()).isEqualTo(DateUtils.truncate(now, Calendar.SECOND)); assertThat(issue.closeDate()).isNull(); assertThat(issue.isChanged()).isTrue(); }); }
@Test @UseDataProvider("allResolutionsBeforeClosing") public void automatically_reopen_closed_issue_to_previous_resolution_of_closing_the_issue_if_most_recent_of_all_resolution_changes(String resolutionBeforeClosed) { String randomPreviousStatus = ALL_STATUSES_LEADING_TO_CLOSED[new Random().nextInt(ALL_STATUSES_LEADING_TO_CLOSED.length)]; DefaultIssue[] issues = Arrays.stream(SUPPORTED_RESOLUTIONS_FOR_UNCLOSING) .map(resolution -> { DefaultIssue issue = newClosedIssue(resolution); Date now = new Date(); addResolutionChange(issue, addDays(now, -60), null, RESOLUTION_FALSE_POSITIVE); addResolutionChange(issue, addDays(now, -10), RESOLUTION_FALSE_POSITIVE, resolutionBeforeClosed); addResolutionAndStatusChange(issue, now, randomPreviousStatus, STATUS_CLOSED, resolutionBeforeClosed, resolution); return issue; }) .toArray(DefaultIssue[]::new); Date now = new Date(); workflow.start(); Arrays.stream(issues).forEach(issue -> { workflow.doAutomaticTransition(issue, IssueChangeContext.createScan(now)); assertThat(issue.status()).isEqualTo(randomPreviousStatus); assertThat(issue.resolution()).isEqualTo(resolutionBeforeClosed); assertThat(issue.updateDate()).isEqualTo(DateUtils.truncate(now, Calendar.SECOND)); assertThat(issue.closeDate()).isNull(); assertThat(issue.isChanged()).isTrue(); }); }
@Test public void should_sort_by_update_date() { Date date = new Date(); Date date1 = DateUtils.addDays(date, -3); Date date2 = DateUtils.addDays(date, -2); Date date3 = DateUtils.addDays(date, -1); IssueDto issue1 = new IssueDto().setId(1L).setIssueUpdateDate(date1); IssueDto issue2 = new IssueDto().setId(2L).setIssueUpdateDate(date3); IssueDto issue3 = new IssueDto().setId(3L).setIssueUpdateDate(date2); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3); IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(false).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(3); assertThat(result.get(0).getIssueUpdateDate()).isEqualTo(date3); assertThat(result.get(1).getIssueUpdateDate()).isEqualTo(date2); assertThat(result.get(2).getIssueUpdateDate()).isEqualTo(date1); }
@Test public void should_sort_by_creation_date() { Date date = new Date(); Date date1 = DateUtils.addDays(date, -3); Date date2 = DateUtils.addDays(date, -2); Date date3 = DateUtils.addDays(date, -1); IssueDto issue1 = new IssueDto().setId(1L).setIssueCreationDate(date1); IssueDto issue2 = new IssueDto().setId(2L).setIssueCreationDate(date3); IssueDto issue3 = new IssueDto().setId(3L).setIssueCreationDate(date2); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3); IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CREATION_DATE).asc(false).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(3); assertThat(result.get(0).getIssueCreationDate()).isEqualTo(date3); assertThat(result.get(1).getIssueCreationDate()).isEqualTo(date2); assertThat(result.get(2).getIssueCreationDate()).isEqualTo(date1); }
@Test public void should_sort_by_close_date() { Date date = new Date(); Date date1 = DateUtils.addDays(date, -3); Date date2 = DateUtils.addDays(date, -2); Date date3 = DateUtils.addDays(date, -1); IssueDto issue1 = new IssueDto().setId(1L).setIssueCloseDate(date1); IssueDto issue2 = new IssueDto().setId(2L).setIssueCloseDate(date3); IssueDto issue3 = new IssueDto().setId(3L).setIssueCloseDate(date2); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3); IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(false).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(3); assertThat(result.get(0).getIssueCloseDate()).isEqualTo(date3); assertThat(result.get(1).getIssueCloseDate()).isEqualTo(date2); assertThat(result.get(2).getIssueCloseDate()).isEqualTo(date1); }
@Test public void purge_inactive_short_living_branches() { when(system2.now()).thenReturn(new Date().getTime()); RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertMainBranch(); ComponentDto longBranch = db.components().insertProjectBranch(project); ComponentDto recentShortBranch = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.SHORT)); // short branch with other components and issues, updated 31 days ago when(system2.now()).thenReturn(DateUtils.addDays(new Date(), -31).getTime()); ComponentDto shortBranch = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.SHORT)); ComponentDto module = db.components().insertComponent(newModuleDto(shortBranch)); ComponentDto subModule = db.components().insertComponent(newModuleDto(module)); ComponentDto file = db.components().insertComponent(newFileDto(subModule)); db.issues().insert(rule, shortBranch, file); db.issues().insert(rule, shortBranch, subModule); db.issues().insert(rule, shortBranch, module); // back to present when(system2.now()).thenReturn(new Date().getTime()); underTest.purge(dbSession, newConfigurationWith30Days(system2, project.uuid()), PurgeListener.EMPTY, new PurgeProfiler()); dbSession.commit(); assertThat(uuidsIn("projects")).containsOnly(project.uuid(), longBranch.uuid(), recentShortBranch.uuid()); }
@Test public void purge_inactive_pull_request() { when(system2.now()).thenReturn(new Date().getTime()); RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertMainBranch(); ComponentDto longBranch = db.components().insertProjectBranch(project); ComponentDto recentPullRequest = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.PULL_REQUEST)); // pull request with other components and issues, updated 31 days ago when(system2.now()).thenReturn(DateUtils.addDays(new Date(), -31).getTime()); ComponentDto pullRequest = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.PULL_REQUEST)); ComponentDto module = db.components().insertComponent(newModuleDto(pullRequest)); ComponentDto subModule = db.components().insertComponent(newModuleDto(module)); ComponentDto file = db.components().insertComponent(newFileDto(subModule)); db.issues().insert(rule, pullRequest, file); db.issues().insert(rule, pullRequest, subModule); db.issues().insert(rule, pullRequest, module); // back to present when(system2.now()).thenReturn(new Date().getTime()); underTest.purge(dbSession, newConfigurationWith30Days(system2, project.uuid()), PurgeListener.EMPTY, new PurgeProfiler()); dbSession.commit(); assertThat(uuidsIn("projects")).containsOnly(project.uuid(), longBranch.uuid(), recentPullRequest.uuid()); }
@Test public void should_delete_old_closed_issues() { RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertMainBranch(); ComponentDto module = db.components().insertComponent(newModuleDto(project)); ComponentDto file = db.components().insertComponent(newFileDto(module)); IssueDto oldClosed = db.issues().insert(rule, project, file, issue -> { issue.setStatus("CLOSED"); issue.setIssueCloseDate(DateUtils.addDays(new Date(), -31)); }); IssueDto notOldEnoughClosed = db.issues().insert(rule, project, file, issue -> { issue.setStatus("CLOSED"); issue.setIssueCloseDate(new Date()); }); IssueDto notClosed = db.issues().insert(rule, project, file); when(system2.now()).thenReturn(new Date().getTime()); underTest.purge(dbSession, newConfigurationWith30Days(system2, project.uuid()), PurgeListener.EMPTY, new PurgeProfiler()); dbSession.commit(); // old closed got deleted assertThat(db.getDbClient().issueDao().selectByKey(dbSession, oldClosed.getKey())).isEmpty(); // others remain assertThat(db.countRowsOfTable("issues")).isEqualTo(2); assertThat(db.getDbClient().issueDao().selectByKey(dbSession, notOldEnoughClosed.getKey())).isNotEmpty(); assertThat(db.getDbClient().issueDao().selectByKey(dbSession, notClosed.getKey())).isNotEmpty(); }
public Order setUpCartWithInactiveSku() throws AddToCartException { Customer customer = customerService.saveCustomer(createNamedCustomer()); Order order = orderService.createNewCartForCustomer(customer); Product newProduct = addTestProduct("Plastic Crate Should Be Inactive", "Crates"); Category newCategory = newProduct.getDefaultCategory(); order = orderService.addItem(order.getId(), new OrderItemRequestDTO(newProduct.getId(), newProduct.getDefaultSku().getId(), newCategory.getId(), 1), true); // Make the SKU inactive newProduct.getDefaultSku().setActiveEndDate(DateUtils.addDays(new Date(), -1)); catalogService.saveSku(newProduct.getDefaultSku()); return order; }
@Test public void close_issues_clean_index_and_file_sources_of_disabled_components_specified_by_uuid_in_configuration() { when(system2.now()).thenReturn(DateUtils.addDays(new Date(), -31).getTime()); RuleDefinitionDto rule = db.rules().insert(); ComponentDto project = db.components().insertMainBranch(p -> p.setEnabled(false));
/** * Return tokens expiration time, now + 1 day. * * @return */ private Date getExpirationTime() { return DateUtils.addDays(new Date(), 1); } }
@Override public List<T> getUpdatedRangesByComponentAcAndDate(String componentAc, Date updateDate) { return getSession().createCriteria(getEntityClass()).createAlias("parent", "p").createAlias("p.updateProcess", "p2") .add(Restrictions.lt("p2.date", DateUtils.addDays(updateDate, 1))) .add(Restrictions.gt("p2.date", DateUtils.addDays(updateDate, -1))) .add(Restrictions.eq("componentAc", componentAc)).list(); }
@Override public List<T> getByDate(Date updatedDate) { return getSession().createCriteria(getEntityClass()) .createAlias("updateProcess", "p") .add(Restrictions.lt("p.date", DateUtils.addDays(updatedDate, 1))) .add(Restrictions.gt("p.date", DateUtils.addDays(updatedDate, -1))) .addOrder(Order.asc("eventDate")).list(); }
private void prepareHistoricProcesses(String businessKey) { Date oldCurrentTime = ClockUtil.getCurrentTime(); ClockUtil.setCurrentTime(DateUtils.addDays(new Date(), -6)); List<String> processInstanceIds = new ArrayList<String>(); for (int i = 0; i < 5; i++) { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(businessKey); processInstanceIds.add(processInstance.getId()); } runtimeService.deleteProcessInstances(processInstanceIds, null, true, true); ClockUtil.setCurrentTime(oldCurrentTime); }
private void prepareBPMNData(int instanceCount, String businesskey) { Date oldCurrentTime = ClockUtil.getCurrentTime(); ClockUtil.setCurrentTime(DateUtils.addDays(new Date(), DAYS_IN_THE_PAST)); final List<String> ids = prepareHistoricProcesses(businesskey, getVariables(), instanceCount); deleteProcessInstances(ids); ClockUtil.setCurrentTime(oldCurrentTime); }
@Deployment(resources = {"org/camunda/bpm/engine/test/history/oneTaskProcess.bpmn20.xml"}) public void testHistoricProcessInstanceStartDate() { runtimeService.startProcessInstanceByKey("oneTaskProcess"); Date date = new Date(); assertEquals(1, historyService.createHistoricProcessInstanceQuery().startDateOn(date).count()); assertEquals(1, historyService.createHistoricProcessInstanceQuery().startDateBy(date).count()); assertEquals(1, historyService.createHistoricProcessInstanceQuery().startDateBy(DateUtils.addDays(date, -1)).count()); assertEquals(0, historyService.createHistoricProcessInstanceQuery().startDateBy(DateUtils.addDays(date, 1)).count()); assertEquals(0, historyService.createHistoricProcessInstanceQuery().startDateOn(DateUtils.addDays(date, -1)).count()); assertEquals(0, historyService.createHistoricProcessInstanceQuery().startDateOn(DateUtils.addDays(date, 1)).count()); }
private void prepareDMNData(int instanceCount) { Date oldCurrentTime = ClockUtil.getCurrentTime(); ClockUtil.setCurrentTime(DateUtils.addDays(new Date(), DAYS_IN_THE_PAST)); for (int i = 0; i < instanceCount; i++) { //spread end_time between different "minutes" ClockUtil.setCurrentTime(DateUtils.setMinutes(ClockUtil.getCurrentTime(), random.nextInt(60))); engineRule.getDecisionService().evaluateDecisionByKey(DECISION).variables(getDMNVariables()).evaluate(); } ClockUtil.setCurrentTime(oldCurrentTime); }
@Deployment(resources = {"org/camunda/bpm/engine/test/history/oneTaskProcess.bpmn20.xml"}) public void testHistoricProcessInstanceFinishDateFinished() { ProcessInstance pi = runtimeService.startProcessInstanceByKey("oneTaskProcess"); Date date = new Date(); runtimeService.deleteProcessInstance(pi.getId(), "cancel"); assertEquals(1, historyService.createHistoricProcessInstanceQuery().finishDateOn(date).count()); assertEquals(1, historyService.createHistoricProcessInstanceQuery().finishDateBy(date).count()); assertEquals(1, historyService.createHistoricProcessInstanceQuery().finishDateBy(DateUtils.addDays(date, 1)).count()); assertEquals(0, historyService.createHistoricProcessInstanceQuery().finishDateBy(DateUtils.addDays(date, -1)).count()); assertEquals(0, historyService.createHistoricProcessInstanceQuery().finishDateOn(DateUtils.addDays(date, -1)).count()); assertEquals(0, historyService.createHistoricProcessInstanceQuery().finishDateOn(DateUtils.addDays(date, 1)).count()); }
protected void prepareDecisionInstances(String key, int daysInThePast, Integer historyTimeToLive, int instanceCount) { List<DecisionDefinition> decisionDefinitions = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(key).list(); assertEquals(1, decisionDefinitions.size()); repositoryService.updateDecisionDefinitionHistoryTimeToLive(decisionDefinitions.get(0).getId(), historyTimeToLive); Date oldCurrentTime = ClockUtil.getCurrentTime(); ClockUtil.setCurrentTime(DateUtils.addDays(oldCurrentTime, daysInThePast)); Map<String, Object> variables = Variables.createVariables().putValue("status", "silver").putValue("sum", 723); for (int i = 0; i < instanceCount; i++) { engineRule.getDecisionService().evaluateDecisionByKey(key).variables(variables).evaluate(); } ClockUtil.setCurrentTime(oldCurrentTime); }