@anchan828/nest-redlock 0.0.3 → 0.0.6

package/README.md

@@ -108,6 +108,16 @@ export class ExampleService {
 }
 ```
 
+## Using the RedisRedlockService mock
+
+If you do not want to use Redis in your Unit tests, define the mock class as RedisRedlockService.
+
+```ts
+const app = await Test.createTestingModule({
+  providers: [TestService, { provide: RedisRedlockService, useClass: MockRedisRedlockService }],
+}).compile();
+```
+
 ## Troubleshooting
 
 ### Nest can't resolve dependencies of the XXX. Please make sure that the "@redisRedlockService" property is available in the current context.
@@ -128,6 +138,16 @@ import Redis from "ioredis";
 export class AppModule {}
 ```
 
+#### What should I do with Unit tests, I don't want to use Redis.
+
+Use `MockRedisRedlockService` class. Register MockRedisRedlockService with the provider as RedisRedlockService.
+
+```ts
+const app = await Test.createTestingModule({
+  providers: [TestService, { provide: RedisRedlockService, useClass: MockRedisRedlockService }],
+}).compile();
+```
+
 ## License
 
 [MIT](LICENSE)

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { RedisRedlock } from "./redis-redlock.decorator";
 export { GenerateResourceFunc, RedisRedlockModuleOptions } from "./redis-redlock.interface";
+export { MockRedisRedlockService } from "./redis-redlock.mock-service";
 export { RedisRedlockModule } from "./redis-redlock.module";
 export { RedisRedlockService } from "./redis-redlock.service";

package/dist/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisRedlockService = exports.RedisRedlockModule = exports.RedisRedlock = void 0;
+exports.RedisRedlockService = exports.RedisRedlockModule = exports.MockRedisRedlockService = exports.RedisRedlock = void 0;
 var redis_redlock_decorator_1 = require("./redis-redlock.decorator");
 Object.defineProperty(exports, "RedisRedlock", { enumerable: true, get: function () { return redis_redlock_decorator_1.RedisRedlock; } });
+var redis_redlock_mock_service_1 = require("./redis-redlock.mock-service");
+Object.defineProperty(exports, "MockRedisRedlockService", { enumerable: true, get: function () { return redis_redlock_mock_service_1.MockRedisRedlockService; } });
 var redis_redlock_module_1 = require("./redis-redlock.module");
 Object.defineProperty(exports, "RedisRedlockModule", { enumerable: true, get: function () { return redis_redlock_module_1.RedisRedlockModule; } });
 var redis_redlock_service_1 = require("./redis-redlock.service");

package/dist/redis-redlock.mock-service.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { ExecutionResult, Lock, RedlockAbortSignal, Settings } from "redlock";
+import { EventEmitter } from "stream";
+export declare class MockRedisRedlockService extends EventEmitter {
+    quit(): Promise<void>;
+    acquire(resources: string[], duration: number, settings?: Partial<Settings> | undefined): Promise<Lock>;
+    release(lock: Lock, settings?: Partial<Settings> | undefined): Promise<ExecutionResult>;
+    extend(existing: Lock, duration: number, settings?: Partial<Settings> | undefined): Promise<Lock>;
+    using<T>(resources: string[], duration: number, settings: Partial<Settings>, routine?: ((signal: RedlockAbortSignal) => Promise<T>) | undefined): Promise<T>;
+    using<T>(resources: string[], duration: number, routine: (signal: RedlockAbortSignal) => Promise<T>): Promise<T>;
+}

package/dist/redis-redlock.mock-service.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRedisRedlockService = void 0;
+const stream_1 = require("stream");
+class MockRedisRedlockService extends stream_1.EventEmitter {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    async quit() { }
+    async acquire(resources, duration, settings) {
+        return createLockMock();
+    }
+    async release(lock, settings) {
+        return { attempts: [] };
+    }
+    async extend(existing, duration, settings) {
+        return createLockMock();
+    }
+    async using(resources, duration, settingsOrRoutine, routine) {
+        const routineFunc = typeof settingsOrRoutine === "function" ? settingsOrRoutine : routine;
+        return await routineFunc?.({ aborted: false });
+    }
+}
+exports.MockRedisRedlockService = MockRedisRedlockService;
+function createLockMock() {
+    let lock;
+    // eslint-disable-next-line prefer-const
+    lock = {
+        release: async () => ({ attempts: [] }),
+        extend: async (duration) => lock,
+    };
+    return lock;
+}

package/dist/redis-redlock.module.js

@@ -23,7 +23,16 @@ let RedisRedlockModule = class RedisRedlockModule extends redis_redlock_module_d
     }
     async onModuleDestroy() {
         for (const client of this.options.clients) {
-            await client.quit();
+            switch (client.status) {
+                case "end":
+                    continue;
+                case "ready":
+                    await client.quit();
+                    break;
+                default:
+                    client.disconnect();
+                    break;
+            }
         }
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-redlock",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "This is a [Nest](https://github.com/nestjs/nest) implementation of the redlock algorithm for distributed redis locks.",
   "homepage": "https://github.com/anchan828/nest-redlock#readme",
   "bugs": {
@@ -22,6 +22,9 @@
     "lint:fix": "npm run lint -- --fix",
     "test": "jest --coverage --runInBand"
   },
+  "dependencies": {
+    "redlock": "^5.0.0-beta.2"
+  },
   "devDependencies": {
     "@commitlint/cli": "17.0.3",
     "@commitlint/config-conventional": "17.0.3",
@@ -42,7 +45,6 @@
     "jest": "28.1.3",
     "lint-staged": "13.0.3",
     "prettier": "2.7.1",
-    "redlock": "5.0.0-beta.2",
     "reflect-metadata": "0.1.13",
     "rxjs": "7.5.6",
     "supertest": "6.2.4",