@nosto/nosto-cli 1.0.1

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

@@ -0,0 +1,96 @@
+import { describe, it } from "vitest"
+
+import { pullSearchTemplate } from "#modules/search-templates/pull.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+import { mockFetchSourceFile, mockListSourceFiles, setupMockServer } from "#test/utils/mockServer.ts"
+
+const fs = setupMockFileSystem()
+const server = setupMockServer()
+const terminal = setupMockConsole()
+
+describe("Pull Search Template", () => {
+  it("should fetch all files when no paths specified", async () => {
+    mockListSourceFiles(server, {
+      response: [
+        { path: "index.js", size: 10 },
+        { path: "wizard.js", size: 25 }
+      ]
+    })
+    mockFetchSourceFile(server, {
+      path: "index.js",
+      response: "index.js content"
+    })
+    mockFetchSourceFile(server, {
+      path: "wizard.js",
+      response: "wizard.js content"
+    })
+
+    await pullSearchTemplate({ paths: [], force: true })
+    fs.expectFile("index.js").toContain('"index.js content"')
+    fs.expectFile("wizard.js").toContain('"wizard.js content"')
+  })
+
+  it("should filter by specified paths", async () => {
+    mockListSourceFiles(server, {
+      response: [
+        { path: "index.js", size: 10 },
+        { path: "wizard.js", size: 25 }
+      ]
+    })
+    mockFetchSourceFile(server, {
+      path: "index.js",
+      response: "index.js content"
+    })
+    mockFetchSourceFile(server, {
+      path: "wizard.js",
+      response: "wizard.js content"
+    })
+
+    await pullSearchTemplate({ paths: ["index.js"], force: true })
+
+    fs.expectFile("index.js").toContain('"index.js content"')
+    fs.expectFile("wizard.js").not.toExist()
+  })
+
+  it("should prompt for confirmation when files will be overridden", async () => {
+    fs.writeFile("index.js", "old content")
+    mockListSourceFiles(server, {
+      response: [{ path: "index.js", size: 10 }]
+    })
+    mockFetchSourceFile(server, {
+      path: "index.js",
+      response: "index.js content"
+    })
+
+    terminal.setUserResponse("N")
+    await pullSearchTemplate({ paths: [], force: false })
+    terminal.expect.user.toHaveBeenPromptedWith("Are you sure you want to override your local data? (y/N):")
+  })
+
+  it("should cancel operation when user declines override", async () => {
+    fs.writeFile("index.js", "old content")
+    mockListSourceFiles(server, {
+      response: [{ path: "index.js", size: 10 }]
+    })
+
+    terminal.setUserResponse("N")
+    await pullSearchTemplate({ paths: [], force: false })
+    fs.expectFile("/index.js").toContain("old content")
+  })
+
+  it("should proceed with download when user confirms override", async () => {
+    fs.writeFile("index.js", "old content")
+    mockListSourceFiles(server, {
+      response: [{ path: "index.js", size: 10 }]
+    })
+    mockFetchSourceFile(server, {
+      path: "index.js",
+      response: "index.js content"
+    })
+
+    terminal.setUserResponse("Y")
+    await pullSearchTemplate({ paths: [], force: false })
+    fs.expectFile("index.js").toContain('"index.js content"')
+  })
+})

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

