test: adds reporter tests to modules

Author: geotrev

__tests__/increment.spec.js

@@ -82,24 +82,6 @@ describe("runIncrement()", () => {
       )
     })
 
-    it("prints write command if dry run and verbose", async () => {
-      // Given
-      const dryConfig = { ...config, verbose: true, dryRun: true }
-      // When
-      await runIncrement(dryConfig, entryOne)
-      // Then
-      expect(report).toBeCalled()
-    })
-
-    it("prints write command if verbose", async () => {
-      // Given
-      const verbConfig = { ...config, verbose: true }
-      // When
-      await runIncrement(verbConfig, entryOne)
-      // Then
-      expect(report).toBeCalled()
-    })
-
     it("does not write to package.json if dry run", async () => {
       // Given
       const dryConfig = { ...config, dryRun: true }
@@ -135,4 +117,70 @@ describe("runIncrement()", () => {
       expect(exitWithError).toBeCalled()
     })
   })
+
+  describe("reports", () => {
+    beforeEach(() => {
+      fs.writeFileSync = jest.fn()
+    })
+
+    afterEach(() => {
+      fs.writeFileSync.mockRestore()
+    })
+
+    it("reports write command if dry run and verbose", async () => {
+      // Given
+      const dryConfig = { ...config, verbose: true, dryRun: true }
+      // When
+      await runIncrement(dryConfig, entryOne)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: `fs.writeFileSync(path.resolve(dir, "package.json"), newPkgJson, "utf8")`,
+          type: "info",
+          indent: true,
+        })
+      )
+    })
+
+    it("reports write command if verbose", async () => {
+      // Given
+      const verbConfig = { ...config, verbose: true }
+      // When
+      await runIncrement(verbConfig, entryOne)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: `fs.writeFileSync(path.resolve(dir, "package.json"), newPkgJson, "utf8")`,
+          type: "info",
+          indent: true,
+        })
+      )
+    })
+
+    it("reports start", async () => {
+      // When
+      await runIncrement(config, entryTwo)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "Version",
+          type: "start",
+          indent: true,
+        })
+      )
+    })
+
+    it("reports success", async () => {
+      // When
+      await runIncrement(config, entryTwo)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "Version successful",
+          type: "succeed",
+          indent: true,
+        })
+      )
+    })
+  })
 })

__tests__/initialize.spec.js

@@ -1,8 +1,12 @@
 import "./mocks.js"
 import { normalizeConfig } from "../bin/helpers/normalize-config.js"
+import { report } from "../bin/helpers/reporter.js"
 import { checkUnstaged, checkRefStatus } from "../bin/helpers/git-helpers.js"
 import { initialize } from "../bin/modules/initialize"
 
+jest.mock("../bin/helpers/reporter.js", () => ({
+  report: jest.fn(),
+}))
 jest.mock("../bin/helpers/normalize-config.js", () => ({
   normalizeConfig: jest.fn(),
 }))
@@ -46,4 +50,30 @@ describe("initialize()", () => {
     expect(checkUnstaged).not.toBeCalled()
     expect(checkRefStatus).not.toBeCalled()
   })
+
+  describe("reports", () => {
+    it("reports start", async () => {
+      // When
+      await initialize({ git: { skipChecks: true } })
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "Preparing to release",
+          type: "start",
+        })
+      )
+    })
+
+    it("reports success", async () => {
+      // When
+      await initialize({ git: { skipChecks: true } })
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "Ready to release!",
+          type: "succeed",
+        })
+      )
+    })
+  })
 })

__tests__/npm.spec.js

@@ -1,13 +1,16 @@
 import "./mocks.js"
 import path from "path"
+import { report } from "../bin/helpers/reporter.js"
 import { runNpm } from "../bin/modules/npm.js"
 import { runIncrement } from "../bin/modules/increment.js"
 import { runPublish } from "../bin/modules/publish.js"
 
+jest.mock("../bin/helpers/reporter.js", () => ({
+  report: jest.fn(),
+}))
 jest.mock("../bin/modules/increment.js", () => ({
   runIncrement: jest.fn(),
 }))
-
 jest.mock("../bin/modules/publish.js", () => ({
   runPublish: jest.fn(),
 }))
@@ -72,4 +75,35 @@ describe("runNpm()", () => {
     // Then
     expect(runPublish).not.toBeCalled()
   })
+
+  describe("report", () => {
+    it("reports for each package", async () => {
+      // When
+      await runNpm(config)
+      // Then
+      for (const pkg of config.packages) {
+        expect(report).toBeCalledWith(
+          expect.objectContaining({
+            m: {
+              text: `${pkg.name}@${config.releaseVersion}`,
+              symbol: "📦",
+            },
+            type: "stopAndPersist",
+          })
+        )
+      }
+    })
+
+    it("reports success", async () => {
+      // When
+      await runNpm(config)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "All packages versioned/published without errors",
+          type: "succeed",
+        })
+      )
+    })
+  })
 })

__tests__/publish.spec.js

@@ -2,11 +2,15 @@ import "./mocks.js"
 import path from "path"
 import { getAddCommand, getPublishCommand } from "../bin/helpers/commands.js"
 import { cmd } from "../bin/helpers/cmd.js"
+import { report } from "../bin/helpers/reporter.js"
 import { runPublish } from "../bin/modules/publish.js"
 
 jest.mock("../bin/helpers/cmd.js", () => ({
   cmd: jest.fn(),
 }))
+jest.mock("../bin/helpers/reporter.js", () => ({
+  report: jest.fn(),
+}))
 
 const entry = {
   name: "@test/one",
@@ -109,4 +113,45 @@ describe("runPublish()", () => {
       true
     )
   })
+
+  describe("report", () => {
+    it("reports start", async () => {
+      // When
+      await runPublish(baseConfig, entry)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "Publish",
+          type: "start",
+          indent: true,
+        })
+      )
+    })
+
+    it("reports private publish skipped", async () => {
+      // When
+      await runPublish(baseConfig, privateEntry)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "Publish skipped (private)",
+          type: "succeed",
+          indent: true,
+        })
+      )
+    })
+
+    it("reports publish success", async () => {
+      // When
+      await runPublish(baseConfig, entry)
+      // Then
+      expect(report).toBeCalledWith(
+        expect.objectContaining({
+          m: "Publish successful",
+          type: "succeed",
+          indent: true,
+        })
+      )
+    })
+  })
 })