Stubit

implementation 'org.stubit:http:0.8.6'

try (var httpStub = new HttpStub()) {
  String stubAddress = httpStub.address();

  assertThat(stubAddress).isNotNull().startsWith("http://localhost:");
}

String stubAddress = httpStub.address();

var request = new Request.Builder().url(httpStub.address() + "/nothing/here").build();
var response = okHttpClient.newCall(request).execute();

assertThat(response.code()).isEqualTo(404);
assertThat(response.body().string()).isEqualTo("No stubbing for GET /nothing/here");

Stubbing stubbing =
    Stubbing.stub()
        .path("/some/where") (1)
        .method("GET") (2)
        .returns(StubbedResponse.response().body("Hello").statusCode(200)); (3)

httpStub.add(stubbing);

var request = new Request.Builder().url(httpStub.address() + "/some/where").build();
var response = okHttpClient.newCall(request).execute();

assertThat(response.code()).isEqualTo(200);
assertThat(response.body().string()).isEqualTo("Hello");

var getRequest = new Request.Builder().url(httpStub.address() + "/some/where").build();
okHttpClient.newCall(getRequest).execute();
var postRequest =
    new Request.Builder()
        .url(httpStub.address() + "/some/where")
        .post(RequestBody.create("Hello".getBytes(StandardCharsets.UTF_8)))
        .build();
okHttpClient.newCall(postRequest).execute();

assertThat(httpStub.receivedRequests()).hasSize(2);
assertThat(httpStub.receivedRequests(request -> "GET".equals(request.method())))
    .singleElement();
assertThat(httpStub.receivedRequests(request -> "POST".equals(request.method())))
    .singleElement();

class TestService {

  private final TestCrudRepository repository;

  @Autowired
  public TestService(TestCrudRepository repository) {
    this.repository = repository;
  }

  public List<TestEntity> getAll() {
    return stream(repository.findAll().spliterator(), false).toList();
  }

  public TestEntity getByName(String name) {
    return repository.findByName(name).orElseThrow();
  }
}

interface TestCrudRepository extends CrudRepository<TestEntity, UUID> {

  Optional<TestEntity> findByName(String name);
}

class TestCrudRepositoryStub extends CrudRepositoryStub<TestEntity, UUID>
    implements TestCrudRepository {

  @Override
  public Optional<TestEntity> findByName(String name) {
    return data.values().stream().filter(e -> e.getName().equals(name)).findFirst();
  }
}

TestCrudRepositoryStub repository = new TestCrudRepositoryStub();
TestService testService = new TestService(repository);

TestEntity savedEntity = repository.save(new TestEntity(randomUUID(), "first entity"));

Iterable<TestEntity> savedEntities =
    repository.saveAll(
        List.of(
            new TestEntity(randomUUID(), "second entity"),
            new TestEntity(randomUUID(), "third entity")));

assertThat(testService.getAll()).contains(savedEntity).containsAll(savedEntities);
assertThat(repository.findByName("first entity")).isPresent().contains(savedEntity);

repository.deleteAll();

String germanLicensePlate =
    aStringStartingWith(lettersFrom(anIntBetween(1, 3), Alphabet.GERMAN).toUpperCase())
        .followedBy("-")
        .followedBy(latinLetters(2).toUpperCase())
        .followedBy(arabicDigits(anIntBetween(1, 4)))
        .build();

assertThat(germanLicensePlate).matches("[A-ZÄÖÜẞ]{1,3}-[A-Z]{2}\\d{1,4}");

String iranianLicensePlate =
    aStringStartingWith(digitsFrom(2, DigitSystem.PERSIAN))
        .followedBy(aLetterFrom(Alphabet.BASIC_ARABIC))
        .followedBy(digitsFrom(3, DigitSystem.PERSIAN))
        .build();

assertThat(iranianLicensePlate).matches("[۰-۹]{2}[\\u0600-\\u06FF][۰-۹]{3}");

Duration someDuration = aDurationBetween(Duration.ZERO, Duration.ofDays(7));
assertThat(someDuration).isBetween(Duration.ZERO, Duration.ofDays(7));

Duration someDuration = aDuration().build();
assertThat(someDuration).isBetween(Duration.ZERO, Duration.ofSeconds(Long.MAX_VALUE - 1));

Duration someDurationBetween1And2Hours =
    aDuration().min(Duration.ofHours(1)).max(Duration.ofHours(2)).build();
assertThat(someDurationBetween1And2Hours).isBetween(Duration.ofHours(1), Duration.ofHours(2));

Duration someDurationLessThan2Hours = aDuration().max(Duration.ofHours(2)).build();
assertThat(someDurationLessThan2Hours).isLessThanOrEqualTo(Duration.ofHours(2));

Duration someDurationGreaterThan1Hour = aDuration().min(Duration.ofHours(1)).build();
assertThat(someDurationGreaterThan1Hour).isGreaterThanOrEqualTo(Duration.ofHours(1));

