func (*WorkerSuite) TestStopKills(c *gc.C) { w := workertest.NewErrorWorker(nil) defer workertest.CleanKill(c, w) worker.Stop(w) workertest.CheckKilled(c, w) }
func (*OccupySuite) TestStartSuccess(c *gc.C) { fix := newFixture(c) defer fix.TearDown(c) c.Check(fix.Guard(c).Unlock(), jc.ErrorIsNil) // Start a worker... expect := workertest.NewErrorWorker(nil) defer workertest.CleanKill(c, expect) run := func() (worker.Worker, error) { return expect, nil } worker, err := fortress.Occupy(fix.Guest(c), run, nil) c.Assert(err, jc.ErrorIsNil) c.Check(worker, gc.Equals, expect) // ...and check we can't lockdown again... locked := make(chan error, 1) go func() { locked <- fix.Guard(c).Lockdown(nil) }() select { case err := <-locked: c.Fatalf("unexpected Lockdown result: %v", err) case <-time.After(coretesting.ShortWait): } // ...until the worker completes. workertest.CleanKill(c, worker) select { case err := <-locked: c.Check(err, jc.ErrorIsNil) case <-time.After(coretesting.LongWait): c.Fatalf("visit never completed") } }
func newMockBackend() *mockBackend { return &mockBackend{ envWatcher: &mockEnvWatcher{ Worker: workertest.NewErrorWorker(nil), changes: make(chan []string), }, } }
func (s *Suite) TestCheckKilledTimeout(c *gc.C) { w := workertest.NewErrorWorker(nil) defer workertest.CleanKill(c, w) err := workertest.CheckKilled(c, w) s.CheckFailed(c) c.Check(err, gc.ErrorMatches, "workertest: worker not stopping") }
func (s *Suite) TestCheckKillSuccess(c *gc.C) { expect := errors.New("fledbon") w := workertest.NewErrorWorker(expect) defer workertest.DirtyKill(c, w) err := workertest.CheckKill(c, w) c.Check(err, gc.Equals, expect) }
func NewFakeNotifyWatcher() *FakeNotifyWatcher { ch := make(chan struct{}, 1) ch <- struct{}{} return &FakeNotifyWatcher{ Worker: workertest.NewErrorWorker(nil), C: ch, } }
func (s *Suite) TestCheckKilledSuccess(c *gc.C) { expect := errors.New("snifplog") w := workertest.NewErrorWorker(expect) defer workertest.DirtyKill(c, w) w.Kill() err := workertest.CheckKilled(c, w) c.Check(err, gc.Equals, expect) }
func newStubWatcher() *stubWatcher { changes := make(chan []string, 3) changes <- []string{"expected", "first"} changes <- []string{"expected", "second"} changes <- []string{"unexpected?"} return &stubWatcher{ Worker: workertest.NewErrorWorker(nil), changes: changes, } }
func newStubWatcher() *stubWatcher { changes := make(chan struct{}, 3) changes <- struct{}{} changes <- struct{}{} changes <- struct{}{} return &stubWatcher{ Worker: workertest.NewErrorWorker(nil), notifyChan: changes, } }
// newMockWatcher returns a watcher.NotifyWatcher that always // sends 3 changes and then sits quietly until killed. func newMockWatcher() *mockWatcher { const count = 3 changes := make(chan struct{}, count) for i := 0; i < count; i++ { changes <- struct{}{} } return &mockWatcher{ Worker: workertest.NewErrorWorker(nil), changes: changes, } }
func newStubWatcher(watcherSendInvalidValues bool) *stubWatcher { changes := make(chan []string, 3) changes <- []string{firstActionID, secondActionID} changes <- []string{thirdActionID} if watcherSendInvalidValues { changes <- []string{"invalid-action-id"} } return &stubWatcher{ Worker: workertest.NewErrorWorker(nil), changes: changes, } }
func (context *context) startPinger() (presence.Pinger, error) { context.stub.AddCall("Start") context.checkCleanedUp() if startErr := context.stub.NextErr(); startErr != nil { return nil, startErr } context.mu.Lock() defer context.mu.Unlock() pingerErr := context.stub.NextErr() context.current = workertest.NewErrorWorker(pingerErr) context.starts <- context.current return mockPinger{context.current}, nil }
func (mock *mockFacade) WatchModelResources() (watcher.NotifyWatcher, error) { mock.stub.AddCall("WatchModelResources") if err := mock.stub.NextErr(); err != nil { return nil, err } const count = 5 changes := make(chan struct{}, count) for i := 0; i < count; i++ { changes <- struct{}{} } return &mockWatcher{ Worker: workertest.NewErrorWorker(nil), changes: changes, }, nil }
// newWorkerList converts the supplied errors into a list of workers to // be returned in order from the result's Next func (at which point they // are sent on the reports chan as well). func newWorkerList(errs []error) *workerList { count := len(errs) reports := make(chan worker.Worker, count) workers := make([]worker.Worker, count) for i, err := range errs { if err == ErrFailStart { workers[i] = nil } else { workers[i] = workertest.NewErrorWorker(err) } } return &workerList{ workers: workers, reports: reports, } }
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 (*WorkerSuite) TestDeadWaits(c *gc.C) { w := workertest.NewErrorWorker(nil) defer workertest.CleanKill(c, w) dead := worker.Dead(w) select { case <-time.After(coretesting.ShortWait): case _, ok := <-dead: if !ok { c.Fatalf("Dead closed early") } else { c.Fatalf("Dead sent unexpectedly") } } w.Kill() select { case _, ok := <-dead: c.Check(ok, jc.IsFalse) case <-time.After(coretesting.LongWait): c.Fatalf("Dead never closed") } }
func newMockWatcher(changes chan struct{}) *mockWatcher { return &mockWatcher{ Worker: workertest.NewErrorWorker(nil), changes: changes, } }
func (s *Suite) TestCleanKillFailure(c *gc.C) { w := workertest.NewErrorWorker(errors.New("kebdrix")) workertest.CleanKill(c, w) s.CheckFailed(c) }
func (s *Suite) TestCleanKillSuccess(c *gc.C) { w := workertest.NewErrorWorker(nil) workertest.CleanKill(c, w) }
func newStubWatcher() *stubWatcher { return &stubWatcher{ Worker: workertest.NewErrorWorker(nil), changes: make(chan watcher.MigrationStatus, 1), } }
func (s *Suite) TestCheckAliveSuccess(c *gc.C) { w := workertest.NewErrorWorker(nil) defer workertest.CleanKill(c, w) workertest.CheckAlive(c, w) }
func (s *Suite) TestDirtyKillSuccess(c *gc.C) { w := workertest.NewErrorWorker(errors.New("hifstit")) workertest.DirtyKill(c, w) }
// newNotifyWatcher returns a watcher.NotifyWatcher that will fail with the // supplied error when Kill()ed. func newNotifyWatcher(err error) *notifyWatcher { return ¬ifyWatcher{ Worker: workertest.NewErrorWorker(err), changes: make(chan struct{}, 1000), } }