func MatchesJSONBytes(t assert.TestingT, object interface{}, expectedJSON []byte) {
objectBytes, err := json.Marshal(object)
assert.NoError(t, err)
// Use strings instead of []byte for reasonable error message
assert.Equal(t, string(expectedJSON), string(objectBytes))
}
func init() {
Describe("concreteRunner", func() {
It("runner run parses the payload", func() {
runner := NewRunner()
expectedValue := valueType{ID: 13, Success: true}
expectedErr := errors.New("fake-run-error")
action := &actionWithGoodRunMethod{Value: expectedValue, Err: expectedErr}
payload := `{
"arguments":[
"setup",
123,
{"user":"******","pwd":"rob123","id":12},
["a","b","c"],
456
]
}`
value, err := runner.Run(action, []byte(payload))
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(Equal("fake-run-error"))
Expect(value).To(Equal(expectedValue))
Expect(err).To(Equal(expectedErr))
Expect(action.SubAction).To(Equal("setup"))
Expect(action.SomeID).To(Equal(123))
Expect(action.ExtraArgs).To(Equal(argsType{User: "******", Password: "******", ID: 12}))
Expect(action.SliceArgs).To(Equal([]string{"a", "b", "c"}))
})
It("runner run errs when actions not enough arguments", func() {
runner := NewRunner()
expectedValue := valueType{ID: 13, Success: true}
action := &actionWithGoodRunMethod{Value: expectedValue}
payload := `{"arguments":["setup"]}`
_, err := runner.Run(action, []byte(payload))
Expect(err).To(HaveOccurred())
})
It("runner run errs when action arguments types do not match", func() {
runner := NewRunner()
expectedValue := valueType{ID: 13, Success: true}
action := &actionWithGoodRunMethod{Value: expectedValue}
payload := `{"arguments":[123, "setup", {"user":"******","pwd":"rob123","id":12}]}`
_, err := runner.Run(action, []byte(payload))
Expect(err).To(HaveOccurred())
})
It("extracts argument types correctly", func() {
runner := NewRunner()
action := &actionWithTypes{}
payload := `{
"arguments":[{
"int_type":-1024000,
"int32_type":-1024000,
"int64_type":-1024000,
"float32_type":1e2,
"float64_type":1.024e+06,
"uint_type":1024000,
"string_type":"fake-string",
"bool_type":false
}]
}`
_, err := runner.Run(action, []byte(payload))
Expect(err).ToNot(HaveOccurred())
Expect(action.Arg.IntType).To(Equal(int(-1024000)))
Expect(action.Arg.Int32Type).To(Equal(int32(-1024000)))
Expect(action.Arg.Int64Type).To(Equal(int64(-1024000)))
Expect(action.Arg.Float32Type).To(Equal(float32(100)))
Expect(action.Arg.Float64Type).To(Equal(float64(1.024e+06)))
Expect(action.Arg.UintType).To(Equal(uint(1024000)))
Expect(action.Arg.StringType).To(Equal("fake-string"))
Expect(action.Arg.BoolType).To(Equal(false))
})
It("runner handles optional arguments being passed in", func() {
runner := NewRunner()
expectedValue := valueType{ID: 13, Success: true}
expectedErr := errors.New("fake-run-error")
action := &actionWithOptionalRunArgument{Value: expectedValue, Err: expectedErr}
payload := `{"arguments":["setup", {"user":"******","pwd":"rob123","id":12}, {"user":"******","pwd":"bob123","id":13}]}`
value, err := runner.Run(action, []byte(payload))
Expect(value).To(Equal(expectedValue))
Expect(err).To(Equal(expectedErr))
Expect(action.SubAction).To(Equal("setup"))
assert.Equal(GinkgoT(), action.OptionalArgs, []argsType{
{User: "******", Password: "******", ID: 12},
{User: "******", Password: "******", ID: 13},
})
})
It("runner handles optional arguments when not passed in", func() {
runner := NewRunner()
action := &actionWithOptionalRunArgument{}
payload := `{"arguments":["setup"]}`
runner.Run(action, []byte(payload))
Expect(action.SubAction).To(Equal("setup"))
Expect(action.OptionalArgs).To(Equal([]argsType{}))
})
It("runner run errs when action does not implement run", func() {
runner := NewRunner()
_, err := runner.Run(&actionWithoutRunMethod{}, []byte(`{"arguments":[]}`))
Expect(err).To(HaveOccurred())
})
It("runner run errs when actions run does not return two values", func() {
runner := NewRunner()
_, err := runner.Run(&actionWithOneRunReturnValue{}, []byte(`{"arguments":[]}`))
Expect(err).To(HaveOccurred())
})
It("runner run errs when actions run second return type is not error", func() {
runner := NewRunner()
_, err := runner.Run(&actionWithSecondReturnValueNotError{}, []byte(`{"arguments":[]}`))
Expect(err).To(HaveOccurred())
})
Describe("Resume", func() {
It("calls Resume() on action", func() {
runner := NewRunner()
testAction := &fakeaction.TestAction{
ResumeErr: errors.New("fake-action-error"),
ResumeValue: "fake-action-resume-value",
}
value, err := runner.Resume(testAction, []byte{})
Expect(value).To(Equal("fake-action-resume-value"))
Expect(err.Error()).To(Equal("fake-action-error"))
Expect(testAction.Resumed).To(BeTrue())
})
})
})
}
func init() {
Describe("concreteApplier", func() {
var (
jobApplier *fakejobs.FakeApplier
packageApplier *fakepackages.FakeApplier
logRotateDelegate *FakeLogRotateDelegate
jobSupervisor *fakejobsuper.FakeJobSupervisor
applier Applier
)
BeforeEach(func() {
jobApplier = fakejobs.NewFakeApplier()
packageApplier = fakepackages.NewFakeApplier()
logRotateDelegate = &FakeLogRotateDelegate{}
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
applier = NewConcreteApplier(
jobApplier,
packageApplier,
logRotateDelegate,
jobSupervisor,
boshdirs.NewProvider("/fake-base-dir"),
)
})
Describe("Prepare", func() {
It("prepares each jobs", func() {
job := buildJob()
err := applier.Prepare(
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.PreparedJobs).To(Equal([]models.Job{job}))
})
It("returns error when preparing jobs fails", func() {
job := buildJob()
jobApplier.PrepareError = errors.New("fake-prepare-job-error")
err := applier.Prepare(
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-prepare-job-error"))
})
It("prepares each packages", func() {
pkg1 := buildPackage()
pkg2 := buildPackage()
err := applier.Prepare(
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg1, pkg2}},
)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.PreparedPackages).To(Equal([]models.Package{pkg1, pkg2}))
})
It("returns error when preparing packages fails", func() {
pkg := buildPackage()
packageApplier.PrepareError = errors.New("fake-prepare-package-error")
err := applier.Prepare(
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-prepare-package-error"))
})
})
Describe("Apply", func() {
It("removes all jobs from job supervisor", func() {
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{})
Expect(err).ToNot(HaveOccurred())
Expect(jobSupervisor.RemovedAllJobs).To(BeTrue())
})
It("removes all previous jobs from job supervisor before starting to apply jobs", func() {
// force remove all error
jobSupervisor.RemovedAllJobsErr = errors.New("fake-remove-all-jobs-error")
job := buildJob()
applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
// check that jobs were not applied before removing all other jobs
Expect(jobApplier.AppliedJobs).To(Equal([]models.Job{}))
})
It("returns error if removing all jobs from job supervisor fails", func() {
jobSupervisor.RemovedAllJobsErr = errors.New("fake-remove-all-jobs-error")
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-remove-all-jobs-error"))
})
It("apply applies jobs", func() {
job := buildJob()
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.AppliedJobs).To(Equal([]models.Job{job}))
})
It("apply errs when applying jobs errs", func() {
job := buildJob()
jobApplier.ApplyError = errors.New("fake-apply-job-error")
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-job-error"))
})
It("asked jobApplier to keep only the jobs in the desired and current specs", func() {
currentJob := buildJob()
desiredJob := buildJob()
err := applier.Apply(
&fakeas.FakeApplySpec{JobResults: []models.Job{currentJob}},
&fakeas.FakeApplySpec{JobResults: []models.Job{desiredJob}},
)
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.KeepOnlyJobs).To(Equal([]models.Job{currentJob, desiredJob}))
})
It("returns error when jobApplier fails to keep only the jobs in the desired and current specs", func() {
jobApplier.KeepOnlyErr = errors.New("fake-keep-only-error")
currentJob := buildJob()
desiredJob := buildJob()
err := applier.Apply(
&fakeas.FakeApplySpec{JobResults: []models.Job{currentJob}},
&fakeas.FakeApplySpec{JobResults: []models.Job{desiredJob}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-keep-only-error"))
})
It("apply applies packages", func() {
pkg1 := buildPackage()
pkg2 := buildPackage()
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg1, pkg2}},
)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.AppliedPackages).To(Equal([]models.Package{pkg1, pkg2}))
})
It("apply errs when applying packages errs", func() {
pkg := buildPackage()
packageApplier.ApplyError = errors.New("fake-apply-package-error")
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-package-error"))
})
It("asked packageApplier to keep only the packages in the desired and current specs", func() {
currentPkg := buildPackage()
desiredPkg := buildPackage()
err := applier.Apply(
&fakeas.FakeApplySpec{PackageResults: []models.Package{currentPkg}},
&fakeas.FakeApplySpec{PackageResults: []models.Package{desiredPkg}},
)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.KeptOnlyPackages).To(Equal([]models.Package{currentPkg, desiredPkg}))
})
It("returns error when packageApplier fails to keep only the packages in the desired and current specs", func() {
packageApplier.KeepOnlyErr = errors.New("fake-keep-only-error")
currentPkg := buildPackage()
desiredPkg := buildPackage()
err := applier.Apply(
&fakeas.FakeApplySpec{PackageResults: []models.Package{currentPkg}},
&fakeas.FakeApplySpec{PackageResults: []models.Package{desiredPkg}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-keep-only-error"))
})
It("apply configures jobs", func() {
job1 := models.Job{Name: "fake-job-name-1", Version: "fake-version-name-1"}
job2 := models.Job{Name: "fake-job-name-2", Version: "fake-version-name-2"}
jobs := []models.Job{job1, job2}
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: jobs})
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.ConfiguredJobs).To(Equal([]models.Job{job2, job1}))
Expect(jobApplier.ConfiguredJobIndices).To(Equal([]int{0, 1}))
Expect(jobSupervisor.Reloaded).To(BeTrue())
})
It("apply errs if monitor fails reload", func() {
jobs := []models.Job{}
jobSupervisor.ReloadErr = errors.New("error reloading monit")
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: jobs})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("error reloading monit"))
})
It("apply errs if a job fails configuring", func() {
jobApplier.ConfigureError = errors.New("error configuring job")
job := models.Job{Name: "fake-job-name-1", Version: "fake-version-name-1"}
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("error configuring job"))
})
It("apply sets up logrotation", func() {
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{MaxLogFileSizeResult: "fake-size"},
)
Expect(err).ToNot(HaveOccurred())
assert.Equal(GinkgoT(), logRotateDelegate.SetupLogrotateArgs, SetupLogrotateArgs{
GroupName: boshsettings.VCAPUsername,
BasePath: "/fake-base-dir",
Size: "fake-size",
})
})
It("apply errs if setup logrotate fails", func() {
logRotateDelegate.SetupLogrotateErr = errors.New("fake-set-up-logrotate-error")
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-set-up-logrotate-error"))
})
})
})
}
