Skip to content

chore(deps): update sonarqube docker tag to v26.6.0.123539 #236

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
renovate merged 2 commits into from
Jun 26, 2026
Merged

chore(deps): update sonarqube docker tag to v26.6.0.123539 #236

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
fd7431f
chore(deps): update sonarqube docker tag to v26.6.0.123539
renovate[bot] Jun 26, 2026
04427ae
test(error): use fixed instants in assert tests
renanfranca Jun 26, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion src/main/docker/sonar.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
services:
sonar:
image: sonarqube:26.5.0.122743-community
image: sonarqube:26.6.0.123539-community
container_name: sonar
# Authentication is turned off for out of the box experience while trying out SonarQube
# For real use cases delete sonar.forceAuthentication variable or set sonar.forceAuthentication=true
Expand Down
61 changes: 28 additions & 33 deletions src/test/java/com/seed4j/cli/shared/error/domain/AssertTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,9 @@ class AssertTest {

private static final String FIELD_NAME = "fieldName";
private static final String NOT_NULL_OR_EMPTY = "NotNullOrEmpty";
private static final Instant INSTANT = Instant.parse("2024-02-21T21:00:00Z");
private static final Instant PAST_INSTANT = Instant.EPOCH;
private static final Instant FUTURE_INSTANT = Instant.parse("2999-12-31T23:59:59Z");

@Nested
class NotNullTest {
Expand Down Expand Up @@ -1157,7 +1160,7 @@ void shouldNotValidateNullAsNotNull() {

@Test
void shouldValidateActualInstantAsNotNull() {
assertThatCode(() -> Assert.field(FIELD_NAME, Instant.now()).notNull()).doesNotThrowAnyException();
assertThatCode(() -> Assert.field(FIELD_NAME, INSTANT).notNull()).doesNotThrowAnyException();
}

@Test
Expand All @@ -1169,14 +1172,14 @@ void shouldNotValidateNullInstantAsPast() {

@Test
void shouldNotValidateFutureInstantAsPast() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, future()).inPast())
assertThatThrownBy(() -> Assert.field(FIELD_NAME, FUTURE_INSTANT).inPast())
.isExactlyInstanceOf(NotBeforeTimeException.class)
.hasMessageContaining(FIELD_NAME);
}

@Test
void shouldValidatePastDateAsPast() {
assertThatCode(() -> Assert.field(FIELD_NAME, past()).inPast()).doesNotThrowAnyException();
assertThatCode(() -> Assert.field(FIELD_NAME, PAST_INSTANT).inPast()).doesNotThrowAnyException();
}

@Test
Expand All @@ -1188,33 +1191,33 @@ void shouldNotValidateNullInstantAsFuture() {

@Test
void shouldNotValidatePastInstantAsFuture() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, past()).inFuture())
assertThatThrownBy(() -> Assert.field(FIELD_NAME, PAST_INSTANT).inFuture())
.isExactlyInstanceOf(NotAfterTimeException.class)
.hasMessageContaining(FIELD_NAME);
}

@Test
void shouldValidateFutureDateAsFuture() {
assertThatCode(() -> Assert.field(FIELD_NAME, future()).inFuture()).doesNotThrowAnyException();
assertThatCode(() -> Assert.field(FIELD_NAME, FUTURE_INSTANT).inFuture()).doesNotThrowAnyException();
}

@Test
void shouldNotValidateInstantAfterNullInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, past()).after(null))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, PAST_INSTANT).after(null))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining("other");
}

@Test
void shouldNotValidateNullInstantAfterInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).after(past()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).after(PAST_INSTANT))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining(FIELD_NAME);
}

@Test
void shouldNotValidateSameInstantAsAfterInstant() {
Instant date = past();
Instant date = PAST_INSTANT;

assertThatThrownBy(() -> Assert.field(FIELD_NAME, date).after(date))
.isExactlyInstanceOf(NotAfterTimeException.class)
Expand All @@ -1224,68 +1227,68 @@ void shouldNotValidateSameInstantAsAfterInstant() {

@Test
void shouldNotValidatePastInstantAsAfterFutureInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, past()).after(future()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, PAST_INSTANT).after(FUTURE_INSTANT))
.isExactlyInstanceOf(NotAfterTimeException.class)
.hasMessageContaining(FIELD_NAME)
.hasMessageContaining("strictly");
}

@Test
void shouldValidateFutureInstantAsAfterPastInstant() {
assertThatCode(() -> Assert.field(FIELD_NAME, future()).after(past())).doesNotThrowAnyException();
assertThatCode(() -> Assert.field(FIELD_NAME, FUTURE_INSTANT).after(PAST_INSTANT)).doesNotThrowAnyException();
}

