WIP Test Coverage

Author: moaxaca

package.json

@@ -2,7 +2,7 @@
   "private": false,
   "author": "Matthew Oaxaca",
   "license": "MIT",
-  "version": "1.1.8",
+  "version": "2.0.0",
   "name": "async-redis",
   "keywords": [
     "redis",
@@ -40,6 +40,8 @@
     "redis": "3.0.2"
   },
   "devDependencies": {
+    "@types/node": "^14.0.27",
+    "@types/redis": "^2.8.25",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
     "coveralls": "^3.1.0",

src/index.d.ts

@@ -1,7 +1,21 @@
-import { Commands, RedisClient, ClientOpts } from 'redis';
+import { Commands, RedisClient, ClientOpts, ServerInfo } from 'redis';
+import {EventEmitter} from "events";
+
+type Callback<T> = (err: Error | null, reply: T) => void;
 
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 type Omitted = Omit<RedisClient, keyof Commands<boolean>>;
+type OkOrError = 'OK'|Error
+
+interface OverloadedCommand<T, R> {
+  (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, arg6: T): R;
+  (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T): R;
+  (arg1: T, arg2: T, arg3: T, arg4: T): R;
+  (arg1: T, arg2: T, arg3: T): R;
+  (arg1: T, arg2: T | T[]): R;
+  (arg1: T | T[]): R;
+  (...args: Array<T>): R;
+}
 
 interface Promisified<T = RedisClient> extends Omitted, Commands<Promise<boolean>> {}
 
@@ -19,10 +33,117 @@ interface AsyncRedisConstructor {
   decorate: (client: RedisClient) => Promisified;
 }
 
-interface AsyncRedisCommands {
+interface AsyncRedisEventHandlers extends EventEmitter {
+  on(event: 'message' | 'message_buffer', listener: (channel: string, message: string) => void): this;
+  on(event: 'pmessage' | 'pmessage_buffer', listener: (pattern: string, channel: string, message: string) => void): this;
+  on(event: 'subscribe' | 'unsubscribe', listener: (channel: string, count: number) => void): this;
+  on(event: 'psubscribe' | 'punsubscribe', listener: (pattern: string, count: number) => void): this;
+  on(event: string, listener: (...args: any[]) => void): this;
+}
+
+interface AsyncRedisCommands<R> {
+  /**
+   * Listen for all requests received by the server in real time.
+   */
+  monitor(cb?: Callback<undefined>): any;
+  MONITOR(cb?: Callback<undefined>): any;
+
+  /**
+   * Get information and statistics about the server.
+   */
+  info(): Promise<ServerInfo|boolean>;
+  info(section?: string | string[]): Promise<ServerInfo|boolean>;
+  INFO(): Promise<ServerInfo|boolean>;
+  INFO(section?: string | string[]): Promise<ServerInfo|boolean>;
+
+  /**
+   * Ping the server.
+   */
+  ping(): Promise<string|boolean>;
+  ping(message: string): Promise<string|boolean>;
+  PING(): Promise<string|boolean>;
+  PING(message: string): Promise<string|boolean>;
+
+  /**
+   * Authenticate to the server.
+   */
+  auth(password: string): Promise<string>;
+  AUTH(password: string): Promise<string>;
+
+  /**
+   * Get array of Redis command details.
+   *
+   * COUNT - Get total number of Redis commands.
+   * GETKEYS - Extract keys given a full Redis command.
+   * INFO - Get array of specific REdis command details.
+   */
+  command(cb?: Callback<Array<[string, number, string[], number, number, number]>>): R;
+  COMMAND(cb?: Callback<Array<[string, number, string[], number, number, number]>>): R;
+
+  /**
+   * Get array of Redis command details.
+   *
+   * COUNT - Get array of Redis command details.
+   * GETKEYS - Extract keys given a full Redis command.
+   * INFO - Get array of specific Redis command details.
+   * GET - Get the value of a configuration parameter.
+   * REWRITE - Rewrite the configuration file with the in memory configuration.
+   * SET - Set a configuration parameter to the given value.
+   * RESETSTAT - Reset the stats returned by INFO.
+   */
+  config: OverloadedCommand<string, boolean>;
+  CONFIG: OverloadedCommand<string, boolean>;
+
+  /**
+   * Return the number of keys in the selected database.
+   */
+  dbsize(): Promise<number>;
+  DBSIZE(): Promise<number>;
+
+  /**
+   * OBJECT - Get debugging information about a key.
+   * SEGFAULT - Make the server crash.
+   */
+  debug: OverloadedCommand<string, boolean>;
+  DEBUG: OverloadedCommand<string, boolean>;
+
+  /**
+   * PubSub Commands
+   */
+  /**
+   * Post a message to a channel.
+   */
+  publish(channel: string, value: string): Promise<number|boolean>;
+  PUBLISH(channel: string, value: string): Promise<number|boolean>;
+
   /**
    * CRUD Commands
    */
+
+  /**
+   * Append a value to a key.
+   */
+  append(key: string, value: string): Promise<number>;
+  APPEND(key: string, value: string): Promise<number>;
+
+  /**
+   * Asynchronously rewrite the append-only file.
+   */
+  bgrewriteaof(): Promise<OkOrError>;
+  BGREWRITEAOF(): Promise<OkOrError>;
+
+  /**
+   * Asynchronously save the dataset to disk.
+   */
+  bgsave(): Promise<OkOrError>;
+  BGSAVE(): Promise<OkOrError>;
+
+  /**
+   * Determine if a key exists.
+   */
+  exists: OverloadedCommand<string, R>;
+  EXISTS: OverloadedCommand<string, R>;
+
   /**
    * Set the string value of a key.
    */
@@ -36,5 +157,6 @@ interface AsyncRedisCommands {
   SET(key: string, value: string, mode: string, duration: number, flag: string): Promise<string|undefined>;
 }
 
-declare const AsyncRedis: AsyncRedisConstructor;
+interface AsyncRedisInterface extends AsyncRedisConstructor, AsyncRedisEventHandlers, AsyncRedisCommands<boolean> {}
+declare const AsyncRedis: AsyncRedisInterface;
 export = AsyncRedis;

src/index.js

@@ -23,7 +23,7 @@ AsyncRedis.prototype.setup = function(redisClient) {
   const commandConfigs = redisCommands(redisClient);
   objectDecorator(redisClient, (name, method) => {
     if (commandConfigs.commands.has(name)) {
-      objectPromisify(this, method);
+      objectPromisify(this, redisClient, name);
     } else if (commandConfigs.queueCommands.has(name)) {
       return (...args) => {
         const multi = method.apply(redisClient, args);

src/object-decorator.js

@@ -5,9 +5,8 @@
  */
 module.exports = (object, decorator) => {
   for (const prop in object) {
-    console.log(prop);
     if (typeof object[prop] === 'function') {
-      object[prop] = decorator(prop, object[prop]);
+      decorator(prop, object[prop]);
     }
   }
   return object;

src/object-promisify.js

@@ -1,19 +1,20 @@
 /**
+ * @param proxy
  * @param object
- * @param method
- * @returns {*}
+ * @param name
+ * @returns void
  */
-module.exports = (object, method) => {
-  return (...args) => new Promise((resolve, reject) => {
-    args.push((error, ...results) => {
-      console.log(results);
-      if (error) {
-        reject(error, ...results);
-      } else {
-        resolve(...results);
-      }
+module.exports = (proxy, object, name) => {
+  proxy[name] = (...args) => {
+    return new Promise((resolve, reject) => {
+      args.push((error, ...results) => {
+        if (error) {
+          reject(error, ...results);
+        } else {
+          resolve(...results);
+        }
+      });
+      object[name](...args);
     });
-    objects.
-    method.apply(object, args);
-  });
+  };
 };

test/integration/commands.spec.js

@@ -1,5 +1,9 @@
+require('../setup');
 const { assert } = require('chai');
 
+/**
+ * @type {AsyncRedis}
+ */
 const AsyncRedis = require('../../src');
 const getTestRedisConfig = require('../util/getTestRedisConfig');
 
@@ -14,25 +18,59 @@ describe('Commands', () => {
     redis.flushall();
   });
 
-  xdescribe('APPEND Commands', () => {
-    it('should execute append', async () => {
-      const status = await redis.append('SETUSER', 'hello');
-      assert.equal(status, 'OK');
+  describe('Auth', () => {
+    it('should check decoration', async () => {
+      assert.equal(typeof redis.auth, 'function');
     });
 
-    it('should execute exists', async () => {
-      const status = await redis.append('SETUSER', 'world');
+    it('should test rejection', async () => {
+      const promise = redis.auth('bad_password');
+      assert.isRejected(promise, Error);
+    });
+  });
+
+  describe('CRUD - AOF (Append Only File)', () => {
+    it('should work with AOF', async () => {
+      await redis.config('set', 'appendonly', 'no');
+      await redis.config('rewrite');
+      let status = await redis.bgrewriteaof();
+      assert.equal(status, 'Background append only file rewriting started');
+      status = await redis.set('test', 'value');
       assert.equal(status, 'OK');
+      status = await redis.bgsave();
+      await redis.bgrewriteaof();
+      assert.equal(status, 'Background saving started');
     });
   });
 
-  describe('CRUD (set, get, del)', () => {
-    it('should return ok', async () => {
+  describe('CRUD (append, set, get, del, exists)', () => {
+    it('should execute append', async () => {
+      let status = await redis.append('KEY', 'hello');
+      assert.equal(status, 5);
+      status = await redis.append('KEY', 'world');
+      assert.equal(status, 10);
+    });
+
+    it('should execute exists', async () => {
+      let status = await redis.exists('KEY');
+      assert.equal(status, 0);
+      await redis.set('KEY', '');
+      status = await redis.exists('KEY');
+      assert.equal(status, 1);
+    });
+
+    it('should set and return ok', async () => {
       const status = await redis.set('hello', 'world');
       assert.equal(status, "OK");
     });
 
-    it('should return true', async () => {
+    it('should get value', async () => {
+      await redis.set('hello', 'world');
+      const value = await redis.get('hello');
+      assert.equal(value, "world");
+    });
+
+    it('should del and return true', async () => {
       await redis.set('hello', 'world');
       const status = await redis.del('hello');
       assert.equal(status, true);
@@ -44,17 +82,65 @@ describe('Commands', () => {
     });
   });
 
-  xdescribe('test rejection', () => {
-    it('should reject promise on throw', async () => {
-      const promise = redis.set('hello');
-      assert.isRejected(promise, Error);
-    });
-  });
-
   xdescribe('test multi not a promise', () => {
     it('should be not equal', async () => {
       const notAPromise = redis.multi();
       assert.notEqual(Promise.resolve(notAPromise), notAPromise);
     });
   });
+
+  describe('PubSub', () => {
+
+  });
+
+  describe('Utility', () => {
+    it('should return server info', async () => {
+      let info = await redis.info();
+      assert.equal(info.slice(0, 8), '# Server');
+    });
+
+    it('should ping', async () => {
+      let reply = await redis.ping();
+      assert.equal(reply, 'PONG');
+    });
+
+    it('should return db size', async () => {
+      let status = await redis.set('test', 'value');
+      assert.equal(status, 'OK');
+      status = await redis.dbsize();
+      assert.equal(status, 1);
+    });
+
+    it('should execute debug', async () => {
+      let status = await redis.set('test', 'value');
+      assert.equal(status, 'OK');
+      status = await redis.debug('object', 'test');
+      assert(status);
+    });
+
+    it('should execute monitor', async () => {
+      const promises = [];
+      promises.push(new Promise((resolve, reject) => {
+        redis.monitor((error, status) => {
+          if (error) {
+            reject(error)
+          } else {
+            assert.equal(status, 'OK');
+            resolve();
+          }
+        });
+      }));
+      promises.push(new Promise((resolve) => {
+        redis.on('monitor', function(time, args) {
+          assert.equal(args.length, 3);
+          assert.equal(args[0], 'set');
+          assert.equal(args[1], 'hello');
+          assert.equal(args[2], 'world');
+          resolve();
+        });
+      }));
+      promises.push(redis.set('hello', 'world'));
+      await Promise.all(promises);
+    });
+  });
 });