Mocks vs TestContainers

GenericContainer redis = new GenericContainer(
        DockerImageName.parse("redis:5.0.3-alpine"))
        .withExposedPorts(6379);

String address = redis.getHost();
Integer port = redis.getFirstMappedPort();

underTest = new RedisBackedCache(address, port);

try {
  murders = restClient.loadMurders();
}
catch (IOException e) {
  logger.error("failed to load", e);
  murders = emptyList();
}

GenericContainer redis = new GenericContainer(
        DockerImageName.parse("redis:5.0.3-alpine"))
        .withExposedPorts(6379);

String address = redis.getHost();
Integer port = redis.getFirstMappedPort();

underTest = new RedisBackedCache(address, port);

//build.gradle.kts
testImplementation("com.github.fppt:jedis-mock:1.1.1")

//This binds mock redis server to a random port
RedisServer server = RedisServer
        .newRedisServer()
        .start();

//Jedis connection:
Jedis jedis = new Jedis(server.getHost(), server.getBindPort());
//Lettuce connection:
RedisClient redisClient = RedisClient
        .create(String.format("redis://%s:%s",
        server.getHost(), server.getBindPort()));

RedisServer server = RedisServer.newRedisServer()
  .setOptions(ServiceOptions.withInterceptor((state, cmd, params) -> {
    if ("get".equalsIgnoreCase(cmd)) {
      //explicitly specify the response
      return Response.bulkString(Slice.create("MOCK_VALUE"));
    } else {
      //delegate to the mock
      return MockExecutor.proceed(state, cmd, params);
    }
})).start();

RedisServer server = RedisServer.newRedisServer()
  .setOptions(ServiceOptions.withInterceptor((state, cmd, params) -> {
    if ("echo".equalsIgnoreCase(cmd)) {
      //check the request
      assertEquals("hello", params.get(0).toString());
    }
    //delegate to the mock
    return MockExecutor.proceed(state, cmd, params);
})).start();

RedisServer server = RedisServer.newRedisServer()
  .setOptions(ServiceOptions.withInterceptor((state, cmd, params) -> {
    if ("echo".equalsIgnoreCase(cmd)) {
      //simulate a failure
      return MockExecutor.breakConnection(state);
    } else {
      //delegate to the mock
      return MockExecutor.proceed(state, cmd, params);
    }
})).start();

//5 seconds?? maybe 6? maybe 4?
while (!(records =
           consumer.poll(Duration.ofSeconds(5))).isEmpty()) {
    for (ConsumerRecord<String, String> rec : records) {
        values.add(rec.value());
    }
}

Awaitility.await().atMost(10, SECONDS).until(() ->
                  { // returns true
                  });

Awaitility.await().atMost(10, SECONDS).until(() ->
                  { // returns true
                  });

Awaitility.await().atMost(10, SECONDS).until(() ->
                  { // returns true
                  });

Awaitility.await().atMost(10, SECONDS).until(()->
                  { // returns false for more than 10 seconds
                  });

//This must be a thread-safe data structure!
List<String> actual = new CopyOnWriteArrayList<>();
ExecutorService service = Executors.newSingleThreadExecutor();
Future<?> consumingTask = service.submit(() -> {
    //We must take into account the cooperative termination!
    while (!Thread.currentThread().isInterrupted()) {
    ConsumerRecords<String, String> records =
      consumer.poll(Duration.ofMillis(100));
    for (ConsumerRecord<String, String> rec : records) {
      actual.add(rec.value());
}}});

try {
  Awaitility.await().atMost(5, SECONDS)
           .until(() -> List.of("A", "B").equals(actual));
} finally {
    //We should not forget to finalize the execution
    //even in case of errors!
    consumingTask.cancel(true);
    service.awaitTermination(200, MILLISECONDS);
}

List<String> values = outputTopic.readValuesToList();
Assertions.assertEquals(List.of("A", "B"), values);

jdbc:postgresql://host/database

jdbc:log4jdbc:postgresql://host/database

@CelestaTest
class OrderDaoTest {
  OrderDao orderDao = new OrderDao();
  CustomerCursor customer;
  ItemCursor item;

@CelestaTest
class OrderDaoTest {
  OrderDao orderDao = new OrderDao();
  CustomerCursor customer;
  ItemCursor item;

  @BeforeEach
  void setUp(CallContext ctx) {
    customer = new CustomerCursor(ctx);
    customer.setName("John Doe")
                 .setEmail("john@example.com").insert();

    item = new ItemCursor(ctx);
    item.setId("12345")
           .setName("cheese").setDefaultPrice(42).insert();
  }

@Test
void orderedItemsMethodReturnsAggregatedValues(CallContext ctx)
    throws Exception {
  //ARRANGE
  ItemCursor item2 = new ItemCursor(ctx);
  item2.setId("2")
    .setName("item 2").insert();

  OrderCursor orderCursor = new OrderCursor(ctx);
  orderCursor.setId(null)
    .setItemId(item.getId())
    .setCustomerId(customer.getId())
    .setQuantity(1).insert();

  //and so on

//ACT
List<ItemDto> result = orderDao.getItems(ctx);

//ASSERT
Approvals.verifyJson(new ObjectMapper()
  .writer().writeValueAsString(result));