@Test
void shouldNotValidateInstantAfterOrAtNullInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, past()).afterOrAt(null))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, PAST_INSTANT).afterOrAt(null))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining("other");
}

@Test
void shouldNotValidateNullInstantAfterOrAtInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).afterOrAt(past()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).afterOrAt(PAST_INSTANT))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining(FIELD_NAME);
}

@Test
void shouldNotValidatePastInstantAsAfterOrAtFutureInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, past()).afterOrAt(future()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, PAST_INSTANT).afterOrAt(FUTURE_INSTANT))
.isExactlyInstanceOf(NotAfterTimeException.class)
.hasMessageContaining(FIELD_NAME)
.hasMessageNotContaining("strictly");
}

@Test
void shouldValidateFutureInstantAsAfterOrAtPastInstant() {
assertThatCode(() -> Assert.field(FIELD_NAME, future()).afterOrAt(past())).doesNotThrowAnyException();
assertThatCode(() -> Assert.field(FIELD_NAME, FUTURE_INSTANT).afterOrAt(PAST_INSTANT)).doesNotThrowAnyException();
}

@Test
void shouldValidateSameInstantAsAfterOrAtInstant() {
Instant date = past();
Instant date = PAST_INSTANT;

assertThatCode(() -> Assert.field(FIELD_NAME, date).afterOrAt(date)).doesNotThrowAnyException();
}

@Test
void shouldNotValidateInstantBeforeNullInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, past()).before(null))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, PAST_INSTANT).before(null))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining("other");
}

@Test
void shouldNotValidateNullInstantBeforeInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).before(past()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).before(PAST_INSTANT))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining(FIELD_NAME);
}

@Test
void shouldNotValidateSameInstantAsBeforeInstant() {
Instant date = past();
Instant date = PAST_INSTANT;

assertThatThrownBy(() -> Assert.field(FIELD_NAME, date).before(date))
.isExactlyInstanceOf(NotBeforeTimeException.class)
Expand All @@ -1295,57 +1298,49 @@ void shouldNotValidateSameInstantAsBeforeInstant() {

@Test
void shouldNotValidateFutureInstantAsBeforePastInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, future()).before(past()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, FUTURE_INSTANT).before(PAST_INSTANT))
.isExactlyInstanceOf(NotBeforeTimeException.class)
.hasMessageContaining(FIELD_NAME)
.hasMessageContaining("strictly");
}

@Test
void shouldValidatePastInstantAsBeforeFutureInstant() {
assertThatCode(() -> Assert.field(FIELD_NAME, past()).before(future())).doesNotThrowAnyException();
assertThatCode(() -> Assert.field(FIELD_NAME, PAST_INSTANT).before(FUTURE_INSTANT)).doesNotThrowAnyException();
}

@Test
void shouldNotValidateInstantBeforeOrAtNullInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, past()).beforeOrAt(null))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, PAST_INSTANT).beforeOrAt(null))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining("other");
}

@Test
void shouldNotValidateNullInstantBeforeOrAtInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).beforeOrAt(past()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, (Instant) null).beforeOrAt(PAST_INSTANT))
.isExactlyInstanceOf(MissingMandatoryValueException.class)
.hasMessageContaining(FIELD_NAME);
}

@Test
void shouldNotValidateFutureInstantAsBeforeOrAtPastInstant() {
assertThatThrownBy(() -> Assert.field(FIELD_NAME, future()).beforeOrAt(past()))
assertThatThrownBy(() -> Assert.field(FIELD_NAME, FUTURE_INSTANT).beforeOrAt(PAST_INSTANT))
.isExactlyInstanceOf(NotBeforeTimeException.class)
.hasMessageContaining(FIELD_NAME)
.hasMessageNotContaining("strictly");
}

@Test
void shouldValidatePastInstantAsAfterOrAtFutureInstant() {
assertThatCode(() -> Assert.field(FIELD_NAME, past()).beforeOrAt(future())).doesNotThrowAnyException();
assertThatCode(() -> Assert.field(FIELD_NAME, PAST_INSTANT).beforeOrAt(FUTURE_INSTANT)).doesNotThrowAnyException();
}

@Test
void shouldValidateSameInstantAsBeforeOrAtInstant() {
Instant date = past();
Instant date = PAST_INSTANT;

assertThatCode(() -> Assert.field(FIELD_NAME, date).beforeOrAt(date)).doesNotThrowAnyException();
}

private Instant past() {
return Instant.now().minusSeconds(10);
}

private Instant future() {
return Instant.now().plusSeconds(10);
}
}
}