@nosto/nosto-cli 1.0.4 → 1.1.0

package/test/console/logger.test.ts

@@ -93,4 +93,20 @@ describe("Logger", () => {
     Logger.error("Error message", new Error("Test error"))
     expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("Error: Test error"))
   })
+
+  it("prints merchant id when set in context", () => {
+    const consoleMock = vi.spyOn(console, "info").mockImplementation(() => undefined)
+    Logger.context.merchantId = "merchant123"
+    Logger.context.logLevel = "info"
+    Logger.info("Info message")
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("[merchant123]"))
+  })
+
+  it("prints the dry run label when isDryRun is true", () => {
+    const consoleMock = vi.spyOn(console, "info").mockImplementation(() => undefined)
+    Logger.context.isDryRun = true
+    Logger.context.logLevel = "info"
+    Logger.info("Info message")
+    expect(consoleMock).toHaveBeenCalledWith(expect.stringContaining("(DRY RUN)"))
+  })
 })

package/test/console/userPrompt.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest"
+
+import { promptForConfirmation } from "#console/userPrompt.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+
+const terminal = setupMockConsole()
+
+describe("promptForConfirmation", () => {
+  it("should accept positive confirmation", async () => {
+    terminal.setUserResponse("y")
+    const response = await promptForConfirmation("Test prompt?", "Y")
+    expect(response).toBe(true)
+  })
+
+  it("should accept negative confirmation", async () => {
+    terminal.setUserResponse("n")
+    const response = await promptForConfirmation("Test prompt?", "Y")
+    expect(response).toBe(false)
+  })
+
+  it("should use default confirmation when input is empty", async () => {
+    terminal.setUserResponse("")
+    const responseYes = await promptForConfirmation("Test prompt?", "Y")
+    expect(responseYes).toBe(true)
+
+    terminal.setUserResponse("")
+    const responseNo = await promptForConfirmation("Test prompt?", "N")
+    expect(responseNo).toBe(false)
+  })
+})

package/test/errors/withErrorHandler.test.ts

@@ -1,17 +1,59 @@
 import { HTTPError, TimeoutError } from "ky"
-import { describe, expect, it, vi } from "vitest"
+import { beforeEach, describe, expect, it, vi } from "vitest"
 
+import { clearCachedConfig } from "#config/config.ts"
+import { InvalidLoginResponseError } from "#errors/InvalidLoginResponseError.ts"
 import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
-import { withErrorHandler } from "#errors/withErrorHandler.ts"
+import { NostoError } from "#errors/NostoError.ts"
+import { NotNostoTemplateError } from "#errors/NotNostoTemplateError.ts"
+import { prettyPrintStack, withErrorHandler } from "#errors/withErrorHandler.ts"
 import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+
