github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/worker/leadership/manifold_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package leadership_test
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/juju/errors"
    10  	"github.com/juju/testing"
    11  	jc "github.com/juju/testing/checkers"
    12  	"github.com/juju/utils/clock"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/agent"
    16  	"github.com/juju/juju/api/base"
    17  	coreleadership "github.com/juju/juju/core/leadership"
    18  	"github.com/juju/juju/worker"
    19  	"github.com/juju/juju/worker/dependency"
    20  	dt "github.com/juju/juju/worker/dependency/testing"
    21  	"github.com/juju/juju/worker/leadership"
    22  )
    23  
    24  type ManifoldSuite struct {
    25  	testing.IsolationSuite
    26  	testing.Stub
    27  	manifold dependency.Manifold
    28  }
    29  
    30  var _ = gc.Suite(&ManifoldSuite{})
    31  
    32  func (s *ManifoldSuite) SetUpTest(c *gc.C) {
    33  	s.IsolationSuite.SetUpTest(c)
    34  	s.Stub = testing.Stub{}
    35  	s.manifold = leadership.Manifold(leadership.ManifoldConfig{
    36  		AgentName:           "agent-name",
    37  		APICallerName:       "api-caller-name",
    38  		Clock:               clock.WallClock,
    39  		LeadershipGuarantee: 123456 * time.Millisecond,
    40  	})
    41  }
    42  
    43  func (s *ManifoldSuite) TestInputs(c *gc.C) {
    44  	c.Check(s.manifold.Inputs, jc.DeepEquals, []string{"agent-name", "api-caller-name"})
    45  }
    46  
    47  func (s *ManifoldSuite) TestStartClockMissing(c *gc.C) {
    48  	manifold := leadership.Manifold(leadership.ManifoldConfig{})
    49  	context := dt.StubContext(nil, nil)
    50  	worker, err := manifold.Start(context)
    51  	c.Check(worker, gc.IsNil)
    52  	c.Check(err.Error(), gc.Equals, "missing Clock not valid")
    53  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    54  }
    55  
    56  func (s *ManifoldSuite) TestStartAgentMissing(c *gc.C) {
    57  	context := dt.StubContext(nil, map[string]interface{}{
    58  		"agent-name":      dependency.ErrMissing,
    59  		"api-caller-name": &dummyAPICaller{},
    60  	})
    61  
    62  	worker, err := s.manifold.Start(context)
    63  	c.Check(worker, gc.IsNil)
    64  	c.Check(err, gc.Equals, dependency.ErrMissing)
    65  }
    66  
    67  func (s *ManifoldSuite) TestStartAPICallerMissing(c *gc.C) {
    68  	context := dt.StubContext(nil, map[string]interface{}{
    69  		"agent-name":      &dummyAgent{},
    70  		"api-caller-name": dependency.ErrMissing,
    71  	})
    72  
    73  	worker, err := s.manifold.Start(context)
    74  	c.Check(worker, gc.IsNil)
    75  	c.Check(err, gc.Equals, dependency.ErrMissing)
    76  }
    77  
    78  func (s *ManifoldSuite) TestStartError(c *gc.C) {
    79  	dummyAgent := &dummyAgent{}
    80  	dummyAPICaller := &dummyAPICaller{}
    81  	context := dt.StubContext(nil, map[string]interface{}{
    82  		"agent-name":      dummyAgent,
    83  		"api-caller-name": dummyAPICaller,
    84  	})
    85  	s.PatchValue(&leadership.NewManifoldWorker, func(a agent.Agent, apiCaller base.APICaller, clock clock.Clock, guarantee time.Duration) (worker.Worker, error) {
    86  		s.AddCall("newManifoldWorker", a, apiCaller, clock, guarantee)
    87  		return nil, errors.New("blammo")
    88  	})
    89  
    90  	worker, err := s.manifold.Start(context)
    91  	c.Check(worker, gc.IsNil)
    92  	c.Check(err, gc.ErrorMatches, "blammo")
    93  	s.CheckCalls(c, []testing.StubCall{{
    94  		FuncName: "newManifoldWorker",
    95  		Args:     []interface{}{dummyAgent, dummyAPICaller, clock.WallClock, 123456 * time.Millisecond},
    96  	}})
    97  }
    98  
    99  func (s *ManifoldSuite) TestStartSuccess(c *gc.C) {
   100  	dummyAgent := &dummyAgent{}
   101  	dummyAPICaller := &dummyAPICaller{}
   102  	context := dt.StubContext(nil, map[string]interface{}{
   103  		"agent-name":      dummyAgent,
   104  		"api-caller-name": dummyAPICaller,
   105  	})
   106  	dummyWorker := &dummyWorker{}
   107  	s.PatchValue(&leadership.NewManifoldWorker, func(a agent.Agent, apiCaller base.APICaller, clock clock.Clock, guarantee time.Duration) (worker.Worker, error) {
   108  		s.AddCall("newManifoldWorker", a, apiCaller, clock, guarantee)
   109  		return dummyWorker, nil
   110  	})
   111  
   112  	worker, err := s.manifold.Start(context)
   113  	c.Check(err, jc.ErrorIsNil)
   114  	c.Check(worker, gc.Equals, dummyWorker)
   115  	s.CheckCalls(c, []testing.StubCall{{
   116  		FuncName: "newManifoldWorker",
   117  		Args:     []interface{}{dummyAgent, dummyAPICaller, clock.WallClock, 123456 * time.Millisecond},
   118  	}})
   119  }
   120  
   121  func (s *ManifoldSuite) TestOutputBadTarget(c *gc.C) {
   122  	var target interface{}
   123  	err := s.manifold.Output(&leadership.Tracker{}, &target)
   124  	c.Check(target, gc.IsNil)
   125  	c.Check(err.Error(), gc.Equals, "expected *leadership.Tracker output; got *interface {}")
   126  }
   127  
   128  func (s *ManifoldSuite) TestOutputBadWorker(c *gc.C) {
   129  	var target coreleadership.Tracker
   130  	err := s.manifold.Output(&dummyWorker{}, &target)
   131  	c.Check(target, gc.IsNil)
   132  	c.Check(err.Error(), gc.Equals, "expected *Tracker input; got *leadership_test.dummyWorker")
   133  }
   134  
   135  func (s *ManifoldSuite) TestOutputSuccess(c *gc.C) {
   136  	source := &leadership.Tracker{}
   137  	var target coreleadership.Tracker
   138  	err := s.manifold.Output(source, &target)
   139  	c.Check(err, jc.ErrorIsNil)
   140  	c.Check(target, gc.Equals, source)
   141  }
   142  
   143  type dummyAgent struct {
   144  	agent.Agent
   145  }
   146  
   147  type dummyAPICaller struct {
   148  	base.APICaller
   149  }
   150  
   151  type dummyWorker struct {
   152  	worker.Worker
   153  }