@nosto/nosto-cli 1.2.0 → 1.2.2

package/test/modules/deployments/list.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest"
+
+import { deploymentsList } from "#modules/deployments/list.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { createMockDeployment } from "#test/utils/mockDeployment.ts"
+import { mockListDeployments, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+const terminal = setupMockConsole()
+setupMockConfig()
+
+describe("deploymentsList", () => {
+  it("should display list of deployments", async () => {
+    const mockDeployments = [
+      createMockDeployment({
+        id: "1763737018",
+        created: 1732200000000,
+        latest: true,
+        userId: "user@nosto.com",
+        description: "Latest deployment"
+      }),
+      createMockDeployment({
+        id: "1763737609",
+        created: 1732199000000,
+        active: true,
+        userId: "user@nosto.com",
+        description: "Additional fixes etc.."
+      })
+    ]
+
+    mockListDeployments(server, { response: mockDeployments })
+
+    await deploymentsList()
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Found 2 deployment(s):"))
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("ID: 1763737018"))
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("ID: 1763737609"))
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Latest deployment"))
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Additional fixes etc.."))
+  })
+
+  it("should display message when no deployments found", async () => {
+    mockListDeployments(server, { response: [] })
+
+    await deploymentsList()
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("No deployments found"))
+  })
+
+  it("should display deployments without optional fields", async () => {
+    const mockDeployments = [createMockDeployment({ id: "1763737018", latest: true })]
+
+    mockListDeployments(server, { response: mockDeployments })
+
+    await deploymentsList()
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Found 1 deployment(s):"))
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("ID: 1763737018"))
+  })
+
+  it("should display active status correctly", async () => {
+    const mockDeployments = [createMockDeployment({ active: true })]
+
+    mockListDeployments(server, { response: mockDeployments })
+
+    await deploymentsList()
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Active"))
+  })
+
+  it("should display inactive status correctly", async () => {
+    const mockDeployments = [createMockDeployment()]
+
+    mockListDeployments(server, { response: mockDeployments })
+
+    await deploymentsList()
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Inactive"))
+  })
+
+  it("should display latest badge for latest deployment", async () => {
+    const mockDeployments = [createMockDeployment({ latest: true })]
+
+    mockListDeployments(server, { response: mockDeployments })
+
+    await deploymentsList()
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("[LATEST]"))
+  })
+
+  it("should format dates correctly", async () => {
+    const mockDeployments = [createMockDeployment({ latest: true })]
+
+    mockListDeployments(server, { response: mockDeployments })
+
+    await deploymentsList()
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringMatching(/\d{4}-\d{2}-\d{2} \d{2}:\d{2}/))
+  })
+})

package/test/modules/deployments/redeploy.test.ts

