feat: add tests for node/heart.ts

Author: Joe Previte

src/node/heart.ts

@@ -27,21 +27,21 @@ export class Heart {
 
     logger.trace("heartbeat")
     fs.writeFile(this.heartbeatPath, "").catch((error) => {
-      logger.warn(error.message)
+      logger.warn(error.message) // TODO@jsjoeio - write code for this line
     })
     this.lastHeartbeat = Date.now()
     if (typeof this.heartbeatTimer !== "undefined") {
-      clearTimeout(this.heartbeatTimer)
+      clearTimeout(this.heartbeatTimer) // TODO@jsjoeio - write code for this line
     }
     this.heartbeatTimer = setTimeout(() => {
-      this.isActive()
+      this.isActive() // TODO@jsjoeio - start write code for here.
         .then((active) => {
           if (active) {
             this.beat()
           }
         })
         .catch((error) => {
-          logger.warn(error.message)
+          logger.warn(error.message) // TODO@jsjoeio - end.
         })
     }, this.heartbeatInterval)
   }

test/unit/node/heart.test.ts

@@ -0,0 +1,76 @@
+import { readFile, writeFile } from "fs/promises"
+import { logger } from "@coder/logger"
+import { Heart } from "../../../src/node/heart"
+import { clean, mockLogger, tmpdir } from "../../utils/helpers"
+
+describe("Heart", () => {
+  function isFakeActive(resolveTo: boolean): () => Promise<boolean> {
+    return () => new Promise((resolve) => setTimeout(() => resolve(resolveTo), 500))
+  }
+  const testName = "heartTests"
+  let testDir = ""
+
+  beforeAll(async () => {
+    mockLogger()
+    await clean(testName)
+    testDir = await tmpdir(testName)
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it("should write to a file when given a valid file path", async () => {
+    // Set up heartbeat file with contents
+    const text = "test"
+    const pathToFile = `${testDir}/file.txt`
+    await writeFile(pathToFile, text)
+    const fileContents = await readFile(pathToFile, { encoding: "utf8" })
+    expect(fileContents).toBe(text)
+    // call beat
+    const heart = new Heart(pathToFile, isFakeActive(true))
+    try {
+      heart.beat()
+      // Check that the heart wrote to the heartbeatFilePath and overwrote our text
+      const fileContentsAfterBeat = await readFile(pathToFile, { encoding: "utf8" })
+      expect(fileContentsAfterBeat).not.toBe(text)
+    } catch (_e) {}
+    heart.dispose()
+  })
+
+  it("should log a warning when given an invalid file path", async () => {
+    const heart = new Heart(`fakeDir/fake.txt`, isFakeActive(false))
+    try {
+      heart.beat()
+      // HACK@jsjoeio - beat has some async logic but is not an async method
+      // Therefore, we have to create an artificial wait in order to make sure
+      // all async code has completed before asserting
+      await new Promise((r) => setTimeout(r, 100))
+      expect(logger.trace).toHaveBeenCalled()
+      expect(logger.warn).toHaveBeenCalled()
+    } catch (_e) {}
+    heart.dispose()
+    // expect(logger.warn).toHaveBeenCalledWith(`hi`)
+  })
+
+  it("should let you know if the beat is alive", () => {
+    const heart = new Heart(`${testDir}/shutdown.txt`, isFakeActive(true))
+    try {
+      heart.beat()
+    } catch (_e) {}
+
+    const isAlive = heart.alive()
+    expect(isAlive).toBe(true)
+    heart.dispose()
+  })
+
+  it("should shutdown when dispose is called", () => {
+    try {
+      const heart = new Heart(`${testDir}/shutdown.txt`, isFakeActive(true))
+      heart.dispose()
+
+      const isAlive = heart.alive()
+      expect(isAlive).toBe(false)
+    } catch (_e) {}
+  })
+})