chore: refactor classes into factory functions

Fix casing and types from pr feedback

Author: kschelonka

src/services/BreachDataService.test.ts

@@ -4,13 +4,13 @@
 
 import MockRedis from "ioredis-mock";
 import { type Redis } from "ioredis";
-import { BreachDataService } from "./BreachDataService";
+import { createBreachDataService } from "./BreachDataService";
 import { REDIS_ALL_BREACHES_KEY } from "../db/redis/client";
 import { seeds } from "../test/db";
-import { IBreachSyncService } from "./BreachSyncService";
 import { mockLogger } from "../test/helpers/mockLogger";
+import { BreachSyncService } from "./BreachSyncService";
 
-describe("BreachService", () => {
+describe("BreachDataService factory", () => {
   const redis = new MockRedis() as unknown as Redis;
   const logger = mockLogger();
 
@@ -20,107 +20,85 @@ describe("BreachService", () => {
   afterEach(async () => {
     await redis.flushall();
   });
-  describe("constructor", () => {
-    it("opts overwrites default values", () => {
-      const mockSync: IBreachSyncService = {
-        syncBreaches: jest.fn().mockResolvedValue(undefined),
-      };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([]),
-      };
-      const service = new BreachDataService(redis, mockSync, repo, logger, {
-        negTtlSec: 199,
-      });
-      expect(service.opts).toEqual({ negTtlSec: 199 });
-    });
-    it("fills default opts values if not passed", () => {
-      const mockSync: IBreachSyncService = {
-        syncBreaches: jest.fn().mockResolvedValue(undefined),
-      };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([]),
-      };
-      const service = new BreachDataService(redis, mockSync, repo, logger);
-      expect(service.opts).toEqual({ negTtlSec: 300 });
-    });
-    it("fills default opts values if key is missing", () => {
-      const mockSync: IBreachSyncService = {
-        syncBreaches: jest.fn().mockResolvedValue(undefined),
-      };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([]),
-      };
-      const service = new BreachDataService(redis, mockSync, repo, logger, {});
-      expect(service.opts).toEqual({ negTtlSec: 300 });
-    });
-  });
   describe("getBreach", () => {
     it("caches negatively if breach is missing after sync", async () => {
-      const mockSync: IBreachSyncService = {
+      const mockSync: BreachSyncService = {
         syncBreaches: jest.fn().mockResolvedValue(undefined),
       };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([]),
-      };
-      const service = new BreachDataService(redis, mockSync, repo, logger);
+      const getBreachesFromDb = jest.fn().mockResolvedValue([]);
+      const service = createBreachDataService({
+        redis,
+        sync: mockSync,
+        getBreachesFromDb,
+        logger,
+      });
       const result = await service.getBreach("SomeBreach");
       expect(result).toBeUndefined();
       expect(await redis.get("breach:neg:somebreach")).toEqual("1");
     });
     it("short-circuits if negatively cached and does not fetch or sync", async () => {
-      const mockSync: IBreachSyncService = {
+      const mockSync: BreachSyncService = {
         syncBreaches: jest.fn().mockResolvedValue(undefined),
       };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([]),
-      };
+      const getBreachesFromDb = jest.fn().mockResolvedValue([]);
       await redis.set("breach:neg:somebreach", "1", "EX", 60);
-      const service = new BreachDataService(redis, mockSync, repo, logger);
+      const service = createBreachDataService({
+        redis,
+        sync: mockSync,
+        getBreachesFromDb,
+        logger,
+      });
       const result = await service.getBreach("SomeBreach");
       expect(result).toBeUndefined();
       expect(mockSync.syncBreaches).not.toHaveBeenCalled();
-      expect(repo.getBreaches).not.toHaveBeenCalled();
+      expect(getBreachesFromDb).not.toHaveBeenCalled();
     });
     it("does not query db if cache contains the expected breach", async () => {
       const fakeBreach = seeds.breaches();
       await redis.set(REDIS_ALL_BREACHES_KEY, JSON.stringify([fakeBreach]));
-      const mockSync: IBreachSyncService = {
+      const mockSync: BreachSyncService = {
         syncBreaches: jest.fn().mockResolvedValue(undefined),
       };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([]),
-      };
-      const service = new BreachDataService(redis, mockSync, repo, logger);
+      const getBreachesFromDb = jest.fn().mockResolvedValue([]);
+      const service = createBreachDataService({
+        redis,
+        sync: mockSync,
+        getBreachesFromDb,
+        logger,
+      });
       const result = await service.getBreach(fakeBreach.name);
       expect(result).not.toBeUndefined();
       expect(result!.Name).toEqual(fakeBreach.name);
       expect(result!.Domain).toEqual(fakeBreach.domain);
       expect(mockSync.syncBreaches).not.toHaveBeenCalled();
-      expect(repo.getBreaches).not.toHaveBeenCalled();
+      expect(getBreachesFromDb).not.toHaveBeenCalled();
     });
     it("reads from db and updates cache if cache miss; no sync if key found", async () => {
       const fakeBreach = seeds.breaches();
-      const mockSync: IBreachSyncService = {
+      const mockSync: BreachSyncService = {
         syncBreaches: jest.fn().mockResolvedValue(undefined),
       };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([fakeBreach]),
-      };
-      const service = new BreachDataService(redis, mockSync, repo, logger);
+      const getBreachesFromDb = jest.fn().mockResolvedValue([fakeBreach]);
+      const service = createBreachDataService({
+        redis,
+        sync: mockSync,
+        getBreachesFromDb,
+        logger,
+      });
       const result = await service.getBreach(fakeBreach.name);
       expect(result).not.toBeUndefined();
       expect(result!.Name).toEqual(fakeBreach.name);
       expect(result!.Domain).toEqual(fakeBreach.domain);
       expect(mockSync.syncBreaches).not.toHaveBeenCalled();
-      expect(repo.getBreaches).toHaveBeenCalledTimes(1);
+      expect(getBreachesFromDb).toHaveBeenCalledTimes(1);
       const cached = await redis.get(REDIS_ALL_BREACHES_KEY);
       expect(cached).toStrictEqual(JSON.stringify([fakeBreach]));
     });
     it("requests sync if breach not found and reads from cache", async () => {
       const existingBreach = seeds.breaches();
       const newBreach = seeds.breaches();
       await redis.set(REDIS_ALL_BREACHES_KEY, JSON.stringify([existingBreach]));
-      const mockSync: IBreachSyncService = {
+      const mockSync: BreachSyncService = {
         syncBreaches: jest
           .fn()
           .mockImplementationOnce(async () => {
@@ -131,28 +109,34 @@ describe("BreachService", () => {
           })
           .mockResolvedValue(undefined),
       };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([]),
-      };
-      const service = new BreachDataService(redis, mockSync, repo, logger);
+      const getBreachesFromDb = jest.fn().mockResolvedValue([]);
+      const service = createBreachDataService({
+        redis,
+        sync: mockSync,
+        getBreachesFromDb,
+        logger,
+      });
       const result = await service.getBreach(newBreach.name);
       expect(result).not.toBeUndefined();
       expect(result!.Name).toEqual(newBreach.name);
       expect(result!.Domain).toEqual(newBreach.domain);
       expect(mockSync.syncBreaches).toHaveBeenCalledTimes(1);
-      expect(repo.getBreaches).not.toHaveBeenCalled();
+      expect(getBreachesFromDb).not.toHaveBeenCalled();
     });
     it("deletes key and rereads from db if cache has unparseable data", async () => {
       const fakeBreach = seeds.breaches();
-      const mockSync: IBreachSyncService = {
+      const mockSync: BreachSyncService = {
         syncBreaches: jest.fn().mockResolvedValue(undefined),
       };
-      const repo = {
-        getBreaches: jest.fn().mockResolvedValue([fakeBreach]),
-      };
+      const getBreachesFromDb = jest.fn().mockResolvedValue([fakeBreach]);
       // Seed an invalid cache entry
       await redis.set(REDIS_ALL_BREACHES_KEY, "{");
-      const service = new BreachDataService(redis, mockSync, repo, logger);
+      const service = createBreachDataService({
+        redis,
+        sync: mockSync,
+        getBreachesFromDb,
+        logger,
+      });
       const result = await service.getBreach("WhateverBreach");
       expect(result).toEqual(undefined);
       const cache = await redis.get(REDIS_ALL_BREACHES_KEY);