callbackURL = fakeServer.URL() + "/the-callback/url"
		})

		AfterEach(func() {
			close(statusCodes)
		})

		simulateTaskCompleting := func() {
			task := model_helpers.NewValidTask("the-task-guid")
			task.CompletionCallbackUrl = callbackURL
			enqueue <- task
		}

		Context("when the task has a completion callback URL", func() {
			It("marks the task as resolving", func() {
				Expect(fakeBBS.ResolvingTaskCallCount()).To(Equal(0))

				simulateTaskCompleting()
				statusCodes <- 200

				Eventually(fakeBBS.ResolveTaskCallCount).Should(Equal(1))
				actualGuid := fakeBBS.ResolveTaskArgsForCall(0)
				Expect(actualGuid).To(Equal("the-task-guid"))
			})

			It("processes tasks in parallel", func() {
				for i := 0; i < task_handler.POOL_SIZE; i++ {
					simulateTaskCompleting()
				}
				Eventually(reqCount).Should(HaveLen(task_handler.POOL_SIZE))
			})
		BeforeEach(func() {
			var err error
			request, err = http.NewRequest("", "http://example.com?:task_guid=the-task-guid", nil)
			Expect(err).NotTo(HaveOccurred())

			resolvingErr = nil
		})

		JustBeforeEach(func() {
			fakeClient.ResolvingTaskReturns(resolvingErr)
			handler.Delete(responseRecorder, request)
		})

		It("succeeds", func() {
			Expect(fakeClient.ResolvingTaskCallCount()).To(Equal(1))
			Expect(fakeClient.ResolvingTaskArgsForCall(0)).To(Equal("the-task-guid"))
			Expect(fakeClient.ResolveTaskCallCount()).To(Equal(1))
			Expect(fakeClient.ResolveTaskArgsForCall(0)).To(Equal("the-task-guid"))

			Expect(responseRecorder.Code).To(Equal(http.StatusOK))
		})

		Context("when marking the task as resolving fails", func() {
			Context("with invalid transition", func() {
				BeforeEach(func() {
					resolvingErr = models.NewTaskTransitionError(models.Task_Running, models.Task_Pending)
				})

				It("fails with a 409", func() {
					Expect(fakeClient.ResolvingTaskCallCount()).To(Equal(1))