LocalDate someLockdownDay =
    aLocalDateBetween(LocalDate.of(2020, 3, 8), LocalDate.of(2020, 5, 4));
assertThat(someLockdownDay).isBetween(LocalDate.of(2020, 3, 8), LocalDate.of(2020, 5, 4));

LocalDate someLocalDate = aLocalDate().build();
assertThat(someLocalDate).isBetween(LocalDate.MIN, LocalDate.MAX);

LocalDate someDateIn2025 = aLocalDate().year(2025).build();
assertThat(someDateIn2025.getYear()).isEqualTo(2025);

LocalDate someDateInMarch = aLocalDate().month(Month.MARCH).build();
assertThat(someDateInMarch.getMonth()).isEqualTo(Month.MARCH);

LocalDate someDateInMarch2025 = aLocalDate().year(2025).month(Month.MARCH).build();
assertThat(someDateInMarch2025.getYear()).isEqualTo(2025);
assertThat(someDateInMarch2025.getMonth()).isEqualTo(Month.MARCH);

LocalDate some3rd = aLocalDate().dayOfMonth(3).build();
assertThat(some3rd.getDayOfMonth()).isEqualTo(3);

LocalDate someSunday = aLocalDate().dayOfWeek(DayOfWeek.SUNDAY).build();
assertThat(someSunday.getDayOfWeek()).isEqualTo(DayOfWeek.SUNDAY);

LocalDate someTuesday1999 = aLocalDate().year(1999).dayOfWeek(DayOfWeek.TUESDAY).build();
assertThat(someTuesday1999.getDayOfWeek()).isEqualTo(DayOfWeek.TUESDAY);
assertThat(someTuesday1999.getYear()).isEqualTo(1999);

LocalDate someLocalDate = aLocalDateInRange().build();
assertThat(someLocalDate).isBetween(LocalDate.MIN, LocalDate.MAX);

LocalDate someFutureDay = aLocalDateInRange().future().build();
assertThat(someFutureDay).isAfterOrEqualTo(LocalDate.now());

LocalDate somePastDay = aLocalDateInRange().past().build();
assertThat(somePastDay).isBeforeOrEqualTo(LocalDate.now());

LocalDate somePastAfterChristDay =
    aLocalDateInRange().past().after(LocalDate.of(1, 1, 1)).build();
assertThat(somePastAfterChristDay)
    .isBeforeOrEqualTo(LocalDate.now())
    .isAfterOrEqualTo(LocalDate.of(1, 1, 1));

LocalDate someFutureDayInTheNext5Years =
    aLocalDateInRange().future().before(Year.now().plusYears(5).atDay(1)).build();
assertThat(someFutureDayInTheNext5Years)
    .isAfterOrEqualTo(LocalDate.now())
    .isBeforeOrEqualTo(Year.now().plusYears(5).atDay(1));

LocalDate someLockdownDay =
    aLocalDateInRange()
        .after(LocalDate.of(2020, 3, 8))
        .before(LocalDate.of(2020, 5, 4))
        .build();
assertThat(someLockdownDay).isBetween(LocalDate.of(2020, 3, 8), LocalDate.of(2020, 5, 4));

LocalTime someTimeBusinessHours = aLocalTimeBetween(LocalTime.of(9, 0), LocalTime.of(17, 0, 0));
assertThat(someTimeBusinessHours).isBetween(LocalTime.of(9, 0), LocalTime.of(17, 0));

LocalTime someLocalTime = aLocalTime().build();
assertThat(someLocalTime).isBetween(LocalTime.MIN, LocalTime.MAX);

LocalTime someTimeAt12 = aLocalTime().hour(12).build();
assertThat(someTimeAt12.getHour()).isEqualTo(12);

LocalTime someHalfTime = aLocalTime().minute(30).build();
assertThat(someHalfTime.getMinute()).isEqualTo(30);

LocalTime someTimeAlmostFull = aLocalTime().minute(59).second(59).nano(999_999_999).build();
assertThat(someTimeAlmostFull.getMinute()).isEqualTo(59);
assertThat(someTimeAlmostFull.getSecond()).isEqualTo(59);
assertThat(someTimeAlmostFull.getNano()).isEqualTo(999_999_999);

LocalTime someLocalTime = aLocalTimeInRange().build();
assertThat(someLocalTime).isBetween(LocalTime.MIN, LocalTime.MAX);

LocalTime someFutureTime = aLocalTimeInRange().future().build();
assertThat(someFutureTime).isAfterOrEqualTo(LocalTime.now());

LocalTime somePastTime = aLocalTimeInRange().past().build();
assertThat(somePastTime).isBeforeOrEqualTo(LocalTime.now());

LocalTime someTimeAfterNoon = aLocalTimeInRange().after(LocalTime.NOON).build();
assertThat(someTimeAfterNoon).isAfterOrEqualTo(LocalTime.NOON);