@nosto/nosto-cli 1.0.4 → 1.1.0

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

@@ -4,7 +4,7 @@ import { pushSearchTemplate } from "#modules/search-templates/push.ts"
 import { setupMockConfig } from "#test/utils/mockConfig.ts"
 import { setupMockConsole } from "#test/utils/mockConsole.ts"
 import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
-import { mockPutSourceFile, setupMockServer } from "#test/utils/mockServer.ts"
+import { mockFetchSourceFile, mockPutSourceFile, setupMockServer } from "#test/utils/mockServer.ts"
 
 const fs = setupMockFileSystem()
 const server = setupMockServer()
@@ -106,4 +106,148 @@ describe("Push Search Template", () => {
 
     await pushSearchTemplate({ paths: [], force: true })
   })
+
+  it("should abort if remote template is already up to date", async () => {
+    fs.writeFile("index.js", "old content")
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "34a780ad578b997db55b260beb60b501f3e04d30ba1a51fcf43cd8dd1241780d",
+      contentType: "raw"
+    })
+
+    await pushSearchTemplate({ paths: [], force: false })
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Remote template is already up to date.")
+    fs.expectFile("/.nostocache/hash").toContain("34a780ad578b997db55b260beb60b501f3e04d30ba1a51fcf43cd8dd1241780d")
+  })
+
+  it("should skip prompt when remote and last seen hashes match", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile(".nostocache/hash", "matching-hash")
+
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "matching-hash",
+      contentType: "raw"
+    })
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "build/hash" })
+
+    await pushSearchTemplate({ paths: [], force: false })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Pushing template from: /")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Found 2 files to push (1 source, 1 built, 0 ignored).")
+  })
+
+  it("should handle build/hash file already existing", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile(".nostocache/hash", "matching-hash")
+    fs.writeFile("build/hash", "matching-hash")
+
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "matching-hash",
+      contentType: "raw"
+    })
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "build/hash" })
+
+    await pushSearchTemplate({ paths: [], force: false })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Pushing template from: /")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Found 2 files to push (1 source, 1 built, 1 ignored).")
+  })
+
+  it("should prompt for confirmation when remote hash exists but no last seen hash", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "remote-hash",
+      contentType: "raw"
+    })
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "build/hash" })
+
+    terminal.setUserResponse("y")
+
+    await pushSearchTemplate({ paths: [], force: false })
+
+    terminal.expect.user.toHaveBeenPromptedWith(
+      "It seems that this is the first time you are pushing to this environment. Please make sure your local copy is up to date. Continue? (y/N):"
+    )
+  })
+
+  it("should prompt for confirmation when remote hash differs from last seen hash", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile(".nostocache/hash", "old-hash")
+
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "different-remote-hash",
+      contentType: "raw"
+    })
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "build/hash" })
+
+    terminal.setUserResponse("y")
+
+    await pushSearchTemplate({ paths: [], force: false })
+
+    terminal.expect.user.toHaveBeenPromptedWith(
+      "It seems that the template has been changed since your last push. Are you sure you want to continue? (y/N):"
+    )
+  })
+
+  it("should prompt for confirmation when no remote hash exists", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile(".nostocache/hash", "some-hash")
+
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      error: { status: 404, message: "Not Found" }
+    })
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "build/hash" })
+
+    terminal.setUserResponse("y")
+
+    await pushSearchTemplate({ paths: [], force: false })
+
+    terminal.expect.user.toHaveBeenPromptedWith(
+      "It seems that this is the first time you are pushing to this environment. Please make sure your local copy is up to date. Continue? (y/N):"
+    )
+  })
+
+  it("should cancel operation when user declines prompt for first-time push", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "remote-hash",
+      contentType: "raw"
+    })
+
+    terminal.setUserResponse("N")
+
+    await pushSearchTemplate({ paths: [], force: false })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Push operation cancelled by user.")
+  })
+
+  it("should cancel operation when user declines prompt for conflicting changes", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile(".nostocache/hash", "old-hash")
+
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      response: "different-remote-hash",
+      contentType: "raw"
+    })
+
+    terminal.setUserResponse("N")
+
+    await pushSearchTemplate({ paths: [], force: false })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Push operation cancelled by user.")
+  })
 })

package/test/modules/setup.test.ts

@@ -31,6 +31,22 @@ describe("Setup Module", () => {
     fs.expectFile(".nosto.json").toExist()
   })
 
