github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/worker/modelworkermanager/manifold_test.go (about)

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package modelworkermanager_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/worker.v1"
    12  	"gopkg.in/juju/worker.v1/dependency"
    13  	dt "gopkg.in/juju/worker.v1/dependency/testing"
    14  	"gopkg.in/juju/worker.v1/workertest"
    15  
    16  	"github.com/juju/juju/state"
    17  	statetesting "github.com/juju/juju/state/testing"
    18  	jworker "github.com/juju/juju/worker"
    19  	"github.com/juju/juju/worker/modelworkermanager"
    20  )
    21  
    22  type ManifoldSuite struct {
    23  	statetesting.StateSuite
    24  
    25  	manifold     dependency.Manifold
    26  	context      dependency.Context
    27  	stateTracker stubStateTracker
    28  
    29  	stub testing.Stub
    30  }
    31  
    32  var _ = gc.Suite(&ManifoldSuite{})
    33  
    34  func (s *ManifoldSuite) SetUpTest(c *gc.C) {
    35  	s.StateSuite.SetUpTest(c)
    36  
    37  	s.stateTracker = stubStateTracker{pool: s.StatePool}
    38  	s.stub.ResetCalls()
    39  
    40  	s.context = s.newContext(nil)
    41  	s.manifold = modelworkermanager.Manifold(modelworkermanager.ManifoldConfig{
    42  		StateName:      "state",
    43  		NewWorker:      s.newWorker,
    44  		NewModelWorker: s.newModelWorker,
    45  	})
    46  }
    47  
    48  func (s *ManifoldSuite) newContext(overlay map[string]interface{}) dependency.Context {
    49  	resources := map[string]interface{}{"state": &s.stateTracker}
    50  	for k, v := range overlay {
    51  		resources[k] = v
    52  	}
    53  	return dt.StubContext(nil, resources)
    54  }
    55  
    56  func (s *ManifoldSuite) newWorker(config modelworkermanager.Config) (worker.Worker, error) {
    57  	s.stub.MethodCall(s, "NewWorker", config)
    58  	if err := s.stub.NextErr(); err != nil {
    59  		return nil, err
    60  	}
    61  	return worker.NewRunner(worker.RunnerParams{}), nil
    62  }
    63  
    64  func (s *ManifoldSuite) newModelWorker(modelUUID string, modelType state.ModelType) (worker.Worker, error) {
    65  	s.stub.MethodCall(s, "NewModelWorker", modelUUID, modelType)
    66  	if err := s.stub.NextErr(); err != nil {
    67  		return nil, err
    68  	}
    69  	return worker.NewRunner(worker.RunnerParams{}), nil
    70  }
    71  
    72  var expectedInputs = []string{"state"}
    73  
    74  func (s *ManifoldSuite) TestInputs(c *gc.C) {
    75  	c.Assert(s.manifold.Inputs, jc.SameContents, expectedInputs)
    76  }
    77  
    78  func (s *ManifoldSuite) TestMissingInputs(c *gc.C) {
    79  	for _, input := range expectedInputs {
    80  		context := s.newContext(map[string]interface{}{
    81  			input: dependency.ErrMissing,
    82  		})
    83  		_, err := s.manifold.Start(context)
    84  		c.Assert(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    85  	}
    86  }
    87  
    88  func (s *ManifoldSuite) TestStart(c *gc.C) {
    89  	w := s.startWorkerClean(c)
    90  	workertest.CleanKill(c, w)
    91  
    92  	s.stub.CheckCallNames(c, "NewWorker")
    93  	args := s.stub.Calls()[0].Args
    94  	c.Assert(args, gc.HasLen, 1)
    95  	c.Assert(args[0], gc.FitsTypeOf, modelworkermanager.Config{})
    96  	config := args[0].(modelworkermanager.Config)
    97  
    98  	c.Assert(config.NewModelWorker, gc.NotNil)
    99  	mw, err := config.NewModelWorker("foo", state.ModelTypeIAAS)
   100  	c.Assert(err, jc.ErrorIsNil)
   101  	workertest.CleanKill(c, mw)
   102  	s.stub.CheckCallNames(c, "NewWorker", "NewModelWorker")
   103  	s.stub.CheckCall(c, 1, "NewModelWorker", "foo", state.ModelTypeIAAS)
   104  	config.NewModelWorker = nil
   105  
   106  	c.Assert(config, jc.DeepEquals, modelworkermanager.Config{
   107  		ModelWatcher: s.State,
   108  		ModelGetter:  modelworkermanager.StatePoolModelGetter{s.StatePool},
   109  		ErrorDelay:   jworker.RestartDelay,
   110  	})
   111  }
   112  
   113  func (s *ManifoldSuite) TestStopWorkerClosesState(c *gc.C) {
   114  	w := s.startWorkerClean(c)
   115  	defer workertest.CleanKill(c, w)
   116  
   117  	s.stateTracker.CheckCallNames(c, "Use")
   118  
   119  	workertest.CleanKill(c, w)
   120  	s.stateTracker.CheckCallNames(c, "Use", "Done")
   121  }
   122  
   123  func (s *ManifoldSuite) startWorkerClean(c *gc.C) worker.Worker {
   124  	w, err := s.manifold.Start(s.context)
   125  	c.Assert(err, jc.ErrorIsNil)
   126  	workertest.CheckAlive(c, w)
   127  	return w
   128  }
   129  
   130  type stubStateTracker struct {
   131  	testing.Stub
   132  	pool *state.StatePool
   133  }
   134  
   135  func (s *stubStateTracker) Use() (*state.StatePool, error) {
   136  	s.MethodCall(s, "Use")
   137  	return s.pool, s.NextErr()
   138  }
   139  
   140  func (s *stubStateTracker) Done() error {
   141  	s.MethodCall(s, "Done")
   142  	return s.NextErr()
   143  }
   144  
   145  func (s *stubStateTracker) Report() map[string]interface{} {
   146  	s.MethodCall(s, "Report")
   147  	return nil
   148  }