func itValidatesPresenceOfPlacementError(lrp *models.ActualLRP) {
Context("when placement error is set", func() {
BeforeEach(func() {
lrp.PlacementError = "insufficient capacity"
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
Context("when placement error is not set", func() {
BeforeEach(func() {
lrp.PlacementError = ""
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
func itValidatesAbsenceOfPlacementError(lrp *models.ActualLRP) {
Context("when placement error is set", func() {
BeforeEach(func() {
lrp.PlacementError = "insufficient capacity"
})
It("validate returns an error", func() {
err := lrp.Validate()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("placement error"))
})
})
Context("when placement error is not set", func() {
BeforeEach(func() {
lrp.PlacementError = ""
})
It("validate does not return an error", func() {
Expect(lrp.Validate()).NotTo(HaveOccurred())
})
})
}
models.ActualLRPStateCrashed: receptor.ActualLRPStateCrashed,
}
for modelState, jsonState := range expectedStateMap {
actualLRP.State = modelState
Expect(serialization.ActualLRPProtoToResponse(actualLRP, false).State).To(Equal(jsonState))
}
actualLRP.State = ""
Expect(serialization.ActualLRPProtoToResponse(actualLRP, false).State).To(Equal(receptor.ActualLRPStateInvalid))
})
Context("when there is placement error", func() {
BeforeEach(func() {
actualLRP.State = models.ActualLRPStateUnclaimed
actualLRP.PlacementError = "some-error"
})
It("includes the placement error", func() {
actualResponse := serialization.ActualLRPProtoToResponse(actualLRP, false)
Expect(actualResponse.PlacementError).To(Equal("some-error"))
})
})
Context("when there is a crash reason", func() {
BeforeEach(func() {
actualLRP.State = models.ActualLRPStateCrashed
actualLRP.CrashReason = "crashed"
})
It("includes the placement error", func() {
Expect(claimErr).To(Equal(models.ErrActualLRPCannotBeClaimed))
})
It("does not alter the existing actual", func() {
lrpGroupInBBS, err := etcdDB.ActualLRPGroupByProcessGuidAndIndex(logger, processGuid, index)
Expect(err).NotTo(HaveOccurred())
Expect(lrpGroupInBBS.Instance.InstanceGuid).To(Equal(instanceGuid))
})
})
})
Context("when there is a placement error", func() {
BeforeEach(func() {
instanceKey = models.NewActualLRPInstanceKey("some-instance-guid", cellID)
actualLRP.PlacementError = "insufficient resources"
etcdHelper.SetRawActualLRP(actualLRP)
})
It("should clear placement error", func() {
Expect(claimErr).NotTo(HaveOccurred())
Expect(claimedActualLRP.PlacementError).To(BeEmpty())
lrp, err := etcdDB.ActualLRPGroupByProcessGuidAndIndex(logger, processGuid, index)
Expect(err).NotTo(HaveOccurred())
Expect(lrp.Instance.PlacementError).To(BeEmpty())
})
})
})
Context("when the actual LRP does not exist", func() {
BeforeEach(func() {
})
It("does not emit any events", func() {
Consistently(actualHub.EmitCallCount).Should(Equal(0))
})
})
})
Context("when the instance is unclaimed", func() {
BeforeEach(func() {
actual.State = models.ActualLRPStateUnclaimed
})
Context("without a placement error", func() {
BeforeEach(func() {
actual.PlacementError = ""
group := &models.ActualLRPGroup{Evacuating: afterActual}
fakeEvacuationDB.EvacuateActualLRPReturns(group, nil)
})
It("evacuates the LRP", func() {
response := models.EvacuationResponse{}
err := response.Unmarshal(responseRecorder.Body.Bytes())
Expect(err).NotTo(HaveOccurred())
Expect(response.KeepContainer).To(BeTrue())
Expect(response.Error).To(BeNil())
Expect(fakeEvacuationDB.EvacuateActualLRPCallCount()).To(Equal(1))
_, actualLRPKey, actualLRPInstanceKey, actualLrpNetInfo, ttl := fakeEvacuationDB.EvacuateActualLRPArgsForCall(0)
Expect(*actualLRPKey).To(Equal(actual.ActualLRPKey))
Expect(*actualLRPInstanceKey).To(Equal(actual.ActualLRPInstanceKey))