@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest"
+
+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"
+
+const fs = setupMockFileSystem()
+const server = setupMockServer()
+const terminal = setupMockConsole()
+
+describe("Push Search Template", () => {
+  it("should throw error if target folder does not exist", async () => {
+    setupMockConfig({ projectPath: "/nonexistent/path" })
+
+    await expect(pushSearchTemplate({ paths: [], force: true })).rejects.toThrow(
+      "ENOENT: no such file or directory, scandir '/nonexistent/path'"
+    )
+  })
+
+  it("should throw error if target path is not a directory", async () => {
+    fs.writeFile("file.txt", "file content")
+    setupMockConfig({
+      projectPath: "./file.txt"
+    })
+
+    await expect(pushSearchTemplate({ paths: [], force: true })).rejects.toThrow(
+      "ENOTDIR: not a directory, scandir '/file.txt'"
+    )
+  })
+
+  it("should exit early if no files to push", async () => {
+    fs.writeFile(".gitignore", "*.js")
+    fs.writeFile("index.js", "content with @nosto/preact")
+
+    await pushSearchTemplate({ paths: [], force: true })
+
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith("No files to push. Exiting.")
+  })
+
+  it("should process files and display summary", async () => {
+    fs.writeFile(".gitignore", "*.log")
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile("file1.js", "file1 content")
+    fs.writeFile("file2.js", "file2 content")
+    fs.writeFile("ignored.log", "log content")
+
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "file1.js" })
+    mockPutSourceFile(server, { path: "file2.js" })
+
+    await pushSearchTemplate({ paths: [], force: true })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Pushing template from: /")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Found 4 files to push (3 source, 1 built, 1 ignored).")
+  })
+
+  it("should not ignore build directory", async () => {
+    fs.writeFile(".gitignore", "build/")
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile("build/index.js", "build content")
+
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "build/index.js" })
+
+    await pushSearchTemplate({ paths: [], force: true })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Pushing template from: /")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Found 3 files to push (1 source, 2 built, 0 ignored).")
+  })
+
+  it("should cancel operation when user declines", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile("file1.js", "file1 content")
+
+    terminal.setUserResponse("N")
+
+    await pushSearchTemplate({ paths: [], force: false })
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Push operation cancelled by user.")
+  })
+
+  it("should filter files by specified paths", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile("file1.js", "file1 content")
+    fs.writeFile("file2.js", "file2 content")
+    fs.writeFile("file3.js", "file3 content")
+
+    mockPutSourceFile(server, { path: "index.js" })
+    mockPutSourceFile(server, { path: "file1.js" })
+    mockPutSourceFile(server, { path: "file3.js" })
+
+    await pushSearchTemplate({ paths: ["index.js", "file1.js", "file3.js"], force: true })
+    expect(terminal.getSpy("warn")).not.toHaveBeenCalledWith("No files to push. Exiting.")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Pushing template from: /")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Found 4 files to push (3 source, 1 built, 0 ignored).")
+  })
+
+  // TODO: Times out because of retry delay. Should be configurable in tests.
+  it.skip("should handle upload failures gracefully", async () => {
+    fs.writeFile("index.js", "content with @nosto/preact")
+    fs.writeFile("file1.js", "file1 content")
+
+    mockPutSourceFile(server, { path: "index.js", error: { status: 500, message: "Upload failed" } })
+    mockPutSourceFile(server, { path: "file1.js", error: { status: 500, message: "Upload failed" } })
+
+    await pushSearchTemplate({ paths: [], force: true })
+  })
+})

package/test/modules/setup.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest"
+
+import { printSetupHelp } from "#modules/setup.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+
+const fs = setupMockFileSystem()
+const terminal = setupMockConsole()
+
+describe("Setup Module", () => {
+  it("should print configuration help information", async () => {
+    fs.writeFile(".nosto.json", '{"apiKey": "test"}')
+
+    expect(async () => await printSetupHelp(".", {})).not.toThrow()
+    expect(terminal.getSpy("warn")).not.toHaveBeenCalledWith("Configuration file not found in project directory.")
+  })
+
+  it("should show warning when config file not found", async () => {
+    terminal.setUserResponse("N")
+
+    expect(async () => await printSetupHelp(".", {})).not.toThrow()
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith("Configuration file not found in project directory.")
+  })
+
+  it("should create config file when user confirms", async () => {
+    terminal.setUserResponse("Y")
+
+    await printSetupHelp(".", {})
+
+    terminal.expect.user.toHaveBeenPromptedWith("Would you like to create a configuration file? (Y/n):")
+    fs.expectFile(".nosto.json").toExist()
+  })
+
+  it("should not create config file when user declines", async () => {
+    terminal.setUserResponse("N")
+
+    await printSetupHelp(".", {})
+
+    fs.expectFile(".nosto.json").not.toExist()
+  })
+
+  it("should not prompt when config file already exists", async () => {
+    fs.writeFile(".nosto.json", '{"apiKey": "test"}')
+
+    await printSetupHelp(".", {})
+
+    terminal.expect.user.not.toHaveBeenPrompted()
+  })
+})

