github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/worker/machinelock/manifold_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package machinelock_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	"github.com/juju/utils/fslock"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/agent"
    14  	"github.com/juju/juju/worker"
    15  	"github.com/juju/juju/worker/dependency"
    16  	dt "github.com/juju/juju/worker/dependency/testing"
    17  	"github.com/juju/juju/worker/machinelock"
    18  )
    19  
    20  type ManifoldSuite struct {
    21  	testing.IsolationSuite
    22  	testing.Stub
    23  	manifold dependency.Manifold
    24  	context  dependency.Context
    25  	lock     *fslock.Lock
    26  }
    27  
    28  var _ = gc.Suite(&ManifoldSuite{})
    29  
    30  func (s *ManifoldSuite) SetUpTest(c *gc.C) {
    31  	s.IsolationSuite.SetUpTest(c)
    32  	s.Stub = testing.Stub{}
    33  	s.manifold = machinelock.Manifold(machinelock.ManifoldConfig{
    34  		AgentName: "agent-name",
    35  	})
    36  	s.context = dt.StubContext(nil, map[string]interface{}{
    37  		"agent-name": &dummyAgent{},
    38  	})
    39  
    40  	lock, err := fslock.NewLock(c.MkDir(), "test-lock", fslock.Defaults())
    41  	c.Assert(err, jc.ErrorIsNil)
    42  	s.lock = lock
    43  	s.PatchValue(machinelock.CreateLock, func(dataDir string) (*fslock.Lock, error) {
    44  		s.AddCall("createLock", dataDir)
    45  		if err := s.NextErr(); err != nil {
    46  			return nil, err
    47  		}
    48  		return s.lock, nil
    49  	})
    50  }
    51  
    52  func (s *ManifoldSuite) TestInputs(c *gc.C) {
    53  	c.Check(s.manifold.Inputs, jc.DeepEquals, []string{"agent-name"})
    54  }
    55  
    56  func (s *ManifoldSuite) TestStartMissingAgent(c *gc.C) {
    57  	context := dt.StubContext(nil, map[string]interface{}{
    58  		"agent-name": dependency.ErrMissing,
    59  	})
    60  	worker, err := s.manifold.Start(context)
    61  	c.Check(worker, gc.IsNil)
    62  	c.Check(err, gc.Equals, dependency.ErrMissing)
    63  	s.CheckCalls(c, nil)
    64  }
    65  
    66  func (s *ManifoldSuite) TestStartError(c *gc.C) {
    67  	s.SetErrors(errors.New("no lock for you"))
    68  	worker, err := s.manifold.Start(s.context)
    69  	c.Check(worker, gc.IsNil)
    70  	c.Check(err, gc.ErrorMatches, "no lock for you")
    71  	s.CheckCalls(c, []testing.StubCall{{
    72  		FuncName: "createLock",
    73  		Args:     []interface{}{"/path/to/data/dir"},
    74  	}})
    75  }
    76  
    77  func (s *ManifoldSuite) setupWorkerTest(c *gc.C) worker.Worker {
    78  	worker, err := s.manifold.Start(s.context)
    79  	c.Check(err, jc.ErrorIsNil)
    80  	s.AddCleanup(func(c *gc.C) {
    81  		worker.Kill()
    82  		err := worker.Wait()
    83  		c.Check(err, jc.ErrorIsNil)
    84  	})
    85  	s.CheckCalls(c, []testing.StubCall{{
    86  		FuncName: "createLock",
    87  		Args:     []interface{}{"/path/to/data/dir"},
    88  	}})
    89  	return worker
    90  }
    91  
    92  func (s *ManifoldSuite) TestStartSuccess(c *gc.C) {
    93  	s.setupWorkerTest(c)
    94  }
    95  
    96  func (s *ManifoldSuite) TestOutputSuccess(c *gc.C) {
    97  	worker := s.setupWorkerTest(c)
    98  	var lock *fslock.Lock
    99  	err := s.manifold.Output(worker, &lock)
   100  	c.Check(err, jc.ErrorIsNil)
   101  	c.Check(lock, gc.Equals, s.lock)
   102  }
   103  
   104  func (s *ManifoldSuite) TestOutputBadWorker(c *gc.C) {
   105  	var lock *fslock.Lock
   106  	err := s.manifold.Output(&dummyWorker{}, &lock)
   107  	c.Check(err, gc.ErrorMatches, "in should be a \\*valueWorker; is .*")
   108  	c.Check(lock, gc.IsNil)
   109  }
   110  
   111  func (s *ManifoldSuite) TestOutputBadTarget(c *gc.C) {
   112  	worker := s.setupWorkerTest(c)
   113  	var lock int
   114  	err := s.manifold.Output(worker, &lock)
   115  	c.Check(err, gc.ErrorMatches, "cannot output into \\*int")
   116  	c.Check(lock, gc.Equals, 0)
   117  }
   118  
   119  type dummyAgent struct {
   120  	agent.Agent
   121  }
   122  
   123  func (_ dummyAgent) CurrentConfig() agent.Config {
   124  	return &dummyAgentConfig{}
   125  }
   126  
   127  type dummyAgentConfig struct {
   128  	agent.Config
   129  }
   130  
   131  func (_ dummyAgentConfig) DataDir() string {
   132  	return "/path/to/data/dir"
   133  }
   134  
   135  type dummyWorker struct {
   136  	worker.Worker
   137  }