@@ -0,0 +1,218 @@
+import { describe, expect, it } from "vitest"
+
+import { deploymentsRedeploy, selectDeploymentInteractively } from "#modules/deployments/redeploy.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { createMockDeployment } from "#test/utils/mockDeployment.ts"
+import { mockListDeployments, mockUpdateDeployment, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+const terminal = setupMockConsole()
+setupMockConfig()
+
+describe("deploymentsRedeploy", () => {
+  it("should redeploy deployment by ID when provided", async () => {
+    const mockDeployments = [
+      createMockDeployment({
+        id: "1763737018",
+        latest: true,
+        description: "Test deployment"
+      })
+    ]
+    mockListDeployments(server, { response: mockDeployments })
+    const mock = mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await deploymentsRedeploy({ deploymentId: "1763737018", force: true })
+
+    expect(mock.invocations).toHaveLength(1)
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Redeployed successfully!")
+  })
+
+  it("should show error when deployment ID not found", async () => {
+    const mockDeployments = [createMockDeployment({ id: "1763737018", latest: true })]
+    mockListDeployments(server, { response: mockDeployments })
+    const mock = mockUpdateDeployment(server, { deploymentId: "9999999999" })
+
+    await deploymentsRedeploy({ deploymentId: "9999999999", force: true })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith('Deployment with ID "9999999999" not found.')
+  })
+
+  it("should display deployment info", async () => {
+    const mockDeployments = [
+      createMockDeployment({
+        id: "1763737018",
+        latest: true,
+        description: "Test deployment"
+      })
+    ]
+    mockListDeployments(server, { response: mockDeployments })
+    mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await deploymentsRedeploy({ deploymentId: "1763737018", force: true })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Selected deployment: "))
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Description: Test deployment")
+  })
+
+  it("should prompt for confirmation when not forced", async () => {
+    const mockDeployments = [createMockDeployment({ id: "1763737018", latest: true })]
+    mockListDeployments(server, { response: mockDeployments })
+    terminal.setUserResponse("y")
+    const mock = mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await deploymentsRedeploy({ deploymentId: "1763737018", force: false })
+
+    expect(mock.invocations).toHaveLength(1)
+    terminal.expect.user.toHaveBeenPromptedWith("Are you sure you want to redeploy version 1763737018? (y/N):")
+  })
+
+  it("should cancel when user declines confirmation", async () => {
+    const mockDeployments = [createMockDeployment({ id: "1763737018", latest: true })]
+    mockListDeployments(server, { response: mockDeployments })
+    terminal.setUserResponse("n")
+    const mock = mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await deploymentsRedeploy({ deploymentId: "1763737018", force: false })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Redeployment cancelled by user.")
+  })
+
+  it("should handle deployment without description field", async () => {
+    const mockDeployments = [createMockDeployment({ id: "1763737018", latest: true })]
+    mockListDeployments(server, { response: mockDeployments })
+    mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await deploymentsRedeploy({ deploymentId: "1763737018", force: true })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Selected deployment: "))
+    expect(terminal.getSpy("info")).not.toHaveBeenCalledWith(expect.stringContaining("Description:"))
+  })
+
+  it("should display redeployment progress message", async () => {
+    const mockDeployments = [
+      {
+        id: "1763737018",
+        created: 1732200000000,
+        active: false,
+        latest: true
+      }
+    ]
+    mockListDeployments(server, { response: mockDeployments })
+    mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await deploymentsRedeploy({ deploymentId: "1763737018", force: true })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Selected deployment"))
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Redeployed successfully!")
+  })
+
+  it("should error when no deployment selected interactively", async () => {
+    mockListDeployments(server, { response: [] })
+
+    await deploymentsRedeploy({ force: true })
+
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith("No deployment selected. Aborting.")
+  })
+})
+
+describe("selectDeploymentInteractively", () => {
+  it("should return null when no deployments found", async () => {
+    mockListDeployments(server, { response: [] })
+
+    const result = await selectDeploymentInteractively("Select deployment:")
+
+    expect(result).toBeNull()
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith("No deployments found.")
+  })
+
+  it("should display active deployment indicator and format choices correctly", async () => {
+    const mockDeployments = [
+      createMockDeployment({
+        id: "1763737018",
+        created: 1732200000000,
+        active: true,
+        description: "Active deployment"
+      }),
+      createMockDeployment({
+        id: "1763737019",
+        created: 1732199000000,
+        latest: true,
+        description: "Latest deployment"
+      }),
+      createMockDeployment({
+        id: "1763737020",
+        created: 1732198000000
+      })
+    ]
+    mockListDeployments(server, { response: mockDeployments })
+    terminal.setSelectResponse("1763737018")
+
+    const result = await selectDeploymentInteractively("Select deployment:")
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining("Currently active deployment"))
+    expect(result).toEqual({
+      id: "1763737018",
+      deployment: mockDeployments[0]
+    })
+    expect(terminal.getSelectSpy()).toHaveBeenCalledWith({
+      message: "Select deployment:",
+      choices: expect.arrayContaining([
+        expect.objectContaining({
+          value: "1763737018",
+          description: "Active deployment"
+        }),
+        expect.objectContaining({
+          value: "1763737019",
+          description: "Latest deployment"
+        }),
+        expect.objectContaining({
+          value: "1763737020",
+          description: "No description"
+        })
+      ]),
+      pageSize: 10
+    })
+  })
+
+  it("should return null when no selection is made", async () => {
+    const mockDeployments = [createMockDeployment({ id: "1763737018", latest: true })]
+    mockListDeployments(server, { response: mockDeployments })
+    terminal.setSelectResponse(undefined)
+
+    const result = await selectDeploymentInteractively("Select deployment:")
+
+    expect(result).toBeNull()
+  })
+
+  it("should return null when selected deployment not found", async () => {
+    const mockDeployments = [createMockDeployment({ id: "1763737018", latest: true })]
+    mockListDeployments(server, { response: mockDeployments })
+    terminal.setSelectResponse("nonexistent")
+
+    const result = await selectDeploymentInteractively("Select deployment:")
+
+    expect(result).toBeNull()
+  })
+
+  it("should use interactive selection when no deploymentId provided", async () => {
+    const mockDeployments = [
+      createMockDeployment({
+        id: "1763737018",
+        latest: true,
+        description: "Test deployment"
+      })
+    ]
+    mockListDeployments(server, { response: mockDeployments })
+    terminal.setSelectResponse("1763737018")
+    const mock = mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await deploymentsRedeploy({ force: true })
+
+    expect(terminal.getSelectSpy()).toHaveBeenCalled()
+    expect(mock.invocations).toHaveLength(1)
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Redeployed successfully!")
+  })
+})

