test: added test coverage

Author: robdmoore

.cache/test.json

@@ -0,0 +1,3 @@
+{
+  "test": 1
+}

.vscode/settings.json

@@ -3,5 +3,11 @@
   "editor.defaultFormatter": "esbenp.prettier-vscode",
   "editor.codeActionsOnSave": {
     "source.fixAll.eslint": "explicit"
+  },
+  "jest.outputConfig": { "revealWithFocus": "none" },
+  "jest.autoRun": {
+    "watch": false,
+    "onSave": "test-file",
+    "onStartup": false
   }
 }

jest.config.ts

@@ -12,5 +12,7 @@ const config: Config.InitialOptions = {
       },
     ],
   },
+  transformIgnorePatterns: ['node_modules'],
+  prettierPath: require.resolve('prettier-2'),
 }
 export default config

package-lock.json

@@ -44,7 +44,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.391.0",
     "glob": "^10.3.10",
-    "mime": "^4.0.1"
+    "mime": "^3.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^18.4.3",
@@ -53,6 +53,7 @@
     "@makerx/prettier-config": "^2.0.0",
     "@makerx/ts-config": "^1.0.1",
     "@types/jest": "^29.5.11",
+    "@types/mime": "^3.0.4",
     "@types/node": "^18.13.0",
     "@typescript-eslint/eslint-plugin": "^6.15.0",
     "@typescript-eslint/parser": "^6.15.0",
@@ -65,6 +66,7 @@
     "jest": "^29.7.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.1.1",
+    "prettier-2": "npm:prettier@^2",
     "rimraf": "^5.0.5",
     "semantic-release": "^22.0.12",
     "ts-jest": "^29.1.1",

package.json

@@ -0,0 +1,122 @@
+import { describe, beforeEach, test } from '@jest/globals'
+import path from 'node:path'
+import * as fs from 'node:fs/promises'
+import { FileSystemObjectCache } from './fileSystemObjectCache'
+
+const testDir = path.join(__dirname, '..', '.cache')
+
+describe('FileSystemObjectCache', () => {
+  beforeEach(async () => {
+    if (await fs.stat(testDir).catch(() => false)) {
+      await fs.rm(testDir, { force: true, recursive: true })
+    }
+  })
+
+  test('Creates the directory when instantiated', async () => {
+    new FileSystemObjectCache(testDir, true)
+    expect(await fs.stat(testDir).catch(() => false)).toBeTruthy()
+  })
+
+  test('Puts an object in cache as json', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+
+    await cache.put('test', { test: 1 })
+
+    const data = await fs.readFile(path.join(testDir, 'test.json'), { encoding: 'utf-8' })
+    expect(data).toMatchInlineSnapshot(`
+      "{
+        "test": 1
+      }"
+    `)
+  })
+
+  test("Get an object from cache if it didn't exist", async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+
+    const cached = await cache.getAndCache<{ test: number }>('test', async (_) => ({
+      test: 1,
+    }))
+
+    expect(cached.test).toBe(1)
+  })
+
+  test('Get an object from cache if it did exist', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+    await cache.put('test', { test: 1 })
+
+    const cached = await cache.getAndCache<{ test: number }>('test', async (_) => ({
+      test: 2,
+    }))
+
+    expect(cached.test).toBe(1)
+  })
+
+  test('Get an object from cache if it is not yet stale', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+    await cache.put('test', { test: 1 })
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    const cached = await cache.getAndCache<{ test: number }>(
+      'test',
+      async (_) => ({
+        test: 2,
+      }),
+      { staleAfterSeconds: 2 },
+    )
+
+    expect(cached.test).toBe(1)
+  })
+
+  test('Get a fresh object if it is stale', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+    await cache.put('test', { test: 1 })
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    const cached = await cache.getAndCache<{ test: number }>(
+      'test',
+      async (_) => ({
+        test: 2,
+      }),
+      { staleAfterSeconds: 0 },
+    )
+
+    expect(cached.test).toBe(2)
+  })
+
+  test('Get an object from cache if it is stale but there is an error and returnStaleOnError is set', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+    await cache.put('test', { test: 1 })
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    const cached = await cache.getAndCache<{ test: number }>(
+      'test',
+      async (_) => {
+        throw new Error('error')
+      },
+      {
+        staleAfterSeconds: 0,
+        returnStaleResultOnError: true,
+      },
+    )
+
+    expect(cached.test).toBe(1)
+  })
+
+  test('Throw an error if it is stale and there is an error refreshing', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+    await cache.put('test', { test: 1 })
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    await expect(() =>
+      cache.getAndCache<{ test: number }>(
+        'test',
+        async (_) => {
+          throw new Error('_ERROR_')
+        },
+        {
+          staleAfterSeconds: 0,
+        },
+      ),
+    ).rejects.toThrow('_ERROR_')
+  })
+})

src/fileSystemObjectCache.spec.ts

@@ -63,7 +63,9 @@ export class FileSystemObjectCache implements ObjectCache {
     )
     const existingCache = await fs.stat(cachePath).catch((_e) => false)
     const expired =
-      staleAfterSeconds && typeof existingCache !== 'boolean' && (+new Date() - +existingCache.mtime) / 1000 > staleAfterSeconds
+      staleAfterSeconds !== undefined &&
+      typeof existingCache !== 'boolean' &&
+      (+new Date() - +existingCache.mtime) / 1000 > staleAfterSeconds
 
     if (!existingCache || expired) {
       // eslint-disable-next-line no-console

src/fileSystemObjectCache.ts

@@ -64,7 +64,8 @@ export class S3ObjectCache implements ObjectCache {
       .send(new GetObjectCommand(bucketAndKey))
       .then(async (x) => ({ Body: await x.Body!.transformToByteArray(), LastModified: x.LastModified, ContentType: x.ContentType }))
       .catch(() => undefined)
-    const expired = staleAfterSeconds && existingCache && (+new Date() - +existingCache.LastModified!) / 1000 > staleAfterSeconds
+    const expired =
+      staleAfterSeconds !== undefined && existingCache && (+new Date() - +existingCache.LastModified!) / 1000 > staleAfterSeconds
 
     if (mimeType === undefined) {
       mimeType = existingCache?.ContentType ?? 'application/octet-stream'