+  it("should create config file with merchant param", async () => {
+    await printSetupHelp(".", { merchant: "test-merchant" })
+
+    fs.expectFile(".nosto.json").toExist()
+    fs.expectFile(".nosto.json").toContain(expect.stringContaining('"merchant": "test-merchant"'))
+  })
+
+  it("should include environmental variables in created config file", async () => {
+    process.env.NOSTO_API_KEY = "env-variable-key"
+    terminal.setUserResponse("Y")
+
+    await printSetupHelp(".", {})
+
+    fs.expectFile(".nosto.json").toContain(expect.stringContaining('"apiKey": "env-variable-key"'))
+  })
+
   it("should not create config file when user declines", async () => {
     terminal.setUserResponse("N")
 

package/test/modules/status.test.ts

@@ -1,5 +1,6 @@
-import { describe, expect, it } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
+import * as config from "#config/config.ts"
 import { printStatus } from "#modules/status.ts"
 import { setupMockConfig } from "#test/utils/mockConfig.ts"
 import { setupMockConsole } from "#test/utils/mockConsole.ts"
@@ -12,11 +13,51 @@ describe("Status Module", () => {
     expect(terminal.getSpy("info")).toHaveBeenCalledWith("Configuration is not valid:")
   })
 
-  it("should indicate valid configuration", async () => {
-    setupMockConfig({ merchant: "test-merchant" })
+  it("should indicate valid configuration for api key", async () => {
+    setupMockConfig({ merchant: "test-merchant", apiKey: "test-key" })
 
     await expect(printStatus(".")).resolves.not.toThrow()
     expect(terminal.getSpy("info")).toHaveBeenCalledWith("Configuration seems to be valid:")
-    expect(terminal.getSpy("error")).toHaveBeenCalledWith("Some required configuration is missing\n")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Using API key for authentication"))
+  })
+
+  it("should indicate valid configuration for user auth", async () => {
+    setupMockConfig({
+      merchant: "test-merchant",
+      apiKey: "",
+      auth: { user: "test", token: "test", expiresAt: new Date(Date.now() + 3600 * 1000) }
+    })
+
+    await expect(printStatus(".")).resolves.not.toThrow()
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Configuration seems to be valid:")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(
+      expect.stringContaining("Using user account for authentication")
+    )
+  })
+
+  it("should indicate invalid user auth", async () => {
+    setupMockConfig({ merchant: "test-merchant", apiKey: "", auth: { user: "", token: "", expiresAt: new Date(0) } })
+
+    await expect(printStatus(".")).resolves.not.toThrow()
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Configuration is not valid:")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Missing authentication"))
+  })
+
+  it("should indicate expired user auth", async () => {
+    setupMockConfig({
+      merchant: "test-merchant",
+      apiKey: "",
+      auth: { user: "test", token: "test", expiresAt: new Date(1) }
+    })
+
+    await expect(printStatus(".")).resolves.not.toThrow()
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Configuration is not valid:")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Authentication token expired"))
+  })
+
+  it("should rethrow unknown errors in config loading", async () => {
+    vi.spyOn(config, "loadConfig").mockRejectedValueOnce(new Error("Unknown error"))
+
+    await expect(printStatus(".")).rejects.toThrow(/Unknown error/)
   })
 })

package/test/setup.ts

@@ -2,6 +2,7 @@ import { Volume } from "memfs"
 import { beforeEach } from "vitest"
 import { vi } from "vitest"
 
+import { mockHttpServer } from "./utils/mockAuthServer.ts"
 import { mockedConsoleIn, mockedConsoleOut } from "./utils/mockConsole.ts"
 
 export const testVolume = Volume.fromJSON({}, "/")
@@ -26,3 +27,13 @@ vi.mock("#/console/logger.ts", () => mockedConsoleOut)
 vi.mock("node:test", () => {
   throw new Error("You seem to have accidentally imported node:test instead of vitest.")
 })
+
+vi.mock("open", () => {
+  return {
+    default: vi.fn()
+  }
+})
+
+vi.mock("node:http", () => ({
+  default: mockHttpServer
+}))

package/test/utils/generateEndpointMock.ts

@@ -4,14 +4,19 @@ import type { SetupServer } from "msw/node"
 type HttpMethod = keyof typeof http
 
 export type MockParams<ResponseT extends DefaultBodyType | void> =
-  | (ResponseT extends void ? object : { response: ResponseT })
+  | (ResponseT extends void ? object : { response: ResponseT; contentType?: "json" | "raw" })
   | {
       error: { status: number; message: string }
     }
 
 export const generateEndpointMock = (
   server: SetupServer,
-  { method, path, ...params }: { method: HttpMethod; path: string } & MockParams<DefaultBodyType>
+  {
+    method,
+    path,
+    contentType,
+    ...params
+  }: { method: HttpMethod; path: string; contentType?: "json" | "raw" } & MockParams<DefaultBodyType>
 ) => {
   let invocations: unknown[] = []
 
@@ -36,7 +41,9 @@ export const generateEndpointMock = (
 
     const requestsWithBody = ["POST", "PUT", "PATCH"]
     invocations.push(requestsWithBody.includes(request.method) ? await toBody(request) : {})
-
+    if (contentType === "raw") {
+      return HttpResponse.text(returnedResponse as string, { status })
+    }
     return HttpResponse.json(returnedResponse, { status })
   })
   server.use(handler)