package/test/modules/deployments/rollback.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest"
+
+import { deploymentsRollback } from "#modules/deployments/rollback.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { mockRollbackDeployment, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+const terminal = setupMockConsole()
+setupMockConfig()
+
+describe("deploymentsRollback", () => {
+  it("should disable deployment when user confirms", async () => {
+    terminal.setUserResponse("y")
+    const mock = mockRollbackDeployment(server, {})
+
+    await deploymentsRollback({ force: false })
+
+    expect(mock.invocations).toHaveLength(1)
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Active deployment disabled successfully!")
+  })
+
+  it("should cancel when user declines", async () => {
+    terminal.setUserResponse("n")
+    const mock = mockRollbackDeployment(server, {})
+
+    await deploymentsRollback({ force: false })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Operation cancelled by user.")
+  })
+
+  it("should skip confirmation when force is true", async () => {
+    const mock = mockRollbackDeployment(server, {})
+
+    await deploymentsRollback({ force: true })
+
+    expect(mock.invocations).toHaveLength(1)
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Active deployment disabled successfully!")
+  })
+
+  it("should display confirmation message", async () => {
+    terminal.setUserResponse("y")
+    mockRollbackDeployment(server, {})
+
+    await deploymentsRollback({ force: false })
+
+    terminal.expect.user.toHaveBeenPromptedWith(
+      "Are you sure you want to disable the currently active deployment? (y/N):"
+    )
+  })
+
+  it("should display progress message", async () => {
+    mockRollbackDeployment(server, {})
+
+    await deploymentsRollback({ force: true })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Disabling active deployment...")
+  })
+})

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

@@ -4,8 +4,15 @@ 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"
-
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+import {
+  mockFetchLibraryFile,
+  mockFetchSourceFile,
+  mockPutSourceFile,
+  setupMockServer
+} from "#test/utils/mockServer.ts"
+
+const fs = setupMockFileSystem()
 const server = setupMockServer()
 const terminal = setupMockConsole()
 
@@ -95,5 +102,81 @@ describe("Search Templates build / legacy", () => {
       processOnSpy.mockRestore()
       processExitSpy.mockRestore()
     })
