Update project to auto-clone at startup. Few other minor updates.

Author: mikesir87

compose.override.yaml

@@ -10,6 +10,9 @@ services:
     configs:
       - source: docker-java-properties
         target: /home/coder/.docker-java.properties
+      - source: clone-repo-script
+        target: /entrypoint.d/clone-repo.sh
+        mode: 0755
 
   #   # Override the default ports to publish additional ports you may need
   #   # More details - https://github.com/dockersamples/labspace-infra/blob/main/docs/configuration.md#overriding-the-workspace-ports
@@ -26,4 +29,16 @@ services:
 configs:
   docker-java-properties:
     content: |
-      api.version=1.48
+      api.version=1.48
+  clone-repo-script:
+    content: |
+      #!/bin/bash
+      set -e
+
+      if [ ! -d "/home/coder/project/.git" ]; then
+        find "/home/coder/project" -type f -name '.*' -exec rm '{}' \;
+        git clone https://github.com/testcontainers/workshop.git /home/coder/project
+        rm /home/coder/project/step-*.md
+      else
+        echo "Repository already cloned, skipping."
+      fi

compose.yaml

@@ -1,3 +1,3 @@
 include:
-  - oci://dockersamples/labspace-content-dev:latest-sdlc
+  - oci://dockersamples/labspace-content-dev
   - ./compose.override.yaml

labspace/01-introduction.md

@@ -10,22 +10,20 @@ By the end, you will have learned the following:
 
 ## Setup
 
-1. Clone the workshop repository into the lab environment:
-
-    ```bash
-    git clone https://github.com/testcontainers/workshop.git
-    ```
-
-2. Build the project to download the dependencies
-
-    Switch to the workshop folder:
-
-    ```bash
-    cd workshop
-    ```
-
-3. Build the project with Maven:
+1. Run a build to download all of the dependencies and validate the application builds successfully:
 
     ```bash
     ./mvnw verify
     ```
+
+    If successful, you should see output similar to the following:
+
+    ```console no-copy-button no-run-button
+    [INFO] The original artifact has been renamed to /home/coder/project/target/demo-0.0.1-SNAPSHOT.jar.original
+    [INFO] ------------------------------------------------------------------------
+    [INFO] BUILD SUCCESS
+    [INFO] ------------------------------------------------------------------------
+    [INFO] Total time:  27.838 s
+    [INFO] Finished at: 2026-03-20T19:41:38Z
+    [INFO] ------------------------------------------------------------------------
+    ```

labspace/02-exploring-the-app.md

@@ -10,23 +10,23 @@ When a rating is submitted, we must verify that the talk for the given ID is pre
 
 Our database of choice is PostgreSQL, accessed with Spring JDBC.
 
-Check :fileLink[TalksRepository]{path="workshop/src/main/java/com/example/demo/repository/TalksRepository.java"}.
+Check :fileLink[TalksRepository]{path="src/main/java/com/example/demo/repository/TalksRepository.java"}.
 
 ### Redis
 
 We store the ratings in Redis database with Spring Data Redis.
 
-Check :fileLink[RatingsRepository]{path="workshop/src/main/java/com/example/demo/repository/RatingsRepository.java"}.
+Check :fileLink[RatingsRepository]{path="src/main/java/com/example/demo/repository/RatingsRepository.java"}.
 
 ### Kafka
 
 We use ES/CQRS to materialize the events into the state. Kafka acts as a broker and we use Spring Kafka.
 
-Check :fileLink[RatingsListener]{path="workshop/src/main/java/com/example/demo/streams/RatingsListener.java"}.
+Check :fileLink[RatingsListener]{path="src/main/java/com/example/demo/streams/RatingsListener.java"}.
 
 ## API
 
