Example #1
0
func TestGetStateRunWithFullFormatOption(t *testing.T) {
	settings := &fakesettings.FakeSettingsService{}
	settings.AgentId = "my-agent-id"
	settings.Vm.Name = "vm-abc-def"

	specService, jobSupervisor, fakeVitals, action := buildGetStateAction(settings)
	jobSupervisor.StatusStatus = "running"

	specService.Spec = boshas.V1ApplySpec{
		Deployment: "fake-deployment",
	}

	expectedVitals := boshvitals.Vitals{
		Load: []string{"foo", "bar", "baz"},
	}
	fakeVitals.GetVitals = expectedVitals
	expectedVm := map[string]interface{}{"name": "vm-abc-def"}

	state, err := action.Run("full")
	assert.NoError(t, err)

	boshassert.MatchesJsonString(t, state.AgentId, `"my-agent-id"`)
	boshassert.MatchesJsonString(t, state.JobState, `"running"`)
	boshassert.MatchesJsonString(t, state.Deployment, `"fake-deployment"`)
	assert.Equal(t, *state.Vitals, expectedVitals)
	boshassert.MatchesJsonMap(t, state.Vm, expectedVm)
}
Example #2
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("mount disk should be asynchronous", func() {
			settings := &fakesettings.FakeSettingsService{}
			_, action := buildMountDiskAction(settings)
			Expect(action.IsAsynchronous()).To(BeTrue())
		})

		It("is not persistent", func() {
			settings := &fakesettings.FakeSettingsService{}
			_, action := buildMountDiskAction(settings)
			Expect(action.IsPersistent()).To(BeFalse())
		})

		It("mount disk", func() {
			settings := &fakesettings.FakeSettingsService{}
			settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
			platform, mountDisk := buildMountDiskAction(settings)

			result, err := mountDisk.Run("vol-123")
			Expect(err).NotTo(HaveOccurred())
			boshassert.MatchesJsonString(GinkgoT(), result, "{}")

			Expect(settings.SettingsWereLoaded).To(BeTrue())

			Expect(platform.MountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
			Expect(platform.MountPersistentDiskMountPoint).To(Equal("/foo/store"))
		})

		It("mount disk when store already mounted", func() {
			settings := &fakesettings.FakeSettingsService{}
			settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
			platform, mountDisk := buildMountDiskAction(settings)

			platform.IsMountPointResult = true

			result, err := mountDisk.Run("vol-123")
			Expect(err).NotTo(HaveOccurred())
			boshassert.MatchesJsonString(GinkgoT(), result, "{}")

			Expect(platform.IsMountPointPath).To(Equal("/foo/store"))

			Expect(platform.MountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
			Expect(platform.MountPersistentDiskMountPoint).To(Equal("/foo/store_migration_target"))
		})

		It("mount disk when device path not found", func() {
			settings := &fakesettings.FakeSettingsService{}
			settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
			_, mountDisk := buildMountDiskAction(settings)

			_, err := mountDisk.Run("vol-456")
			Expect(err).To(HaveOccurred())
		})
	})
}
Example #3
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("json with value", func() {

			resp := NewValueResponse("some value")
			boshassert.MatchesJsonString(GinkgoT(), resp, `{"value":"some value"}`)
		})
		It("json with exception", func() {

			resp := NewExceptionResponse("oops!")
			boshassert.MatchesJsonString(GinkgoT(), resp, `{"exception":{"message":"oops!"}}`)
		})
	})
}
Example #4
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("mount disk should be asynchronous", func() {
			settings := &fakesettings.FakeSettingsService{}
			_, action := buildMountDiskAction(settings)
			assert.True(GinkgoT(), action.IsAsynchronous())
		})
		It("mount disk", func() {

			settings := &fakesettings.FakeSettingsService{}
			settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
			platform, mountDisk := buildMountDiskAction(settings)

			result, err := mountDisk.Run("vol-123")
			assert.NoError(GinkgoT(), err)
			boshassert.MatchesJsonString(GinkgoT(), result, "{}")

			assert.True(GinkgoT(), settings.SettingsWereRefreshed)

			assert.Equal(GinkgoT(), platform.MountPersistentDiskDevicePath, "/dev/sdf")
			assert.Equal(GinkgoT(), platform.MountPersistentDiskMountPoint, "/foo/store")
		})
		It("mount disk when store already mounted", func() {

			settings := &fakesettings.FakeSettingsService{}
			settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
			platform, mountDisk := buildMountDiskAction(settings)

			platform.IsMountPointResult = true

			result, err := mountDisk.Run("vol-123")
			assert.NoError(GinkgoT(), err)
			boshassert.MatchesJsonString(GinkgoT(), result, "{}")

			assert.Equal(GinkgoT(), platform.IsMountPointPath, "/foo/store")

			assert.Equal(GinkgoT(), platform.MountPersistentDiskDevicePath, "/dev/sdf")
			assert.Equal(GinkgoT(), platform.MountPersistentDiskMountPoint, "/foo/store_migration_target")
		})
		It("mount disk when device path not found", func() {

			settings := &fakesettings.FakeSettingsService{}
			settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
			_, mountDisk := buildMountDiskAction(settings)

			_, err := mountDisk.Run("vol-456")
			assert.Error(GinkgoT(), err)
		})
	})
}
Example #5
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("unmount disk should be asynchronous", func() {
			platform := fakeplatform.NewFakePlatform()
			action := buildUnmountDiskAction(platform)
			Expect(action.IsAsynchronous()).To(BeTrue())
		})

		It("is not persistent", func() {
			platform := fakeplatform.NewFakePlatform()
			action := buildUnmountDiskAction(platform)
			Expect(action.IsPersistent()).To(BeFalse())
		})

		It("unmount disk when the disk is mounted", func() {

			platform := fakeplatform.NewFakePlatform()
			platform.UnmountPersistentDiskDidUnmount = true

			unmountDisk := buildUnmountDiskAction(platform)

			result, err := unmountDisk.Run("vol-123")
			Expect(err).ToNot(HaveOccurred())
			boshassert.MatchesJsonString(GinkgoT(), result, `{"message":"Unmounted partition of /dev/sdf"}`)

			Expect(platform.UnmountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
		})
		It("unmount disk when the disk is not mounted", func() {

			platform := fakeplatform.NewFakePlatform()
			platform.UnmountPersistentDiskDidUnmount = false

			mountDisk := buildUnmountDiskAction(platform)

			result, err := mountDisk.Run("vol-123")
			Expect(err).ToNot(HaveOccurred())
			boshassert.MatchesJsonString(GinkgoT(), result, `{"message":"Partition of /dev/sdf is not mounted"}`)

			Expect(platform.UnmountPersistentDiskDevicePath).To(Equal("/dev/sdf"))
		})
		It("unmount disk when device path not found", func() {

			platform := fakeplatform.NewFakePlatform()
			mountDisk := buildUnmountDiskAction(platform)

			_, err := mountDisk.Run("vol-456")
			Expect(err).To(HaveOccurred())
		})
	})
}
Example #6
0
func assertRequestIsProcessedSynchronously(t *testing.T, req boshmbus.Request) {
	settings, handler, platform, taskService, actionFactory := getAgentDependencies()

	// when action is successful
	actionFactory.CreateAction = &fakeaction.TestAction{
		RunValue: "some value",
	}

	agent := New(settings, handler, platform, taskService, actionFactory)

	err := agent.Run()
	assert.NoError(t, err)
	assert.True(t, handler.ReceivedRun)

	resp := handler.Func(req)
	assert.Equal(t, req.Method, actionFactory.CreateMethod)
	assert.Equal(t, req.GetPayload(), actionFactory.CreateAction.RunPayload)
	assert.Equal(t, boshmbus.NewValueResponse("some value"), resp)

	// when action returns an error
	actionFactory.CreateAction = &fakeaction.TestAction{
		RunErr: errors.New("some error"),
	}

	agent = New(settings, handler, platform, taskService, actionFactory)
	agent.Run()

	resp = handler.Func(req)
	boshassert.MatchesJsonString(t, resp, `{"exception":{"message":"some error"}}`)
}
Example #7
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("list disk should be synchronous", func() {

			settings := &fakesettings.FakeSettingsService{}
			platform := fakeplatform.NewFakePlatform()
			action := NewListDisk(settings, platform)
			assert.False(GinkgoT(), action.IsAsynchronous())
		})
		It("list disk run", func() {

			settings := &fakesettings.FakeSettingsService{
				Disks: boshsettings.Disks{
					Persistent: map[string]string{
						"volume-1": "/dev/sda",
						"volume-2": "/dev/sdb",
						"volume-3": "/dev/sdc",
					},
				},
			}
			platform := fakeplatform.NewFakePlatform()
			platform.MountedDevicePaths = []string{"/dev/sdb", "/dev/sdc"}

			action := NewListDisk(settings, platform)
			value, err := action.Run()
			assert.NoError(GinkgoT(), err)
			boshassert.MatchesJsonString(GinkgoT(), value, `["volume-2","volume-3"]`)
		})
	})
}
Example #8
0
func testLogs(t assert.TestingT, logType string, filters []string, expectedFilters []string) {
	deps, action := buildLogsAction()

	deps.copier.FilteredCopyToTempTempDir = "/fake-temp-dir"
	deps.compressor.CompressFilesInDirTarballPath = "logs_test.go"
	deps.blobstore.CreateBlobId = "my-blob-id"

	logs, err := action.Run(logType, filters)
	assert.NoError(t, err)

	var expectedPath string
	switch logType {
	case "job":
		expectedPath = filepath.Join("/fake", "dir", "sys", "log")
	case "agent":
		expectedPath = filepath.Join("/fake", "dir", "bosh", "log")
	}

	assert.Equal(t, expectedPath, deps.copier.FilteredCopyToTempDir)
	assert.Equal(t, expectedFilters, deps.copier.FilteredCopyToTempFilters)

	assert.Equal(t, deps.copier.FilteredCopyToTempTempDir, deps.compressor.CompressFilesInDirDir)
	assert.Equal(t, deps.copier.CleanUpTempDir, deps.compressor.CompressFilesInDirDir)

	assert.Equal(t, deps.compressor.CompressFilesInDirTarballPath, deps.blobstore.CreateFileName)

	boshassert.MatchesJsonString(t, logs, `{"blobstore_id":"my-blob-id"}`)
}
Example #9
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("migrate disk should be asynchronous", func() {
			_, action := buildMigrateDiskAction()
			Expect(action.IsAsynchronous()).To(BeTrue())
		})

		It("is not persistent", func() {
			_, action := buildMigrateDiskAction()
			Expect(action.IsPersistent()).To(BeFalse())
		})

		It("migrate disk action run", func() {

			platform, action := buildMigrateDiskAction()

			value, err := action.Run()
			Expect(err).ToNot(HaveOccurred())
			boshassert.MatchesJsonString(GinkgoT(), value, "{}")

			Expect(platform.MigratePersistentDiskFromMountPoint).To(Equal("/foo/store"))
			Expect(platform.MigratePersistentDiskToMountPoint).To(Equal("/foo/store_migration_target"))
		})
	})
}
Example #10
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("get", func() {
			fs, specPath, service := buildV1Service()
			fs.WriteToFile(specPath, `{"deployment":"fake-deployment-name"}`)

			spec, err := service.Get()
			assert.NoError(GinkgoT(), err)
			expectedSpec := V1ApplySpec{
				Deployment: "fake-deployment-name",
			}
			assert.Equal(GinkgoT(), expectedSpec, spec)
		})
		It("set", func() {

			fs, specPath, service := buildV1Service()

			spec := V1ApplySpec{
				JobSpec: JobSpec{
					Name: "fake-job",
				},
			}

			err := service.Set(spec)
			assert.NoError(GinkgoT(), err)
			specPathStats := fs.GetFileTestStat(specPath)
			assert.NotNil(GinkgoT(), specPathStats)
			boshassert.MatchesJsonString(GinkgoT(), spec, specPathStats.Content)
		})
	})
}
func TestMigrateDiskActionRun(t *testing.T) {
	platform, action := buildMigrateDiskAction()

	value, err := action.Run()
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, value, "{}")

	assert.Equal(t, platform.MigratePersistentDiskFromMountPoint, "/foo/store")
	assert.Equal(t, platform.MigratePersistentDiskToMountPoint, "/foo/store_migration_target")
}
Example #12
0
func init() {
	Describe("Testing with Ginkgo", func() {
		It("unmount disk should be asynchronous", func() {
			platform := fakeplatform.NewFakePlatform()
			action := buildUnmountDiskAction(platform)
			assert.True(GinkgoT(), action.IsAsynchronous())
		})
		It("unmount disk when the disk is mounted", func() {

			platform := fakeplatform.NewFakePlatform()
			platform.UnmountPersistentDiskDidUnmount = true

			unmountDisk := buildUnmountDiskAction(platform)

			result, err := unmountDisk.Run("vol-123")
			assert.NoError(GinkgoT(), err)
			boshassert.MatchesJsonString(GinkgoT(), result, `{"message":"Unmounted partition of /dev/sdf"}`)

			assert.Equal(GinkgoT(), platform.UnmountPersistentDiskDevicePath, "/dev/sdf")
		})
		It("unmount disk when the disk is not mounted", func() {

			platform := fakeplatform.NewFakePlatform()
			platform.UnmountPersistentDiskDidUnmount = false

			mountDisk := buildUnmountDiskAction(platform)

			result, err := mountDisk.Run("vol-123")
			assert.NoError(GinkgoT(), err)
			boshassert.MatchesJsonString(GinkgoT(), result, `{"message":"Partition of /dev/sdf is not mounted"}`)

			assert.Equal(GinkgoT(), platform.UnmountPersistentDiskDevicePath, "/dev/sdf")
		})
		It("unmount disk when device path not found", func() {

			platform := fakeplatform.NewFakePlatform()
			mountDisk := buildUnmountDiskAction(platform)

			_, err := mountDisk.Run("vol-456")
			assert.Error(GinkgoT(), err)
		})
	})
}
func TestUnmountDiskWhenTheDiskIsNotMounted(t *testing.T) {
	platform := fakeplatform.NewFakePlatform()
	platform.UnmountPersistentDiskDidUnmount = false

	mountDisk := buildUnmountDiskAction(platform)

	result, err := mountDisk.Run("vol-123")
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, result, `{"message":"Partition of /dev/sdf is not mounted"}`)

	assert.Equal(t, platform.UnmountPersistentDiskDevicePath, "/dev/sdf")
}
Example #14
0
func TestUnmountDiskWhenTheDiskIsMounted(t *testing.T) {
	platform := fakeplatform.NewFakePlatform()
	platform.UnmountPersistentDiskDidUnmount = true

	unmountDisk := buildUnmountDiskAction(platform)
	payload := `{"arguments":["vol-123"]}`

	result, err := unmountDisk.Run([]byte(payload))
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, result, `{"message":"Unmounted partition of /dev/sdf"}`)

	assert.Equal(t, platform.UnmountPersistentDiskDevicePath, "/dev/sdf")
}
func TestDispatchRespondsWithExceptionWhenTheMethodIsUnknown(t *testing.T) {
	logger, taskService, actionFactory, actionRunner := getActionDispatcherDependencies()

	req := boshhandler.NewRequest("reply to me", "gibberish", []byte{})

	actionFactory.CreateErr = true

	dispatcher := NewActionDispatcher(logger, taskService, actionFactory, actionRunner)

	resp := dispatcher.Dispatch(req)

	boshassert.MatchesJsonString(t, resp, `{"exception":{"message":"unknown message gibberish"}}`)
	assert.Equal(t, actionFactory.CreateMethod, "gibberish")
}
Example #16
0
func TestRunRespondsWithExceptionWhenTheMethodIsUnknown(t *testing.T) {
	req := boshmbus.NewRequest("reply to me", "gibberish", []byte{})

	settings, handler, platform, taskService, actionFactory := getAgentDependencies()
	agent := New(settings, handler, platform, taskService, actionFactory)

	err := agent.Run()
	assert.NoError(t, err)
	assert.True(t, handler.ReceivedRun)

	resp := handler.Func(req)

	boshassert.MatchesJsonString(t, resp, `{"exception":{"message":"unknown message gibberish"}}`)
}
Example #17
0
func TestGetTaskRunReturnsARunningTask(t *testing.T) {
	taskService, action := buildGetTaskAction()

	taskService.Tasks = map[string]boshtask.Task{
		"57": boshtask.Task{
			Id:    "found-57-id",
			State: boshtask.TaskStateRunning,
		},
	}

	taskValue, err := action.Run("57")
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, taskValue, `{"agent_task_id":"found-57-id","state":"running"}`)
}
Example #18
0
func TestApplyReturnsApplied(t *testing.T) {
	_, _, action := buildApplyAction()

	applySpec := boshas.V1ApplySpec{
		JobSpec: boshas.JobSpec{
			Name: "router",
		},
	}

	value, err := action.Run(applySpec)
	assert.NoError(t, err)

	boshassert.MatchesJsonString(t, value, `"applied"`)
}
Example #19
0
func TestMountDisk(t *testing.T) {
	settings := &fakesettings.FakeSettingsService{}
	settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
	platform, mountDisk := buildMountDiskAction(settings)

	result, err := mountDisk.Run("vol-123")
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, result, "{}")

	assert.True(t, settings.SettingsWereRefreshed)

	assert.Equal(t, platform.MountPersistentDiskDevicePath, "/dev/sdf")
	assert.Equal(t, platform.MountPersistentDiskMountPoint, "/foo/store")
}
Example #20
0
func TestGetTaskRunReturnsASuccessfulTask(t *testing.T) {
	taskService, action := buildGetTaskAction()

	taskService.Tasks = map[string]boshtask.Task{
		"57": boshtask.Task{
			Id:    "found-57-id",
			State: boshtask.TaskStateDone,
			Value: "some-task-value",
		},
	}

	taskValue, err := action.Run("57")
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, taskValue, `"some-task-value"`)
}
func TestDispatchHandlesSynchronousActionWhenErr(t *testing.T) {
	logger, taskService, actionFactory, actionRunner := getActionDispatcherDependencies()

	// when action returns an error
	actionFactory.CreateAction = &fakeaction.TestAction{}
	actionRunner.RunErr = errors.New("some error")

	dispatcher := NewActionDispatcher(logger, taskService, actionFactory, actionRunner)

	req := boshhandler.NewRequest("reply to me!", "some action", []byte("some payload"))
	resp := dispatcher.Dispatch(req)
	expectedJson := fmt.Sprintf("{\"exception\":{\"message\":\"Action Failed %s: some error\"}}", req.Method)
	boshassert.MatchesJsonString(t, resp, expectedJson)
	assert.Equal(t, actionFactory.CreateMethod, "some action")
}
Example #22
0
func TestDrainReturnsIntegerValueOfDrainscriptStdoutAfterTrimmingWhitespace(t *testing.T) {
	cmdRunner, fs, _, specService, action := buildDrain()

	currentSpec := boshas.V1ApplySpec{}
	currentSpec.JobSpec.Template = "foo"
	specService.Spec = currentSpec

	drainScriptPath := filepath.Join("/fake-dir/jobs", currentSpec.JobSpec.Template, "bin", "drain")
	fs.WriteToFile(drainScriptPath, "")
	cmdRunner.AddCmdResult(drainScriptPath+" job_check_status hash_unchanged", fakesys.FakeCmdResult{Stdout: "-56\n"})

	value, err := action.Run(drainTypeStatus)
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, value, "-56")
}
func TestSet(t *testing.T) {
	fs, specPath, service := buildV1Service()

	spec := V1ApplySpec{
		JobSpec: JobSpec{
			Name: "fake-job",
		},
	}

	err := service.Set(spec)
	assert.NoError(t, err)
	specPathStats := fs.GetFileTestStat(specPath)
	assert.NotNil(t, specPathStats)
	boshassert.MatchesJsonString(t, spec, specPathStats.Content)
}
Example #24
0
func TestMountDiskWhenStoreAlreadyMounted(t *testing.T) {
	settings := &fakesettings.FakeSettingsService{}
	settings.Disks.Persistent = map[string]string{"vol-123": "/dev/sdf"}
	platform, mountDisk := buildMountDiskAction(settings)

	platform.IsMountPointResult = true

	result, err := mountDisk.Run("vol-123")
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, result, "{}")

	assert.Equal(t, platform.IsMountPointPath, "/foo/store")

	assert.Equal(t, platform.MountPersistentDiskDevicePath, "/dev/sdf")
	assert.Equal(t, platform.MountPersistentDiskMountPoint, "/foo/store_migration_target")
}
Example #25
0
func TestGetTaskRunReturnsAFailedTask(t *testing.T) {
	taskService, action := buildGetTaskAction()

	taskService.Tasks = map[string]boshtask.Task{
		"57": boshtask.Task{
			Id:    "found-57-id",
			State: boshtask.TaskStateFailed,
			Error: errors.New("Oops we failed..."),
		},
	}

	taskValue, err := action.Run("57")
	assert.Error(t, err)
	assert.Equal(t, "Oops we failed...", err.Error())
	boshassert.MatchesJsonString(t, taskValue, `null`)
}
Example #26
0
func TestExternalValidateWritesConfigFile(t *testing.T) {
	fs, runner, uuidGen, configPath := getExternalBlobstoreDependencies()

	options := map[string]string{"fake-key": "fake-value"}

	blobstore := newExternalBlobstore("fake-provider", options, fs, runner, uuidGen, configPath)

	runner.CommandExistsValue = true
	assert.NoError(t, blobstore.Validate())

	s3CliConfig, err := fs.ReadFile(configPath)
	assert.NoError(t, err)

	expectedJson := map[string]string{"fake-key": "fake-value"}
	boshassert.MatchesJsonString(t, expectedJson, s3CliConfig)
}
Example #27
0
func TestGetTaskRunReturnsAFailedTask(t *testing.T) {
	taskService, action := buildGetTaskAction()

	taskService.Tasks = map[string]boshtask.Task{
		"57": boshtask.Task{
			Id:    "found-57-id",
			State: boshtask.TaskStateFailed,
			Error: "Oops we failed...",
		},
	}

	taskValue, err := action.Run([]byte(`{"arguments":["57"]}`))
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, taskValue,
		`{"agent_task_id":"found-57-id","state":"failed","exception":"Oops we failed..."}`)
}
Example #28
0
func TestGetTaskRunReturnsASuccessfulTask(t *testing.T) {
	taskService, action := buildGetTaskAction()

	taskService.Tasks = map[string]boshtask.Task{
		"57": boshtask.Task{
			Id:    "found-57-id",
			State: boshtask.TaskStateDone,
			Value: "some-task-value",
		},
	}

	taskValue, err := action.Run([]byte(`{"arguments":["57"]}`))
	assert.NoError(t, err)
	boshassert.MatchesJsonString(t, taskValue,
		`{"agent_task_id":"found-57-id","state":"done","value":"some-task-value"}`)
}
Example #29
0
func TestGetTaskRunReturns(t *testing.T) {
	settings, fs, platform, taskService := getFakeFactoryDependencies()
	taskService.Tasks = map[string]boshtask.Task{
		"57": boshtask.Task{
			Id:    "found-57-id",
			State: boshtask.TaskStateFailed,
		},
	}

	factory := NewFactory(settings, fs, platform, taskService)
	getTask := factory.Create("get_task")

	taskValue, err := getTask.Run([]byte(`{"arguments":["57"]}`))
	assert.NoError(t, err)

	boshassert.MatchesJsonString(t, taskValue, `{"agent_task_id":"found-57-id","state":"failed"}`)
}
Example #30
0
func TestGetTaskRunReturnsASuccessfulTask(t *testing.T) {
	settings, platform, blobstore, taskService := getFakeFactoryDependencies()
	taskService.Tasks = map[string]boshtask.Task{
		"57": boshtask.Task{
			Id:    "found-57-id",
			State: boshtask.TaskStateDone,
			Value: "some-task-value",
		},
	}

	factory := NewFactory(settings, platform, blobstore, taskService)
	getTask := factory.Create("get_task")

	taskValue, err := getTask.Run([]byte(`{"arguments":["57"]}`))
	assert.NoError(t, err)

	boshassert.MatchesJsonString(t, taskValue, `{"agent_task_id":"found-57-id","state":"done","value":"some-task-value"}`)
}