func init() {
Describe("Testing with Ginkgo", func() {
It("migrate disk should be asynchronous", func() {
_, action := buildMigrateDiskAction()
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
_, action := buildMigrateDiskAction()
Expect(action.IsPersistent()).To(BeFalse())
})
It("migrate disk action run", func() {
platform, action := buildMigrateDiskAction()
value, err := action.Run()
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), value, "{}")
Expect(platform.MigratePersistentDiskFromMountPoint).To(Equal("/foo/store"))
Expect(platform.MigratePersistentDiskToMountPoint).To(Equal("/foo/store_migration_target"))
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
It("mount disk should be asynchronous", func() {
settings := &fakesettings.FakeSettingsService{}
_, action := buildMountDiskAction(settings)
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
settings := &fakesettings.FakeSettingsService{}
_, action := buildMountDiskAction(settings)
Expect(action.IsPersistent()).To(BeFalse())
})
It("mount disk", func() {
settings := &fakesettings.FakeSettingsService{}
settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
platform, mountDisk := buildMountDiskAction(settings)
result, err := mountDisk.Run("vol-123")
Expect(err).NotTo(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), result, "{}")
Expect(settings.SettingsWereLoaded).To(BeTrue())
Expect(platform.MountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
Expect(platform.MountPersistentDiskMountPoint).To(Equal("/foo/store"))
})
It("mount disk when store already mounted", func() {
settings := &fakesettings.FakeSettingsService{}
settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
platform, mountDisk := buildMountDiskAction(settings)
platform.IsMountPointResult = true
result, err := mountDisk.Run("vol-123")
Expect(err).NotTo(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), result, "{}")
Expect(platform.IsMountPointPath).To(Equal("/foo/store"))
Expect(platform.MountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
Expect(platform.MountPersistentDiskMountPoint).To(Equal("/foo/store_migration_target"))
})
It("mount disk when device path not found", func() {
settings := &fakesettings.FakeSettingsService{}
settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
_, mountDisk := buildMountDiskAction(settings)
_, err := mountDisk.Run("vol-456")
Expect(err).To(HaveOccurred())
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
It("ssh should be synchronous", func() {
settings := &fakesettings.FakeSettingsService{}
_, action := buildSshAction(settings)
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
settings := &fakesettings.FakeSettingsService{}
_, action := buildSshAction(settings)
Expect(action.IsPersistent()).To(BeFalse())
})
It("ssh setup without default ip", func() {
settings := &fakesettings.FakeSettingsService{}
_, action := buildSshAction(settings)
params := SshParams{
User: "******",
Password: "******",
PublicKey: "some-key",
}
_, err := action.Run("setup", params)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("No default ip"))
})
It("ssh setup with username and password", func() {
testSshSetupWithGivenPassword(GinkgoT(), "some-password")
})
It("ssh setup without password", func() {
testSshSetupWithGivenPassword(GinkgoT(), "")
})
It("ssh run cleanup deletes ephemeral user", func() {
settings := &fakesettings.FakeSettingsService{}
platform, action := buildSshAction(settings)
params := SshParams{UserRegex: "^foobar.*"}
response, err := action.Run("cleanup", params)
Expect(err).ToNot(HaveOccurred())
Expect("^foobar.*").To(Equal(platform.DeleteEphemeralUsersMatchingRegex))
boshassert.MatchesJsonMap(GinkgoT(), response, map[string]interface{}{
"command": "cleanup",
"status": "success",
})
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
It("unmount disk should be asynchronous", func() {
platform := fakeplatform.NewFakePlatform()
action := buildUnmountDiskAction(platform)
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
platform := fakeplatform.NewFakePlatform()
action := buildUnmountDiskAction(platform)
Expect(action.IsPersistent()).To(BeFalse())
})
It("unmount disk when the disk is mounted", func() {
platform := fakeplatform.NewFakePlatform()
platform.UnmountPersistentDiskDidUnmount = true
unmountDisk := buildUnmountDiskAction(platform)
result, err := unmountDisk.Run("vol-123")
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), result, `{"message":"Unmounted partition of /dev/sdf"}`)
Expect(platform.UnmountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
})
It("unmount disk when the disk is not mounted", func() {
platform := fakeplatform.NewFakePlatform()
platform.UnmountPersistentDiskDidUnmount = false
mountDisk := buildUnmountDiskAction(platform)
result, err := mountDisk.Run("vol-123")
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), result, `{"message":"Partition of /dev/sdf is not mounted"}`)
Expect(platform.UnmountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
})
It("unmount disk when device path not found", func() {
platform := fakeplatform.NewFakePlatform()
mountDisk := buildUnmountDiskAction(platform)
_, err := mountDisk.Run("vol-456")
Expect(err).To(HaveOccurred())
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
It("logs should be asynchronous", func() {
_, action := buildLogsAction()
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
_, action := buildLogsAction()
Expect(action.IsPersistent()).To(BeFalse())
})
It("logs errs if given invalid log type", func() {
_, action := buildLogsAction()
_, err := action.Run("other-logs", []string{})
Expect(err).To(HaveOccurred())
})
It("agent logs with filters", func() {
filters := []string{"**/*.stdout.log", "**/*.stderr.log"}
expectedFilters := []string{"**/*.stdout.log", "**/*.stderr.log"}
testLogs(GinkgoT(), "agent", filters, expectedFilters)
})
It("agent logs without filters", func() {
filters := []string{}
expectedFilters := []string{"**/*"}
testLogs(GinkgoT(), "agent", filters, expectedFilters)
})
It("job logs without filters", func() {
filters := []string{}
expectedFilters := []string{"**/*.log"}
testLogs(GinkgoT(), "job", filters, expectedFilters)
})
It("job logs with filters", func() {
filters := []string{"**/*.stdout.log", "**/*.stderr.log"}
expectedFilters := []string{"**/*.stdout.log", "**/*.stderr.log"}
testLogs(GinkgoT(), "job", filters, expectedFilters)
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
var (
logger boshlog.Logger
platform *fakeplatform.FakePlatform
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LEVEL_NONE)
})
It("list disk should be synchronous", func() {
settings := &fakesettings.FakeSettingsService{}
action := NewListDisk(settings, platform, logger)
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
settings := &fakesettings.FakeSettingsService{}
action := NewListDisk(settings, platform, logger)
Expect(action.IsPersistent()).To(BeFalse())
})
It("list disk run", func() {
settings := &fakesettings.FakeSettingsService{
Disks: boshsettings.Disks{
Persistent: map[string]string{
"volume-1": "/dev/sda",
"volume-2": "/dev/sdb",
"volume-3": "/dev/sdc",
},
},
}
platform.MountedDevicePaths = []string{"/dev/sdb", "/dev/sdc"}
action := NewListDisk(settings, platform, logger)
value, err := action.Run()
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJsonString(GinkgoT(), value, `["volume-2","volume-3"]`)
})
})
}
func init() {
Describe("Ping", func() {
It("is synchronous", func() {
action := NewPing()
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
action := NewPing()
Expect(action.IsPersistent()).To(BeFalse())
})
It("ping run returns pong", func() {
action := NewPing()
pong, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(pong).To(Equal("pong"))
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
It("apply should be asynchronous", func() {
_, _, action := buildApplyAction()
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
_, _, action := buildApplyAction()
Expect(action.IsPersistent()).To(BeFalse())
})
It("apply returns applied", func() {
_, _, action := buildApplyAction()
applySpec := boshas.V1ApplySpec{
ConfigurationHash: "fake-config-hash",
}
value, err := action.Run(applySpec)
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJsonString(GinkgoT(), value, `"applied"`)
})
It("apply run saves the first argument to spec json", func() {
_, specService, action := buildApplyAction()
applySpec := boshas.V1ApplySpec{
ConfigurationHash: "fake-config-hash",
}
_, err := action.Run(applySpec)
Expect(err).ToNot(HaveOccurred())
Expect(applySpec).To(Equal(specService.Spec))
})
It("apply run skips applier when apply spec does not have configuration hash", func() {
applier, _, action := buildApplyAction()
applySpec := boshas.V1ApplySpec{
JobSpec: boshas.JobSpec{
Template: "fake-job-template",
},
}
_, err := action.Run(applySpec)
Expect(err).ToNot(HaveOccurred())
Expect(applier.Applied).To(BeFalse())
})
It("apply run runs applier with apply spec when apply spec has configuration hash", func() {
applier, _, action := buildApplyAction()
expectedApplySpec := boshas.V1ApplySpec{
JobSpec: boshas.JobSpec{
Template: "fake-job-template",
},
ConfigurationHash: "fake-config-hash",
}
_, err := action.Run(expectedApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(applier.Applied).To(BeTrue())
Expect(expectedApplySpec).To(Equal(applier.ApplyApplySpec))
})
It("apply run errs when applier fails", func() {
applier, _, action := buildApplyAction()
applier.ApplyError = errors.New("fake-apply-error")
_, err := action.Run(boshas.V1ApplySpec{ConfigurationHash: "fake-config-hash"})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-error"))
})
})
}
func init() {
Describe("GetState", func() {
It("get state should be synchronous", func() {
settings := &fakesettings.FakeSettingsService{}
_, _, _, action := buildGetStateAction(settings)
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
settings := &fakesettings.FakeSettingsService{}
_, _, _, action := buildGetStateAction(settings)
Expect(action.IsPersistent()).To(BeFalse())
})
Describe("Run", func() {
It("returns state", func() {
settings := &fakesettings.FakeSettingsService{}
settings.AgentID = "my-agent-id"
settings.VM.Name = "vm-abc-def"
specService, jobSupervisor, _, action := buildGetStateAction(settings)
jobSupervisor.StatusStatus = "running"
specService.Spec = boshas.V1ApplySpec{
Deployment: "fake-deployment",
}
expectedSpec := GetStateV1ApplySpec{
AgentID: "my-agent-id",
JobState: "running",
BoshProtocol: "1",
VM: boshsettings.VM{Name: "vm-abc-def"},
Ntp: boshntp.NTPInfo{
Offset: "0.34958",
Timestamp: "12 Oct 17:37:58",
},
}
expectedSpec.Deployment = "fake-deployment"
state, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(state.AgentID).To(Equal(expectedSpec.AgentID))
Expect(state.JobState).To(Equal(expectedSpec.JobState))
Expect(state.Deployment).To(Equal(expectedSpec.Deployment))
boshassert.LacksJSONKey(GinkgoT(), state, "vitals")
Expect(state).To(Equal(expectedSpec))
})
It("returns state in full format", func() {
settings := &fakesettings.FakeSettingsService{}
settings.AgentID = "my-agent-id"
settings.VM.Name = "vm-abc-def"
specService, jobSupervisor, fakeVitals, action := buildGetStateAction(settings)
jobSupervisor.StatusStatus = "running"
specService.Spec = boshas.V1ApplySpec{
Deployment: "fake-deployment",
}
expectedVitals := boshvitals.Vitals{
Load: []string{"foo", "bar", "baz"},
}
fakeVitals.GetVitals = expectedVitals
expectedVM := map[string]interface{}{"name": "vm-abc-def"}
state, err := action.Run("full")
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), state.AgentID, `"my-agent-id"`)
boshassert.MatchesJSONString(GinkgoT(), state.JobState, `"running"`)
boshassert.MatchesJSONString(GinkgoT(), state.Deployment, `"fake-deployment"`)
Expect(*state.Vitals).To(Equal(expectedVitals))
boshassert.MatchesJSONMap(GinkgoT(), state.VM, expectedVM)
})
Context("when current cannot be retrieved", func() {
It("without current spec", func() {
settings := &fakesettings.FakeSettingsService{}
specService, _, _, action := buildGetStateAction(settings)
specService.GetErr = errors.New("fake-spec-get-error")
_, err := action.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-spec-get-error"))
})
})
Context("when vitals cannot be retrieved", func() {
It("returns error", func() {
settings := &fakesettings.FakeSettingsService{}
_, _, fakeVitals, action := buildGetStateAction(settings)
fakeVitals.GetErr = errors.New("fake-vitals-get-error")
_, err := action.Run("full")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-vitals-get-error"))
})
})
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
It("compile package should be asynchronous", func() {
_, action := buildCompilePackageAction()
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
_, action := buildCompilePackageAction()
Expect(action.IsPersistent()).To(BeFalse())
})
It("compile package compiles the package abd returns blob id", func() {
compiler, action := buildCompilePackageAction()
compiler.CompileBlobID = "my-blob-id"
compiler.CompileSha1 = "some sha1"
blobID, sha1, name, version, deps := getCompileActionArguments()
expectedPkg := boshcomp.Package{
BlobstoreID: blobID,
Sha1: sha1,
Name: name,
Version: version,
}
expectedJSON := map[string]interface{}{
"result": map[string]string{
"blobstore_id": "my-blob-id",
"sha1": "some sha1",
},
}
expectedDeps := []boshmodels.Package{
{
Name: "first_dep",
Version: "first_dep_version",
Source: boshmodels.Source{
Sha1: "first_dep_sha1",
BlobstoreID: "first_dep_blobstore_id",
},
},
{
Name: "sec_dep",
Version: "sec_dep_version",
Source: boshmodels.Source{
Sha1: "sec_dep_sha1",
BlobstoreID: "sec_dep_blobstore_id",
},
},
}
val, err := action.Run(blobID, sha1, name, version, deps)
Expect(err).ToNot(HaveOccurred())
Expect(expectedPkg).To(Equal(compiler.CompilePkg))
Expect(expectedDeps).To(Equal(compiler.CompileDeps))
boshassert.MatchesJSONMap(GinkgoT(), val, expectedJSON)
})
It("compile package errs when compile fails", func() {
compiler, action := buildCompilePackageAction()
compiler.CompileErr = errors.New("fake-compile-error")
blobID, sha1, name, version, deps := getCompileActionArguments()
_, err := action.Run(blobID, sha1, name, version, deps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-compile-error"))
})
})
}