make code more testable; add more unit tests

Author: patinthehat

src/lib/cache/Cache.ts

@@ -14,5 +14,5 @@ export abstract class Cache {
 
     public abstract purge();
 
-    public abstract clear();
+    public abstract clear(): boolean;
 }

src/lib/cache/MemoryCache.ts

@@ -59,6 +59,6 @@ export class MemoryCache extends Cache {
     }
 
     public clear() {
-        //
+        return true;
     }
 }

src/lib/cache/RedisCache.ts

@@ -13,7 +13,7 @@ export class RedisCache extends Cache {
 
         this.prefix = keyPrefix;
 
-        this.redis = new Redis(); //{ keyPrefix: keyPrefix });
+        this.redis = new Redis({ keyPrefix: keyPrefix });
     }
 
     public destroy() {
@@ -37,10 +37,10 @@ export class RedisCache extends Cache {
     }
 
     public purge() {
-        //
+        return true;
     }
 
     public clear() {
-        //
+        return true;
     }
 }

src/lib/resolver.ts

@@ -1,3 +1,4 @@
+import { Cache } from './cache/Cache';
 import { RedisCache } from './cache/RedisCache';
 import { MemoryCache } from './cache/MemoryCache';
 import { getResolver as getCommentsResolver } from '@/resolvers/comments';
@@ -8,12 +9,23 @@ import { getResolver as getCommentCountResolver } from '@/resolvers/Story/commen
 import { getResolver as getUserResolver } from '@/resolvers/user';
 import { getScalarType as getDateScalar } from '@/scalars/Date';
 
+export const getCacheInstance = (driver: string): Cache => {
+    switch (driver) {
+        case 'redis':
+            return new RedisCache();
+
+        case 'memory':
+        default:
+            return new MemoryCache();
+    }
+};
+
 export const getResolvers = (cacheDriver: string) => {
     const storyIds: number[] = [];
     const stories: Record<string, any>[] = [];
     const jobIds: number[] = [];
     const jobs: Record<string, any>[] = [];
-    const cache = cacheDriver === 'redis' ? new RedisCache() : new MemoryCache();
+    const cache = getCacheInstance(cacheDriver);
 
     const dateScalar = getDateScalar();
 

tests/lib/cache/MemoryCache.test.ts

@@ -57,3 +57,20 @@ it('purges expired entries before checking if an item exists', async () => {
     expect(await cache.has('one')).toBeFalsy();
     expect(cache.map['one']).toBeUndefined();
 });
+
+it('prefixes all keys with a prefix', async () => {
+    const customCache = new MemoryCache('myprefix');
+
+    try {
+        customCache.put('one', 1, 10);
+
+        expect(await customCache.has('one')).toBeTruthy();
+        expect(customCache.map['myprefix:one']).not.toBeUndefined();
+    } finally {
+        customCache.destroy();
+    }
+});
+
+it('clears items', () => {
+    expect(cache.clear()).toBeTruthy();
+});

tests/lib/cache/RedisCache.test.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-undef */
 
 import { RedisCache } from '@/lib/cache/RedisCache';
+const Redis = require('ioredis');
 
 let cache: RedisCache;
 
@@ -37,27 +38,25 @@ it('determines if an item is in the cache', async () => {
     expect(await cache.has('two')).toBeFalsy();
 });
 
-// it('purges expired items', () => {
-//     cache.put('one', 1, 10);
-//     cache.map['one'].expires = 0;
+it('prefixes all keys with a prefix', async () => {
+    const testRedis = new Redis();
+    const customCache = new RedisCache('myprefix');
 
-//     cache.purge();
+    try {
+        customCache.put('one', 1, 10);
 
-//     expect(cache.map['one']).toBeUndefined();
-// });
-
-// it('purges expired entries before returning an item', async () => {
-//     cache.put('one', 1, 10);
-//     cache.map['one'].expires -= 15 * 1000;
-
-//     expect(await cache.get('one')).toBeNull();
-//     expect(cache.map['one']).toBeUndefined();
-// });
+        expect(await customCache.has('one')).toBeTruthy();
+        expect(await testRedis.exists('myprefix:one')).toBeTruthy();
+    } finally {
+        customCache.destroy();
+        testRedis.disconnect();
+    }
+});
 
-// it('purges expired entries before checking if an item exists', async () => {
-//     cache.put('one', 1, 10);
-//     cache.map['one'].expires -= 15 * 1000;
+it('purges expired items', () => {
+    expect(cache.purge()).toBeTruthy();
+});
 
-//     expect(await cache.has('one')).toBeFalsy();
-//     expect(cache.map['one']).toBeUndefined();
-// });
+it('clears items', () => {
+    expect(cache.clear()).toBeTruthy();
+});

tests/lib/resolver.test.ts

@@ -0,0 +1,37 @@
+/* eslint-disable no-undef */
+
+import { MemoryCache } from '@/lib/cache/MemoryCache';
+import { RedisCache } from '@/lib/cache/RedisCache';
+import { getCacheInstance, getResolvers } from '@/lib/resolver';
+
+it('returns a MemoryCache instance for the "memory" driver', () => {
+    const cache = getCacheInstance('memory');
+
+    expect(cache).toBeInstanceOf(MemoryCache);
+});
+
+it('returns a MemoryCache instance an unknown driver', () => {
+    const cache = getCacheInstance('unknown');
+
+    expect(cache).toBeInstanceOf(MemoryCache);
+});
+
+it('returns a RedisCache instance for the "redis" driver', () => {
+    const cache = getCacheInstance('redis');
+
+    expect(cache).toBeInstanceOf(RedisCache);
+
+    cache.destroy();
+});
+
+it('returns a resolver object', () => {
+    process.env.NODE_ENV = 'testing';
+
+    const resolvers = getResolvers('memory');
+
+    expect(resolvers['Comment']).not.toBeUndefined();
+    expect(resolvers['Date']).not.toBeUndefined();
+    expect(resolvers['Job']).not.toBeUndefined();
+    expect(resolvers['Query']).not.toBeUndefined();
+    expect(resolvers['Story']).not.toBeUndefined();
+});

tests/lib/server.test.ts

@@ -0,0 +1,18 @@
+/* eslint-disable no-undef */
+
+import { App } from '@tinyhttp/app';
+import { MemoryCache } from '@/lib/cache/MemoryCache';
+import { getApolloServer, getServer } from '@/lib/server';
+import { ApolloServer } from 'apollo-server-express';
+
+it('returns an instance of Apollo Server', () => {
+    const server = getApolloServer(true, new MemoryCache());
+
+    expect(server).toBeInstanceOf(ApolloServer);
+});
+
+it('returns an instance of tinyhttp/app', () => {
+    const server = getServer(new App(), true, new MemoryCache());
+
+    expect(server).toBeInstanceOf(App);
+});