package instance_test

import (

"time"

"github.com/cloudfoundry/bosh-agent/v2/agentclient"

bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec"

bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud"

bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk"

"github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes"

. "github.com/cloudfoundry/bosh-cli/v7/deployment/instance"

"github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes"

bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest"

"github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/sshtunnelfakes"

"github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes"

fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes"

bosherr "github.com/cloudfoundry/bosh-utils/errors"

"github.com/cloudfoundry/bosh-utils/logger/loggerfakes"

. "github.com/onsi/ginkgo/v2"

. "github.com/onsi/gomega"

)

var _ = Describe("Instance", func() {

var (

mockStateBuilder *statefakes.FakeBuilder

mockState *statefakes.FakeState

fakeVMManager *vmfakes.FakeManager

fakeVM *vmfakes.FakeVM

fakeSSHTunnelFactory *sshtunnelfakes.FakeFactory

fakeSSHTunnel *sshtunnelfakes.FakeSSHTunnel

fakeStage *fakebiui.FakeStage

logger *loggerfakes.FakeLogger

instance Instance

pingTimeout = 1 * time.Second

pingDelay = 500 * time.Millisecond

skipDrain bool

jobName = "fake-job-name"

jobIndex = 0

)

BeforeEach(func() {

fakeVMManager = &vmfakes.FakeManager{}

fakeVM = &vmfakes.FakeVM{

CIDStub: func() string { return "fake-vm-cid" },

ExistsStub: func() (bool, error) { return true, nil },

}

fakeSSHTunnel = &sshtunnelfakes.FakeSSHTunnel{

StartStub: func(readyErrCh chan<- error, errCh chan<- error) {

readyErrCh <- nil

errCh <- nil

},

}

fakeSSHTunnelFactory = &sshtunnelfakes.FakeFactory{}

fakeSSHTunnelFactory.NewSSHTunnelReturns(fakeSSHTunnel)

mockStateBuilder = &statefakes.FakeBuilder{}

mockState = &statefakes.FakeState{}

logger = &loggerfakes.FakeLogger{}

skipDrain = false

instance = NewInstance(

jobName,

jobIndex,

fakeVM,

fakeVMManager,

fakeSSHTunnelFactory,

mockStateBuilder,

logger,

)

fakeStage = fakebiui.NewFakeStage()

})

Describe("Delete", func() {

It("checks if the agent on the vm is responsive", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0)

Expect(timeout).To(Equal(pingTimeout))

Expect(delay).To(Equal(pingDelay))

})

It("deletes existing vm", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeVM.DeleteCallCount()).To(Equal(1))

})

It("logs start and stop events", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Waiting for the agent on VM 'fake-vm-cid'"},

{Name: "Running the pre-stop scripts 'fake-job-name/0'"},

{Name: "Draining jobs on instance 'fake-job-name/0'"},

{Name: "Stopping jobs on instance 'fake-job-name/0'"},

{Name: "Running the post-stop scripts 'fake-job-name/0'"},

{Name: "Deleting VM 'fake-vm-cid'"},

}))

})

Context("when agent is responsive", func() {

It("logs waiting for the agent event", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeStage.PerformCalls[0]).To(Equal(&fakebiui.PerformCall{

Name: "Waiting for the agent on VM 'fake-vm-cid'",

}))

})

It("drains", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.DrainCallCount()).To(Equal(1))

})

It("can skip draining", func() {

skipDrain = true

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.DrainCallCount()).To(Equal(0))

})

It("stops vm", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.StopCallCount()).To(Equal(1))

})

It("unmounts vm disks", func() {

firstDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-1" }}

secondDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-2" }}

fakeVM.DisksReturns([]bidisk.Disk{firstDisk, secondDisk}, nil)

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.UnmountDiskArgsForCall(0)).To(Equal(firstDisk))

Expect(fakeVM.UnmountDiskArgsForCall(1)).To(Equal(secondDisk))

Expect(fakeStage.PerformCalls[5:7]).To(Equal([]*fakebiui.PerformCall{

{Name: "Unmounting disk 'fake-disk-1'"},

{Name: "Unmounting disk 'fake-disk-2'"},

}))

})

Context("when stopping vm fails", func() {

var (

stopError = bosherr.Error("fake-stop-error")

)

BeforeEach(func() {

fakeVM.StopReturns(stopError)

})

It("returns an error", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-stop-error"))

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Waiting for the agent on VM 'fake-vm-cid'"},

{Name: "Running the pre-stop scripts 'fake-job-name/0'"},

{Name: "Draining jobs on instance 'fake-job-name/0'"},

{

Name: "Stopping jobs on instance 'fake-job-name/0'",

Error: stopError,

},

}))

})

})