+
+    it("should push templates after build when push is true", async () => {
+      // Create source file with Nosto import
+      fs.writeFile("/test-project/index.ts", "import { search } from '@nosto/preact'")
+
+      // Mock rebuild to create build output
+      mockContext.rebuild.mockImplementation(async () => {
+        fs.writeFile("/test-project/build/index.js", "console.log('built')")
+        return { errors: [], warnings: [] }
+      })
+
+      // Mock the API endpoints
+      mockFetchSourceFile(server, {
+        path: "build/hash",
+        error: { status: 404, message: "Not Found" }
+      })
+
+      const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+      const hashMock = mockPutSourceFile(server, { path: "build/hash" })
+
+      terminal.setUserResponse("y")
+
+      await buildSearchTemplate({ watch: false, push: true })
+
+      expect(mockContext.rebuild).toHaveBeenCalled()
+      expect(mockContext.dispose).toHaveBeenCalled()
+      expect(indexMock.invocations).toHaveLength(1)
+      expect(hashMock.invocations).toHaveLength(1)
+    })
+
+    it("should not push templates when push is false", async () => {
+      // Create source file with Nosto import
+      fs.writeFile("/test-project/index.ts", "import { search } from '@nosto/preact'")
+
+      // Create build output
+      fs.writeFile("/test-project/build/index.js", "console.log('built')")
+
+      const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+
+      await buildSearchTemplate({ watch: false, push: false })
+
+      expect(mockContext.rebuild).toHaveBeenCalled()
+      expect(mockContext.dispose).toHaveBeenCalled()
+      expect(indexMock.invocations).toHaveLength(0)
+    })
+
+    it("should not push templates when push is undefined", async () => {
+      // Create source file with Nosto import
+      fs.writeFile("/test-project/index.ts", "import { search } from '@nosto/preact'")
+
+      // Create build output
+      fs.writeFile("/test-project/build/index.js", "console.log('built')")
+
+      const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+
+      await buildSearchTemplate({ watch: false })
+
+      expect(mockContext.rebuild).toHaveBeenCalled()
+      expect(mockContext.dispose).toHaveBeenCalled()
+      expect(indexMock.invocations).toHaveLength(0)
+    })
+
+    it("should not push templates in watch mode even if push is true", async () => {
+      // Create source file with Nosto import
+      fs.writeFile("/test-project/index.ts", "import { search } from '@nosto/preact'")
+
+      // Create build output
+      fs.writeFile("/test-project/build/index.js", "console.log('built')")
+
+      const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+
+      await buildSearchTemplate({ watch: true, push: true })
+
+      expect(mockContext.watch).toHaveBeenCalled()
+      expect(indexMock.invocations).toHaveLength(0)
+    })
   })
 })

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

@@ -3,8 +3,15 @@ import { beforeEach, describe, expect, it, vi } from "vitest"
 import { parseSearchTemplatesConfigFile } from "#config/searchTemplatesConfig.ts"
 import { buildSearchTemplate } from "#modules/search-templates/build.ts"
 import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+import { mockFetchSourceFile, mockPutSourceFile, setupMockServer } from "#test/utils/mockServer.ts"
 import { setupMockStarterManifest } from "#test/utils/mockStarterManifest.ts"
 
+const fs = setupMockFileSystem()
+const server = setupMockServer()
+const terminal = setupMockConsole()
+
 describe("Search Templates build / modern", () => {
   beforeEach(() => {
     setupMockStarterManifest()
@@ -34,4 +41,103 @@ describe("Search Templates build / modern", () => {
     await buildSearchTemplate({ watch: true })
     expect(manifest.onBuildWatch).toHaveBeenCalled()
   })
+
+  it("should push templates after build when push is true", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: {
+        onBuild: vi.fn().mockImplementation(async () => {
+          // Simulate the build creating output files
+          fs.writeFile("build/index.js", "console.log('built')")
+        })
+      }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+
+    // Create a source file that contains Nosto import (required by push logic)
+    fs.writeFile("index.ts", "import { search } from '@nosto/preact'")
+
+    // Mock the API endpoints - the push operation will check for remote hash first
+    mockFetchSourceFile(server, {
+      path: "build/hash",
+      error: { status: 404, message: "Not Found" }
+    })
+
+    const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+    const hashMock = mockPutSourceFile(server, { path: "build/hash" })
+
+    // Set force: true to skip the confirmation prompt
+    terminal.setUserResponse("y")
+
+    await buildSearchTemplate({ watch: false, push: true })
+
+    expect(manifest.onBuild).toHaveBeenCalled()
+    expect(indexMock.invocations).toHaveLength(1)
+    expect(hashMock.invocations).toHaveLength(1)
+  })
+
+  it("should not push templates when push is false", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: { onBuild: vi.fn() }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+
+    // Create build output files that would be pushed if push was true
+    fs.writeFile("build/index.js", "console.log('built')")
+
+    // Mock the API endpoints to track if they're called
+    const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+
+    await buildSearchTemplate({ watch: false, push: false })
+
+    expect(manifest.onBuild).toHaveBeenCalled()
+    expect(indexMock.invocations).toHaveLength(0)
+  })
+
+  it("should not push templates when push is undefined", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: { onBuild: vi.fn() }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+
+    // Create build output files that would be pushed if push was true
+    fs.writeFile("build/index.js", "console.log('built')")
+
+    // Mock the API endpoints to track if they're called
+    const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+
+    await buildSearchTemplate({ watch: false })
+
+    expect(manifest.onBuild).toHaveBeenCalled()
+    expect(indexMock.invocations).toHaveLength(0)
+  })
+
+  it("should not push templates in watch mode even if push is true", async () => {
+    const manifest = setupMockStarterManifest({
+      mockScript: {
+        onBuildWatch: vi.fn().mockImplementation(async ({ onAfterBuild }) => {
+          await onAfterBuild()
+        })
+      }
+    })
+    setupMockConfig({
+      searchTemplates: await parseSearchTemplatesConfigFile({ projectPath: "." })
+    })
+
+    // Create build output files that would be pushed if not in watch mode
+    fs.writeFile("build/index.js", "console.log('built')")
+
+    // Mock the API endpoints to track if they're called
+    const indexMock = mockPutSourceFile(server, { path: "build/index.js" })
+
+    await buildSearchTemplate({ watch: true, push: true })
+
+    expect(manifest.onBuildWatch).toHaveBeenCalled()
+    expect(indexMock.invocations).toHaveLength(0)
+  })
 })

