Exemplo n.º 1
0
			var protoDeserialization models.Task
			err = proto.Unmarshal(protoSerialization, &protoDeserialization)
			Expect(err).NotTo(HaveOccurred())

			Expect(protoDeserialization).To(Equal(task))
		})
	})

	Describe("VersionDownTo", func() {
		Context("V1", func() {
			BeforeEach(func() {
				task.Action = models.WrapAction(models.Timeout(
					&models.RunAction{
						Path: "/the/path",
						User: "******",
					},
					10*time.Millisecond,
				))
			})

			It("converts TimeoutMs to Timeout in Nanoseconds", func() {
				task.VersionDownTo(format.V1)
				Expect(task.GetAction().GetTimeoutAction().DeprecatedTimeoutNs).To(BeEquivalentTo(10 * time.Millisecond))
			})
		})

		Context("V0", func() {
			var (
				downloadAction1, downloadAction2 *models.DownloadAction
			)
		It("returns a not implemented error", func() {
			Expect(migration.Down(logger)).To(HaveOccurred())
		})
	})

	Describe("Up", func() {
		var (
			task         *models.Task
			migrationErr error
		)

		Describe("Task Migration", func() {
			BeforeEach(func() {
				task = model_helpers.NewValidTask("task-guid-1")
				task.Action = models.WrapAction(&models.TimeoutAction{Action: model_helpers.NewValidAction(),
					DeprecatedTimeoutNs: 5 * int64(time.Second),
				})
			})

			JustBeforeEach(func() {
				taskData, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, task)
				Expect(err).NotTo(HaveOccurred())
				_, err = storeClient.Set(etcddb.TaskSchemaPath(task), taskData, 0)
				Expect(err).NotTo(HaveOccurred())

				migration.SetStoreClient(storeClient)
				migration.SetCryptor(cryptor)
				migration.SetClock(fakeClock)
				migrationErr = migration.Up(logger)
			})
				It("calls the DB with a cell filter", func() {
					Expect(controller.TasksCallCount()).To(Equal(1))
					_, domain, cellID := controller.TasksArgsForCall(0)
					Expect(domain).To(Equal(""))
					Expect(cellID).To(Equal("cell-id"))
				})
			})

			Context("and the returned tasks have cache dependencies", func() {
				BeforeEach(func() {
					task1.TaskDefinition = &models.TaskDefinition{}
					task2.TaskDefinition = &models.TaskDefinition{}

					task1.Action = &models.Action{
						UploadAction: &models.UploadAction{
							From: "web_location",
						},
					}

					task1.CachedDependencies = []*models.CachedDependency{
						{Name: "name-1", From: "from-1", To: "to-1", CacheKey: "cache-key-1", LogSource: "log-source-1"},
					}

					task2.CachedDependencies = []*models.CachedDependency{
						{Name: "name-2", From: "from-2", To: "to-2", CacheKey: "cache-key-2", LogSource: "log-source-2"},
						{Name: "name-3", From: "from-3", To: "to-3", CacheKey: "cache-key-3", LogSource: "log-source-3"},
					}
				})

				It("translates the cache dependencies into download actions", func() {
					Expect(responseRecorder.Code).To(Equal(http.StatusOK))