-The API is a Spring Web REST controller :fileLink[RatingsController]{path="workshop/src/main/java/com/example/demo/api/RatingsController.java"} and exposes two endpoints:
+The API is a Spring Web REST controller :fileLink[RatingsController]{path="src/main/java/com/example/demo/api/RatingsController.java"} and exposes two endpoints:
 
 * `POST /ratings { "talkId": ?, "value": 1-5 }` to add a rating for a talk
 * `GET /ratings?talkId=?` to get the histogram of ratings of the given talk

labspace/03-adding-some-tests.md

@@ -9,7 +9,7 @@ Add `AbstractIntegrationTest` class to `src/test/java` sourceset.
 
 It will be an abstract class with standard Spring Boot's testing framework annotations on it:
 
-```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
+```java save-as=src/test/java/com/example/demo/AbstractIntegrationTest.java
 package com.example.demo;
 
 import org.springframework.boot.test.context.SpringBootTest;
@@ -25,7 +25,7 @@ public class AbstractIntegrationTest {
 Now we need to test that the context starts.  
 Add `DemoApplicationTest`, extend it from your base class `AbstractIntegrationTest` and add a dummy test:
 
-```java save-as=workshop/src/test/java/com/example/demo/DemoApplicationTest.java
+```java save-as=src/test/java/com/example/demo/DemoApplicationTest.java
 package com.example.demo;
 
 import org.junit.jupiter.api.Test;
@@ -53,7 +53,7 @@ The Spring context starts. However, we need to populate the database with some d
 
 Let's add a `schema.sql` file with the following content:
 
-```sql save-as=workshop/src/test/resources/schema.sql
+```sql save-as=src/test/resources/schema.sql
 CREATE TABLE IF NOT EXISTS talks(
   id    VARCHAR(64)  NOT NULL,
   title VARCHAR(255) NOT NULL,
@@ -79,7 +79,7 @@ Now run the test again.
 
 Oh no, it fails!
 
-```plaintext
+```plaintext no-copy-button
 ...
 Caused by: org.h2.jdbc.JdbcSQLException: Syntax error in SQL statement "INSERT INTO TALKS (ID, TITLE) VALUES ('testcontainers-integration-testing', 'Modern Integration Testing with Testcontainers') ON[*] CONFLICT DO NOTHING";
 ...

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

@@ -12,38 +12,63 @@ It means that starting to use Testcontainers in our project \(once we add a depe
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, properties = {
  "spring.datasource.url=jdbc:tc:postgresql:16-alpine://testcontainers/workshop"
 })
+public class ...
 ```
 
-Let's apply it to the `AbstractIntegrationTest` class:
+1. Update the :fileLink[`AbstractIntegrationTest`]{path="src/test/java/com/example/demo/AbstractIntegrationTest.java"} class to add the `@SpringBootTest` annotation:
 
-```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
-package com.example.demo;
+    ```java save-as=src/test/java/com/example/demo/AbstractIntegrationTest.java
+    package com.example.demo;
 
-import org.springframework.boot.test.context.SpringBootTest;
+    import org.springframework.boot.test.context.SpringBootTest;
 
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, properties = {
-        "spring.datasource.url=jdbc:tc:postgresql:16-alpine://testcontainers/workshop"
-})
-public class AbstractIntegrationTest {
+    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, properties = {
+            "spring.datasource.url=jdbc:tc:postgresql:16-alpine://testcontainers/workshop"
+    })
+    public class AbstractIntegrationTest {
 
-}
-```
+    }
+    ```
 
-If we split the magical JDBC url, we see:
+    If we split the magical JDBC url, we see:
+
+    * `jdbc:tc:` - this part says that we should use Testcontainers as a JDBC provider
+    * `postgresql:16-alpine://` - we use a PostgreSQL database, and we select the correct PostgreSQL image from the Docker Hub as the image
+    * `testcontainers/workshop` - the host name \(can be anything\) is `testcontainers` and the database name is `workshop`. Your choice!
+
+2. Run the tests with the following command:
+
+    ```bash
+    ./mvnw clean test
+    ```
+
+    When the tests run, you'll see log output indicating it is pulling the `postgresql:16-alpine` container image. It will then use this container to run the tests.
+
+    Eventually, you will see output similar to the following indicating the tests ran successfully:
+
+    ```console no-copy-button no-run-button
+    [INFO] Results:
+    [INFO] 
+    [INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+    [INFO] 
+    [INFO] ------------------------------------------------------------------------
+    [INFO] BUILD SUCCESS
+    [INFO] ------------------------------------------------------------------------
+    [INFO] Total time:  15.529 s
+    [INFO] Finished at: 2026-03-20T19:47:25Z
+    [INFO] ------------------------------------------------------------------------
+    ```
 
-* `jdbc:tc:` - this part says that we should use Testcontainers as JDBC provider
-* `postgresql:16-alpine://` - we use a PostgreSQL database, and we select the correct PostgreSQL image from the Docker Hub as the image
-* `testcontainers/workshop` - the host name \(can be anything\) is `testcontainers` and the database name is `workshop`. Your choice!
 
-## Running tests
+## Running tests with Testcontainers Cloud
 
-In order to run these test we'll need a Docker Engine available. To relax the system, we'll use Testcontainers Cloud to spin up Testcontainers-based containers. 
+When the tests ran in the previous step, they used the Docker Engine on your machine. However, there are times in which you might not be able to easily run containers (such as in CI pipelines).
 
-To enbale it you need to:
+In these environments, Testcontainers Cloud can be used to spin up Testcontainers-based containers. To enable it you need to:
 
-1. Go to the [app.testcontainers.cloud](https://app.testcontainers.cloud/) and generate the TC_CLOUD_TOKEN.
+1. Go to the [app.testcontainers.cloud](https://app.testcontainers.cloud/) and generate the `TC_CLOUD_TOKEN`.
 
-2. Set the TC_CLOUD_TOKEN as environment variable:
+2. Set the `TC_CLOUD_TOKEN` as environment variable:
 
     ::variableDefinition[tcc_token]{prompt="What is your TC_CLOUD_TOKEN value?"}
 
@@ -65,26 +90,26 @@ To enbale it you need to:
 
     Test is green? Good!
 
-5. Check the logs.
+5. Check the logs to see the output indicating Testcontainers Cloud is being used:
 
     ```text
-    2025-10-27T21:36:55.945Z  INFO 77211 --- [           main] o.t.d.DockerClientProviderStrategy       : Found Docker environment with Testcontainers Host with tc.host=tcp://127.0.0.1:43387
-    2025-10-27T21:36:55.946Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : Docker host IP address is 127.0.0.1
-    2025-10-27T21:36:56.055Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : Connected to docker: 
+    2026-03-20T21:36:55.945Z  INFO 77211 --- [           main] o.t.d.DockerClientProviderStrategy       : Found Docker environment with Testcontainers Host with tc.host=tcp://127.0.0.1:43387
+    2026-03-20T21:36:55.946Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : Docker host IP address is 127.0.0.1
+    2026-03-20T21:36:56.055Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : Connected to docker: 
     Server Version: 28.3.3 (via Testcontainers Cloud Agent 1.22.0)
     API Version: 1.51
     Operating System: Ubuntu 22.04.5 LTS
     Total Memory: 31556 MB
-    2025-10-27T21:36:56.206Z  INFO 77211 --- [           main] tc.testcontainers/ryuk:0.8.1             : Creating container for image: testcontainers/ryuk:0.8.1
-    2025-10-27T21:36:56.396Z  INFO 77211 --- [           main] tc.testcontainers/ryuk:0.8.1             : Container testcontainers/ryuk:0.8.1 is starting: 779608b4dc49f2c37420ea0a39cc90951912fb767d7d7141c1b0ae1db1717989
-    2025-10-27T21:36:57.321Z  INFO 77211 --- [           main] tc.testcontainers/ryuk:0.8.1             : Container testcontainers/ryuk:0.8.1 started in PT1.114889292S
-    2025-10-27T21:36:57.521Z  INFO 77211 --- [           main] o.t.utility.RyukResourceReaper           : Ryuk started - will monitor and terminate Testcontainers containers on JVM exit
-    2025-10-27T21:36:57.523Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : Checking the system...
-    2025-10-27T21:36:57.530Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : ✔︎ Docker server version should be at least 1.6.0
-    2025-10-27T21:36:57.532Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Creating container for image: postgres:17-alpine
-    2025-10-27T21:36:57.679Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Container postgres:17-alpine is starting: ed1a75d921ab911896763cde925724777aa6cea00700aec567d6b9a293b1e297
-    2025-10-27T21:36:58.939Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Container postgres:17-alpine started in PT1.406803125S
-    2025-10-27T21:36:58.943Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Container is started (JDBC URL: jdbc:postgresql://127.0.0.1:32771/workshop?loggerLevel=OFF)
+    2026-03-20T21:36:56.206Z  INFO 77211 --- [           main] tc.testcontainers/ryuk:0.8.1             : Creating container for image: testcontainers/ryuk:0.8.1
+    2026-03-20T21:36:56.396Z  INFO 77211 --- [           main] tc.testcontainers/ryuk:0.8.1             : Container testcontainers/ryuk:0.8.1 is starting: 779608b4dc49f2c37420ea0a39cc90951912fb767d7d7141c1b0ae1db1717989
+    2026-03-20T21:36:57.321Z  INFO 77211 --- [           main] tc.testcontainers/ryuk:0.8.1             : Container testcontainers/ryuk:0.8.1 started in PT1.114889292S
+    2026-03-20T21:36:57.521Z  INFO 77211 --- [           main] o.t.utility.RyukResourceReaper           : Ryuk started - will monitor and terminate Testcontainers containers on JVM exit
+    2026-03-20T21:36:57.523Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : Checking the system...
+    2026-03-20T21:36:57.530Z  INFO 77211 --- [           main] org.testcontainers.DockerClientFactory   : ✔︎ Docker server version should be at least 1.6.0
+    2026-03-20T21:36:57.532Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Creating container for image: postgres:17-alpine
+    2026-03-20T21:36:57.679Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Container postgres:17-alpine is starting: ed1a75d921ab911896763cde925724777aa6cea00700aec567d6b9a293b1e297
+    2026-03-20T21:36:58.939Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Container postgres:17-alpine started in PT1.406803125S
+    2026-03-20T21:36:58.943Z  INFO 77211 --- [           main] tc.postgres:17-alpine                    : Container is started (JDBC URL: jdbc:postgresql://127.0.0.1:32771/workshop?loggerLevel=OFF)
     ```
 
 As you can see, Testcontainers quickly discovered your environment and connected to Docker. 
@@ -96,7 +121,7 @@ It also performed some pre-flight checks to ensure the environment is valid.
 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.
 
-```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
+```java save-as=src/test/java/com/example/demo/AbstractIntegrationTest.java
 package com.example.demo;
 
 import org.springframework.boot.test.context.SpringBootTest;

labspace/05-dude-r-u-200-ok.md

@@ -3,16 +3,17 @@
 One of the great features of Spring Boot is the Actuator and its health endpoint. 
 It gives you an overview how healthy your app is.
 
-The context starts, but what's about the health of the app?
+The context starts, but what about the health of the app? This endpoint can also be used in a test to quickly validate the application starts up completely.
 
 ## Configure Rest Assured
 
 To check the health endpoint of our app, we will use the [RestAssured](http://rest-assured.io/) library.
 
 However, before using it, we first need to configure it. 
-Update your abstract test class with `setUpAbstractIntegrationTest` method since we will share it between all tests:
 
-```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
+1. Update your abstract test class with `setUpAbstractIntegrationTest` method since we will share it between all tests:
+
+```java save-as=src/test/java/com/example/demo/AbstractIntegrationTest.java
 package com.example.demo;
 
 import io.restassured.RestAssured;
@@ -55,7 +56,7 @@ Now let's check if the app is actually healthy.
 
 1. Add the `healthy` test implementation in the `DemoApplicationTest` class:
 
-    ```java save-as=workshop/src/test/java/com/example/demo/DemoApplicationTest.java
+    ```java save-as=src/test/java/com/example/demo/DemoApplicationTest.java
     package com.example.demo;
 
     import io.restassured.filter.log.LogDetail;
@@ -81,7 +82,7 @@ Now let's check if the app is actually healthy.
     ./mvnw clean test
     ```
 
-    Oh ow! it fails:
+    Oh no! It fails:
 
     ```text
     ...

labspace/06-adding-redis.md

@@ -8,23 +8,27 @@ The integration between the tests code and Testcontainers is straightforward.
 Testcontainers comes with first class support for JUnit, but in our app we want to have a single Redis instance shared between **all** tests. 
 Luckily, there are the `.start()`/`.stop()` methods of `GenericContainer` to start or stop it manually.
 
-Update the `AbstractIntegrationTest` with the following code:
+1. Update the :fileLink[`AbstractIntegrationTest`]{path="src/test/java/com/example/demo/AbstractIntegrationTest.java"} to create a redis container:
 
-```java no-run-button
-static final GenericContainer redis = new GenericContainer("redis:7-alpine")
-                                            .withExposedPorts(6379);
+    ```java no-run-button
+    static final GenericContainer redis = new GenericContainer("redis:7-alpine")
+                                                .withExposedPorts(6379);
+    ```
 
-@DynamicPropertySource
-public static void configureRedis(DynamicPropertyRegistry registry) {
-  redis.start();
-  registry.add("spring.data.redis.host", redis::getHost);
-  registry.add("spring.data.redis.port", redis::getFirstMappedPort);
-}
-```
+2. In that same class, add a method annotated with `@DynamicPropertySource` to provide the properties needed to connect to the Redis container:
+
+    ```java
+    @DynamicPropertySource
+    public static void configureRedis(DynamicPropertyRegistry registry) {
+        redis.start();
+        registry.add("spring.data.redis.host", redis::getHost);
+        registry.add("spring.data.redis.port", redis::getFirstMappedPort);
+    }
+    ```
 
-The full `AbstractIntegrationTest` class implementation will look like:
+The full `AbstractIntegrationTest` class implementation should now look like the following:
 
-```java save-as=workshop/src/test/java/com/example/demo/AbstractIntegrationTest.java
+```java save-as=src/test/java/com/example/demo/AbstractIntegrationTest.java
 package com.example.demo;
 
 import io.restassured.RestAssured;
@@ -78,4 +82,21 @@ Run the tests, now they should all pass.
 
 ```bash
 ./mvnw clean test
+```
+
+If successful, you should see output similar to the following:
+
+```console no-copy-button no-run-button
+[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 6.688 s - in com.example.demo.DemoApplicationTest
+[INFO] 
+[INFO] Results:
+[INFO] 
+[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+[INFO] 
+[INFO] ------------------------------------------------------------------------
+[INFO] BUILD SUCCESS
+[INFO] ------------------------------------------------------------------------
+[INFO] Total time:  8.092 s
+[INFO] Finished at: 2026-03-20T19:59:19Z
+[INFO] ------------------------------------------------------------------------
 ```

labspace/07-test-the-api.md

@@ -2,7 +2,7 @@
 
 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
+```java save-as=src/test/java/com/example/demo/RatingsControllerTest.java
 package com.example.demo;
 
 import com.example.demo.model.Rating;
@@ -86,7 +86,7 @@ There is a [Testcontainers Kafka module](https://java.testcontainers.org/modules
 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
+```java save-as=src/test/java/com/example/demo/AbstractIntegrationTest.java
 package com.example.demo;
 
 import io.restassured.RestAssured;