testcontainers 7.20.4 → 7.22.0

package/README.md

@@ -523,6 +523,16 @@ const environment = await new DockerComposeEnvironment(composeFilePath, composeF
   .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/functions/container/remove-container.js

@@ -1,14 +1,23 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeContainer = void 0;
 const logger_1 = require("../../../logger");
-const removeContainer = (container, options) => {
+const removeContainer = (container, options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        return container.remove({ v: options.removeVolumes });
+        yield container.remove({ v: options.removeVolumes });
     }
     catch (err) {
         logger_1.log.error(`Failed to remove container ${container.id}: ${err}`);
         throw err;
     }
-};
+});
 exports.removeContainer = removeContainer;

package/dist/docker/functions/container/start-container.js

@@ -1,14 +1,23 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startContainer = void 0;
 const logger_1 = require("../../../logger");
-const startContainer = (container) => {
+const startContainer = (container) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        return container.start();
+        yield container.start();
     }
     catch (err) {
         logger_1.log.error(`Failed to start container ${container.id}: ${err}`);
         throw err;
     }
-};
+});
 exports.startContainer = startContainer;

package/dist/docker/get-docker-host.js

@@ -21,48 +21,40 @@ const getDockerHost = (dockerode) => __awaiter(void 0, void 0, void 0, function*
     if (process.env.DOCKER_HOST) {
         logger_1.log.info(`Detected DOCKER_HOST environment variable: ${process.env.DOCKER_HOST}`);
     }
-    for (const hostStrategy of hostStrategies(dockerode)) {
+    for (const [hostStrategyName, hostStrategy] of Object.entries(hostStrategies(dockerode))) {
         const result = yield hostStrategy();
-        if (result && result.host) {
-            result.callback();
-            return result.host;
+        if (result) {
+            logger_1.log.info(`Docker host strategy ${hostStrategyName}: ${result}`);
+            return result;
         }
     }
-    logger_1.log.info(`Using fallback Docker host: ${DEFAULT_HOST}`);
+    logger_1.log.info(`Docker host strategy FALLBACK: ${DEFAULT_HOST}`);
     return DEFAULT_HOST;
 });
 exports.getDockerHost = getDockerHost;
-const hostStrategies = (dockerode) => [
-    () => __awaiter(void 0, void 0, void 0, function* () {
-        const host = dockerode.modem.host;
-        return { host, callback: () => logger_1.log.info(`Using Docker host from modem: ${host}`) };
-    }),
-    () => __awaiter(void 0, void 0, void 0, function* () {
-        const host = process.env["TESTCONTAINERS_HOST_OVERRIDE"];
-        return { host, callback: () => logger_1.log.info(`Using TESTCONTAINERS_HOST_OVERRIDE: ${host}`) };
-    }),
-    () => __awaiter(void 0, void 0, void 0, function* () {
+const hostStrategies = (dockerode) => ({
+    MODEM: () => __awaiter(void 0, void 0, void 0, function* () { return dockerode.modem.host; }),
+    TESTCONTAINERS_HOST_OVERRIDE: () => __awaiter(void 0, void 0, void 0, function* () { return process.env["TESTCONTAINERS_HOST_OVERRIDE"]; }),
+    OUTSIDE_CONTAINER: () => __awaiter(void 0, void 0, void 0, function* () {
         if (!isInContainer()) {
-            return { host: DEFAULT_HOST, callback: () => logger_1.log.info(`Using default Docker host: ${DEFAULT_HOST}`) };
+            return DEFAULT_HOST;
         }
     }),
-    () => __awaiter(void 0, void 0, void 0, function* () {
+    INSIDE_CONTAINER_NO_IPAM: () => __awaiter(void 0, void 0, void 0, function* () {
         const network = yield dockerode.getNetwork("bridge").inspect();
         if (!network.IPAM || !network.IPAM.Config) {
-            return {
-                host: DEFAULT_HOST,
-                callback: () => logger_1.log.info(`Using default Docker host from within container: ${DEFAULT_HOST}`),
-            };
-        }
-        const gateways = network.IPAM.Config.filter((config) => !!config.Gateway);
-        if (gateways.length > 0) {
-            const host = gateways[0].Gateway;
-            return { host, callback: () => logger_1.log.info(`Using Docker host from network gateway within container: ${host}`) };
+            return DEFAULT_HOST;
         }
     }),
-    () => __awaiter(void 0, void 0, void 0, function* () {
-        const host = yield run_in_container_1.runInContainer("alpine:3.5", ["sh", "-c", "ip route|awk '/default/ { print $3 }'"]);
-        return { host, callback: () => logger_1.log.info(`Using Docker host from evaluated gateway within container: ${host}`) };
+    INSIDE_CONTAINER_IPAM: () => __awaiter(void 0, void 0, void 0, function* () {
+        const network = yield dockerode.getNetwork("bridge").inspect();
+        if (network.IPAM && network.IPAM.Config) {
+            const gateways = network.IPAM.Config.filter((config) => !!config.Gateway);
+            if (gateways.length > 0) {
+                return gateways[0].Gateway;
+            }
+        }
     }),
-];
+    CONTAINER_GATEWAY: () => __awaiter(void 0, void 0, void 0, function* () { return run_in_container_1.runInContainer("alpine:3.5", ["sh", "-c", "ip route|awk '/default/ { print $3 }'"]); }),
+});
 const isInContainer = () => fs_1.default.existsSync("/.dockerenv");

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

@@ -12,6 +12,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultDockerComposeOptions = void 0;
+const session_id_1 = require("../docker/session-id");
 const defaultDockerComposeOptions = (_a) => {
     var { env = {} } = _a, options = __rest(_a, ["env"]);
     return {
@@ -19,7 +20,7 @@ const defaultDockerComposeOptions = (_a) => {
         cwd: options.filePath,
         config: options.files,
         commandOptions: options.commandOptions,
-        env: Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), env),
+        env: Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: session_id_1.sessionId }), env),
     };
 };
 exports.defaultDockerComposeOptions = defaultDockerComposeOptions;

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

@@ -2,7 +2,6 @@ import { Env } from "../docker/types";
 export declare type DockerComposeOptions = {
     filePath: string;
     files: string | string[];
-    projectName: string;
     commandOptions?: string[];
     env?: Env;
 };

package/dist/docker-compose/functions/container-name-resolver.d.ts

@@ -1 +1 @@
-export declare const resolveContainerName: (projectName: string, containerName: string) => string;
+export declare const resolveContainerName: (containerName: string) => string;

package/dist/docker-compose/functions/container-name-resolver.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveContainerName = void 0;
-const resolveContainerName = (projectName, containerName) => {
-    if (containerName.includes(projectName)) {
-        return containerName.substring(`/${projectName}_`.length);
+const session_id_1 = require("../../docker/session-id");
+const resolveContainerName = (containerName) => {
+    if (containerName.includes(session_id_1.sessionId)) {
+        return containerName.substring(`/${session_id_1.sessionId}_`.length);
     }
     else if (containerName.startsWith("/")) {
         return containerName.substring(1);
     }
     else {
-        throw new Error(`Unable to resolve container name for container name: "${containerName}", project name: "${projectName}"`);
+        throw new Error(`Unable to resolve container name for container name: "${containerName}", session ID: "${session_id_1.sessionId}"`);
     }
 };
 exports.resolveContainerName = resolveContainerName;

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

@@ -1,17 +1,17 @@
 import { WaitStrategy } from "../wait-strategy";
-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 build;
+    private recreate;
     private env;
     private waitStrategy;
     private startupTimeout;
-    constructor(composeFilePath: string, composeFiles: string | string[], uuid?: Uuid);
+    constructor(composeFilePath: string, composeFiles: string | string[]);
     withBuild(): this;
     withEnv(key: EnvKey, value: EnvValue): 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

@@ -17,7 +17,6 @@ const logger_1 = require("../logger");
 const port_check_1 = require("../port-check");
 const wait_strategy_1 = require("../wait-strategy");
 const reaper_1 = require("../reaper");
-const uuid_1 = require("../uuid");
 const list_containers_1 = require("../docker/functions/container/list-containers");
 const get_container_1 = require("../docker/functions/container/get-container");
 const docker_host_1 = require("../docker/docker-host");
@@ -26,14 +25,15 @@ const container_logs_1 = require("../docker/functions/container/container-logs")
 const started_docker_compose_environment_1 = require("./started-docker-compose-environment");
 const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
 const docker_compose_up_1 = require("../docker-compose/functions/docker-compose-up");
+const session_id_1 = require("../docker/session-id");
 class DockerComposeEnvironment {
-    constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
+    constructor(composeFilePath, composeFiles) {
         this.build = false;
+        this.recreate = true;
         this.env = {};
         this.waitStrategy = {};
         this.startupTimeout = 60000;
-        this.projectName = `testcontainers-${uuid.nextUuid()}`;
-        this.options = { filePath: composeFilePath, files: composeFiles, projectName: this.projectName };
+        this.options = { filePath: composeFilePath, files: composeFiles };
     }
     withBuild() {
         this.build = true;
@@ -43,6 +43,10 @@ class DockerComposeEnvironment {
         this.env[key] = value;
         return this;
     }
+    withNoRecreate() {
+        this.recreate = false;
+        return this;
+    }
     withWaitStrategy(containerName, waitStrategy) {
         this.waitStrategy[containerName] = waitStrategy;
         return this;
@@ -53,22 +57,25 @@ class DockerComposeEnvironment {
     }
     up(services) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Starting DockerCompose environment ${this.projectName}`);
-            (yield reaper_1.ReaperInstance.getInstance()).addProject(this.projectName);
+            logger_1.log.info(`Starting DockerCompose environment`);
+            yield reaper_1.ReaperInstance.getInstance();
             const commandOptions = [];
             if (this.build) {
                 commandOptions.push("--build");
             }
+            if (!this.recreate) {
+                commandOptions.push("--no-recreate");
+            }
             yield docker_compose_up_1.dockerComposeUp(Object.assign(Object.assign({}, this.options), { commandOptions, env: this.env }), services);
-            const startedContainers = (yield list_containers_1.listContainers()).filter((container) => container.Labels["com.docker.compose.project"] === this.projectName);
+            const startedContainers = (yield list_containers_1.listContainers()).filter((container) => container.Labels["com.docker.compose.project"] === session_id_1.sessionId);
             const startedContainerNames = startedContainers.reduce((containerNames, startedContainer) => [
                 ...containerNames,
                 startedContainer.Names.join(", "),
             ], []);
             logger_1.log.info(`Started the following containers: ${startedContainerNames.join(", ")}`);
             const startedGenericContainers = (yield Promise.all(startedContainers.map((startedContainer) => __awaiter(this, void 0, void 0, function* () {
-                const container = yield get_container_1.getContainerById(startedContainer.Id);
-                const containerName = container_name_resolver_1.resolveContainerName(this.projectName, startedContainer.Names[0]);
+                const container = get_container_1.getContainerById(startedContainer.Id);
+                const containerName = container_name_resolver_1.resolveContainerName(startedContainer.Names[0]);
                 (yield container_logs_1.containerLogs(container))
                     .on("data", (data) => logger_1.containerLog.trace(`${containerName}: ${data}`))
                     .on("err", (data) => logger_1.containerLog.error(`${containerName}: ${data}`));

package/dist/docker-ignore.js

@@ -18,28 +18,23 @@ const os_1 = __importDefault(require("os"));
 const glob_1 = __importDefault(require("glob"));
 const path_1 = __importDefault(require("path"));
 const findDockerIgnoreFiles = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    const dockerIgnoreFiles = new Set();
     const dockerIgnoreFilePath = path_1.default.join(context, ".dockerignore");
     if (!fs_1.existsSync(dockerIgnoreFilePath)) {
-        return dockerIgnoreFiles;
+        return new Set();
     }
     const dockerIgnorePatterns = (yield fs_1.promises.readFile(dockerIgnoreFilePath, { encoding: "utf-8" }))
         .toString()
         .split(os_1.default.EOL)
         .map((dockerIgnorePattern) => path_1.default.resolve(context, dockerIgnorePattern));
-    const dockerIgnoreMatches = yield Promise.all(dockerIgnorePatterns.map((dockerIgnorePattern) => {
-        return new Promise((resolve, reject) => glob_1.default(dockerIgnorePattern, (err, matches) => {
-            if (err) {
-                return reject(err);
-            }
-            else {
-                resolve(matches);
-            }
-        }));
-    }));
-    dockerIgnoreMatches.forEach((dockerIgnoreFileBatch) => {
-        dockerIgnoreFileBatch.forEach((dockerIgnoreFile) => dockerIgnoreFiles.add(dockerIgnoreFile));
-    });
-    return dockerIgnoreFiles;
+    const dockerIgnoreMatches = (yield Promise.all(dockerIgnorePatterns.map(findIgnoredFilesForPattern))).reduce((prev, next) => [...prev, ...next]);
+    return new Set(dockerIgnoreMatches);
 });
 exports.findDockerIgnoreFiles = findDockerIgnoreFiles;
+const findIgnoredFilesForPattern = (dockerIgnorePattern) => new Promise((resolve, reject) => glob_1.default(dockerIgnorePattern, (err, matches) => {
+    if (err) {
+        return reject(err);
+    }
+    else {
+        resolve(matches);
+    }
+}));

package/dist/generic-container/started-generic-container.js

@@ -26,7 +26,7 @@ class StartedGenericContainer {
     }
     stop(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.stopContainer(options);
+            return this.stopContainer(options);
         });
     }
     stopContainer(options = {}) {

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export { KafkaContainer, StartedKafkaContainer } from "./modules/kafka/kafka-con
 export { Neo4jContainer, StartedNeo4jContainer } from "./modules/neo4j/neo4j-container";
 export { ArangoDBContainer, StartedArangoContainer } from "./modules/arangodb/arangodb-container";
 export { ElasticsearchContainer, StartedElasticsearchContainer } from "./modules/elasticsearch/elasticsearch-container";
+export { MySqlContainer, StartedMySqlContainer } from "./modules/mysql/mysql-container";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StartedElasticsearchContainer = exports.ElasticsearchContainer = exports.StartedArangoContainer = exports.ArangoDBContainer = exports.StartedNeo4jContainer = exports.Neo4jContainer = exports.StartedKafkaContainer = exports.KafkaContainer = exports.StartedPostgreSqlContainer = exports.PostgreSqlContainer = exports.AlwaysPullPolicy = exports.DefaultPullPolicy = exports.Wait = exports.StoppedNetwork = exports.StartedNetwork = exports.Network = exports.DownedDockerComposeEnvironment = exports.StoppedDockerComposeEnvironment = exports.StartedDockerComposeEnvironment = exports.DockerComposeEnvironment = exports.TestContainers = exports.GenericContainerBuilder = exports.GenericContainer = void 0;
+exports.StartedMySqlContainer = exports.MySqlContainer = exports.StartedElasticsearchContainer = exports.ElasticsearchContainer = exports.StartedArangoContainer = exports.ArangoDBContainer = exports.StartedNeo4jContainer = exports.Neo4jContainer = exports.StartedKafkaContainer = exports.KafkaContainer = exports.StartedPostgreSqlContainer = exports.PostgreSqlContainer = exports.AlwaysPullPolicy = exports.DefaultPullPolicy = exports.Wait = exports.StoppedNetwork = exports.StartedNetwork = exports.Network = exports.DownedDockerComposeEnvironment = exports.StoppedDockerComposeEnvironment = exports.StartedDockerComposeEnvironment = exports.DockerComposeEnvironment = exports.TestContainers = exports.GenericContainerBuilder = exports.GenericContainer = void 0;
 var generic_container_1 = require("./generic-container/generic-container");
 Object.defineProperty(exports, "GenericContainer", { enumerable: true, get: function () { return generic_container_1.GenericContainer; } });
 var generic_container_builder_1 = require("./generic-container/generic-container-builder");
@@ -39,3 +39,6 @@ Object.defineProperty(exports, "StartedArangoContainer", { enumerable: true, get
 var elasticsearch_container_1 = require("./modules/elasticsearch/elasticsearch-container");
 Object.defineProperty(exports, "ElasticsearchContainer", { enumerable: true, get: function () { return elasticsearch_container_1.ElasticsearchContainer; } });
 Object.defineProperty(exports, "StartedElasticsearchContainer", { enumerable: true, get: function () { return elasticsearch_container_1.StartedElasticsearchContainer; } });
+var mysql_container_1 = require("./modules/mysql/mysql-container");
+Object.defineProperty(exports, "MySqlContainer", { enumerable: true, get: function () { return mysql_container_1.MySqlContainer; } });
+Object.defineProperty(exports, "StartedMySqlContainer", { enumerable: true, get: function () { return mysql_container_1.StartedMySqlContainer; } });

package/dist/modules/abstract-started-container.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="node" />
 import { StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
 import { Port } from "../port";
-import { ContainerName, Host, Id } from "../docker/types";
-import { Command, ExecResult } from "../docker/types";
+import { ContainerName, Host, Id, Command, ExecResult } from "../docker/types";
 import { Readable } from "stream";
 export declare class AbstractStartedContainer {
     protected readonly startedTestContainer: StartedTestContainer;

package/dist/modules/kafka/kafka-container.js

@@ -63,7 +63,7 @@ class KafkaContainer extends generic_container_1.GenericContainer {
                 const zooKeeperHost = this.uuid.nextUuid();
                 zooKeeperPort = yield this.portGenerator.generatePort();
                 this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `${zooKeeperHost}:${zooKeeperPort}`);
-                const zookeeperContainer = yield new generic_container_1.GenericContainer(this.zooKeeperImage)
+                const zookeeperContainer = new generic_container_1.GenericContainer(this.zooKeeperImage)
                     .withName(zooKeeperHost)
                     .withEnv("ZOOKEEPER_CLIENT_PORT", zooKeeperPort.toString());
                 if (this.networkMode !== undefined) {

package/dist/modules/mysql/mysql-container.d.ts

@@ -0,0 +1,30 @@
+import { GenericContainer } from "../../generic-container/generic-container";
+import { StartedTestContainer } from "../../test-container";
+import { AbstractStartedContainer } from "../abstract-started-container";
+import { Port } from "../../port";
+export declare class MySqlContainer extends GenericContainer {
+    private database;
+    private username;
+    private userPassword;
+    private rootPassword;
+    constructor(image?: string);
+    withDatabase(database: string): this;
+    withUsername(username: string): this;
+    withRootPassword(rootPassword: string): this;
+    withUserPassword(userPassword: string): this;
+    start(): Promise<StartedMySqlContainer>;
+}
+export declare class StartedMySqlContainer extends AbstractStartedContainer {
+    private readonly database;
+    private readonly username;
+    private readonly userPassword;
+    private readonly rootPassword;
+    private readonly port;
+    constructor(startedTestContainer: StartedTestContainer, database: string, username: string, userPassword: string, rootPassword: string);
+    getPort(): Port;
+    getDatabase(): string;
+    getUsername(): string;
+    getUserPassword(): string;
+    getRootPassword(): string;
+    executeQuery(query: string, additionalFlags?: string[]): Promise<string>;
+}

package/dist/modules/mysql/mysql-container.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartedMySqlContainer = exports.MySqlContainer = void 0;
+const generic_container_1 = require("../../generic-container/generic-container");
+const uuid_1 = require("../../uuid");
+const abstract_started_container_1 = require("../abstract-started-container");
+class MySqlContainer extends generic_container_1.GenericContainer {
+    constructor(image = "mysql:8.0.26") {
+        super(image);
+        this.database = "test";
+        this.username = new uuid_1.RandomUuid().nextUuid();
+        this.userPassword = new uuid_1.RandomUuid().nextUuid();
+        this.rootPassword = new uuid_1.RandomUuid().nextUuid();
+    }
+    withDatabase(database) {
+        this.database = database;
+        return this;
+    }
+    withUsername(username) {
+        this.username = username;
+        return this;
+    }
+    withRootPassword(rootPassword) {
+        this.rootPassword = rootPassword;
+        return this;
+    }
+    withUserPassword(userPassword) {
+        this.userPassword = userPassword;
+        return this;
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.withExposedPorts(3306)
+                .withEnv("MYSQL_DATABASE", this.database)
+                .withEnv("MYSQL_ROOT_PASSWORD", this.rootPassword)
+                .withEnv("MYSQL_USER", this.username)
+                .withEnv("MYSQL_PASSWORD", this.userPassword)
+                .withStartupTimeout(120000);
+            return new StartedMySqlContainer(yield _super.start.call(this), this.database, this.username, this.userPassword, this.rootPassword);
+        });
+    }
+}
+exports.MySqlContainer = MySqlContainer;
+class StartedMySqlContainer extends abstract_started_container_1.AbstractStartedContainer {
+    constructor(startedTestContainer, database, username, userPassword, rootPassword) {
+        super(startedTestContainer);
+        this.database = database;
+        this.username = username;
+        this.userPassword = userPassword;
+        this.rootPassword = rootPassword;
+        this.port = startedTestContainer.getMappedPort(3306);
+    }
+    getPort() {
+        return this.port;
+    }
+    getDatabase() {
+        return this.database;
+    }
+    getUsername() {
+        return this.username;
+    }
+    getUserPassword() {
+        return this.userPassword;
+    }
+    getRootPassword() {
+        return this.rootPassword;
+    }
+    executeQuery(query, additionalFlags = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.startedTestContainer.exec([
+                "mysql",
+                "-u",
+                this.username,
+                `-p${this.userPassword}`,
+                "-e",
+                `${query};`,
+                ...additionalFlags,
+            ]);
+            if (result.exitCode !== 0) {
+                throw new Error(`executeQuery failed with exit code ${result.exitCode} for query: ${query}`);
+            }
+            return result.output;
+        });
+    }
+}
+exports.StartedMySqlContainer = StartedMySqlContainer;

package/dist/network.d.ts

@@ -1,7 +1,6 @@
 import { Uuid } from "./uuid";
 import { CreateNetworkOptions } from "./docker/functions/network/create-network";
 export declare class Network {
-    private readonly uuid;
     private readonly createNetworkOptions;
     constructor(createNetworkOptions?: Partial<CreateNetworkOptions>, uuid?: Uuid);
     start(): Promise<StartedNetwork>;

package/dist/network.js

@@ -17,8 +17,7 @@ const create_network_1 = require("./docker/functions/network/create-network");
 const remove_network_1 = require("./docker/functions/network/remove-network");
 class Network {
     constructor(createNetworkOptions = {}, uuid = new uuid_1.RandomUuid()) {
-        this.uuid = uuid;
-        this.createNetworkOptions = Object.assign({ name: this.uuid.nextUuid(), driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, createNetworkOptions);
+        this.createNetworkOptions = Object.assign({ name: uuid.nextUuid(), driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, createNetworkOptions);
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/reaper.d.ts

@@ -1,5 +1,4 @@
 export interface Reaper {
-    addProject(projectName: string): void;
     getContainerId(): string;
     stop(): void;
 }

package/dist/reaper.js

@@ -17,14 +17,10 @@ const session_id_1 = require("./docker/session-id");
 const docker_host_1 = require("./docker/docker-host");
 const images_1 = require("./images");
 class RealReaper {
-    constructor(sessionId, container, socket) {
-        this.sessionId = sessionId;
+    constructor(container, socket) {
         this.container = container;
         this.socket = socket;
     }
-    addProject(projectName) {
-        this.socket.write(`label=com.docker.compose.project=${projectName}\r\n`);
-    }
     getContainerId() {
         return this.container.getId();
     }
@@ -33,9 +29,6 @@ class RealReaper {
     }
 }
 class DisabledReaper {
-    addProject() {
-        // noop
-    }
     stop() {
         // noop
     }
@@ -100,11 +93,12 @@ class ReaperInstance {
                     logger_1.log.warn(`Connection to Reaper ${container.getId()} closed`);
                 }
             });
-            return yield new Promise((resolve) => {
+            return new Promise((resolve) => {
                 socket.connect(port, host, () => {
                     logger_1.log.debug(`Connected to Reaper ${container.getId()}`);
                     socket.write(`label=org.testcontainers.session-id=${session_id_1.sessionId}\r\n`);
-                    const reaper = new RealReaper(session_id_1.sessionId, container, socket);
+                    socket.write(`label=com.docker.compose.project=${session_id_1.sessionId}\r\n`);
+                    const reaper = new RealReaper(container, socket);
                     resolve(reaper);
                 });
             });

package/dist/wait-strategy.js

@@ -91,21 +91,16 @@ class LogWaitStrategy extends AbstractWaitStrategy {
                         return line.includes(this.message);
                     }
                 };
-                byline_1.default(stream)
-                    .on("data", (line) => {
-                    if (comparisonFn(line)) {
-                        stream.destroy();
-                        clearTimeout(timeout);
-                        resolve();
-                    }
-                })
-                    .on("err", (line) => {
+                const lineProcessor = (line) => {
                     if (comparisonFn(line)) {
                         stream.destroy();
                         clearTimeout(timeout);
                         resolve();
                     }
-                })
+                };
+                byline_1.default(stream)
+                    .on("data", lineProcessor)
+                    .on("err", lineProcessor)
                     .on("end", () => {
                     stream.destroy();
                     clearTimeout(timeout);
@@ -121,7 +116,7 @@ class HealthCheckWaitStrategy extends AbstractWaitStrategy {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.debug(`Waiting for health check`);
             const retryStrategy = new retry_strategy_1.IntervalRetryStrategy(100);
-            const status = yield retryStrategy.retryUntil(() => __awaiter(this, void 0, void 0, function* () { return (yield inspect_container_1.inspectContainer(container)).healthCheckStatus; }), (status) => status === "healthy" || status === "unhealthy", () => {
+            const status = yield retryStrategy.retryUntil(() => __awaiter(this, void 0, void 0, function* () { return (yield inspect_container_1.inspectContainer(container)).healthCheckStatus; }), (healthCheckStatus) => healthCheckStatus === "healthy" || healthCheckStatus === "unhealthy", () => {
                 const timeout = this.startupTimeout;
                 throw new Error(`Health check not healthy after ${timeout}ms for ${container.id}`);
             }, this.startupTimeout);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "7.20.4",
+  "version": "7.22.0",
   "main": "dist/index",
   "types": "dist/index",
   "keywords": [
@@ -37,41 +37,42 @@
     "archiver": "^5.3.0",
     "byline": "^5.0.0",
     "debug": "^4.3.2",
-    "docker-compose": "^0.23.12",
-    "dockerode": "^3.3.0",
+    "docker-compose": "^0.23.13",
+    "dockerode": "^3.3.1",
     "get-port": "^5.1.1",
-    "glob": "^7.1.7",
+    "glob": "^7.2.0",
     "slash": "^3.0.0",
-    "ssh-remote-port-forward": "^1.0.3",
+    "ssh-remote-port-forward": "^1.0.4",
     "tar-fs": "^2.1.1"
   },
   "devDependencies": {
-    "@elastic/elasticsearch": "^7.13.0",
+    "@elastic/elasticsearch": "^7.14.1",
     "@types/byline": "^4.2.33",
-    "@types/debug": "4.1.6",
+    "@types/debug": "4.1.7",
     "@types/glob": "^7.1.4",
-    "@types/jest": "^26.0.24",
-    "@types/node": "^16.3.2",
+    "@types/jest": "^27.0.2",
+    "@types/node": "^16.9.6",
     "@types/node-fetch": "^2.5.11",
     "@types/pg": "^8.6.1",
     "@types/tar-fs": "^2.0.1",
-    "@typescript-eslint/eslint-plugin": "^4.28.3",
-    "@typescript-eslint/parser": "^4.28.3",
+    "@typescript-eslint/eslint-plugin": "^4.31.2",
+    "@typescript-eslint/parser": "^4.31.2",
     "arangojs": "^7.5.0",
     "cross-env": "^7.0.3",
-    "eslint": "^7.30.0",
+    "eslint": "^7.32.0",
     "eslint-config-prettier": "^8.3.0",
-    "husky": "^7.0.0",
-    "jest": "^27.0.6",
+    "husky": "^7.0.2",
+    "jest": "^27.2.1",
     "kafkajs": "^1.15.0",
-    "lint-staged": "^10.5.4",
-    "neo4j-driver": "^4.3.1",
+    "lint-staged": "^11.1.2",
+    "mysql2": "^2.3.0",
+    "neo4j-driver": "^4.3.3",
     "node-fetch": "^2.6.1",
-    "pg": "^8.6.0",
-    "prettier": "^2.3.2",
+    "pg": "^8.7.1",
+    "prettier": "^2.4.1",
     "rimraf": "^3.0.2",
-    "ts-jest": "^27.0.3",
-    "ts-node": "^10.1.0",
+    "ts-jest": "^27.0.5",
+    "ts-node": "^10.2.1",
     "typescript": "^4.3.5",
     "wait-for-expect": "^3.0.2"
   },