package/test/utils/mockAuthServer.ts

@@ -0,0 +1,72 @@
+import type { IncomingMessage, RequestListener, ServerResponse } from "node:http"
+import { AddressInfo } from "node:net"
+
+import { vi } from "vitest"
+
+import { AuthConfig } from "#config/schema.ts"
+
+// Mock the entire http module at the top level
+let queuedServerRequest: Partial<IncomingMessage> | null = null
+const queuedServerResponse = {
+  writeHead: vi.fn(),
+  end: vi.fn()
+}
+
+let mockedAddressFn: () => string | AddressInfo | null
+export const mockHttpServer: {
+  createServer: (listener: RequestListener) => unknown
+} = {
+  createServer: listener => {
+    process.nextTick(() => {
+      if (queuedServerRequest) {
+        listener(queuedServerRequest as IncomingMessage, queuedServerResponse as unknown as ServerResponse)
+        queuedServerRequest = null
+      }
+    })
+    return {
+      listen: (port: number, hostname?: string | (() => void), callback?: () => void) => {
+        const actualCallback = typeof hostname === "function" ? hostname : callback
+        if (actualCallback) {
+          process.nextTick(actualCallback)
+        }
+        return {}
+      },
+      close: (callback?: () => void) => {
+        if (callback) {
+          process.nextTick(callback)
+        }
+      },
+      address: () => {
+        if (mockedAddressFn) {
+          return mockedAddressFn()
+        }
+        return {
+          port: 3000, // Mock port number
+          address: "localhost",
+          family: "IPv4"
+        }
+      }
+    }
+  }
+}
+
+export function setupMockAuthServer() {
+  return {
+    mockValidResponse: (res: AuthConfig) => {
+      const params = new URLSearchParams({
+        user: res.user,
+        token: res.token,
+        expiresAt: res.expiresAt.toISOString()
+      })
+      queuedServerRequest = {
+        url: `/?${params.toString()}`
+      }
+    },
+    mockGenericResponse: (res: Partial<IncomingMessage>) => {
+      queuedServerRequest = res
+    },
+    mockServerAddress: (callback: string | AddressInfo | null) => {
+      mockedAddressFn = () => callback
+    }
+  }
+}

package/test/utils/mockConsole.ts

@@ -19,6 +19,7 @@ export const mockedConsoleOut = {
       merchantId: "",
       isDryRun: false
     },
+    success: vi.fn(),
     raw: vi.fn(),
     debug: vi.fn(),
     info: vi.fn(),
@@ -36,9 +37,28 @@ export function setupMockConsole() {
     setUserResponse: (response: string) => {
       mockedConsoleIn.userResponse = response
     },
+    setContext: (context: Partial<typeof mockedConsoleOut.Logger.context>) => {
+      mockedConsoleOut.Logger.context = {
+        ...mockedConsoleOut.Logger.context,
+        ...context
+      }
+    },
     clearPrompts: () => {
       mockedConsoleIn.recordedPrompts = []
     },
+    resetMocks: () => {
+      mockedConsoleOut.Logger.success.mockReset()
+      mockedConsoleOut.Logger.raw.mockReset()
+      mockedConsoleOut.Logger.debug.mockReset()
+      mockedConsoleOut.Logger.info.mockReset()
+      mockedConsoleOut.Logger.warn.mockReset()
+      mockedConsoleOut.Logger.error.mockReset()
+      mockedConsoleOut.Logger.context = {
+        logLevel: "info",
+        merchantId: "",
+        isDryRun: false
+      }
+    },
     getSpy: (method: Exclude<keyof typeof mockedConsoleOut.Logger, "context">) => {
       return mockedConsoleOut.Logger[method]
     },

package/test/utils/mockFileSystem.ts

@@ -2,30 +2,64 @@ import fs from "fs"
 import path from "path"
 import { expect } from "vitest"
 
+import { getDefaultConfig } from "#config/config.ts"
+import { PersistentConfig } from "#config/schema.ts"
+import { HomeDirectory } from "#filesystem/homeDirectory.ts"
 import { testVolume } from "#test/setup.ts"
 
 export function setupMockFileSystem() {
   const fs = testVolume
+  const authFilePath = path.join(HomeDirectory, ".nosto", ".auth.json")
+
+  function writeFileContent(targetFile: string, content: string) {
+    const dir = path.join("/", targetFile.substring(0, targetFile.lastIndexOf("/")))
+    const filePath = path.join("/", targetFile)
+    // Ensure parent directory exists
+    if (dir && !fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath)
+    }
+    fs.writeFileSync(filePath, content)
+  }
+
   return {
-    writeFile: (targetFile: string, content: string) => {
-      const dir = path.join("/", targetFile.substring(0, targetFile.lastIndexOf("/")))
-      const filePath = path.join("/", targetFile)
-      // Ensure parent directory exists
-      if (dir && !fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true })
+    writeFile: (targetFile: string, content: unknown | string) => {
+      if (typeof content === "string") {
+        writeFileContent(targetFile, content)
+      } else {
+        writeFileContent(targetFile, JSON.stringify(content))
       }
-      if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath)
-      }
-      fs.writeFileSync(filePath, content)
     },
     writeFolder: (targetFolder: string) => {
       const dir = path.join("/", targetFolder)
       fs.mkdirSync(dir, { recursive: true })
     },