+const terminal = setupMockConsole()
 
 describe("Error Handler", () => {
+  beforeEach(() => {
+    terminal.resetMocks()
+    clearCachedConfig()
+  })
   it("should execute function without error handling if no error occurs", async () => {
     const mockFn = vi.fn()
 
     await withErrorHandler(mockFn)
 
     expect(mockFn).toHaveBeenCalled()
+    expect(terminal.getSpy("error")).not.toHaveBeenCalled()
+  })
+
+  it("should handle NostoError", async () => {
+    const mockFn = vi.fn(() => {
+      throw new NostoError("Test Nosto error")
+    })
+
+    expect(() => withErrorHandler(mockFn)).not.toThrow()
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith("- Test Nosto error")
+  })
+
+  it("should handle NotNostoTemplateError", async () => {
+    const mockFn = vi.fn(() => {
+      throw new NotNostoTemplateError("Test Nosto error")
+    })
+
+    expect(() => withErrorHandler(mockFn)).not.toThrow()
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith("- Test Nosto error")
+  })
+
+  it("should handle InvalidLoginResponseError", async () => {
+    const mockFn = vi.fn(() => {
+      throw new InvalidLoginResponseError("Test Nosto error")
+    })
+
+    expect(() => withErrorHandler(mockFn)).not.toThrow()
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith(
+      "Received malformed login response from server. This is probably a bug on our side.",
+      expect.any(InvalidLoginResponseError)
+    )
   })
 
   it("should handle MissingConfigurationError", async () => {
@@ -19,11 +61,11 @@ describe("Error Handler", () => {
       throw new MissingConfigurationError("Test config error")
     })
 
-    await withErrorHandler(mockFn)
+    expect(() => withErrorHandler(mockFn)).not.toThrow()
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith("Test config error")
   })
 
   it("should handle HTTPError", async () => {
-    setupMockConfig({ verbose: true })
     const mockFn = vi.fn(() => {
       throw new HTTPError(
         {
@@ -38,10 +80,23 @@ describe("Error Handler", () => {
       )
     })
 
-    await withErrorHandler(mockFn)
+    expect(() => withErrorHandler(mockFn)).not.toThrow()
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith("- GET https://example.com/api")
   })
 
   it("should handle HTTPError", async () => {
+    const mockFn = vi.fn(() => {
+      throw new TimeoutError({
+        method: "GET",
+        url: "https://example.com/api"
+      } as Request)
+    })
+
+    expect(() => withErrorHandler(mockFn)).not.toThrow()
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith("HTTP Request timed out:")
+  })
+
+  it("should print out stack trace", async () => {
     setupMockConfig({ verbose: true })
     const mockFn = vi.fn(() => {
       throw new TimeoutError({
@@ -51,6 +106,22 @@ describe("Error Handler", () => {
     })
 
     await withErrorHandler(mockFn)
+    expect(terminal.getSpy("raw")).toHaveBeenCalledWith(expect.stringContaining("withErrorHandler.test.ts:"))
+  })
+
+  it("should print out verbosity note", async () => {
+    setupMockConfig({ verbose: false, logLevel: "info" })
+    terminal.setContext({ logLevel: "info" })
+    const mockFn = vi.fn(() => {
+      throw new TimeoutError({
+        method: "GET",
+        url: "https://example.com/api"
+      } as Request)
+    })
+
+    await withErrorHandler(mockFn)
+    expect(terminal.getSpy("raw")).not.toHaveBeenCalledWith(expect.stringContaining("withErrorHandler.test.ts:"))
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Rerun with --verbose to see details"))
   })
 
   it("should rethrow unknown errors", async () => {
@@ -61,4 +132,8 @@ describe("Error Handler", () => {
 
     await expect(withErrorHandler(mockFn)).rejects.toThrow("Unknown error")
   })
+
+  it("handles error without stack gracefully", async () => {
+    expect(() => prettyPrintStack(undefined)).not.toThrow()
+  })
 })

package/test/filesystem/asserts/assertGitRepo.test.ts

@@ -0,0 +1,35 @@
+import chalk from "chalk"
+import { describe, expect, it } from "vitest"
+
+import { assertGitRepo } from "#filesystem/asserts/assertGitRepo.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+const terminal = setupMockConsole()
+
+describe("assertGitRepo", () => {
+  it("prints a warning if not in a git repository", () => {
+    setupMockConfig({ projectPath: "." })
+    assertGitRepo()
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith(
+      `We heavily recommend using git for your projects. You can start with just running ${chalk.blueBright("git init")}`
+    )
+  })
+
+  it("prints a warning if not in a git repository and not in project folder", () => {
+    setupMockConfig({ projectPath: "/project" })
+    assertGitRepo()
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith(
+      `We heavily recommend using git for your projects. You can start with just running ${chalk.blueBright("cd /project && git init")}`
+    )
+  })
+
+  it("does not print a warning if in a git repository", () => {
+    setupMockConfig({ projectPath: "." })
+    fs.writeFolder(".git")
+    assertGitRepo()
+    expect(terminal.getSpy("warn")).not.toHaveBeenCalled()
+  })
+})

package/test/filesystem/asserts/assertNostoTemplate.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest"
+
+import { NotNostoTemplateError } from "#errors/NotNostoTemplateError.ts"
+import { assertNostoTemplate } from "#filesystem/asserts/assertNostoTemplate.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+
+describe("assertNostoTemplate", () => {
+  it("throws error when target folder does not exist", () => {
+    setupMockConfig({ projectPath: "/nonexistent" })
+
+    expect(() => assertNostoTemplate()).toThrow(/Target folder does not exist/)
+  })
+
+  it("throws error when target path is not a directory", () => {
+    setupMockConfig({ projectPath: "/file.txt" })
+    fs.writeFile("/file.txt", "content")
+
+    expect(() => assertNostoTemplate()).toThrow(/Target path is not a directory/)
+  })
+
+  it("returns early for modern template projects", () => {
+    fs.writeFile("nosto.config.ts", "export default {}")
+
+    expect(() => assertNostoTemplate()).not.toThrow()
+  })
+
+  it("throws NotNostoTemplateError when index.js does not exist in legacy project", () => {
+    expect(() => assertNostoTemplate()).toThrow(NotNostoTemplateError)
+    expect(() => assertNostoTemplate()).toThrow("Index file does not exist")
+  })
+
+  it("throws NotNostoTemplateError when index.js does not contain @nosto/preact", () => {
+    fs.writeFile("index.js", "console.log('hello world')")
+
+    expect(() => assertNostoTemplate()).toThrow(NotNostoTemplateError)
+    expect(() => assertNostoTemplate()).toThrow("Index file does not contain @nosto/preact")
+  })
+
+  it("succeeds for valid legacy template project with @nosto/preact", () => {
+    fs.writeFile("index.js", "import { render } from '@nosto/preact'")
+
+    expect(() => assertNostoTemplate()).not.toThrow()
+  })
+
+  it("succeeds for legacy template project with @nosto/preact in require format", () => {
+    fs.writeFile("index.js", "require('@nosto/preact')")
+
+    expect(() => assertNostoTemplate()).not.toThrow()
+  })
+})

package/test/filesystem/filesystem.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 
-import { listAllFiles, writeFile } from "#filesystem/filesystem.ts"
+import { listAllFiles, readFileIfExists, writeFile } from "#filesystem/filesystem.ts"
 import { setupMockConfig } from "#test/utils/mockConfig.ts"
 import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
 
@@ -50,4 +50,20 @@ describe("Filesystem", () => {
       unfilteredFileCount: 2
     })
   })
+
+  describe("readFileIfExists", () => {
+    it("should read file content if file exists", () => {
+      const filePath = "readable.txt"
+      const fileContent = "This is readable content."
+      mockFileSystem.writeFile(filePath, fileContent)
+
+      const content = readFileIfExists(filePath)
+      expect(content).toBe(fileContent)
+    })
+
+    it("should return null if file does not exist", () => {
+      const content = readFileIfExists("nonexistent.txt")
+      expect(content).toBeNull()
+    })
+  })
 })

package/test/filesystem/plugins.test.ts

@@ -1,10 +1,13 @@
 import { PluginBuild } from "esbuild"
-import { describe, it } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
-import { createLoaderPlugin } from "#filesystem/esbuildPlugins.ts"
+import { createLoaderPlugin, notifyOnRebuildPlugin, pushOnRebuildPlugin } from "#filesystem/esbuildPlugins.ts"
+import * as push from "#modules/search-templates/push.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
 import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
 
 const fs = setupMockFileSystem()
+const terminal = setupMockConsole()
 
 describe("createLoaderPlugin", () => {
   it("creates loader after successful build", () => {
@@ -33,3 +36,71 @@ describe("createLoaderPlugin", () => {
     fs.expectFile("build/loader.js").not.toExist()
   })
 })
+
+describe("notifyOnRebuildPlugin", () => {
+  it("logs build duration after successful build", () => {
+    const plugin = notifyOnRebuildPlugin()
+    plugin.setup({
+      onStart: callback => {
+        callback()
+      },
+      onEnd(callback: (result: { errors: unknown[] }) => void) {
+        callback({ errors: [] })
+      }
+    } as PluginBuild)
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringMatching(/Templates built in \d+ ms\./))
+  })
+
+  it("exits early on failure", () => {
+    const plugin = notifyOnRebuildPlugin()
+    plugin.setup({
+      onStart: (_: unknown) => {},
+      onEnd(callback: (result: { errors: unknown[] }) => void) {
+        callback({ errors: [new Error("Test error")] })
+      }
+    } as PluginBuild)
+
+    expect(terminal.getSpy("info")).not.toHaveBeenCalledWith(expect.stringMatching(/Templates built in \d+ ms\./))
+  })
+})
+
+describe("pushOnRebuildPlugin", () => {
+  it("pushes search templates after successful build", () => {
+    const pushSpy = vi.spyOn(push, "pushSearchTemplate").mockImplementation(() => Promise.resolve())
+
+    fs.writeFolder("build")
+    fs.writeFile("build/index.js", "file content")
+    fs.writeFile("build/loader.js", "file content")
+
+    const plugin = pushOnRebuildPlugin()
+    plugin.setup({
+      onEnd(callback: (result: { errors: unknown[] }) => void) {
+        callback({ errors: [] })
+      }
+    } as PluginBuild)
+
+    expect(pushSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        paths: ["build/index.js", "build/loader.js"]
+      })
+    )
+  })
+
+  it("exits early on failure", () => {
+    const pushSpy = vi.spyOn(push, "pushSearchTemplate").mockImplementation(() => Promise.resolve())
+
+    fs.writeFolder("build")
+    fs.writeFile("build/index.js", "file content")
+    fs.writeFile("build/loader.js", "file content")
+
+    const plugin = pushOnRebuildPlugin()
+    plugin.setup({
+      onEnd(callback: (result: { errors: unknown[] }) => void) {
+        callback({ errors: [new Error("Test error")] })
+      }
+    } as PluginBuild)
+
+    expect(pushSpy).not.toHaveBeenCalled()
+  })
+})

package/test/filesystem/processInBatches.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest"
+
+import { processInBatches } from "#filesystem/processInBatches.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+
+const terminal = setupMockConsole()
+
+describe("processInBatches", () => {
+  it("handles thrown errors gracefully", async () => {
+    await processInBatches({
+      files: ["first.js"],
+      logIcon: "",
+      processElement: async () => {
+        throw new Error("Test error")
+      }
+    })
+
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith(expect.stringContaining("✗ first.js: Test error"))
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith(expect.stringContaining("Batch completed with 1 failures"))
+  })
+
+  it("handles thrown ducks gracefully", async () => {
+    await processInBatches({
+      files: ["first.js"],
+      logIcon: "",
+      processElement: async () => {
+        throw "a duck"
+      }
+    })
+
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith(expect.stringContaining("✗ first.js: a duck"))
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith(expect.stringContaining("Batch completed with 1 failures"))
+  })
+})

package/test/modules/login.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest"
+
+import { AuthConfigFilePath } from "#config/authConfig.ts"
+import { loginToPlaycart } from "#modules/login.ts"
+import { setupMockAuthServer } from "#test/utils/mockAuthServer.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+const authServer = setupMockAuthServer()
+
+describe("Login Module", () => {
+  it("authenticates successfully", async () => {
+    const authConfig = {
+      user: "test-user",
+      token: "test-token",
+      expiresAt: new Date(Date.now() + 60 * 60 * 1000)
+    }
+
+    authServer.mockValidResponse(authConfig)
+    await loginToPlaycart()
+    fs.expectFile(AuthConfigFilePath).toContain(JSON.stringify(authConfig, null, 2) + "\n")
+  })
+
+  it("throws on invalid response", async () => {
+    authServer.mockGenericResponse({ url: "/?invalidParam=invalid" })
+    await expect(loginToPlaycart()).rejects.toThrow(/Failed to parse playcart response/)
+  })
+
+  it("throws on empty url in response", async () => {
+    authServer.mockGenericResponse({})
+    await expect(loginToPlaycart()).rejects.toThrow(/Failed to parse playcart response/)
+  })
+
+  it("throws if unable to bind to a port", async () => {
+    authServer.mockServerAddress(null)
+    await expect(loginToPlaycart()).rejects.toThrow("Failed to get server address")
+  })
+})

package/test/modules/logout.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest"
+
+import { AuthConfigFilePath } from "#config/authConfig.ts"
+import { removeLoginCredentials } from "#modules/logout.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+const terminal = setupMockConsole()
+
+describe("Logout Module", () => {
+  it("deletes the stored credentials", () => {
+    fs.writeFile(AuthConfigFilePath, "some-credentials")
+
+    removeLoginCredentials()
+
+    fs.expectFile(AuthConfigFilePath).not.toExist()
+  })
+
+  it("warns if the credentials file does not exist", () => {
+    removeLoginCredentials()
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith("File already deleted.")
+  })
+})

package/test/modules/search-templates/build.legacy.test.ts

@@ -3,9 +3,11 @@ import { beforeEach, describe, expect, it, vi } from "vitest"
 
 import { buildSearchTemplate } from "#modules/search-templates/build.ts"
 import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
 import { mockFetchLibraryFile, setupMockServer } from "#test/utils/mockServer.ts"
 
 const server = setupMockServer()
+const terminal = setupMockConsole()
 
 vi.mock("esbuild", () => ({
   context: vi.fn()
@@ -70,5 +72,28 @@ describe("Search Templates build / legacy", () => {
 
       processOnSpy.mockRestore()
     })
+
+    it("should handle SIGINT signal correctly", async () => {
+      const processOnSpy = vi.spyOn(process, "on").mockImplementation(() => process)
+      const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never)
+
+      await buildSearchTemplate({ watch: true })
+
+      // Get the SIGINT handler that was registered
+      const sigintCall = processOnSpy.mock.calls.find(call => call[0] === "SIGINT")
+      const sigintHandler = sigintCall?.[1] as () => void
+      expect(sigintHandler).toBeDefined()
+
+      // Simulate SIGINT signal
+      sigintHandler()
+
+      // Verify the handler behavior
+      expect(mockContext.dispose).toHaveBeenCalled()
+      expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Watch mode stopped."))
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+
+      processOnSpy.mockRestore()
+      processExitSpy.mockRestore()
+    })
   })
 })

package/test/modules/search-templates/build.modern.test.ts

@@ -22,7 +22,11 @@ describe("Search Templates build / modern", () => {
 
   it("should build templates with watch mode", async () => {
     const manifest = setupMockStarterManifest({
-      mockScript: { onBuildWatch: vi.fn() }
+      mockScript: {
+        onBuildWatch: vi.fn().mockImplementation(async ({ onAfterBuild }) => {
+          await onAfterBuild()
+        })
+      }
     })
     setupMockConfig({
       searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })

package/test/modules/search-templates/dev.legacy.test.ts

@@ -65,6 +65,29 @@ describe("Search Templates dev mode / legacy", () => {
     processOnSpy.mockRestore()
   })
 
+  it("should handle SIGINT signal correctly", async () => {
+    const processOnSpy = vi.spyOn(process, "on").mockImplementation(() => process)
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never)
+
+    await searchTemplateDevMode()
+
+    // Get the SIGINT handler that was registered
+    const sigintCall = processOnSpy.mock.calls.find(call => call[0] === "SIGINT")
+    const sigintHandler = sigintCall?.[1] as () => void
+    expect(sigintHandler).toBeDefined()
+
+    // Simulate SIGINT signal
+    sigintHandler()
+
+    // Verify the handler behavior
+    expect(mockContext.dispose).toHaveBeenCalled()
+    expect(mockConsole.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Watch mode stopped."))
+    expect(processExitSpy).toHaveBeenCalledWith(0)
+
+    processOnSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
   it("should have pulled the library", async () => {
     await searchTemplateDevMode()
 

package/test/modules/search-templates/pull.test.ts

@@ -1,4 +1,4 @@
-import { describe, it } from "vitest"
+import { describe, expect, it } from "vitest"
 
 import { pullSearchTemplate } from "#modules/search-templates/pull.ts"
 import { setupMockConsole } from "#test/utils/mockConsole.ts"
@@ -31,6 +31,16 @@ describe("Pull Search Template", () => {
     fs.expectFile("wizard.js").toContain('"wizard.js content"')
   })
 
+  it("should copy the hash as the new last seen hash", async () => {
+    mockListSourceFiles(server, {
+      response: []
+    })
+    fs.writeFile("build/hash", "123")
+
+    await pullSearchTemplate({ paths: [], force: true })
+    fs.expectFile(".nostocache/hash").toContain("123")
+  })
+
   it("should filter by specified paths", async () => {
     mockListSourceFiles(server, {
       response: [
@@ -66,6 +76,21 @@ describe("Pull Search Template", () => {
     terminal.setUserResponse("N")
     await pullSearchTemplate({ paths: [], force: false })
     terminal.expect.user.toHaveBeenPromptedWith("Are you sure you want to override your local data? (y/N):")
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith(expect.stringContaining("index.js"))
+  })
+
+  it("should prompt for confirmation when many files will be overridden", async () => {
+    const files = Array.from({ length: 15 }, (_, i) => {
+      fs.writeFile(`file${i}.js`, "old content")
+      return { path: `file${i}.js`, size: 10 }
+    })
+    mockListSourceFiles(server, {
+      response: files
+    })
+
+    terminal.setUserResponse("N")
+    await pullSearchTemplate({ paths: [], force: false })
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith(expect.stringContaining("and 5 more"))
   })
 
   it("should cancel operation when user declines override", async () => {
@@ -93,4 +118,16 @@ describe("Pull Search Template", () => {
     await pullSearchTemplate({ paths: [], force: false })
     fs.expectFile("index.js").toContain('"index.js content"')
   })
+
+  it("should abort if the remote template is already up to date", async () => {
+    fs.writeFile("index.js", "old content")
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "34a780ad578b997db55b260beb60b501f3e04d30ba1a51fcf43cd8dd1241780d",
+      contentType: "raw"
+    })
+
+    await pullSearchTemplate({ paths: [], force: false })
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Local template is already up to date.")
+  })
 })