如何在Scala中使用testcontainers-scala实现跨测试套件的容器复用？

Great question! Since Scala doesn’t have static members like Java, we can leverage Scala singleton objects to manage shared TestContainers instances that persist across all your test suites. This way, containers start once and stay running until the entire test pipeline finishes, avoiding costly restarts between suites. Here’s a step-by-step implementation:

Step 1: Create a Singleton Container Manager #

Scala’s object is a lazy-loaded singleton, perfect for holding global container state. We’ll initialize our containers here, add a shutdown hook to clean up when the JVM exits, and expose methods to access running containers.

import org.testcontainers.containers.PostgreSQLContainer
import org.testcontainers.utility.DockerImageName

// Singleton to manage shared containers across all test suites
object SharedTestContainers {
  // Lazy initialize the container - only starts when first accessed
  private lazy val postgresContainer: PostgreSQLContainer[_] = 
    new PostgreSQLContainer(DockerImageName.parse("postgres:15-alpine"))
      .withDatabaseName("test_db")
      .withUsername("test_user")
      .withPassword("test_pass")

  // Get the running container instance (starts it if not already running)
  def getPostgresContainer: PostgreSQLContainer[_] = {
    if (!postgresContainer.isRunning) {
      postgresContainer.start()
      println(s"Postgres container started on port ${postgresContainer.getMappedPort(5432)}")
    }
    postgresContainer
  }

  // Shutdown hook to stop containers when the JVM exits (after all tests finish)
  sys.addShutdownHook {
    if (postgresContainer.isRunning) {
      println("Stopping shared Postgres container...")
      postgresContainer.stop()
    }
  }
}

Step 2: Update Your Test Base Class #

Modify your base test suite to use the singleton container instead of starting/stopping containers in beforeAll/afterAll. We’ll remove the container stop logic from afterAll entirely— the shutdown hook handles cleanup.

import org.scalatest.BeforeAndAfterAll
import org.scalatest.funsuite.AnyFunSuite

abstract class BaseTestSuite extends AnyFunSuite with BeforeAndAfterAll {
  // Fetch the shared container instance from the singleton
  protected val postgresContainer = SharedTestContainers.getPostgresContainer

  override def beforeAll(): Unit = {
    super.beforeAll()
    // No need to start the container here - getPostgresContainer ensures it's running
    // Add any suite-specific setup here (e.g., schema migrations)
  }

  // Remove container stop logic from afterAll!
  override def afterAll(): Unit = {
    super.afterAll()
    // Only clean up suite-specific resources here, not containers
  }
}

Step 3: Use the Base Class in Your Test Suites #

Now all your test suites can inherit from the base class and use the shared container without worrying about restarts:

class UserServiceTest extends BaseTestSuite {
  test("should fetch user from database") {
    // Use container details to connect to the database
    val jdbcUrl = postgresContainer.getJdbcUrl
    val username = postgresContainer.getUsername
    // ... your test logic here
  }
}

class OrderServiceTest extends BaseTestSuite {
  test("should create order in database") {
    val password = postgresContainer.getPassword
    // ... your test logic here
  }
}

Why This Works #

• Singleton Guarantee: Scala’s object is a global singleton, so all test suites share the exact same container instance.
• Lazy Initialization: The container only starts when first accessed, avoiding unnecessary setup if no tests use it.
• Automatic Cleanup: The JVM shutdown hook stops the container once all tests finish, even if there’s a failure.

Key Notes #

• If you use sbt, ensure Test / fork := false (default setting) so all tests run in the same JVM— this is required for the singleton to persist across suites.
• If different tests need unique container configurations, you can extend this pattern to create multiple singleton managers (e.g., SharedRedisContainer, SharedKafkaContainer).

内容的提问来源于stack exchange，提问作者John Doe