+    chmod: (targetFile: string, mode: number) => {
+      const filePath = path.join("/", targetFile)
+      fs.chmodSync(filePath, mode)
+    },
     expectFile: (targetFile: string) => {
       const filePath = path.join("/", targetFile)
       return makeFileMatcher(filePath)
+    },
+    mockConfigFile: (overrides: Partial<PersistentConfig> = {}) => {
+      const content = {
+        ...getDefaultConfig(),
+        merchant: "test-merchant",
+        apiKey: "test-api-key",
+        ...overrides
+      }
+      writeFileContent(".nosto.json", JSON.stringify(content))
+    },
+    mockUserAuthentication: () => {
+      const userAuth = { user: "test", token: "test", expiresAt: new Date(Date.now() + 1000 * 60 * 60) }
+      fs.mkdirSync(path.dirname(authFilePath), { recursive: true })
+      writeFileContent(authFilePath, JSON.stringify(userAuth))
+    },
+    paths: {
+      authFile: authFilePath
     }
   }
 }
@@ -34,7 +68,7 @@ export function makeFileMatcher(path: string) {
   return {
     toContain: (expectedContent: string) => {
       const content = fs.readFileSync(path, "utf8")
-      expect(content, `File ${path} has content ${content}`).toEqual(expectedContent)
+      expect(content, `File ${path} actually has\n ${content}`).toEqual(expectedContent)
     },
     toExist: () => {
       return expect(fs.existsSync(path), `File ${path} does not exist when it was expected to`).toBe(true)
@@ -42,7 +76,7 @@ export function makeFileMatcher(path: string) {
     not: {
       toContain: (expectedContent: string) => {
         const content = fs.readFileSync(path, "utf8")
-        expect(content, `File ${path} has content ${content}`).not.toEqual(expectedContent)
+        expect(content, `File ${path} actually has\n ${content}`).not.toEqual(expectedContent)
       },
       toExist: () => {
         return expect(fs.existsSync(path), `File ${path} exists when it was not expected to`).toBe(false)

package/test/utils/mockStarterManifest.ts

@@ -2,6 +2,7 @@ import path from "path"
 import { vi } from "vitest"
 
 import { SearchTemplatesConfig } from "#config/schema.ts"
+import { Logger } from "#console/logger.ts"
 import { makeConfig } from "#exports.ts"
 
 import { setupMockFileSystem } from "./mockFileSystem.ts"
@@ -15,10 +16,10 @@ export function setupMockStarterManifest({ projectPath, mockScript }: Props = {}
   const fs = setupMockFileSystem()
   const manifest = makeConfig({
     onBuild: async () => {
-      console.log("Building...")
+      Logger.debug("Building...")
     },
     onBuildWatch: async () => {
-      console.log("Watching...")
+      Logger.debug("Watching...")
     },
     ...mockScript
   })

package/vitest.config.ts

@@ -13,18 +13,26 @@ export default defineConfig({
     include: ["test/**/*.test.ts"],
     exclude: ["node_modules", "dist"],
     setupFiles: ["test/setup.ts"],
+    mockReset: true,
     restoreMocks: true,
     reporters: ["default"],
     coverage: {
       provider: "v8",
       reporter: ["text", "json", "html"],
       thresholds: {
-        statements: 85,
-        branches: 80,
-        functions: 85,
-        lines: 85
+        statements: 90,
+        branches: 90,
+        functions: 90,
+        lines: 90
       },
-      exclude: ["node_modules/", "test/", "vitest.config.ts", "src/bootstrap.sh", "*.config.js"]
+      exclude: [
+        "node_modules/",
+        "test/",
+        "vitest.config.ts",
+        "src/bootstrap.sh",
+        "*.config.js",
+        "src/filesystem/homeDirectory.ts"
+      ]
     }
   },
   esbuild: {