"blah": (*json.RawMessage)(&routeContent),
}
annotation := "annotated"
update = &models.DesiredLRPUpdate{
Instances: &instances,
Routes: &routes,
Annotation: &annotation,
}
_, err := sqlDB.UpdateDesiredLRP(logger, expectedDesiredLRP.ProcessGuid, update)
Expect(err).NotTo(HaveOccurred())
desiredLRP, err := sqlDB.DesiredLRPByProcessGuid(logger, expectedDesiredLRP.ProcessGuid)
Expect(err).NotTo(HaveOccurred())
expectedDesiredLRP.Instances = instances
expectedDesiredLRP.Annotation = annotation
expectedDesiredLRP.Routes = &routes
expectedDesiredLRP.ModificationTag.Increment()
Expect(desiredLRP).To(BeEquivalentTo(expectedDesiredLRP))
})
It("returns the desired lrp from before the update", func() {
instances := int32(20)
update = &models.DesiredLRPUpdate{
Instances: &instances,
}
beforeDesiredLRP, err := sqlDB.UpdateDesiredLRP(logger, expectedDesiredLRP.ProcessGuid, update)
Expect(err).NotTo(HaveOccurred())
Expect(beforeDesiredLRP).To(Equal(expectedDesiredLRP))
var (
processGuid string
update *models.DesiredLRPUpdate
beforeDesiredLRP *models.DesiredLRP
afterDesiredLRP *models.DesiredLRP
requestBody interface{}
)
BeforeEach(func() {
processGuid = "some-guid"
someText := "some-text"
beforeDesiredLRP = model_helpers.NewValidDesiredLRP(processGuid)
beforeDesiredLRP.Instances = 4
afterDesiredLRP = model_helpers.NewValidDesiredLRP(processGuid)
afterDesiredLRP.Annotation = someText
update = &models.DesiredLRPUpdate{
Annotation: &someText,
}
requestBody = &models.UpdateDesiredLRPRequest{
ProcessGuid: processGuid,
Update: update,
}
})
JustBeforeEach(func() {
request := newTestRequest(requestBody)
handler.UpdateDesiredLRP(logger, responseRecorder, request)
})
desiredLRP.CpuWeight = 101
assertDesiredLRPValidationFailsWithMessage(desiredLRP, "cpu_weight")
})
It("requires a valid MemoryMb", func() {
desiredLRP.MemoryMb = -1
assertDesiredLRPValidationFailsWithMessage(desiredLRP, "memory_mb")
})
It("requires a valid DiskMb", func() {
desiredLRP.DiskMb = -1
assertDesiredLRPValidationFailsWithMessage(desiredLRP, "disk_mb")
})
It("limits the annotation length", func() {
desiredLRP.Annotation = randStringBytes(50000)
assertDesiredLRPValidationFailsWithMessage(desiredLRP, "annotation")
})
Context("when security group is present", func() {
It("must be valid", func() {
desiredLRP.EgressRules = []*models.SecurityGroupRule{{
Protocol: "foo",
}}
assertDesiredLRPValidationFailsWithMessage(desiredLRP, "egress_rules")
})
})
Context("when security group is not present", func() {
It("does not error", func() {
desiredLRP.EgressRules = []*models.SecurityGroupRule{}
