Update project to use new content repo layout & other minor tweaks

Author: mikesir87

.github/workflows/publish-labspace.yaml

@@ -15,19 +15,13 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      # Ensure Compose v2.39.3+ is available (includes bug fixes for publishing)
-      # Can remove this action once default runners include it
-      - name: Set up Docker Compose
-        uses: docker/setup-compose-action@v1
-        with:
-          version: v2.39.3
-
       - name: Log in to DockerHub
         uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Publish Compose file
-        run: |
-          docker compose -f oci://dockersamples/labspace -f .labspace/compose.override.yaml publish ${DOCKERHUB_REPO} --with-env -y
+      - name: Publish Labspace
+        uses: dockersamples/publish-labspace-action@v2
+        with:
+          target_repo: ${{ env.DOCKERHUB_REPO }}

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

@@ -1,48 +1,52 @@
-# Labspace starter
+# Labspace - Introduction to Testcontainers - Java
 
-This repository is intended to server as a template to help bootstrap a new Labspace.
+Containers can be used for more than simply running your application. With Testcontainers, you can use containers to easily start the services needed by your application.
 
-## Instructions
+In this Labspace, you'll learn how to use Testcontainers in a Spring-based application.
 
-1. Create a new repository using this repo as the template ([docs here](https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-repository-from-a-template)).
+## Learning objectives
 
-    **NOTE:** After creating the repo, a GHA workflow will run to do some additional bootstrapping. The bootstrapping workflow file will be removed during bootstrapping.
+By the end of this Labspace, you will have learned the following:
 
-2. Clone your newly created repo to your local machine
+- Write end-to-end API tests using real services instead of mocks
+- How to autowire Spring config to use containerized databases
+- How to use GenericContainer to provide additional services and wire them with `@DynamicPropertySource`
 
-3. Start the local development mode:
+## Launch the Labspace
 
-    ```bash
-    # On Mac/Linux
-    CONTENT_PATH=$PWD docker compose -f oci://dockersamples/labspace-content-dev -f .labspace/compose.override.yaml up
+To launch the Labspace, run the following command:
 
-    # On Windows with PowerShell
-    $Env:CONTENT_PATH = (Get-Location).Path; docker compose -f oci://dockersamples/labspace-content-dev -f .labspace/compose.override.yaml up
-    ```
+```bash
+docker compose -f oci://dockersamples/labspace-testcontainers-java up -d
+```
 
-4. Update the `labspace.yaml` with your Labspace's title and description
+And then open your browser to http://localhost:3030.
 
-5. Write your Labspace! Being in dev mode, your changes should be visible in the interface without a restart. Feel free to edit either on your host machine or in the Labspace itself!
+### Using the Docker Desktop extension
 
-    Add any supporting application files or resources directly into the Labspace. This repo will be cloned into the Labspace at startup.
+If you have the Labspace extension installed (`docker extension install dockersamples/labspace-extension` if not), you can also [click this link](https://open.docker.com/dashboard/extension-tab?extensionId=dockersamples/labspace-extension&location=dockersamples/labspace-testcontainers-javaimages&title=Introduction%20to%20Testcontainers%20-%20Java) to launch the Labspace.
 
-    Be sure to check out the [docs](https://github.com/dockersamples/labspace-infra/tree/main/docs) for additional information and guidelines.
 
+## Contributing
 
+If you find something wrong or something that needs to be updated, feel free to submit a PR. If you want to make a larger change, feel free to fork the repo into your own repository.
 
-### Setting up the deployment pipeline
+**Important note:** If you fork it, you will need to update the GHA workflow to point to your own Hub repo.
 
-The template repo contains a workflow file to make it easy to publish your Labspace.
+1. Clone this repo
 
-1. Add GitHub Action Secrets in your new repo for the following:
+2. Start the Labspace in content development mode:
 
-    - `DOCKERHUB_USERNAME` - the username to authenticate to Docker Hub with
-    - `DOCKERHUB_TOKEN` - a personal or organization access token to use for authentication
+    ```bash
+    # On Mac/Linux
+    CONTENT_PATH=$PWD docker compose up --watch
 
-2. In the `.github/workflows/publish-labspace.yaml.temp` file, update the `DOCKERHUB_REPO` with the name of the Docker Hub repo you want to publish to.
+    # On Windows with PowerShell
+    $Env:CONTENT_PATH = (Get-Location).Path; docker compose up --watch
+    ```
 
-3. Rename the workflow file to remove the `.temp` extension.
+3. Open the Labspace at http://localhost:3030.
 
-    ```bash
-    mv .github/workflows/publish-labspace.yaml.temp .github/workflows/publish-labspace.yaml
-    ```
+4. Make the necessary changes and validate they appear as you expect in the Labspace
+
+    Be sure to check out the [docs](https://github.com/dockersamples/labspace-infra/tree/main/docs) for additional information and guidelines.

README.md

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

.labspace/compose.override.yaml compose.override.yaml.labspace/compose.override.yaml renamed to compose.override.yaml

@@ -6,11 +6,15 @@ git clone https://github.com/testcontainers/workshop.git
 ```
 
 ## Build the project to download the dependencies
+
 Switch to the workshop folder:
+
 ```bash
 cd workshop
 ```
+
 and build the project with Maven:
+
 ```bash
 ./mvnw verify
-```
+```

compose.yaml

@@ -5,8 +5,10 @@ But before we write our first test, let's create an abstract test class for the
 
 ## Abstract class
 
-Add `AbstractIntegrationTest` class to `src/test/java` sourceset. 
+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
 package com.example.demo;
 
@@ -36,18 +38,21 @@ public class DemoApplicationTest extends AbstractIntegrationTest{
 ```
 
 Run it and verify that the application starts and the test passes.
+
 ```bash
 ./mvnw clean test
 ```
+
 Spring will detect H2 on the classpath and use it as an embedded DB.
 
 This is already a useful smoke test since it ensures, that Spring Boot is able to initialize the application context successfully.
 
 ## Populate the database
 
-The context starts. 
-However, we need to populate the database with some data before we can write the tests.
+The Spring context starts. However, we need to populate the database with some data before we can write the tests.
+
 Let's add a `schema.sql` file with the following content:
+
 ```sql save-as=workshop/src/test/resources/schema.sql
 CREATE TABLE IF NOT EXISTS talks(
   id    VARCHAR(64)  NOT NULL,
@@ -67,9 +72,11 @@ INSERT
 ```
 
 Now run the test again. 
+
 ```bash
 ./mvnw clean test
 ```
+
 Oh no, it fails!
 
 ```plaintext