Context("when unmounting disk fails", func() {

BeforeEach(func() {

fakeVM.DisksReturns([]bidisk.Disk{&diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk" }}}, nil)

fakeVM.UnmountDiskReturns(bosherr.Error("fake-unmount-error"))

})

It("returns an error", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-unmount-error"))

Expect(fakeStage.PerformCalls[5].Name).To(Equal("Unmounting disk 'fake-disk'"))

Expect(fakeStage.PerformCalls[5].Error).To(HaveOccurred())

Expect(fakeStage.PerformCalls[5].Error.Error()).To(Equal("Unmounting disk 'fake-disk' from VM 'fake-vm-cid': fake-unmount-error"))

})

})

})

Context("when agent fails to respond", func() {

BeforeEach(func() {

fakeVM.WaitUntilReadyReturns(bosherr.Error("fake-wait-error"))

})

It("logs failed event", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Name).To(Equal("Waiting for the agent on VM 'fake-vm-cid'"))

Expect(fakeStage.PerformCalls[0].Error).To(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Error.Error()).To(Equal("Agent unreachable: fake-wait-error"))

})

})

Context("when deleting VM fails", func() {

var (

deleteError = bosherr.Error("fake-delete-error")

)

BeforeEach(func() {

fakeVM.DeleteReturns(deleteError)

})

It("returns an error", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-delete-error"))

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Waiting for the agent on VM 'fake-vm-cid'"},

{Name: "Running the pre-stop scripts 'fake-job-name/0'"},

{Name: "Draining jobs on instance 'fake-job-name/0'"},

{Name: "Stopping jobs on instance 'fake-job-name/0'"},

{Name: "Running the post-stop scripts 'fake-job-name/0'"},

{

Name: "Deleting VM 'fake-vm-cid'",

Error: deleteError,

},

}))

})

})

Context("when VM does not exist (deleted manually)", func() {

BeforeEach(func() {

fakeVM.ExistsReturns(false, nil)

fakeVM.DeleteReturns(bicloud.NewCPIError("delete_vm", bicloud.CmdError{

Type: bicloud.VMNotFoundError,

Message: "fake-vm-not-found-message",

}))

})

It("deletes existing vm", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeVM.DeleteCallCount()).To(Equal(1))

})

It("does not contact the agent", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeVM.WaitUntilReadyCallCount()).To(Equal(0))

Expect(fakeVM.StopCallCount()).To(Equal(0))

Expect(fakeVM.UnmountDiskCallCount()).To(Equal(0))

})

It("logs vm delete as skipped", func() {

err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Name).To(Equal("Deleting VM 'fake-vm-cid'"))

Expect(fakeStage.PerformCalls[0].SkipError.Error()).To(Equal("VM not found: CPI 'delete_vm' method responded with error: CmdError{\"type\":\"Bosh::Clouds::VMNotFound\",\"message\":\"fake-vm-not-found-message\",\"ok_to_retry\":false}"))

})

})

})

Describe("UpdateJobs", func() {

var (

deploymentManifest bideplmanifest.Manifest

applySpec bias.ApplySpec

)

BeforeEach(func() {

// manifest is only being used for the Update.UpdateWatchTime, otherwise it's just being passed through to the StateBuilder

deploymentManifest = bideplmanifest.Manifest{

Name: "fake-deployment-name",

Update: bideplmanifest.Update{

UpdateWatchTime: bideplmanifest.WatchTime{

Start: 0,

End: 5478,

},

},

}

// apply spec is just returned from instance.State.ToApplySpec() and passed to agentClient.Apply()

applySpec = bias.ApplySpec{

Deployment: "fake-deployment-name",

}

})

JustBeforeEach(func() {

fakeAgentState := agentclient.AgentState{JobState: "testing"}

fakeVM.GetStateReturns(fakeAgentState, nil)

mockStateBuilder.BuildReturns(mockState, nil)

mockStateBuilder.BuildInitialStateReturns(mockState, nil)

mockState.ToApplySpecReturns(applySpec)

})

It("builds a new instance state", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(mockStateBuilder.BuildCallCount()).To(Equal(1))

buildJobName, buildJobIndex, buildManifest, buildStage, buildAgentState := mockStateBuilder.BuildArgsForCall(0)

Expect(buildJobName).To(Equal(jobName))

Expect(buildJobIndex).To(Equal(jobIndex))

Expect(buildManifest).To(Equal(deploymentManifest))

Expect(buildStage).To(Equal(fakeStage))

Expect(buildAgentState).To(Equal(agentclient.AgentState{JobState: "testing"}))

Expect(mockStateBuilder.BuildInitialStateCallCount()).To(Equal(1))

initJobName, initJobIndex, initManifest := mockStateBuilder.BuildInitialStateArgsForCall(0)

Expect(initJobName).To(Equal(jobName))

Expect(initJobIndex).To(Equal(jobIndex))

Expect(initManifest).To(Equal(deploymentManifest))

})

It("tells agent to stop jobs, apply a new spec (with new rendered jobs templates), and start jobs", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeVM.StopCallCount()).To(Equal(1))

Expect(fakeVM.ApplyArgsForCall(0)).To(Equal(applySpec))

Expect(fakeVM.ApplyArgsForCall(1)).To(Equal(applySpec))

script1, _ := fakeVM.RunScriptArgsForCall(0)

Expect(script1).To(Equal("pre-start"))

script2, _ := fakeVM.RunScriptArgsForCall(1)

Expect(script2).To(Equal("post-start"))

Expect(fakeVM.StartCallCount()).To(Equal(1))

})