package/test/modules/status.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest"
+
+import { printStatus } from "#modules/status.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+
+const terminal = setupMockConsole()
+
+describe("Status Module", () => {
+  it("should print configuration status by default", async () => {
+    await expect(printStatus(".")).resolves.not.toThrow()
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Configuration is not valid:")
+  })
+
+  it("should indicate valid configuration", async () => {
+    setupMockConfig({ merchant: "test-merchant" })
+
+    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")
+  })
+})

package/test/setup.ts

@@ -0,0 +1,28 @@
+import { Volume } from "memfs"
+import { beforeEach } from "vitest"
+import { vi } from "vitest"
+
+import { mockedConsoleIn, mockedConsoleOut } from "./utils/mockConsole.ts"
+
+export const testVolume = Volume.fromJSON({}, "/")
+
+vi.mock("fs", () => {
+  return {
+    default: testVolume
+  }
+})
+beforeEach(() => {
+  testVolume.reset()
+  process.chdir("/")
+})
+
+vi.mock("readline/promises", () => {
+  return {
+    createInterface: () => mockedConsoleIn.interface
+  }
+})
+vi.mock("#/console/logger.ts", () => mockedConsoleOut)
+
+vi.mock("node:test", () => {
+  throw new Error("You seem to have accidentally imported node:test instead of vitest.")
+})

package/test/utils/generateEndpointMock.ts

@@ -0,0 +1,60 @@
+import { type DefaultBodyType, http, HttpResponse, StrictRequest } from "msw"
+import type { SetupServer } from "msw/node"
+
+type HttpMethod = keyof typeof http
+
+export type MockParams<ResponseT extends DefaultBodyType | void> =
+  | (ResponseT extends void ? object : { response: ResponseT })
+  | {
+      error: { status: number; message: string }
+    }
+
+export const generateEndpointMock = (
+  server: SetupServer,
+  { method, path, ...params }: { method: HttpMethod; path: string } & MockParams<DefaultBodyType>
+) => {
+  let invocations: unknown[] = []
+
+  const handler = http[method](path, async ({ request }) => {
+    const status = (() => {
+      if ("error" in params) {
+        return params.error.status
+      } else if ("response" in params) {
+        return 200
+      }
+      return 204
+    })()
+
+    const returnedResponse = (() => {
+      if ("error" in params) {
+        return params.error
+      } else if ("response" in params) {
+        return params.response
+      }
+      return undefined
+    })()
+
+    const requestsWithBody = ["POST", "PUT", "PATCH"]
+    invocations.push(requestsWithBody.includes(request.method) ? await toBody(request) : {})
+
+    return HttpResponse.json(returnedResponse, { status })
+  })
+  server.use(handler)
+
+  return {
+    invocations,
+    clearInvocations: () => {
+      invocations = []
+    }
+  }
+}
+
+async function toBody(request: StrictRequest<DefaultBodyType>) {
+  const text = await request.text()
+  try {
+    return JSON.parse(text)
+  } catch {
+    // Throwing here would trigger actual API request in test
+  }
+  return text
+}

package/test/utils/mockCommander.ts

@@ -0,0 +1,22 @@
+import { expect } from "vitest"
+
+import { runCLI } from "#commander.ts"
+
+export function setupMockCommander() {
+  return {
+    async run(command: string) {
+      return runCLI(["/cwd", ...command.split(" ")])
+    },
+
+    expect(command: string) {
+      return {
+        toThrow: async () => {
+          await expect(this.run(command)).rejects.toThrow()
+        },
+        toResolve: async () => {
+          await expect(this.run(command)).resolves.not.toThrow()
+        }
+      }
+    }
+  }
+}

package/test/utils/mockConfig.ts

