testcontainers 7.21.0 → 7.23.0

package/README.md

@@ -523,6 +523,26 @@ const environment = await new DockerComposeEnvironment(composeFilePath, composeF
   .up();
 ```
 
+Specify [profiles](https://docs.docker.com/compose/profiles/):
+
+```javascript
+const { DockerComposeEnvironment } = require("testcontainers");
+
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+    .withProfiles("profile1", "profile2")
+    .up();
+```
+
+Specify not to re-create containers that are already running: 
+
+```javascript
+const { DockerComposeEnvironment } = require("testcontainers");
+
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .withNoRecreate()
+  .up();
+```
+
 Bind environment variables to the docker-compose file. For example if we have the following docker-compose file:
 
 ```yaml

package/dist/docker-compose/default-docker-compose-options.js

@@ -18,6 +18,7 @@ const defaultDockerComposeOptions = (_a) => {
         log: false,
         cwd: options.filePath,
         config: options.files,
+        composeOptions: options.composeOptions,
         commandOptions: options.commandOptions,
         env: Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), env),
     };

package/dist/docker-compose/docker-compose-options.d.ts

@@ -4,5 +4,6 @@ export declare type DockerComposeOptions = {
     files: string | string[];
     projectName: string;
     commandOptions?: string[];
+    composeOptions?: string[];
     env?: Env;
 };

package/dist/docker-compose-environment/docker-compose-environment.d.ts

@@ -3,15 +3,20 @@ import { Uuid } from "../uuid";
 import { EnvKey, EnvValue } from "../docker/types";
 import { StartedDockerComposeEnvironment } from "./started-docker-compose-environment";
 export declare class DockerComposeEnvironment {
-    private readonly projectName;
-    private readonly options;
+    private readonly composeFilePath;
+    private readonly composeFiles;
+    private projectName;
     private build;
+    private recreate;
+    private profiles;
     private env;
     private waitStrategy;
     private startupTimeout;
     constructor(composeFilePath: string, composeFiles: string | string[], uuid?: Uuid);
     withBuild(): this;
     withEnv(key: EnvKey, value: EnvValue): this;
+    withProfiles(...profiles: string[]): this;
+    withNoRecreate(): this;
     withWaitStrategy(containerName: string, waitStrategy: WaitStrategy): this;
     withStartupTimeout(startupTimeout: number): this;
     up(services?: Array<string>): Promise<StartedDockerComposeEnvironment>;

package/dist/docker-compose-environment/docker-compose-environment.js

@@ -29,11 +29,14 @@ const docker_compose_up_1 = require("../docker-compose/functions/docker-compose-
 class DockerComposeEnvironment {
     constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
         this.build = false;
+        this.recreate = true;
+        this.profiles = [];
         this.env = {};
         this.waitStrategy = {};
         this.startupTimeout = 60000;
+        this.composeFilePath = composeFilePath;
+        this.composeFiles = composeFiles;
         this.projectName = `testcontainers-${uuid.nextUuid()}`;
-        this.options = { filePath: composeFilePath, files: composeFiles, projectName: this.projectName };
     }
     withBuild() {
         this.build = true;
@@ -43,6 +46,15 @@ class DockerComposeEnvironment {
         this.env[key] = value;
         return this;
     }
+    withProfiles(...profiles) {
+        this.profiles = profiles;
+        return this;
+    }
+    withNoRecreate() {
+        this.recreate = false;
+        this.projectName = "testcontainers-node";
+        return this;
+    }
     withWaitStrategy(containerName, waitStrategy) {
         this.waitStrategy[containerName] = waitStrategy;
         return this;
@@ -53,13 +65,26 @@ class DockerComposeEnvironment {
     }
     up(services) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Starting DockerCompose environment ${this.projectName}`);
+            logger_1.log.info(`Starting DockerCompose environment: ${this.projectName}`);
             (yield reaper_1.ReaperInstance.getInstance()).addProject(this.projectName);
+            const options = {
+                filePath: this.composeFilePath,
+                files: this.composeFiles,
+                projectName: this.projectName,
+            };
             const commandOptions = [];
             if (this.build) {
                 commandOptions.push("--build");
             }
-            yield docker_compose_up_1.dockerComposeUp(Object.assign(Object.assign({}, this.options), { commandOptions, env: this.env }), services);
+            if (!this.recreate) {
+                commandOptions.push("--no-recreate");
+            }
+            const composeOptions = [];
+            this.profiles.forEach((profile) => {
+                composeOptions.push("--profile");
+                composeOptions.push(profile);
+            });
+            yield docker_compose_up_1.dockerComposeUp(Object.assign(Object.assign({}, options), { commandOptions, composeOptions, env: this.env }), services);
             const startedContainers = (yield list_containers_1.listContainers()).filter((container) => container.Labels["com.docker.compose.project"] === this.projectName);
             const startedContainerNames = startedContainers.reduce((containerNames, startedContainer) => [
                 ...containerNames,
@@ -82,7 +107,7 @@ class DockerComposeEnvironment {
                 catch (err) {
                     logger_1.log.error(`Container ${containerName} failed to be ready: ${err}`);
                     try {
-                        yield docker_compose_down_1.dockerComposeDown(this.options);
+                        yield docker_compose_down_1.dockerComposeDown(options);
                     }
                     catch (_a) {
                         logger_1.log.warn(`Failed to stop DockerCompose environment after failed up`);
@@ -95,7 +120,7 @@ class DockerComposeEnvironment {
                 return Object.assign(Object.assign({}, map), { [containerName]: startedGenericContainer });
             }, {});
             logger_1.log.info(`DockerCompose environment started: ${Object.keys(startedGenericContainers).join(", ")}`);
-            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, this.options);
+            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, options);
         });
     }
     getBoundPorts(containerInfo) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "7.21.0",
+  "version": "7.23.0",
   "main": "dist/index",
   "types": "dist/index",
   "keywords": [