Redis

Author: cristianrgreco

docs/modules/redis.md

@@ -1,6 +1,4 @@
-# Redis Module
-
-[Redis](https://redis.io/) The open source, in-memory data store used by millions of developers as a database, cache, streaming engine, and message broker.
+# Redis
 
 ## Install
 
@@ -10,38 +8,46 @@ npm install @testcontainers/redis --save-dev
 
 ## Examples
 
-<!--codeinclude-->
+These examples use the following libraries:
 
-[Start container:](../../packages/modules/redis/src/redis-container.test.ts) inside_block:startContainer
+- [redis](https://www.npmjs.com/package/redis)
 
-<!--/codeinclude-->
+        npm install redis
 
-<!--codeinclude-->
+Choose an image from the [container registry](https://hub.docker.com/_/redis) and substitute `IMAGE`.
 
-[Connect redis client to container:](../../packages/modules/redis/src/redis-container.test.ts) inside_block:simpleConnect
-
-<!--/codeinclude-->
+### Set and get a value
 
 <!--codeinclude-->
-
-[Start container with password authentication:](../../packages/modules/redis/src/redis-container.test.ts) inside_block:startWithCredentials
-
+[](../../packages/modules/redis/src/redis-container.test.ts) inside_block:redisStartContainer
 <!--/codeinclude-->
 
-<!--codeinclude-->
-
-[Define volume for persistent/predefined data:](../../packages/modules/redis/src/redis-container.test.ts) inside_block:persistentData
+### With password
 
+<!--codeinclude-->
+[](../../packages/modules/redis/src/redis-container.test.ts) inside_block:redisStartWithCredentials
 <!--/codeinclude-->
 
+### With persistent data
+
 <!--codeinclude-->
+[](../../packages/modules/redis/src/redis-container.test.ts) inside_block:persistentData
+<!--/codeinclude-->
 
-[Start container with redis/redis-stack-server image:](../../packages/modules/redis/src/redis-container.test.ts) inside_block:startWithRedisStack
+### With predefined data
 
+<!--codeinclude-->
+[](../../packages/modules/redis/src/redis-container.test.ts) inside_block:withPredefinedData
 <!--/codeinclude-->
 
+### Redis stack
+
 <!--codeinclude-->
+[](../../packages/modules/redis/src/redis-container.test.ts) inside_block:startWithRedisStack
+<!--/codeinclude-->
 
-[Execute a command inside the container:](../../packages/modules/redis/src/redis-container.test.ts) inside_block:executeCommand
+### Execute a command inside the container
 
+<!--codeinclude-->
+[](../../packages/modules/redis/src/redis-container.test.ts) inside_block:executeCommand
 <!--/codeinclude-->

packages/modules/redis/src/redis-container.test.ts

@@ -3,64 +3,69 @@ import os from "os";
 import path from "path";
 import { createClient } from "redis";
 import { getImage } from "../../../testcontainers/src/utils/test-helper";
-import { RedisContainer, StartedRedisContainer } from "./redis-container";
+import { RedisContainer } from "./redis-container";
 
 const IMAGE = getImage(__dirname);
 
 describe("RedisContainer", { timeout: 240_000 }, () => {
-  // startContainer {
   it("should connect and execute set-get", async () => {
+    // redisStartContainer {
     await using container = await new RedisContainer(IMAGE).start();
 
-    const client = await connectTo(container);
+    const client = createClient({ url: container.getConnectionUrl() });
+    await client.connect();
 
     await client.set("key", "val");
     expect(await client.get("key")).toBe("val");
 
     client.destroy();
+    // }
   });
-  // }
 
   it("should connect with password and execute set-get", async () => {
     await using container = await new RedisContainer(IMAGE).withPassword("test").start();
 
-    const client = await connectTo(container);
+    const client = createClient({ url: container.getConnectionUrl() });
+    await client.connect();
 
     await client.set("key", "val");
     expect(await client.get("key")).toBe("val");
 
     client.destroy();
   });
 
-  // persistentData {
   it("should reconnect with volume and persistence data", async () => {
+    // persistentData {
     const sourcePath = fs.mkdtempSync(path.join(os.tmpdir(), "redis-"));
+
     await using container = await new RedisContainer(IMAGE).withPassword("test").withPersistence(sourcePath).start();
-    let client = await connectTo(container);
 
+    let client = createClient({ url: container.getConnectionUrl() });
+    await client.connect();
     await client.set("key", "val");
     client.destroy();
+
     await container.restart();
-    client = await connectTo(container);
+    client = createClient({ url: container.getConnectionUrl() });
+    await client.connect();
+
     expect(await client.get("key")).toBe("val");
 
     client.destroy();
-    try {
-      fs.rmSync(sourcePath, { force: true, recursive: true });
-    } catch (e) {
-      //Ignore clean up, when have no access on fs.
-      console.log(e);
-    }
+    fs.rmSync(sourcePath, { force: true, recursive: true });
+    // }
   });
-  // }
 
-  // initial data import {
   it("should load initial data and can read it", async () => {
+    // withPredefinedData {
     await using container = await new RedisContainer(IMAGE)
       .withPassword("test")
       .withInitialData(path.join(__dirname, "initData.redis"))
       .start();
-    const client = await connectTo(container);
+
+    const client = createClient({ url: container.getConnectionUrl() });
+    await client.connect();
+
     const user = {
       first_name: "David",
       last_name: "Bloom",
@@ -69,58 +74,51 @@ describe("RedisContainer", { timeout: 240_000 }, () => {
     expect(await client.get("user:002")).toBe(JSON.stringify(user));
 
     client.destroy();
+    // }
   });
-  // }
 
-  // startWithCredentials {
   it("should start with credentials and login", async () => {
+    // redisStartWithCredentials {
     const password = "testPassword";
 
-    // Test authentication
     await using container = await new RedisContainer(IMAGE).withPassword(password).start();
+
     expect(container.getConnectionUrl()).toEqual(`redis://:${password}@${container.getHost()}:${container.getPort()}`);
+    // }
 
-    const client = await connectTo(container);
+    const client = createClient({ url: container.getConnectionUrl() });
+    await client.connect();
 
     await client.set("key", "val");
     expect(await client.get("key")).toBe("val");
 
     client.destroy();
   });
-  // }
 
-  // executeCommand {
   it("should execute container cmd and return the result", async () => {
+    // executeCommand {
     await using container = await new RedisContainer(IMAGE).start();
 
     const queryResult = await container.executeCliCmd("info", ["clients"]);
+
     expect(queryResult).toEqual(expect.stringContaining("connected_clients:1"));
+    // }
   });
-  // }
 
-  // startWithRedisStack {
   it("should start with redis-stack-server and json module", async () => {
+    // startWithRedisStack {
     await using container = await new RedisContainer("redis/redis-stack-server:7.4.0-v4")
       .withPassword("testPassword")
       .start();
-    const client = await connectTo(container);
+
+    const client = createClient({ url: container.getConnectionUrl() });
+    await client.connect();
 
     await client.json.set("key", "$", { name: "test" });
     const result = await client.json.get("key");
     expect(result).toEqual({ name: "test" });
 
     client.destroy();
+    // }
   });
-  // }
-
-  // simpleConnect {
-  async function connectTo(container: StartedRedisContainer) {
-    const client = createClient({
-      url: container.getConnectionUrl(),
-    });
-    await client.connect();
-    expect(client.isOpen).toBeTruthy();
-    return client;
-  }
-  // }
 });