@@ -0,0 +1,37 @@
+import { beforeEach, vi } from "vitest"
+
+import * as config from "#config/config.ts"
+import { type Config, SearchTemplatesConfigSchema } from "#config/schema.ts"
+
+export function setupMockConfig(overrides: Partial<Config> = {}) {
+  const mockConfig: Config = {
+    apiKey: "test-api-key",
+    merchant: "test-merchant",
+    templatesEnv: "main",
+    apiUrl: "https://api.nosto.com",
+    logLevel: "info",
+    maxRequests: 15,
+    projectPath: "/",
+    libraryUrl: "https://library.nosto.com",
+    dryRun: false,
+    verbose: false,
+    auth: {
+      user: "",
+      token: "",
+      expiresAt: new Date(0)
+    },
+    searchTemplates: {
+      mode: "unknown",
+      data: SearchTemplatesConfigSchema.parse({})
+    },
+    ...overrides
+  }
+
+  // Connect immediately and on beforeEach so that this can be used at top level or in beforeEach
+  vi.spyOn(config, "getCachedConfig").mockReturnValue(mockConfig)
+  vi.spyOn(config, "getCachedSearchTemplatesConfig").mockReturnValue(mockConfig.searchTemplates.data)
+  beforeEach(() => {
+    vi.spyOn(config, "getCachedConfig").mockReturnValue(mockConfig)
+    vi.spyOn(config, "getCachedSearchTemplatesConfig").mockReturnValue(mockConfig.searchTemplates.data)
+  })
+}

package/test/utils/mockConsole.ts

@@ -0,0 +1,65 @@
+import { afterEach, expect, vi } from "vitest"
+
+export const mockedConsoleIn = {
+  userResponse: "q",
+  recordedPrompts: [] as string[],
+  interface: {
+    question: (prompt: string) => {
+      mockedConsoleIn.recordedPrompts.push(prompt)
+      return mockedConsoleIn.userResponse
+    },
+    close: vi.fn()
+  }
+}
+
+export const mockedConsoleOut = {
+  Logger: {
+    context: {
+      logLevel: "info",
+      merchantId: "",
+      isDryRun: false
+    },
+    raw: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn()
+  }
+}
+
+export function setupMockConsole() {
+  afterEach(() => {
+    mockedConsoleIn.recordedPrompts = []
+  })
+
+  return {
+    setUserResponse: (response: string) => {
+      mockedConsoleIn.userResponse = response
+    },
+    clearPrompts: () => {
+      mockedConsoleIn.recordedPrompts = []
+    },
+    getSpy: (method: Exclude<keyof typeof mockedConsoleOut.Logger, "context">) => {
+      return mockedConsoleOut.Logger[method]
+    },
+    expect: {
+      user: {
+        toHaveBeenPromptedWith: (prompt: string) => {
+          expect(
+            mockedConsoleIn.recordedPrompts.map(p => p.trim()),
+            "No matching prompt found.\nExpected:\n" +
+              prompt +
+              "\nGot: \n" +
+              mockedConsoleIn.recordedPrompts.map(p => p.trim()).join("\n") +
+              "\n\n"
+          ).toContain(prompt.trim())
+        },
+        not: {
+          toHaveBeenPrompted: () => {
+            expect(mockedConsoleIn.recordedPrompts.length, "Prompt was recorded when it was not expected").toBe(0)
+          }
+        }
+      }
+    }
+  }
+}

package/test/utils/mockFileSystem.ts

@@ -0,0 +1,52 @@
+import fs from "fs"
+import path from "path"
+import { expect } from "vitest"
+
+import { testVolume } from "#test/setup.ts"
+
+export function setupMockFileSystem() {
+  const fs = testVolume
+  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 })
+      }
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath)
+      }
+      fs.writeFileSync(filePath, content)
+    },
+    writeFolder: (targetFolder: string) => {
+      const dir = path.join("/", targetFolder)
+      fs.mkdirSync(dir, { recursive: true })
+    },
+    expectFile: (targetFile: string) => {
+      const filePath = path.join("/", targetFile)
+      return makeFileMatcher(filePath)
+    }
+  }
+}
+
+export function makeFileMatcher(path: string) {
+  return {
+    toContain: (expectedContent: string) => {
+      const content = fs.readFileSync(path, "utf8")
+      expect(content, `File ${path} has content ${content}`).toEqual(expectedContent)
+    },
+    toExist: () => {
+      return expect(fs.existsSync(path), `File ${path} does not exist when it was expected to`).toBe(true)
+    },
+    not: {
+      toContain: (expectedContent: string) => {
+        const content = fs.readFileSync(path, "utf8")
+        expect(content, `File ${path} has content ${content}`).not.toEqual(expectedContent)
+      },
+      toExist: () => {
+        return expect(fs.existsSync(path), `File ${path} exists when it was not expected to`).toBe(false)
+      }
+    }
+  }
+}

