菜单
Teaches the agent to speed up Node integration tests with Testcontainers reuse — withReuse(true), TESTCONTAINERS_REUSE_ENABLE, the .testcontainers.properties opt-in, stable hashing for Postgres/MySQL/Kafka, and Ryuk/CI caveats.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/PramodDutta/qaskills --skill testcontainers-reuse-node命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| name | Testcontainers Reuse (Node) |
| description | Teaches the agent to speed up Node integration tests with Testcontainers reuse — withReuse(true), TESTCONTAINERS_REUSE_ENABLE, the .testcontainers.properties opt-in, stable hashing for Postgres/MySQL/Kafka, and Ryuk/CI caveats. |
| version | 1.0.0 |
| author | thetestingacademy |
| license | MIT |
| tags | ["testcontainers","reuse","docker","integration-testing","postgres","kafka","ryuk","node"] |
| testingTypes | ["integration","e2e"] |
| frameworks | ["testcontainers","vitest","jest"] |
| languages | ["typescript"] |
| domains | ["api","web"] |
| agents | ["claude-code","cursor","github-copilot","windsurf","codex","aider","continue","cline","zed","bolt","gemini-cli","amp"] |
This skill makes the agent use Testcontainers' reuse feature to cut local integration-test startup from seconds to milliseconds, while avoiding the footguns: reuse is an explicit developer opt-in (it is off in CI by design), it requires a stable container configuration to hash, and a reused container is not cleaned up by Ryuk, so test data must be reset by the test, not the container lifecycle.
Use this skill when local integration tests are slow because every run boots a fresh Postgres/MySQL/Kafka, or when the user asks about withReuse, TESTCONTAINERS_REUSE_ENABLE, or "keep the container alive between runs."
withReuse(true) is set AND testcontainers.reuse.enable=true is in the user's ~/.testcontainers.properties (or TESTCONTAINERS_REUSE_ENABLE=true). It should stay off in CI, where clean state matters more than speed..stop() are mutually exclusive in intent. Do not call .stop() in teardown for a reused container, or you defeat reuse on the next run.Reuse needs a machine-level opt-in. The agent should instruct the user to create this file (it is intentionally not committed):
# ~/.testcontainers.properties
testcontainers.reuse.enable=true
Equivalent for the current shell (useful in scripts, NOT in CI):
export TESTCONTAINERS_REUSE_ENABLE=true
Without this, withReuse(true) is silently ignored and a fresh container starts every time.
withReuse(true) plus a fixed name/labels. The data reset (TRUNCATE) is what makes reuse safe across runs.
import { PostgreSqlContainer, type StartedPostgreSqlContainer } from '@testcontainers/postgresql';
import { Client } from 'pg';
let container: StartedPostgreSqlContainer;
let client: Client;
beforeAll(async () => {
container = await new PostgreSqlContainer('postgres:16-alpine')
.withDatabase('appdb')
.withUsername('test')
.withPassword('test')
// A stable label set keeps the config hash constant -> the same
// container is reused on the next run.
.withLabels({ project: 'my-app', purpose: 'integration' })
.withReuse() // <-- opt into reuse
.start();
client = new Client({ connectionString: container.getConnectionUri() });
await client.connect();
// Schema is created idempotently because the container may already exist.
await client.query(`
CREATE TABLE IF NOT EXISTS users (
id SERIAL PRIMARY KEY,
email TEXT UNIQUE NOT NULL
);
`);
});
beforeEach(async () => {
// Reset DATA, not the container. This is the key to safe reuse.
await client.query('TRUNCATE TABLE users RESTART IDENTITY CASCADE');
});
afterAll(async () => {
await client.end();
// IMPORTANT: do NOT call container.stop() — that kills the reusable container.
});
test('inserts and reads a user', async () => {
await client.query(`INSERT INTO users (email) VALUES ('ada@example.com')`);
const { rows } = await client.query('SELECT email FROM users');
expect(rows).toEqual([{ email: 'ada@example.com' }]);
});
Reuse shines when several test files would each spin up their own DB. A small singleton returns the same started container; the hash makes them converge on one Docker container.
// test/support/postgres.ts
import { PostgreSqlContainer, type StartedPostgreSqlContainer } from '@testcontainers/postgresql';
let started: Promise<StartedPostgreSqlContainer> | undefined;
export function getPostgres(): Promise<StartedPostgreSqlContainer> {
if (!started) {
started = new PostgreSqlContainer('postgres:16-alpine')
.withDatabase('appdb')
.withUsername('test')
.withPassword('test')
.withReuse()
.start();
}
return started;
}
// any.integration.test.ts
import { getPostgres } from './support/postgres';
test('uses the shared reusable container', async () => {
const pg = await getPostgres();
expect(pg.getConnectionUri()).toContain('appdb');
});
Same shape, different module. Idempotent schema + per-test reset.
import { MySqlContainer, type StartedMySqlContainer } from '@testcontainers/mysql';
import mysql from 'mysql2/promise';
let container: StartedMySqlContainer;
beforeAll(async () => {
container = await new MySqlContainer('mysql:8.4')
.withDatabase('appdb')
.withUsername('test')
.withUserPassword('test')
.withReuse()
.start();
const conn = await mysql.createConnection(container.getConnectionUri());
await conn.query(`CREATE TABLE IF NOT EXISTS orders (id INT PRIMARY KEY AUTO_INCREMENT, sku VARCHAR(64))`);
await conn.end();
});
beforeEach(async () => {
const conn = await mysql.createConnection(container.getConnectionUri());
await conn.query('TRUNCATE TABLE orders');
await conn.end();
});
Kafka boot is expensive, so reuse pays off most here. Reset by deleting topics rather than restarting the broker.
import { KafkaContainer, type StartedKafkaContainer } from '@testcontainers/kafka';
import { Kafka } from 'kafkajs';
let container: StartedKafkaContainer;
let kafka: Kafka;
beforeAll(async () => {
container = await new KafkaContainer('confluentinc/cp-kafka:7.6.1')
.withReuse()
.start();
kafka = new Kafka({ brokers: [`${container.getHost()}:${container.getMappedPort(9093)}`] });
});
beforeEach(async () => {
// Reset state by recreating the topic, not the broker.
const admin = kafka.admin();
await admin.connect();
const topics = await admin.listTopics();
if (topics.includes('events')) {
await admin.deleteTopics({ topics: ['events'] });
}
await admin.createTopics({ topics: [{ topic: 'events', numPartitions: 1 }] });
await admin.disconnect();
});
test('produces and consumes an event', async () => {
const producer = kafka.producer();
await producer.connect();
await producer.send({ topic: 'events', messages: [{ value: 'hello' }] });
await producer.disconnect();
// ...consume and assert...
});
In CI, isolation beats speed and reused containers can poison subsequent jobs. Gate the behavior on environment.
import { PostgreSqlContainer } from '@testcontainers/postgresql';
const isCI = process.env.CI === 'true';
const builder = new PostgreSqlContainer('postgres:16-alpine')
.withDatabase('appdb')
.withUsername('test')
.withPassword('test');
// Only reuse locally. In CI, start fresh and let Ryuk reap it.
const container = await (isCI ? builder : builder.withReuse()).start();
~/.testcontainers.properties with testcontainers.reuse.enable=true) in the project README — without it, withReuse() is a no-op.beforeEach (TRUNCATE / recreate topics), never by stopping the container. A reused container persists data by design..stop() in afterAll for reusable containers; closing only the client connection is enough.CI env gate) so jobs get clean, Ryuk-reaped containers and never inherit stale state.CREATE TABLE IF NOT EXISTS) because the container may already exist from a previous run.withReuse() but expecting CI to reuse. CI usually lacks the opt-in (and should) — reuse silently disables, masking the intent. Gate it on environment instead.container.stop() in teardown for a reusable container — it kills the very container the next run wanted to reuse.postgres:latest) — the hash and the pulled image drift, breaking reproducible reuse.docker rm).withReuse(true) / TESTCONTAINERS_REUSE_ENABLE?".testcontainers.properties go?"