Esempio n. 1
0
				"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)
		})
Esempio n. 3
0
			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{}