package/test/utils/mockServer.ts

@@ -0,0 +1,76 @@
+import { SetupServer, setupServer } from "msw/node"
+import { afterAll, afterEach, beforeAll, beforeEach } from "vitest"
+
+import { fetchLibraryFile } from "#api/library/fetchLibraryFile.ts"
+import { fetchSourceFile } from "#api/source/fetchSourceFile.ts"
+import { listSourceFiles } from "#api/source/listSourceFiles.ts"
+import { putSourceFile } from "#api/source/putSourceFile.ts"
+import { getSourceUrl } from "#api/utils.ts"
+import { generateEndpointMock, MockParams } from "#test/utils/generateEndpointMock.ts"
+
+export const setupMockServer = () => {
+  const server = setupServer()
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: "error" })
+  })
+  beforeEach(() => {
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      error: { status: 404, message: "Not Found" }
+    })
+    mockPutSourceFile(server, {
+      path: "build/hash"
+    })
+  })
+  afterEach(() => {
+    server.resetHandlers()
+  })
+  afterAll(() => server.close())
+
+  return server
+}
+
+export function mockListSourceFiles(
+  server: SetupServer,
+  params: MockParams<Awaited<ReturnType<typeof listSourceFiles>>>
+) {
+  return generateEndpointMock(server, {
+    ...params,
+    method: "get",
+    path: getSourceUrl("source/{env}")
+  })
+}
+
+export function mockFetchSourceFile(
+  server: SetupServer,
+  params: { path: string } & MockParams<Awaited<ReturnType<typeof fetchSourceFile>>>
+) {
+  return generateEndpointMock(server, {
+    ...params,
+    method: "get",
+    path: getSourceUrl(`source/{env}/${params.path}`)
+  })
+}
+
+export function mockPutSourceFile(
+  server: SetupServer,
+  params: { path: string } & MockParams<Awaited<ReturnType<typeof putSourceFile>>>
+) {
+  const { path, ...mockParams } = params
+  return generateEndpointMock(server, {
+    method: "put",
+    path: getSourceUrl(`source/{env}/${path}`),
+    ...mockParams
+  })
+}
+
+export function mockFetchLibraryFile(
+  server: SetupServer,
+  params: { path: string } & MockParams<Awaited<ReturnType<typeof fetchLibraryFile>>>
+) {
+  return generateEndpointMock(server, {
+    ...params,
+    method: "get",
+    path: `https://library.nosto.com/${params.path}`
+  })
+}

package/test/utils/mockStarterManifest.ts

@@ -0,0 +1,42 @@
+import path from "path"
+import { vi } from "vitest"
+
+import { SearchTemplatesConfig } from "#config/schema.ts"
+import { makeConfig } from "#exports.ts"
+
+import { setupMockFileSystem } from "./mockFileSystem.ts"
+
+type Props = {
+  projectPath?: string
+  mockScript?: Partial<SearchTemplatesConfig>
+}
+
+export function setupMockStarterManifest({ projectPath, mockScript }: Props = {}) {
+  const fs = setupMockFileSystem()
+  const manifest = makeConfig({
+    onBuild: async () => {
+      console.log("Building...")
+    },
+    onBuildWatch: async () => {
+      console.log("Watching...")
+    },
+    ...mockScript
+  })
+
+  const filePath = path.join("/", projectPath ?? "", "nosto.config.ts")
+
+  vi.doMock(filePath, () => ({
+    default: manifest
+  }))
+
+  let scriptBuilder = `export default {`
+  Object.entries(manifest).forEach(([key, value]) => {
+    scriptBuilder += `
+    ${key}: ${value.toString()},
+    `
+  })
+  scriptBuilder += `}`
+
+  fs.writeFile(filePath, scriptBuilder)
+  return manifest
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowImportingTsExtensions": true,
+    "rootDir": ".",
+    "resolveJsonModule": true,
+    "paths": {
+      "#*": ["./src/*"],
+      "#test/*": ["./test/*"]
+    }
+  },
+  "include": ["src/**/*", "test/**/*", "vitest.config.ts"],
+  "exclude": ["node_modules"]
+}