fix unit tests

Author: Albo Vieira

README.md

@@ -67,7 +67,7 @@ sudo apt-get install memcached
 
 ```javascript
 const client = Cache.create({
-  host: 'localhost' // if any host was informed, it will set localhost as default
+  host: 'localhost:11211' // if any host was informed, it will set localhost as default
   provider: 'memcached',
   ttl: 2000 // a defautt TTL (miliseconds)
 });

dist/models/cache-contract.d.ts

@@ -1,6 +1,6 @@
 export default interface CacheContract {
-    get(key: string): any;
-    has(key: string): any;
-    delete(key: string): any;
-    add<T>(key: string, object: T, ttl?: number | string): any;
+    get<T>(key: string): Promise<T>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    add<T>(key: string, object: T, ttl?: number | string): Promise<boolean>;
 }

docker-compose.yml

@@ -1,5 +1,9 @@
 version: '3'
 services:
+  memcached:
+    image: memcached
+    ports:
+      - '11211:11211'
   redis:
     image: 'redis'
     environment:

tests/base-test.ts

@@ -0,0 +1,69 @@
+import { expect } from 'chai';
+import CacheContract from '../src/models/cache-contract';
+
+async function shouldGet(client: CacheContract) {
+  const done = await client.add('hashKey', { name: 'Albo' });
+  expect(done).to.be.equal(true);
+  const result = await client.get('hashKey');
+  expect(result).to.be.deep.equal({ name: 'Albo' });
+}
+
+async function shouldPersist(client: CacheContract) {
+  const done = await client.add('hashKey', { name: 'Albo' });
+  expect(done).to.be.equal(true);
+  const result = await client.get('hashKey');
+  expect(result).to.be.deep.equal({ name: 'Albo' });
+}
+
+async function shouldCheck(client: CacheContract) {
+  const done = await client.add('teste', { name: 'guarda ai pf' });
+  expect(done).to.be.equal(true);
+  const has = await client.has('teste');
+  expect(has).to.be.equal(has);
+}
+
+async function shouldDelete(client: CacheContract) {
+  const done = await client.add('teste', { name: 'guarda ai pf' });
+  expect(done).to.be.equal(true);
+  const deleted = await client.delete('teste');
+  expect(deleted).to.be.equal(true);
+}
+
+async function shouldKeepForATime(client: CacheContract) {
+  const done = await client.add('hashKey', { name: 'Albo' }, 50);
+  expect(done).to.be.equal(true);
+
+  let result;
+  const promise = new Promise(resolve => {
+    setTimeout(async () => {
+      result = await client.get('hashKey');
+      resolve(result);
+    }, 40);
+  });
+  result = await promise;
+  expect(result).to.be.deep.equal({ name: 'Albo' });
+}
+
+async function shouldAddTTLByStringFormat(client: CacheContract) {
+  const done = await client.add('hashKey', { name: 'Albo' }, '2s');
+  expect(done).to.be.equal(true);
+
+  let result;
+  const promise = new Promise(resolve => {
+    setTimeout(async () => {
+      result = await client.get('hashKey');
+      resolve(result);
+    }, 900);
+  });
+  result = await promise;
+  expect(result).to.be.deep.equal({ name: 'Albo' });
+}
+
+export {
+  shouldGet,
+  shouldCheck,
+  shouldDelete,
+  shouldAddTTLByStringFormat,
+  shouldKeepForATime,
+  shouldPersist
+};

tests/in-memory.spec.ts

@@ -3,6 +3,14 @@ import { expect } from 'chai';
 import { Cache } from './dependencies';
 import CacheContract from '../src/models/cache-contract';
 import { ProvidersEnum } from '../src/models/provider';
+import {
+  shouldGet,
+  shouldPersist,
+  shouldCheck,
+  shouldDelete,
+  shouldKeepForATime,
+  shouldAddTTLByStringFormat
+} from './base-test';
 
 describe('InMemory', () => {
   let client: CacheContract;
@@ -15,60 +23,27 @@ describe('InMemory', () => {
     });
   });
 
-  it('Should get from memory', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' });
-    expect(done).to.be.equal(true);
-    const result = await client.get('hashKey');
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should get', async () => {
+    shouldGet(client);
   });
 
-  it('Should persist in memory', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' });
-    expect(done).to.be.equal(true);
-    const result = await client.get('hashKey');
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should persist', async () => {
+    shouldPersist(client);
   });
 
-  it('Should check on redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
-    const has = await client.has('teste');
-    expect(has).to.be.equal(has);
+  it('Should check if key exist', async () => {
+    shouldCheck(client);
   });
 
-  it('Should delete on redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
-    const deleted = await client.delete('teste');
-    expect(deleted).to.be.equal(true);
+  it('Should delete', async () => {
+    shouldDelete(client);
   });
 
-  it('Should keep in memory for the given time', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' }, 50);
-    expect(done).to.be.equal(true);
-
-    let result;
-    const promise = new Promise(resolve => {
-      setTimeout(async () => {
-        result = await client.get('hashKey');
-        resolve(result);
-      }, 40);
-    });
-    result = await promise;
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should keep for a given time', async () => {
+    shouldKeepForATime(client);
   });
 
-  it('Should add ttl by string format in memorycache', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' }, '1s');
-    expect(done).to.be.equal(true);
-    let result;
-    const promise = new Promise(resolve => {
-      setTimeout(async () => {
-        result = await client.get('hashKey');
-        resolve(result);
-      }, 900);
-    });
-    result = await promise;
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should add ttl by string format', async () => {
+    shouldAddTTLByStringFormat(client);
   });
 });

tests/memcached.spec.ts

@@ -3,6 +3,14 @@ import { expect } from 'chai';
 import { Cache } from './dependencies';
 import { ProvidersEnum } from '../src/models/provider';
 import CacheContract from '../src/models/cache-contract';
+import {
+  shouldGet,
+  shouldPersist,
+  shouldCheck,
+  shouldDelete,
+  shouldKeepForATime,
+  shouldAddTTLByStringFormat
+} from './base-test';
 
 describe('MemCached', () => {
   let client: CacheContract;
@@ -15,61 +23,27 @@ describe('MemCached', () => {
     });
   });
 
-  it('Should get from memCached', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' });
-    expect(done).to.be.equal(true);
-    const result = await client.get('hashKey');
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should get', async () => {
+    shouldGet(client);
   });
 
-  it('Should persist in memCached', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' });
-    expect(done).to.be.equal(true);
-    const result = await client.get('hashKey');
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should persist', async () => {
+    shouldPersist(client);
   });
 
-  it('Should check on redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
-    const has = await client.has('teste');
-    expect(has).to.be.equal(has);
+  it('Should check if key exist', async () => {
+    shouldCheck(client);
   });
 
-  it('Should delete on redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
-    const deleted = await client.delete('teste');
-    expect(deleted).to.be.equal(true);
+  it('Should delete', async () => {
+    shouldDelete(client);
   });
 
-  it('Should keep in memory for the given time', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' }, 50);
-    expect(done).to.be.equal(true);
-
-    let result;
-    const promise = new Promise(resolve => {
-      setTimeout(async () => {
-        result = await client.get('hashKey');
-        resolve(result);
-      }, 40);
-    });
-    result = await promise;
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should keep for a given time', async () => {
+    shouldKeepForATime(client);
   });
 
-  it('Should add ttl by string format in memCached', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' }, '2s');
-    expect(done).to.be.equal(true);
-
-    let result;
-    const promise = new Promise(resolve => {
-      setTimeout(async () => {
-        result = await client.get('hashKey');
-        resolve(result);
-      }, 900);
-    });
-    result = await promise;
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should add ttl by string format', async () => {
+    shouldAddTTLByStringFormat(client);
   });
 });

tests/redis.spec.ts

@@ -1,8 +1,16 @@
-import { before, describe, it } from 'mocha';
+import { before, beforeEach, describe, it } from 'mocha';
 import { expect } from 'chai';
 import { Cache } from './dependencies';
 import CacheContract from '../src/models/cache-contract';
 import { ProvidersEnum } from '../src/models/provider';
+import {
+  shouldGet,
+  shouldPersist,
+  shouldCheck,
+  shouldDelete,
+  shouldKeepForATime,
+  shouldAddTTLByStringFormat
+} from './base-test';
 
 describe('Redis', () => {
   let client: CacheContract;
@@ -22,59 +30,27 @@ describe('Redis', () => {
     });
   });
 
-  it('Should get from redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
-    const result = await client.get('teste');
-    expect(result).to.be.deep.equal({ name: 'guarda ai pf' });
+  it('Should get', async () => {
+    shouldGet(client);
   });
 
-  it('Should persist on redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
+  it('Should persist', async () => {
+    shouldPersist(client);
   });
 
-  it('Should check on redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
-    const has = await client.has('teste');
-    expect(has).to.be.equal(has);
+  it('Should check if key exist', async () => {
+    shouldCheck(client);
   });
 
-  it('Should delete on redis', async () => {
-    const done = await client.add('teste', { name: 'guarda ai pf' });
-    expect(done).to.be.equal(true);
-    const deleted = await client.delete('teste');
-    expect(deleted).to.be.equal(true);
+  it('Should delete', async () => {
+    shouldDelete(client);
   });
 
-  it('Should keep in redis for the given time', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' }, 50);
-    expect(done).to.be.equal(true);
-
-    let result;
-    const promise = new Promise(resolve => {
-      setTimeout(async () => {
-        result = await client.get('hashKey');
-        resolve(result);
-      }, 40);
-    });
-    result = await promise;
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should keep for a given time', async () => {
+    shouldKeepForATime(client);
   });
 
-  it('Should add ttl by string format in redis', async () => {
-    const done = await client.add('hashKey', { name: 'Albo' }, '400');
-    expect(done).to.be.equal(true);
-
-    let result;
-    const promise = new Promise(resolve => {
-      setTimeout(async () => {
-        result = await client.get('hashKey');
-        resolve(result);
-      }, 300);
-    });
-    result = await promise;
-    expect(result).to.be.deep.equal({ name: 'Albo' });
+  it('Should add ttl by string format', async () => {
+    shouldAddTTLByStringFormat(client);
   });
 });