@nosto/nosto-cli 1.2.0 → 1.2.2

package/.github/workflows/release.yml

@@ -6,6 +6,7 @@ on:
 
 permissions:
   contents: read
+  id-token: write
 
 # Allow only one concurrent deployment, and wait for the current one to finish
 concurrency:
@@ -34,9 +35,10 @@ jobs:
         run: npm test
 
       - name: Publish project
-        uses: cycjimmy/semantic-release-action@9cc899c47e6841430bbaedb43de1560a568dfd16 # v5.0.0
+        uses: cycjimmy/semantic-release-action@b12c8f6015dc215fe37bc154d4ad456dd3833c90 # v6.0.0
         id: semantic
         with:
+          semantic_version: 25.0.2
           extra_plugins: |
             @semantic-release/changelog
             @semantic-release/git
@@ -46,4 +48,3 @@ jobs:
             ]
         env:
           GITHUB_TOKEN: ${{ secrets.RELEASE_PAT_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPMJS_TOKEN }}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosto/nosto-cli",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "main": "./src/index.ts",
   "bin": {
     "nosto": "./src/bootstrap.mjs"
@@ -62,5 +62,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nosto/nosto-cli"
   }
 }

package/test/api/deployments/createDeployment.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest"
+
+import { createDeployment } from "#api/deployments/createDeployment.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { mockCreateDeployment, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+setupMockConfig()
+
+describe("createDeployment", () => {
+  it("should create a deployment with description", async () => {
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await createDeployment({ path: "build", description: "Test deployment" })
+
+    expect(mock.invocations).toHaveLength(1)
+    expect(mock.invocations[0]).toEqual({ description: "Test deployment" })
+  })
+
+  it("should throw an error when server returns error", async () => {
+    mockCreateDeployment(server, { path: "build", error: { status: 500, message: "Server Error" } })
+
+    await expect(createDeployment({ path: "build", description: "Test deployment" })).rejects.toThrow()
+  })
+
+  it("should handle empty description", async () => {
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await createDeployment({ path: "build", description: "" })
+
+    expect(mock.invocations).toHaveLength(1)
+    expect(mock.invocations[0]).toEqual({ description: "" })
+  })
+
+  it("should use correct path in URL", async () => {
+    const mock = mockCreateDeployment(server, { path: "custom-path" })
+
+    await createDeployment({ path: "custom-path", description: "Test deployment" })
+
+    expect(mock.invocations).toHaveLength(1)
+  })
+})

