func (*HousingSuite) TestOccupyLocked(c *gc.C) {
manifold := util.Housing{
Occupy: "fortress",
}.Decorate(dependency.Manifold{})
abort := make(chan struct{})
context := dt.StubContext(abort, map[string]interface{}{
"fortress": newGuest(false),
})
// start the start func
started := make(chan struct{})
go func() {
defer close(started)
worker, err := manifold.Start(context)
c.Check(worker, gc.IsNil)
c.Check(errors.Cause(err), gc.Equals, fortress.ErrAborted)
}()
// check it's blocked...
select {
case <-time.After(coretesting.ShortWait):
case <-started:
c.Errorf("Start finished early")
}
// ...until the context is aborted.
close(abort)
select {
case <-started:
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out")
}
}
func (*HousingSuite) TestOccupyBadType(c *gc.C) {
manifold := util.Housing{
Occupy: "fortress",
}.Decorate(dependency.Manifold{})
context := dt.StubContext(nil, map[string]interface{}{
"fortress": false,
})
worker, err := manifold.Start(context)
c.Check(worker, gc.IsNil)
c.Check(err, gc.ErrorMatches, "cannot set false into .*")
}
func (*HousingSuite) TestOccupyMissing(c *gc.C) {
manifold := util.Housing{
Occupy: "fortress",
}.Decorate(dependency.Manifold{})
context := dt.StubContext(nil, map[string]interface{}{
"fortress": dependency.ErrMissing,
})
worker, err := manifold.Start(context)
c.Check(worker, gc.IsNil)
c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
}
func (*HousingSuite) TestFlagBadValue(c *gc.C) {
manifold := util.Housing{
Flags: []string{"flag"},
}.Decorate(dependency.Manifold{})
context := dt.StubContext(nil, map[string]interface{}{
"flag": flag{false},
})
worker, err := manifold.Start(context)
c.Check(worker, gc.IsNil)
c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
}
func (*HousingSuite) TestFlagBlocksOccupy(c *gc.C) {
manifold := util.Housing{
Flags: []string{"flag"},
Occupy: "fortress",
}.Decorate(dependency.Manifold{})
context := dt.StubContext(nil, map[string]interface{}{
"flag": dependency.ErrMissing,
"fortress": errors.New("never happen"),
})
worker, err := manifold.Start(context)
c.Check(worker, gc.IsNil)
c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
}
func (*HousingSuite) TestReplacesFilter(c *gc.C) {
expectIn := errors.New("tweedledum")
expectOut := errors.New("tweedledee")
manifold := util.Housing{
Filter: func(in error) error {
c.Check(in, gc.Equals, expectIn)
return expectOut
},
}.Decorate(dependency.Manifold{
Filter: panicFilter,
})
out := manifold.Filter(expectIn)
c.Check(out, gc.Equals, expectOut)
}
func (*HousingSuite) TestOccupySuccess(c *gc.C) {
expectWorker := workertest.NewErrorWorker(errors.New("ignored"))
defer workertest.DirtyKill(c, expectWorker)
manifold := util.Housing{
Occupy: "fortress",
}.Decorate(dependency.Manifold{
Start: func(dependency.Context) (worker.Worker, error) {
return expectWorker, nil
},
})
guest := newGuest(true)
context := dt.StubContext(nil, map[string]interface{}{
"fortress": guest,
})
// wait for the start func to complete
started := make(chan struct{})
go func() {
defer close(started)
worker, err := manifold.Start(context)
c.Check(worker, gc.Equals, expectWorker)
c.Check(err, jc.ErrorIsNil)
}()
select {
case <-started:
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out")
}
// check the worker's alive
workertest.CheckAlive(c, expectWorker)
// check the visit keeps running...
select {
case <-time.After(coretesting.ShortWait):
case <-guest.done:
c.Fatalf("visit finished early")
}
// ...until the worker stops
expectWorker.Kill()
select {
case <-guest.done:
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out")
}
}
func (*HousingSuite) TestFlagSuccess(c *gc.C) {
expectWorker := &struct{ worker.Worker }{}
manifold := util.Housing{
Flags: []string{"flag"},
}.Decorate(dependency.Manifold{
Start: func(dependency.Context) (worker.Worker, error) {
return expectWorker, nil
},
})
context := dt.StubContext(nil, map[string]interface{}{
"flag": flag{true},
})
worker, err := manifold.Start(context)
c.Check(worker, gc.Equals, expectWorker)
c.Check(err, jc.ErrorIsNil)
}
func (*HousingSuite) TestEmptyHousingPopulatedManifold(c *gc.C) {
manifold := util.Housing{}.Decorate(dependency.Manifold{
Inputs: []string{"x", "y", "z"},
Start: panicStart,
Output: panicOutput,
Filter: panicFilter,
})
c.Check(manifold.Inputs, jc.DeepEquals, []string{"x", "y", "z"})
c.Check(func() {
manifold.Start(nil)
}, gc.PanicMatches, "panicStart")
c.Check(func() {
manifold.Output(nil, nil)
}, gc.PanicMatches, "panicOutput")
c.Check(func() {
manifold.Filter(nil)
}, gc.PanicMatches, "panicFilter")
}