added tc kafka implementation

Author: GannaChernyshova

.labspace/01-introduction.md

@@ -13,14 +13,4 @@ cd workshop
 and build the project with Maven:
 ```bash
 ./mvnw verify
-```
-
-## \(optionally\) Pull the required images before doing the workshop
-
-This might be helpful if the internet connection is somewhat slow.
-```bash
-docker pull postgres:16-alpine
-docker pull redis:7-alpine
-docker pull openjdk:8-jre-alpine
-docker pull confluentinc/cp-kafka:7.5.0
 ```

.labspace/02-main-content.md

@@ -7,7 +7,7 @@ But before we write our first test, let's create an abstract test class for the
 
 Add `AbstractIntegrationTest` class to `src/test/java` sourceset. 
 It will be an abstract class with standard Spring Boot's testing framework annotations on it:
-```plaintext save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
+```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
 package com.example.demo;
 
 import org.springframework.boot.test.context.SpringBootTest;

.labspace/03-adding-some-tests.md

@@ -85,7 +85,7 @@ It did some pre-flight checks as well to ensure that you have a valid environmen
 Changing the PostgreSQL version is as simple as replacing `16-alpine` with, for example, `17-alpine`.
 Try it, but don't forget that it will download the new image from the internet, if it's not already present on your computer.
 
-```plaintext save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
+```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
 package com.example.demo;
 
 import org.springframework.boot.test.context.SpringBootTest;
@@ -96,4 +96,7 @@ import org.springframework.boot.test.context.SpringBootTest;
 public class AbstractIntegrationTest {
 
 }
+```
+```bash
+./mvnw clean test
 ```

.labspace/03-conclusion.md

@@ -10,7 +10,7 @@ Luckily, there are the `.start()`/`.stop()` methods of `GenericContainer` to sta
 
 Just update the `AbstractIntegrationTest` with the following code:
 
-```java no-run-button no-copy-button
+```java no-run-button
 static final GenericContainer redis = new GenericContainer("redis:7-alpine")
                                             .withExposedPorts(6379);
 

.labspace/04-your-first-testcontainers-integration.md

@@ -3,10 +3,9 @@
 Now let's create a test for our API which will verify the business logic.
 
 ```java save-as=workshop/src/test/java/com/example/demo/RatingsControllerTest.java
-package com.example.demo.api;
+package com.example.demo;
 
 import com.example.demo.model.Rating;
-import com.example.demo.support.AbstractIntegrationTest;
 import org.junit.jupiter.api.Test;
 
 import static io.restassured.RestAssured.given;
@@ -80,13 +79,73 @@ Test failed. Why?
 There is no Kafka!
 
 Running Kafka in Docker is easy with Testcontainers.
-There is a Testcontainers module providing integration with Kafka and the `KafkaContainer` abstraction for your code.
+There is a [Testcontainers Kafka module](https://java.testcontainers.org/modules/kafka/) providing integration with Kafka and the `KafkaContainer` abstraction for your code.
 
 Just add it the same way as you added Redis and set the `spring.kafka.bootstrap-servers` system property.
+The full `AbstractIntegrationTest` class implementation will look like:
+
+```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
+package com.example.demo;
+
+import io.restassured.RestAssured;
+import io.restassured.builder.RequestSpecBuilder;
+import io.restassured.specification.RequestSpecification;
+import org.junit.jupiter.api.BeforeEach;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.KafkaContainer;
+import org.testcontainers.shaded.com.google.common.net.HttpHeaders;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, properties = {
+        "spring.datasource.url=jdbc:tc:postgresql:16-alpine://testcontainers/workshop"
+})
+public class AbstractIntegrationTest {
+    protected RequestSpecification requestSpecification;
+
+    @LocalServerPort
+    protected int localServerPort;
+
+    @BeforeEach
+    void setUpAbstractIntegrationTest() {
+        RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
+        requestSpecification = new RequestSpecBuilder()
+                .setPort(localServerPort)
+                .addHeader(
+                        HttpHeaders.CONTENT_TYPE,
+                        MediaType.APPLICATION_JSON_VALUE
+                )
+                .build();
+    }
+
+    static final GenericContainer redis = new GenericContainer("redis:7-alpine")
+            .withExposedPorts(6379);
+    static final KafkaContainer kafka = new KafkaContainer("7.7.6");
+
+    @DynamicPropertySource
+    public static void configureRedisAndKafka(DynamicPropertyRegistry registry) {
+        redis.start();
+        kafka.start();
+        registry.add("spring.data.redis.host", redis::getHost);
+        registry.add("spring.data.redis.port", redis::getFirstMappedPort);
+        registry.add("spring.kafka.bootstrap-servers", kafka::getBootstrapServers);
+    }
+}
+```
+
+Run test one more time:
+```bash
+./mvnw clean test
+```
 
 ## Hint 1:
 
 Some containers expose helper methods. Check if there is one on `KafkaContainer` which might help you.
+![KafkaContainer helpers](.labspace/images/kafka.png)
+
 
 ## Hint 2: