github.com/Pankov404/juju@v0.0.0-20150703034450-be266991dceb/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  	coreagent "github.com/juju/juju/agent"
    14  	"github.com/juju/juju/worker"
    15  	"github.com/juju/juju/worker/agent"
    16  	"github.com/juju/juju/worker/dependency"
    17  	dt "github.com/juju/juju/worker/dependency/testing"
    18  	"github.com/juju/juju/worker/machinelock"
    19  )
    20  
    21  type ManifoldSuite struct {
    22  	testing.IsolationSuite
    23  	testing.Stub
    24  	manifold    dependency.Manifold
    25  	getResource dependency.GetResourceFunc
    26  	lock        *fslock.Lock
    27  }
    28  
    29  var _ = gc.Suite(&ManifoldSuite{})
    30  
    31  func (s *ManifoldSuite) SetUpTest(c *gc.C) {
    32  	s.IsolationSuite.SetUpTest(c)
    33  	s.Stub = testing.Stub{}
    34  	s.manifold = machinelock.Manifold(machinelock.ManifoldConfig{
    35  		AgentName: "agent-name",
    36  	})
    37  	s.getResource = dt.StubGetResource(dt.StubResources{
    38  		"agent-name": dt.StubResource{Output: &dummyAgent{}},
    39  	})
    40  
    41  	lock, err := fslock.NewLock(c.MkDir(), "test-lock")
    42  	c.Assert(err, jc.ErrorIsNil)
    43  	s.lock = lock
    44  	s.PatchValue(machinelock.CreateLock, func(dataDir string) (*fslock.Lock, error) {
    45  		s.AddCall("createLock", dataDir)
    46  		if err := s.NextErr(); err != nil {
    47  			return nil, err
    48  		}
    49  		return s.lock, nil
    50  	})
    51  }
    52  
    53  func (s *ManifoldSuite) TestInputs(c *gc.C) {
    54  	c.Check(s.manifold.Inputs, jc.DeepEquals, []string{"agent-name"})
    55  }
    56  
    57  func (s *ManifoldSuite) TestStartMissingAgent(c *gc.C) {
    58  	getResource := dt.StubGetResource(dt.StubResources{
    59  		"agent-name": dt.StubResource{Error: dependency.ErrMissing},
    60  	})
    61  	worker, err := s.manifold.Start(getResource)
    62  	c.Check(worker, gc.IsNil)
    63  	c.Check(err, gc.Equals, dependency.ErrMissing)
    64  	s.CheckCalls(c, nil)
    65  }
    66  
    67  func (s *ManifoldSuite) TestStartError(c *gc.C) {
    68  	s.SetErrors(errors.New("no lock for you"))
    69  	worker, err := s.manifold.Start(s.getResource)
    70  	c.Check(worker, gc.IsNil)
    71  	c.Check(err, gc.ErrorMatches, "no lock for you")
    72  	s.CheckCalls(c, []testing.StubCall{{
    73  		FuncName: "createLock",
    74  		Args:     []interface{}{"/path/to/data/dir"},
    75  	}})
    76  }
    77  
    78  func (s *ManifoldSuite) setupWorkerTest(c *gc.C) worker.Worker {
    79  	worker, err := s.manifold.Start(s.getResource)
    80  	c.Check(err, jc.ErrorIsNil)
    81  	s.AddCleanup(func(c *gc.C) {
    82  		worker.Kill()
    83  		err := worker.Wait()
    84  		c.Check(err, jc.ErrorIsNil)
    85  	})
    86  	s.CheckCalls(c, []testing.StubCall{{
    87  		FuncName: "createLock",
    88  		Args:     []interface{}{"/path/to/data/dir"},
    89  	}})
    90  	return worker
    91  }
    92  
    93  func (s *ManifoldSuite) TestStartSuccess(c *gc.C) {
    94  	s.setupWorkerTest(c)
    95  }
    96  
    97  func (s *ManifoldSuite) TestOutputSuccess(c *gc.C) {
    98  	worker := s.setupWorkerTest(c)
    99  	var lock *fslock.Lock
   100  	err := s.manifold.Output(worker, &lock)
   101  	c.Check(err, jc.ErrorIsNil)
   102  	c.Check(lock, gc.Equals, s.lock)
   103  }
   104  
   105  func (s *ManifoldSuite) TestOutputBadWorker(c *gc.C) {
   106  	var lock *fslock.Lock
   107  	err := s.manifold.Output(&dummyWorker{}, &lock)
   108  	c.Check(err.Error(), gc.Equals, "expected *machinelock.machineLockWorker->**fslock.Lock; got *machinelock_test.dummyWorker->**fslock.Lock")
   109  	c.Check(lock, gc.IsNil)
   110  }
   111  
   112  func (s *ManifoldSuite) TestOutputBadTarget(c *gc.C) {
   113  	worker := s.setupWorkerTest(c)
   114  	var lock interface{}
   115  	err := s.manifold.Output(worker, &lock)
   116  	c.Check(err.Error(), gc.Equals, "expected *machinelock.machineLockWorker->**fslock.Lock; got *machinelock.machineLockWorker->*interface {}")
   117  	c.Check(lock, gc.IsNil)
   118  }
   119  
   120  type dummyAgent struct {
   121  	agent.Agent
   122  }
   123  
   124  func (_ dummyAgent) CurrentConfig() coreagent.Config {
   125  	return &dummyAgentConfig{}
   126  }
   127  
   128  type dummyAgentConfig struct {
   129  	coreagent.Config
   130  }
   131  
   132  func (_ dummyAgentConfig) DataDir() string {
   133  	return "/path/to/data/dir"
   134  }
   135  
   136  type dummyWorker struct {
   137  	worker.Worker
   138  }