@anchan828/nest-redlock 0.0.9 → 0.0.10

package/README.md

@@ -108,13 +108,13 @@ export class ExampleService {
 }
 ```
 
-## Using the RedlockService mock
+## Using fake RedlockService 
 
-If you do not want to use Redis in your Unit tests, define the mock class as RedlockService.
+If you do not want to use Redis in your Unit tests, define the fake class as RedlockService.
 
 ```ts
 const app = await Test.createTestingModule({
-  providers: [TestService, { provide: RedlockService, useClass: MockRedlockService }],
+  providers: [TestService, { provide: RedlockService, useClass: FakeRedlockService }],
 }).compile();
 ```
 
@@ -140,11 +140,11 @@ export class AppModule {}
 
 #### What should I do with Unit tests, I don't want to use Redis.
 
-Use `MockRedlockService` class. Register MockRedlockService with the provider as RedlockService.
+Use `FakeRedlockService` class. Register FakeRedlockService with the provider as RedlockService.
 
 ```ts
 const app = await Test.createTestingModule({
-  providers: [TestService, { provide: RedlockService, useClass: MockRedlockService }],
+  providers: [TestService, { provide: RedlockService, useClass: FakeRedlockService }],
 }).compile();
 ```
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Redlock } from "./redlock.decorator";
+export { FakeRedlockService } from "./redlock.fake-service";
 export { GenerateResourceFunc, RedlockModuleOptions } from "./redlock.interface";
-export { MockRedlockService } from "./redlock.mock-service";
 export { RedlockModule } from "./redlock.module";
 export { RedlockService } from "./redlock.service";

package/dist/index.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedlockService = exports.RedlockModule = exports.MockRedlockService = exports.Redlock = void 0;
+exports.RedlockService = exports.RedlockModule = exports.FakeRedlockService = exports.Redlock = void 0;
 var redlock_decorator_1 = require("./redlock.decorator");
 Object.defineProperty(exports, "Redlock", { enumerable: true, get: function () { return redlock_decorator_1.Redlock; } });
-var redlock_mock_service_1 = require("./redlock.mock-service");
-Object.defineProperty(exports, "MockRedlockService", { enumerable: true, get: function () { return redlock_mock_service_1.MockRedlockService; } });
+var redlock_fake_service_1 = require("./redlock.fake-service");
+Object.defineProperty(exports, "FakeRedlockService", { enumerable: true, get: function () { return redlock_fake_service_1.FakeRedlockService; } });
 var redlock_module_1 = require("./redlock.module");
 Object.defineProperty(exports, "RedlockModule", { enumerable: true, get: function () { return redlock_module_1.RedlockModule; } });
 var redlock_service_1 = require("./redlock.service");

package/dist/{redlock.mock-service.d.ts → redlock.fake-service.d.ts}

@@ -1,7 +1,7 @@
 /// <reference types="node" />
+import { EventEmitter } from "events";
 import { ExecutionResult, Lock, RedlockAbortSignal, Settings } from "redlock";
-import { EventEmitter } from "stream";
-export declare class MockRedlockService extends EventEmitter {
+export declare class FakeRedlockService 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>;

package/dist/{redlock.mock-service.js → redlock.fake-service.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-redlock",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "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": {