worker: Introducing StringsWorker

worker/notifyworker_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package worker_test
 
 import (
         "fmt"
         "sync"
         "time"
 
         gc "launchpad.net/gocheck"
         "launchpad.net/tomb"
 
         "launchpad.net/juju-core/state/api"
         "launchpad.net/juju-core/state/watcher"
         coretesting "launchpad.net/juju-core/testing"
         jc "launchpad.net/juju-core/testing/checkers"
         "launchpad.net/juju-core/worker"
 )
 
 type notifyWorkerSuite struct {
         coretesting.LoggingSuite
         worker worker.NotifyWorker
-        actor  *actionsHandler
+        actor  *notifyHandler
 }
 
 var _ = gc.Suite(&notifyWorkerSuite{})
 
 func (s *notifyWorkerSuite) SetUpTest(c *gc.C) {
         s.LoggingSuite.SetUpTest(c)
-        s.actor = &actionsHandler{
+        s.actor = &notifyHandler{
                 actions:     nil,
                 handled:     make(chan struct{}, 1),
-                description: "test action handler",
-                watcher: &TestWatcher{
+                description: "test notify handler",
+                watcher: &testNotifyWatcher{
                         changes: make(chan struct{}),
                 },
         }
         s.worker = worker.NewNotifyWorker(s.actor)
 }
 
 func (s *notifyWorkerSuite) TearDownTest(c *gc.C) {
         s.stopWorker(c)
         s.LoggingSuite.TearDownTest(c)
 }
 
-type actionsHandler struct {
+type notifyHandler struct {
         actions []string
         mu      sync.Mutex
         // Signal handled when we get a handle() call
         handled       chan struct{}
         setupError    error
         teardownError error
         handlerError  error
-        watcher       *TestWatcher
+        watcher       *testNotifyWatcher
         description   string
 }
 
-func (a *actionsHandler) SetUp() (api.NotifyWatcher, error) {
-        a.mu.Lock()
-        defer a.mu.Unlock()
-        a.actions = append(a.actions, "setup")
-        if a.watcher == nil {
-                return nil, a.setupError
+var _ worker.NotifyWatchHandler = (*notifyHandler)(nil)
+
+func (nh *notifyHandler) SetUp() (api.NotifyWatcher, error) {
+        nh.mu.Lock()
+        defer nh.mu.Unlock()
+        nh.actions = append(nh.actions, "setup")
+        if nh.watcher == nil {
+                return nil, nh.setupError
         }
-        return a.watcher, a.setupError
+        return nh.watcher, nh.setupError
 }
 
-func (a *actionsHandler) TearDown() error {
-        a.mu.Lock()
-        defer a.mu.Unlock()
-        a.actions = append(a.actions, "teardown")
-        if a.handled != nil {
-                close(a.handled)
+func (nh *notifyHandler) TearDown() error {
+        nh.mu.Lock()
+        defer nh.mu.Unlock()
+        nh.actions = append(nh.actions, "teardown")
+        if nh.handled != nil {
+                close(nh.handled)
         }
-        return a.teardownError
+        return nh.teardownError
 }
 
-func (a *actionsHandler) Handle() error {
-        a.mu.Lock()
-        defer a.mu.Unlock()
-        a.actions = append(a.actions, "handler")
-        if a.handled != nil {
+func (nh *notifyHandler) Handle() error {
+        nh.mu.Lock()
+        defer nh.mu.Unlock()
+        nh.actions = append(nh.actions, "handler")
+        if nh.handled != nil {
                 // Unlock while we are waiting for the send
-                a.mu.Unlock()
-                a.handled <- struct{}{}
-                a.mu.Lock()
+                nh.mu.Unlock()
+                nh.handled <- struct{}{}
+                nh.mu.Lock()
         }
-        return a.handlerError
+        return nh.handlerError
 }
 
-func (a *actionsHandler) String() string {
-        return a.description
+func (nh *notifyHandler) String() string {
+        return nh.description
 }
 
-func (a *actionsHandler) CheckActions(c *gc.C, actions ...string) {
-        a.mu.Lock()
-        defer a.mu.Unlock()
-        c.Check(a.actions, gc.DeepEquals, actions)
+func (nh *notifyHandler) CheckActions(c *gc.C, actions ...string) {
+        nh.mu.Lock()
+        defer nh.mu.Unlock()
+        c.Check(nh.actions, gc.DeepEquals, actions)
 }
 
 // During teardown we try to stop the worker, but don't hang the test suite if
 // Stop never returns
 func (s *notifyWorkerSuite) stopWorker(c *gc.C) {
         if s.worker == nil {
                 return
         }
         done := make(chan error)
         go func() {
                 done <- s.worker.Stop()
         }()
         err := waitForTimeout(c, done, coretesting.LongWait)
         c.Check(err, gc.IsNil)
         s.actor = nil
         s.worker = nil
 }
 
-type TestWatcher struct {
+type testNotifyWatcher struct {
         mu        sync.Mutex
         changes   chan struct{}
-        action    chan struct{}
         stopped   bool
         stopError error
 }
 
-func (tw *TestWatcher) Changes() <-chan struct{} {
-        return tw.changes
+var _ api.NotifyWatcher = (*testNotifyWatcher)(nil)
+
+func (tnw *testNotifyWatcher) Changes() <-chan struct{} {
+        return tnw.changes
 }
 
-func (tw *TestWatcher) Err() error {
-        return tw.stopError
+func (tnw *testNotifyWatcher) Err() error {
+        return tnw.stopError
 }
 
-func (tw *TestWatcher) Stop() error {
-        tw.mu.Lock()
-        defer tw.mu.Unlock()
-        if !tw.stopped {
-                close(tw.changes)
+func (tnw *testNotifyWatcher) Stop() error {
+        tnw.mu.Lock()
+        defer tnw.mu.Unlock()
+        if !tnw.stopped {
+                close(tnw.changes)
         }
-        tw.stopped = true
-        return tw.stopError
+        tnw.stopped = true
+        return tnw.stopError
 }
 
-func (tw *TestWatcher) SetStopError(err error) {
-        tw.mu.Lock()
-        tw.stopError = err
-        tw.mu.Unlock()
+func (tnw *testNotifyWatcher) SetStopError(err error) {
+        tnw.mu.Lock()
+        tnw.stopError = err
+        tnw.mu.Unlock()
 }
 
-func (tw *TestWatcher) TriggerChange(c *gc.C) {
+func (tnw *testNotifyWatcher) TriggerChange(c *gc.C) {
         select {
-        case tw.changes <- struct{}{}:
+        case tnw.changes <- struct{}{}:
         case <-time.After(coretesting.LongWait):
                 c.Errorf("Timeout changes triggering change after %s", coretesting.LongWait)
         }
 }
 
 func waitForTimeout(c *gc.C, ch <-chan error, timeout time.Duration) error {
         select {
         case err := <-ch:
                 return err
         case <-time.After(timeout):
                 c.Errorf("failed to receive value after %s", timeout)
         }
         return nil
 }
 
-func WaitShort(c *gc.C, w worker.NotifyWorker) error {
+func waitShort(c *gc.C, w worker.CommonWorker) error {
         done := make(chan error)
         go func() {
                 done <- w.Wait()
         }()
         return waitForTimeout(c, done, coretesting.ShortWait)
 }
 
-func WaitForHandled(c *gc.C, handled chan struct{}) {
+func waitForHandledNotify(c *gc.C, handled chan struct{}) {
         select {
         case <-handled:
                 return
         case <-time.After(coretesting.LongWait):
                 c.Errorf("handled failed to signal after %s", coretesting.LongWait)
         }
 }
 
 func (s *notifyWorkerSuite) TestKill(c *gc.C) {
         s.worker.Kill()
-        err := WaitShort(c, s.worker)
+        err := waitShort(c, s.worker)
         c.Assert(err, gc.IsNil)
 }
 
 func (s *notifyWorkerSuite) TestStop(c *gc.C) {
         err := s.worker.Stop()
         c.Assert(err, gc.IsNil)
         // After stop, Wait should return right away
-        err = WaitShort(c, s.worker)
+        err = waitShort(c, s.worker)
         c.Assert(err, gc.IsNil)
 }
 
 func (s *notifyWorkerSuite) TestWait(c *gc.C) {
         done := make(chan error)
         go func() {
                 done <- s.worker.Wait()
         }()
         // Wait should not return until we've killed the worker
         select {
         case err := <-done:
                 c.Errorf("Wait() didn't wait until we stopped it: %v", err)
         case <-time.After(coretesting.ShortWait):
         }
         s.worker.Kill()
         err := waitForTimeout(c, done, coretesting.LongWait)
         c.Assert(err, gc.IsNil)
 }
 
 func (s *notifyWorkerSuite) TestStringForwardsHandlerString(c *gc.C) {
-        c.Check(fmt.Sprint(s.worker), gc.Equals, "test action handler")
+        c.Check(fmt.Sprint(s.worker), gc.Equals, "test notify handler")
 }
 
 func (s *notifyWorkerSuite) TestCallSetUpAndTearDown(c *gc.C) {
         // After calling NewNotifyWorker, we should have called setup
         s.actor.CheckActions(c, "setup")
         // If we kill the worker, it should notice, and call teardown
         s.worker.Kill()
-        err := WaitShort(c, s.worker)
+        err := waitShort(c, s.worker)
         c.Check(err, gc.IsNil)
         s.actor.CheckActions(c, "setup", "teardown")
         c.Check(s.actor.watcher.stopped, jc.IsTrue)
 }
 
 func (s *notifyWorkerSuite) TestChangesTriggerHandler(c *gc.C) {
         s.actor.CheckActions(c, "setup")
         s.actor.watcher.TriggerChange(c)
-        WaitForHandled(c, s.actor.handled)
+        waitForHandledNotify(c, s.actor.handled)
         s.actor.CheckActions(c, "setup", "handler")
         s.actor.watcher.TriggerChange(c)
-        WaitForHandled(c, s.actor.handled)
+        waitForHandledNotify(c, s.actor.handled)
         s.actor.watcher.TriggerChange(c)
-        WaitForHandled(c, s.actor.handled)
+        waitForHandledNotify(c, s.actor.handled)
         s.actor.CheckActions(c, "setup", "handler", "handler", "handler")
         c.Assert(s.worker.Stop(), gc.IsNil)
         s.actor.CheckActions(c, "setup", "handler", "handler", "handler", "teardown")
 }
 
 func (s *notifyWorkerSuite) TestSetUpFailureStopsWithTearDown(c *gc.C) {
         // Stop the worker and SetUp again, this time with an error
         s.stopWorker(c)
-        actor := &actionsHandler{
+        actor := &notifyHandler{
                 actions:    nil,
                 handled:    make(chan struct{}, 1),
                 setupError: fmt.Errorf("my special error"),
-                watcher: &TestWatcher{
+                watcher: &testNotifyWatcher{
                         changes: make(chan struct{}),
                 },
         }
         w := worker.NewNotifyWorker(actor)
-        err := WaitShort(c, w)
+        err := waitShort(c, w)
         c.Check(err, gc.ErrorMatches, "my special error")
         actor.CheckActions(c, "setup", "teardown")
         c.Check(actor.watcher.stopped, jc.IsTrue)
 }
 
 func (s *notifyWorkerSuite) TestWatcherStopFailurePropagates(c *gc.C) {
         s.actor.watcher.SetStopError(fmt.Errorf("error while stopping watcher"))
         s.worker.Kill()
         c.Assert(s.worker.Wait(), gc.ErrorMatches, "error while stopping watcher")
         // We've already stopped the worker, don't let teardown notice the
         // worker is in an error state
         s.worker = nil
 }
 
 func (s *notifyWorkerSuite) TestCleanRunNoticesTearDownError(c *gc.C) {
         s.actor.teardownError = fmt.Errorf("failed to tear down watcher")
         s.worker.Kill()
         c.Assert(s.worker.Wait(), gc.ErrorMatches, "failed to tear down watcher")
         s.worker = nil
 }
 
 func (s *notifyWorkerSuite) TestHandleErrorStopsWorkerAndWatcher(c *gc.C) {
         s.stopWorker(c)
-        actor := &actionsHandler{
+        actor := &notifyHandler{
                 actions:      nil,
                 handled:      make(chan struct{}, 1),
                 handlerError: fmt.Errorf("my handling error"),
-                watcher: &TestWatcher{
+                watcher: &testNotifyWatcher{
                         changes: make(chan struct{}),
                 },
         }
         w := worker.NewNotifyWorker(actor)
         actor.watcher.TriggerChange(c)
-        WaitForHandled(c, actor.handled)
-        err := WaitShort(c, w)
+        waitForHandledNotify(c, actor.handled)
+        err := waitShort(c, w)
         c.Check(err, gc.ErrorMatches, "my handling error")
         actor.CheckActions(c, "setup", "handler", "teardown")
         c.Check(actor.watcher.stopped, jc.IsTrue)
 }
 
 func (s *notifyWorkerSuite) TestNoticesStoppedWatcher(c *gc.C) {
         // The default closedHandler doesn't panic if you have a genuine error
         // (because it assumes you want to propagate a real error and then
         // restart
         s.actor.watcher.SetStopError(fmt.Errorf("Stopped Watcher"))
         s.actor.watcher.Stop()
-        err := WaitShort(c, s.worker)
+        err := waitShort(c, s.worker)
         c.Check(err, gc.ErrorMatches, "Stopped Watcher")
         s.actor.CheckActions(c, "setup", "teardown")
         // Worker is stopped, don't fail TearDownTest
         s.worker = nil
 }
 
 func noopHandler(watcher.Errer) error {
         return nil
 }
 
@@ skipping 26 matching lines @@
 
 func (s *notifyWorkerSuite) TestErrorsOnStillAliveButClosedChannel(c *gc.C) {
         foundErr := fmt.Errorf("did not get an error")
         triggeredHandler := func(errer watcher.Errer) error {
                 foundErr = errer.Err()
                 return foundErr
         }
         s.worker.(closerHandler).SetClosedHandler(triggeredHandler)
         s.actor.watcher.SetStopError(tomb.ErrStillAlive)
         s.actor.watcher.Stop()
-        err := WaitShort(c, s.worker)
+        err := waitShort(c, s.worker)
         c.Check(foundErr, gc.Equals, tomb.ErrStillAlive)
         // ErrStillAlive is trapped by the Stop logic and gets turned into a
         // 'nil' when stopping. However TestDefaultClosedHandler can assert
         // that it would have triggered a panic.
         c.Check(err, gc.IsNil)
         s.actor.CheckActions(c, "setup", "teardown")
         // Worker is stopped, don't fail TearDownTest
         s.worker = nil
 }
 
 func (s *notifyWorkerSuite) TestErrorsOnClosedChannel(c *gc.C) {
         foundErr := fmt.Errorf("did not get an error")
         triggeredHandler := func(errer watcher.Errer) error {
                 foundErr = errer.Err()
                 return foundErr
         }
         s.worker.(closerHandler).SetClosedHandler(triggeredHandler)
         s.actor.watcher.Stop()
-        err := WaitShort(c, s.worker)
+        err := waitShort(c, s.worker)
         // If the foundErr is nil, we would have panic-ed (see TestDefaultClosedHandler)
         c.Check(foundErr, gc.IsNil)
         c.Check(err, gc.IsNil)
         s.actor.CheckActions(c, "setup", "teardown")
 }