It("waits until agent reports state as running", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).NotTo(HaveOccurred())

maxAttempts, delay := fakeVM.WaitToBeRunningArgsForCall(0)

Expect(maxAttempts).To(Equal(5))

Expect(delay).To(Equal(1 * time.Second))

})

It("logs start and stop events to the eventLogger", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Updating instance 'fake-job-name/0'"},

{Name: "Waiting for instance 'fake-job-name/0' to be running"},

{Name: "Running the post-start scripts 'fake-job-name/0'"},

}))

})

Context("when instance state building fails", func() {

JustBeforeEach(func() {

mockStateBuilder.BuildReturns(nil, bosherr.Error("fake-template-err"))

})

It("returns an error", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-template-err"))

})

})

Context("when stopping vm fails", func() {

BeforeEach(func() {

fakeVM.StopReturns(bosherr.Error("fake-stop-error"))

})

It("logs start and stop events to the eventLogger", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-stop-error"))

Expect(fakeStage.PerformCalls[0].Name).To(Equal("Updating instance 'fake-job-name/0'"))

Expect(fakeStage.PerformCalls[0].Error).To(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Error.Error()).To(Equal("Stopping the agent: fake-stop-error"))

})

})

Context("when applying a new vm state fails", func() {

BeforeEach(func() {

fakeVM.ApplyReturns(bosherr.Error("fake-apply-error"))

})

It("fails with descriptive error", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("Applying the initial agent state: fake-apply-error"))

})

})

Context("when running the pre-start script fails", func() {

BeforeEach(func() {

fakeVM.RunScriptStub = func(script string, _ map[string]interface{}) error {

switch script {

case "pre-start":

return bosherr.Error("fake-run-script-error")

default:

return nil

}

}

})

It("returns the error", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-run-script-error"))

})

})

Context("when running the post-start script fails", func() {

BeforeEach(func() {

fakeVM.RunScriptStub = func(script string, _ map[string]interface{}) error {

switch script {

case "post-start":

return bosherr.Error("fake-run-script-error-poststart")

default:

return nil

}

}

})

It("returns the error", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-run-script-error-poststart"))

})

})

Context("when starting vm fails", func() {

BeforeEach(func() {

fakeVM.StartReturns(bosherr.Error("fake-start-error"))

})

It("logs start and stop events to the eventLogger", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-start-error"))

Expect(fakeStage.PerformCalls[0].Name).To(Equal("Updating instance 'fake-job-name/0'"))

Expect(fakeStage.PerformCalls[0].Error).To(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Error.Error()).To(Equal("Starting the agent: fake-start-error"))

})

})

Context("when waiting for running state fails", func() {

var (

waitError = bosherr.Error("fake-wait-running-error")

)

BeforeEach(func() {

fakeVM.WaitToBeRunningReturns(waitError)

})

It("logs instance update stages", func() {

err := instance.UpdateJobs(deploymentManifest, fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-wait-running-error"))

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Updating instance 'fake-job-name/0'"},

{

Name: "Waiting for instance 'fake-job-name/0' to be running",

Error: waitError,

},

}))

})

})

})

Describe("WaitUntilReady", func() {

It("waits for the vm", func() {

err := instance.WaitUntilReady(fakeStage)

Expect(err).NotTo(HaveOccurred())

timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0)

Expect(timeout).To(Equal(10 * time.Minute))

Expect(delay).To(Equal(500 * time.Millisecond))

})

It("logs start and stop events to the eventLogger", func() {

err := instance.WaitUntilReady(fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Waiting for the agent on VM 'fake-vm-cid' to be ready"},

}))

})

