@Test public void test_end_user_context() { Date now = new Date(); IssueChangeContext context = IssueChangeContext.createUser(now, "user_uuid"); assertThat(context.scan()).isFalse(); assertThat(context.userUuid()).isEqualTo("user_uuid"); assertThat(context.date()).isEqualTo(now); } }
@Test public void decode_token() { setSecretKey(A_SECRET_KEY); underTest.start(); Date now = new Date(); String token = underTest.encode(new JwtSession(USER_LOGIN, 20 * 60)); Claims claims = underTest.decode(token).get(); assertThat(claims.getId()).isNotEmpty(); assertThat(claims.getSubject()).isEqualTo(USER_LOGIN); assertThat(claims.getExpiration()).isNotNull(); assertThat(claims.getIssuedAt()).isNotNull(); // Check expiration date it set to more than 19 minutes in the future assertThat(claims.getExpiration()).isAfterOrEqualsTo(new Date(now.getTime() + 19 * 60 * 1000)); }
@Test public void long_to_date() { Date date = new Date(); assertThat(DateUtils.longToDate(date.getTime())).isEqualTo(date); assertThat(DateUtils.longToDate(null)).isNull(); }
return isEqualToIgnoringMillis(parse(dateAsString));
return isNotEqualTo(parse(dateAsString));
@Test public void refresh_token() { setSecretKey(A_SECRET_KEY); underTest.start(); Date now = new Date(); Date createdAt = DateUtils.parseDate("2016-01-01"); // Expired in 10 minutes Date expiredAt = new Date(now.getTime() + 10 * 60 * 1000); Claims token = new DefaultClaims() .setId("id") .setSubject("subject") .setIssuer("sonarqube") .setIssuedAt(createdAt) .setExpiration(expiredAt); token.put("key", "value"); // Refresh the token with a higher expiration time String encodedToken = underTest.refresh(token, 20 * 60); Claims result = underTest.decode(encodedToken).get(); assertThat(result.getId()).isEqualTo("id"); assertThat(result.getSubject()).isEqualTo("subject"); assertThat(result.getIssuer()).isEqualTo("sonarqube"); assertThat(result.getIssuedAt()).isEqualTo(createdAt); assertThat(result.get("key")).isEqualTo("value"); // Expiration date has been changed assertThat(result.getExpiration()).isNotEqualTo(expiredAt) .isAfterOrEqualsTo(new Date(now.getTime() + 19 * 1000)); }
private void assertNodeInstance(NodeInstance ni, String nodeName, int slaStatus) { assertThat(ni.getName()).isEqualTo(nodeName); assertThat(ni.getSlaCompliance()).isEqualTo(slaStatus); if (slaStatus != SLA_NA) { assertThat(ni.getSlaDueDate()).isCloseTo(new Date(), 30000); } }
@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); }
assertNotNull(commentById); assertEquals(commentId, commentById.getId()); Assertions.assertThat(commentById.getAddedAt()).isCloseTo(TODAY, 1000); assertEquals(user, commentById.getAddedBy()); assertEquals(txt, commentById.getText()); ((InternalComment)comment2).setAddedAt(new Date()); User user2 = TaskModelProvider.getFactory().newUser(); ((InternalOrganizationalEntity) user2).setId("Master");
@Test public void noRetentionOnTermination() throws InterruptedException { Date date = new Date(); CompletableFuture<Date> future = new CompletableFuture<>(); WeakReference<Date> refDate = new WeakReference<>(date); WeakReference<CompletableFuture<Date>> refFuture = new WeakReference<>(future); Mono<Date> source = Mono.fromFuture(future); Mono<String> data = source.map(Date::toString).log().cache().log(); future.complete(date); assertThat(data.block()).isEqualTo(date.toString()); date = null; future = null; source = null; System.gc(); int cycles; for (cycles = 10; cycles > 0 ; cycles--) { if (refDate.get() == null && refFuture.get() == null) break; Thread.sleep(100); } assertThat(refFuture.get()).isNull(); assertThat(refDate.get()).isNull(); assertThat(cycles).isNotZero() .isPositive(); }
@Test public void do_not_automatically_reopen_closed_issue_which_have_no_previous_status_in_changelog() { DefaultIssue[] issues = Arrays.stream(SUPPORTED_RESOLUTIONS_FOR_UNCLOSING) .map(IssueWorkflowTest::newClosedIssue) .toArray(DefaultIssue[]::new); Date now = new Date(); workflow.start(); Arrays.stream(issues).forEach(issue -> { workflow.doAutomaticTransition(issue, IssueChangeContext.createScan(now)); assertThat(issue.status()).isEqualTo(STATUS_CLOSED); assertThat(issue.updateDate()).isNull(); }); }
@Test public void test_scan_context() { Date now = new Date(); IssueChangeContext context = IssueChangeContext.createScan(now); assertThat(context.scan()).isTrue(); assertThat(context.userUuid()).isNull(); assertThat(context.date()).isEqualTo(now); }
@Test public void improve_coverage() { Date creationDate = new Date(); TrackedIssue trackedIssue = new TrackedIssue() .setKey("XYZ123") assertThat(issue.isNew()).isTrue(); assertThat(issue.attribute("foo")).isNull(); assertThat(issue.creationDate()).isEqualTo(creationDate); assertThat(issue.language()).isNull(); assertThat(issue.updateDate()).isNull(); assertThat(issue.closeDate()).isNull(); assertThat(issue.authorLogin()).isNull(); assertThat(issue.comments()).isEmpty(); assertThat(issue.effort()).isNull(); assertThat(issue.projectKey()).isNull(); assertThat(issue).isNotEqualTo("Foo"); assertThat(issue).isEqualTo(new TrackedIssueAdapter(trackedIssue)); assertThat(issue.hashCode()).isEqualTo(trackedIssue.key().hashCode()); assertThat(issue).isNotEqualTo(new TrackedIssueAdapter(new TrackedIssue() .setKey("another")));
@Test public void getFieldAsDate() { BaseDoc doc = new BaseDoc(Maps.newHashMap()) { @Override public String getId() { return null; } @Override public String getRouting() { return null; } @Override public String getParent() { return null; } }; Date now = new Date(); doc.setField("javaDate", now); assertThat(doc.getFieldAsDate("javaDate")).isEqualToIgnoringMillis(now); doc.setField("stringDate", EsUtils.formatDateTime(now)); assertThat(doc.getFieldAsDate("stringDate")).isEqualToIgnoringMillis(now); }
@Test public void getNullableFieldAsDate() { BaseDoc doc = new BaseDoc(Maps.newHashMap()) { @Override public String getId() { return null; } @Override public String getRouting() { return null; } @Override public String getParent() { return null; } }; Date now = new Date(); doc.setField("javaDate", now); assertThat(doc.getNullableFieldAsDate("javaDate")).isEqualToIgnoringMillis(now); doc.setField("stringDate", EsUtils.formatDateTime(now)); assertThat(doc.getNullableFieldAsDate("stringDate")).isEqualToIgnoringMillis(now); doc.setField("noValue", null); assertThat(doc.getNullableFieldAsDate("noValue")).isNull(); } }
fromShort.setStatus("status"); Date commentDate = new Date(); fromShort.addComment(new DefaultIssueComment() .setIssueKey("short") .setMarkdownText("A comment")); Date diffDate = new Date(); assertThat(raw.resolution()).isEqualTo("resolution"); assertThat(raw.status()).isEqualTo("status"); assertThat(raw.defaultIssueComments()) .extracting(DefaultIssueComment::issueKey, DefaultIssueComment::createdAt, DefaultIssueComment::userUuid, DefaultIssueComment::markdownText) .containsOnly(tuple("raw", commentDate, "user_uuid", "A comment")); assertThat(raw.changes()).hasSize(2); assertThat(raw.changes().get(0).creationDate()).isEqualTo(diffDate); assertThat(raw.changes().get(0).userUuid()).isEqualTo("user_uuid"); assertThat(raw.changes().get(0).issueKey()).isEqualTo("raw"); assertThat(raw.changes().get(0).diffs()).containsOnlyKeys("severity");
@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)); } }
private void assertProcessInstance(Long pid, int processState, int slaStatus) { assertThat(pid).isNotNull(); ProcessInstance pi = queryClient.findProcessInstanceById(pid); assertThat(pi.getState()).isEqualTo(processState); assertThat(pi.getSlaCompliance()).isEqualTo(slaStatus); if (slaStatus != SLA_NA) { assertThat(pi.getSlaDueDate()).isCloseTo(new Date(), 30000); } }
@Test void Should_Increase_Value() { // given final Date beforeChange = new Date(); // when final Date result = valueChanger.increaseValue(beforeChange, beforeChange.getClass()); // then assertThat(result).isNotEqualTo(beforeChange); }