package/test/api/deployments/listDeployments.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest"
+
+import { listDeployments } from "#api/deployments/listDeployments.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { createMockDeployment } from "#test/utils/mockDeployment.ts"
+import { mockListDeployments, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+setupMockConfig()
+
+const mockDeploymentsWithAllFields = [
+  createMockDeployment({
+    id: "1763737018",
+    created: 1732200000000,
+    active: false,
+    latest: true,
+    userId: "user@nosto.com",
+    description: "Latest deployment"
+  }),
+  createMockDeployment({
+    id: "1763737609",
+    created: 1732199000000,
+    active: true,
+    latest: false,
+    userId: "user@nosto.com",
+    description: "Additional fixes etc.."
+  })
+]
+
+const mockDeploymentsWithoutOptionalFields = [
+  createMockDeployment({
+    id: "1763737018",
+    created: 1732200000000,
+    active: false,
+    latest: true
+  })
+]
+
+describe("listDeployments", () => {
+  it("should fetch and return list of deployments", async () => {
+    mockListDeployments(server, { response: mockDeploymentsWithAllFields })
+
+    const deployments = await listDeployments()
+
+    expect(deployments).toEqual(mockDeploymentsWithAllFields)
+    expect(deployments).toHaveLength(2)
+  })
+
+  it("should return empty array when no deployments exist", async () => {
+    mockListDeployments(server, { response: [] })
+
+    const deployments = await listDeployments()
+
+    expect(deployments).toEqual([])
+    expect(deployments).toHaveLength(0)
+  })
+
+  it("should handle deployments without optional fields", async () => {
+    mockListDeployments(server, { response: mockDeploymentsWithoutOptionalFields })
+
+    const deployments = await listDeployments()
+
+    expect(deployments).toEqual(mockDeploymentsWithoutOptionalFields)
+    expect(deployments[0].userId).toBeUndefined()
+    expect(deployments[0].description).toBeUndefined()
+  })
+
+  it("should throw an error when server returns error", async () => {
+    mockListDeployments(server, { error: { status: 500, message: "Server Error" } })
+
+    await expect(listDeployments()).rejects.toThrow()
+  })
+
+  it("should validate response schema", async () => {
+    const invalidDeployments = [
+      {
+        id: "1763737018",
+        // Missing required fields
+        active: false
+      }
+    ]
+
+    // @ts-expect-error - Testing invalid schema
+    mockListDeployments(server, { response: invalidDeployments })
+
+    await expect(listDeployments()).rejects.toThrow()
+  })
+})

package/test/api/deployments/rollbackDeployment.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest"
+
+import { rollbackDeployment } from "#api/deployments/rollbackDeployment.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { mockRollbackDeployment, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+setupMockConfig()
+
+describe("rollbackDeployment", () => {
+  it("should disable active deployment", async () => {
+    const mock = mockRollbackDeployment(server, {})
+
+    await rollbackDeployment()
+
+    expect(mock.invocations).toHaveLength(1)
+  })
+
+  it("should throw an error when server returns error", async () => {
+    mockRollbackDeployment(server, { error: { status: 500, message: "Server Error" } })
+
+    await expect(rollbackDeployment()).rejects.toThrow()
+  })
+
+  it("should handle 404 when no active deployment exists", async () => {
+    mockRollbackDeployment(server, { error: { status: 404, message: "Not Found" } })
+
+    await expect(rollbackDeployment()).rejects.toThrow()
+  })
+})

package/test/api/deployments/updateDeployment.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest"
+
+import { updateDeployment } from "#api/deployments/updateDeployment.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { mockUpdateDeployment, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+setupMockConfig()
+
+describe("updateDeployment", () => {
+  it("should redeploy a deployment by ID", async () => {
+    const mock = mockUpdateDeployment(server, { deploymentId: "1763737018" })
+
+    await updateDeployment("1763737018")
+
+    expect(mock.invocations).toHaveLength(1)
+  })
+
+  it("should throw an error when server returns error", async () => {
+    mockUpdateDeployment(server, { deploymentId: "1763737018", error: { status: 500, message: "Server Error" } })
+
+    await expect(updateDeployment("1763737018")).rejects.toThrow()
+  })
+
+  it("should handle different deployment IDs", async () => {
+    const mock = mockUpdateDeployment(server, { deploymentId: "9999999999" })
+
+    await updateDeployment("9999999999")
+
+    expect(mock.invocations).toHaveLength(1)
+  })
+})

package/test/commander.test.ts

@@ -2,6 +2,10 @@ import { beforeEach, describe, expect, it, MockInstance, vi } from "vitest"
 
 import { clearCachedConfig, getCachedConfig } from "#config/config.ts"
 import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
+import * as deployModule from "#modules/deployments/deploy.ts"
+import * as listModule from "#modules/deployments/list.ts"
+import * as redeployModule from "#modules/deployments/redeploy.ts"
+import * as rollbackModule from "#modules/deployments/rollback.ts"
 import * as login from "#modules/login.ts"
 import * as logout from "#modules/logout.ts"
 import * as build from "#modules/search-templates/build.ts"
@@ -25,6 +29,10 @@ let buildSpy: MockInstance
 let pullSpy: MockInstance
 let pushSpy: MockInstance
 let devSpy: MockInstance
+let deploymentsListSpy: MockInstance
+let deploymentsDeploySpy: MockInstance
+let deploymentsRedeploySpy: MockInstance
+let deploymentsRollbackSpy: MockInstance
 
 describe("commander", () => {
   beforeEach(() => {
@@ -36,6 +44,10 @@ describe("commander", () => {
     pullSpy = vi.spyOn(pull, "pullSearchTemplate").mockImplementation(() => Promise.resolve())
     pushSpy = vi.spyOn(push, "pushSearchTemplate").mockImplementation(() => Promise.resolve())
     devSpy = vi.spyOn(dev, "searchTemplateDevMode").mockImplementation(() => Promise.resolve())
+    deploymentsListSpy = vi.spyOn(listModule, "deploymentsList").mockImplementation(() => Promise.resolve())
+    deploymentsDeploySpy = vi.spyOn(deployModule, "deploymentsDeploy").mockImplementation(() => Promise.resolve())
+    deploymentsRedeploySpy = vi.spyOn(redeployModule, "deploymentsRedeploy").mockImplementation(() => Promise.resolve())
+    deploymentsRollbackSpy = vi.spyOn(rollbackModule, "deploymentsRollback").mockImplementation(() => Promise.resolve())
     clearCachedConfig()
     fs.mockUserAuthentication()
   })
@@ -133,6 +145,134 @@ describe("commander", () => {
     })
   })
 
+  describe("nosto deployments list", () => {
+    beforeEach(() => {
+      fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+    })
+
+    it("should call the function", async () => {
+      await commander.run("nosto dp list")
+      expect(deploymentsListSpy).toHaveBeenCalled()
+    })
+
+    it("should work with alias", async () => {
+      await commander.run("nosto deployments list")
+      expect(deploymentsListSpy).toHaveBeenCalled()
+    })
+
+    it("should rethrow errors", async () => {
+      vi.spyOn(listModule, "deploymentsList").mockImplementation(() => {
+        throw new Error("Unknown error")
+      })
+
+      await commander.expect("nosto dp list").toThrow()
+    })
+  })
+
+  describe("nosto deployments deploy", () => {
+    beforeEach(() => {
+      fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+    })
+
+    it("should call the function with default options", async () => {
+      await commander.run("nosto dp deploy")
+      expect(deploymentsDeploySpy).toHaveBeenCalledWith({
+        description: undefined,
+        force: false
+      })
+    })
+
+    it("should call the function with description", async () => {
+      await commander.run("nosto dp deploy -d test-deployment")
+      expect(deploymentsDeploySpy).toHaveBeenCalledWith({
+        description: "test-deployment",
+        force: false
+      })
+    })
+
+    it("should call the function with force flag", async () => {
+      await commander.run("nosto dp deploy --force")
+      expect(deploymentsDeploySpy).toHaveBeenCalledWith({
+        description: undefined,
+        force: true
+      })
+    })
+
+    it("should rethrow errors", async () => {
+      vi.spyOn(deployModule, "deploymentsDeploy").mockImplementation(() => {
+        throw new Error("Unknown error")
+      })
+
+      await commander.expect("nosto dp deploy").toThrow()
+    })
+  })
+
+  describe("nosto deployments redeploy", () => {
+    beforeEach(() => {
+      fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+    })
+
+    it("should call the function with default options", async () => {
+      await commander.run("nosto dp redeploy")
+      expect(deploymentsRedeploySpy).toHaveBeenCalledWith({
+        deploymentId: undefined,
+        force: false
+      })
+    })
+
+    it("should call the function with deployment ID", async () => {
+      await commander.run("nosto dp redeploy -i deployment-123")
+      expect(deploymentsRedeploySpy).toHaveBeenCalledWith({
+        deploymentId: "deployment-123",
+        force: false
+      })
+    })
+
+    it("should call the function with force flag", async () => {
+      await commander.run("nosto dp redeploy --force")
+      expect(deploymentsRedeploySpy).toHaveBeenCalledWith({
+        deploymentId: undefined,
+        force: true
+      })
+    })
+
+    it("should rethrow errors", async () => {
+      vi.spyOn(redeployModule, "deploymentsRedeploy").mockImplementation(() => {
+        throw new Error("Unknown error")
+      })
+
+      await commander.expect("nosto dp redeploy").toThrow()
+    })
+  })
+
+  describe("nosto deployments disable", () => {
+    beforeEach(() => {
+      fs.writeFile(".nosto.json", JSON.stringify({ apiKey: "123", merchant: "456" }))
+    })
+
+    it("should call the function with default options", async () => {
+      await commander.run("nosto dp disable")
+      expect(deploymentsRollbackSpy).toHaveBeenCalledWith({
+        force: false
+      })
+    })
+
+    it("should call the function with force flag", async () => {
+      await commander.run("nosto dp disable --force")
+      expect(deploymentsRollbackSpy).toHaveBeenCalledWith({
+        force: true
+      })
+    })
+
+    it("should rethrow errors", async () => {
+      vi.spyOn(rollbackModule, "deploymentsRollback").mockImplementation(() => {
+        throw new Error("Unknown error")
+      })
+
+      await commander.expect("nosto dp disable").toThrow()
+    })
+  })
+
   describe("nosto search-templates build", () => {
     it("should fail sanity check", async () => {
       await commander.run("nosto st build")
@@ -150,6 +290,21 @@ describe("commander", () => {
         expect(buildSpy).toHaveBeenCalledWith({ watch: false, push: false })
       })
 
+      it("should call the function with watch flag", async () => {
+        await commander.run("nosto st build --watch")
+        expect(buildSpy).toHaveBeenCalledWith({ watch: true, push: false })
+      })
+
+      it("should call the function with push flag", async () => {
+        await commander.run("nosto st build --push")
+        expect(buildSpy).toHaveBeenCalledWith({ watch: false, push: true })
+      })
+
+      it("should call the function with both watch and push flags", async () => {
+        await commander.run("nosto st build -w -p")
+        expect(buildSpy).toHaveBeenCalledWith({ watch: true, push: true })
+      })
+
       it("should rethrow errors", async () => {
         vi.spyOn(build, "buildSearchTemplate").mockImplementation(() => {
           throw new Error("Unknown error")

package/test/modules/deployments/deploy.test.ts

@@ -0,0 +1,200 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import * as calculateTreeHashModule from "#filesystem/calculateTreeHash.ts"
+import { deploymentsDeploy } from "#modules/deployments/deploy.ts"
+import { setupMockConfig } from "#test/utils/mockConfig.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+import { setupMockFileSystem } from "#test/utils/mockFileSystem.ts"
+import { mockCreateDeployment, mockFetchSourceFile, setupMockServer } from "#test/utils/mockServer.ts"
+
+const server = setupMockServer()
+const terminal = setupMockConsole()
+const fs = setupMockFileSystem()
+setupMockConfig()
+
+describe("deploymentsDeploy", () => {
+  beforeEach(() => {
+    vi.spyOn(calculateTreeHashModule, "calculateTreeHash").mockReturnValue("abcd1234")
+  })
+
+  it("should deploy when hashes match", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "abcd1234")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: true })
+
+    expect(mock.invocations).toHaveLength(1)
+    expect(mock.invocations[0]).toEqual({ description: "Test deployment" })
+    expect(terminal.getSpy("success")).toHaveBeenCalledWith("Deployment created successfully!")
+  })
+
+  it("should show error when no remote files exist", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", error: { status: 404, message: "Not Found" } })
+
+    await deploymentsDeploy({ description: "Test deployment", force: true })
+
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith(
+      "No files found in remote. Please run 'st build --push' first to push your build."
+    )
+  })
+
+  it("should prompt for description when not provided", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "abcd1234")
+    terminal.setUserResponse("My deployment description")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ force: true })
+
+    expect(mock.invocations).toHaveLength(1)
+    expect(mock.invocations[0]).toEqual({ description: "My deployment description" })
+  })
+
+  it("should cancel when empty description provided", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "abcd1234")
+    terminal.setUserResponse("")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ force: true })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith(
+      "Description must be alphanumeric and between 1 and 200 characters."
+    )
+  })
+
+  it("should warn and prompt when local hash doesn't match remote", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "efgh5678", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "efgh5678")
+    terminal.setUserResponse("y")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith("Local files don't match remote.")
+    expect(mock.invocations).toHaveLength(1)
+  })
+
+  it("should cancel deployment when user declines hash mismatch", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "efgh5678", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "efgh5678")
+    terminal.setUserResponse("n")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Deployment cancelled by user.")
+  })
+
+  it("should warn when remote changed since last sync", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "different_hash")
+    terminal.setUserResponse("y")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith("Remote files have changed since your last sync.")
+    expect(mock.invocations).toHaveLength(1)
+  })
+
+  it("should cancel when user declines remote changes prompt", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "different_hash")
+    terminal.setUserResponse("n")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Deployment cancelled by user.")
+  })
+
+  it("should update cache hash after successful deployment", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "old_hash")
+    mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: true })
+
+    fs.expectFile(".nostocache/hash").toContain("abcd1234")
+  })
+
+  it("should prompt for final confirmation when not forced", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "abcd1234")
+    terminal.setUserResponse("y")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(mock.invocations).toHaveLength(1)
+    terminal.expect.user.toHaveBeenPromptedWith(
+      'You are about to create a deployment with description: "Test deployment". Continue? (y/N):'
+    )
+  })
+
+  it("should cancel deployment when user declines final confirmation", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "abcd1234")
+    terminal.setUserResponse("n")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Deployment cancelled by user.")
+  })
+
+  it("should reject description with special characters", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "abcd1234")
+    terminal.setUserResponse("test@deployment#123")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ force: true })
+
+    expect(mock.invocations).toHaveLength(0)
+    expect(terminal.getSpy("error")).toHaveBeenCalledWith(
+      "Description must be alphanumeric and between 1 and 200 characters."
+    )
+  })
+
+  it("should handle both hash mismatch and remote changes warnings", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "efgh5678", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "different_hash")
+    terminal.setUserResponse("y")
+    const mock = mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith("Local files don't match remote.")
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith("Remote files have changed since your last sync.")
+    expect(mock.invocations).toHaveLength(1)
+  })
+
+  it("should display deployment info messages", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "abcd1234", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "abcd1234")
+    mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: true })
+
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith("Creating deployment from remote 'build' path...")
+    expect(terminal.getSpy("info")).toHaveBeenCalledWith(expect.stringContaining('Description: "Test deployment"'))
+  })
+
+  it("should suggest running st push when local hash mismatch", async () => {
+    mockFetchSourceFile(server, { path: "build/hash", response: "efgh5678", contentType: "raw" })
+    fs.writeFile(".nostocache/hash", "efgh5678")
+    terminal.setUserResponse("n")
+    mockCreateDeployment(server, { path: "build" })
+
+    await deploymentsDeploy({ description: "Test deployment", force: false })
+
+    expect(terminal.getSpy("warn")).toHaveBeenCalledWith(expect.stringContaining("st push"))
+  })
+})