package/test/setup.ts

@@ -3,7 +3,7 @@ import { beforeEach } from "vitest"
 import { vi } from "vitest"
 
 import { mockHttpServer } from "./utils/mockAuthServer.ts"
-import { mockedConsoleIn, mockedConsoleOut, mockedSpinner } from "./utils/mockConsole.ts"
+import { mockedConsoleIn, mockedConsoleOut, mockedInquirer, mockedSpinner } from "./utils/mockConsole.ts"
 
 export const testVolume = Volume.fromJSON({}, "/")
 
@@ -24,6 +24,8 @@ vi.mock("readline/promises", () => {
 })
 vi.mock("#/console/logger.ts", () => mockedConsoleOut)
 
+vi.mock("@inquirer/prompts", () => mockedInquirer)
+
 vi.mock("node:test", () => {
   throw new Error("You seem to have accidentally imported node:test instead of vitest.")
 })

package/test/utils/formatDate.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest"
+
+import { formatDate } from "#utils/formatDate.ts"
+
+describe("formatDate", () => {
+  it("should format a Date object correctly", () => {
+    const date = new Date("2025-11-21T14:56:58Z")
+    const formatted = formatDate(date)
+
+    expect(formatted).toBe("2025-11-21 14:56")
+  })
+
+  it("should format a timestamp in milliseconds correctly", () => {
+    const timestamp = 1732200000000 // Nov 21, 2024 14:40:00 GMT
+    const formatted = formatDate(timestamp)
+
+    expect(formatted).toBe("2024-11-21 14:40")
+  })
+
+  it("should pad single-digit months and days with zeros", () => {
+    const date = new Date("2025-01-05T08:03:00Z")
+    const formatted = formatDate(date)
+
+    expect(formatted).toBe("2025-01-05 08:03")
+  })
+
+  it("should pad single-digit hours and minutes with zeros", () => {
+    const date = new Date("2025-11-21T08:03:00Z")
+    const formatted = formatDate(date)
+
+    expect(formatted).toBe("2025-11-21 08:03")
+  })
+
+  it("should handle midnight correctly", () => {
+    const date = new Date("2025-11-21T00:00:00Z")
+    const formatted = formatDate(date)
+
+    expect(formatted).toBe("2025-11-21 00:00")
+  })
+
+  it("should handle end of day correctly", () => {
+    const date = new Date("2025-11-21T23:59:00Z")
+    const formatted = formatDate(date)
+
+    expect(formatted).toBe("2025-11-21 23:59")
+  })
+
+  it("should handle year boundaries correctly", () => {
+    const date = new Date("2025-12-31T23:59:00Z")
+    const formatted = formatDate(date)
+
+    expect(formatted).toBe("2025-12-31 23:59")
+  })
+})