Context("when waiting for the agent fails", func() {

var (

waitError = bosherr.Error("fake-wait-error")

)

BeforeEach(func() {

fakeVM.WaitUntilReadyReturns(waitError)

})

It("logs start and stop events to the eventLogger", func() {

err := instance.WaitUntilReady(fakeStage)

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("fake-wait-error"))

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{

Name: "Waiting for the agent on VM 'fake-vm-cid' to be ready",

Error: waitError,

},

}))

})

})

})

Describe("Stop", func() {

It("checks if the agent on the vm is responsive", func() {

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0)

Expect(timeout).To(Equal(pingTimeout))

Expect(delay).To(Equal(pingDelay))

})

It("logs start and stop events", func() {

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Waiting for the agent on VM 'fake-vm-cid'"},

{Name: "Running the pre-stop scripts 'fake-job-name/0'"},

{Name: "Draining jobs on instance 'fake-job-name/0'"},

{Name: "Stopping jobs on instance 'fake-job-name/0'"},

{Name: "Running the post-stop scripts 'fake-job-name/0'"},

}))

})

Context("when agent is responsive", func() {

It("logs waiting for the agent event", func() {

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeStage.PerformCalls[0]).To(Equal(&fakebiui.PerformCall{

Name: "Waiting for the agent on VM 'fake-vm-cid'",

}))

})

It("drains", func() {

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.DrainCallCount()).To(Equal(1))

})

It("can skip draining", func() {

skipDrain = true

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.DrainCallCount()).To(Equal(0))

})

It("stops all jobs", func() {

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.StopCallCount()).To(Equal(1))

})

It("does not unmount vm disks", func() {

firstDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-1" }}

secondDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-2" }}

fakeVM.DisksReturns([]bidisk.Disk{firstDisk, secondDisk}, nil)

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeVM.UnmountDiskCallCount()).To(Equal(0))

})

})

Context("when agent fails to respond", func() {

BeforeEach(func() {

fakeVM.WaitUntilReadyReturns(bosherr.Error("fake-wait-error"))

})

It("logs failed event", func() {

err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Name).To(Equal("Waiting for the agent on VM 'fake-vm-cid'"))

Expect(fakeStage.PerformCalls[0].Error).To(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Error.Error()).To(Equal("Agent unreachable: fake-wait-error"))

})

})

})

Describe("Start", func() {

var (

update bideplmanifest.Update

)

BeforeEach(func() {

update = bideplmanifest.Update{

UpdateWatchTime: bideplmanifest.WatchTime{

Start: 0,

End: 5478,

},

}

})

It("checks if the agent on the vm is responsive", func() {

err := instance.Start(update, pingTimeout, pingDelay, fakeStage)

Expect(err).NotTo(HaveOccurred())

timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0)

Expect(timeout).To(Equal(pingTimeout))

Expect(delay).To(Equal(pingDelay))

})

It("logs start and stop events", func() {

err := instance.Start(update, pingTimeout, pingDelay, fakeStage)

Expect(err).NotTo(HaveOccurred())

Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{

{Name: "Waiting for the agent on VM 'fake-vm-cid'"},

{Name: "Running the pre-start scripts 'fake-job-name/0'"},

{Name: "Starting the agent 'fake-job-name/0'"},

{Name: "Waiting for instance 'fake-job-name/0' to be running"},

{Name: "Running the post-start scripts 'fake-job-name/0'"},

}))

})

Context("when agent is responsive", func() {

It("logs waiting for the agent event", func() {

err := instance.Start(update, pingTimeout, pingDelay, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeStage.PerformCalls[0]).To(Equal(&fakebiui.PerformCall{

Name: "Waiting for the agent on VM 'fake-vm-cid'",

}))

})

It("waits until agent reports state as running", func() {

err := instance.Start(update, pingTimeout, pingDelay, fakeStage)

Expect(err).NotTo(HaveOccurred())

maxAttempts, delay := fakeVM.WaitToBeRunningArgsForCall(0)

Expect(maxAttempts).To(Equal(5))

Expect(delay).To(Equal(1 * time.Second))

})

})

Context("when agent fails to respond", func() {

BeforeEach(func() {

fakeVM.WaitUntilReadyReturns(bosherr.Error("fake-wait-error"))

})

It("logs failed event", func() {

err := instance.Start(update, pingTimeout, pingDelay, fakeStage)

Expect(err).ToNot(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Name).To(Equal("Waiting for the agent on VM 'fake-vm-cid'"))

Expect(fakeStage.PerformCalls[0].Error).To(HaveOccurred())

Expect(fakeStage.PerformCalls[0].Error.Error()).To(Equal("Agent unreachable: fake-wait-error"))

})

})

})

})