})
})
Context("without a host public key available", func() {
BeforeEach(func() {
platformPublicKeyErr = errors.New("Get Host Public Key Failure")
})
It("should return an error", func() {
Expect(response).To(Equal(SSHResult{}))
Expect(err).ToNot(BeNil())
})
})
})
Context("cleanupSSH", func() {
It("should delete ephemeral user", func() {
response, err := action.Run("cleanup", SSHParams{UserRegex: "^foobar.*"})
Expect(err).ToNot(HaveOccurred())
Expect(platform.DeleteEphemeralUsersMatchingRegex).To(Equal("^foobar.*"))
// Make sure empty ip field is not included in the response
boshassert.MatchesJSONMap(GinkgoT(), response, map[string]interface{}{
"command": "cleanup",
"status": "success",
})
})
})
})
})
func init() {
Describe("Testing with Ginkgo", func() {
It("vitals construction", func() {
_, service := buildVitalsService()
vitals, err := service.Get()
expectedVitals := map[string]interface{}{
"cpu": map[string]string{
"sys": "10.0",
"user": "******",
"wait": "1.0",
},
"disk": map[string]interface{}{
"system": map[string]string{
"percent": "50",
"inode_percent": "10",
},
"ephemeral": map[string]string{
"percent": "75",
"inode_percent": "20",
},
"persistent": map[string]string{
"percent": "100",
"inode_percent": "75",
},
},
"load": []string{"0.20", "4.55", "1.12"},
"mem": map[string]string{
"kb": "700",
"percent": "70",
},
"swap": map[string]string{
"kb": "600",
"percent": "60",
},
}
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONMap(GinkgoT(), vitals, expectedVitals)
})
It("getting vitals when missing disks", func() {
statsCollector, service := buildVitalsService()
statsCollector.DiskStats = map[string]boshstats.DiskStats{
"/": boshstats.DiskStats{
DiskUsage: boshstats.Usage{Used: 100, Total: 200},
InodeUsage: boshstats.Usage{Used: 50, Total: 500},
},
}
vitals, err := service.Get()
Expect(err).ToNot(HaveOccurred())
boshassert.LacksJSONKey(GinkgoT(), vitals.Disk, "ephemeral")
boshassert.LacksJSONKey(GinkgoT(), vitals.Disk, "persistent")
})
It("get getting vitals on system disk error", func() {
statsCollector, service := buildVitalsService()
statsCollector.DiskStats = map[string]boshstats.DiskStats{}
_, err := service.Get()
Expect(err).To(HaveOccurred())
})
})
}
},
boshjobsuper.Process{
Name: "fake-process-name-2",
State: "failing",
},
}
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))
Expect(state.Processes).To(Equal(expectedProcesses))
boshassert.MatchesJSONMap(GinkgoT(), state.VM, expectedVM)
})
Describe("non-populated field formatting", func() {
It("returns network as empty hash if not set", func() {
specService.Spec = boshas.V1ApplySpec{NetworkSpecs: nil}
state, err := action.Run("full")
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), state.NetworkSpecs, `{}`)
// Non-empty NetworkSpecs
specService.Spec = boshas.V1ApplySpec{
NetworkSpecs: map[string]boshas.NetworkSpec{
"fake-net-name": boshas.NetworkSpec{
Fields: map[string]interface{}{"ip": "fake-ip"},
},
"percent": "70",
},
"swap": map[string]string{
"kb": "600",
"percent": "60",
},
}
if Windows {
expectedVitals["load"] = []string{""}
} else {
expectedVitals["load"] = []string{"0.20", "4.55", "1.12"}
}
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONMap(GinkgoT(), vitals, expectedVitals)
})
It("getting vitals when missing disks", func() {
statsCollector, service := buildVitalsService()
statsCollector.DiskStats = map[string]boshstats.DiskStats{
"/": boshstats.DiskStats{
DiskUsage: boshstats.Usage{Used: 100, Total: 200},
InodeUsage: boshstats.Usage{Used: 50, Total: 500},
},
}
vitals, err := service.Get()
Expect(err).ToNot(HaveOccurred())