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

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package restorewatcher_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  	"github.com/juju/juju/worker/restorewatcher"
    19  )
    20  
    21  type ManifoldSuite struct {
    22  	statetesting.StateSuite
    23  
    24  	manifold     dependency.Manifold
    25  	context      dependency.Context
    26  	stateTracker stubStateTracker
    27  
    28  	stub testing.Stub
    29  }
    30  
    31  var _ = gc.Suite(&ManifoldSuite{})
    32  
    33  func (s *ManifoldSuite) SetUpTest(c *gc.C) {
    34  	s.StateSuite.SetUpTest(c)
    35  
    36  	s.stateTracker = stubStateTracker{pool: s.StatePool}
    37  	s.stub.ResetCalls()
    38  
    39  	s.context = s.newContext(nil)
    40  	s.manifold = restorewatcher.Manifold(restorewatcher.ManifoldConfig{
    41  		StateName: "state",
    42  		NewWorker: s.newWorker,
    43  	})
    44  }
    45  
    46  func (s *ManifoldSuite) newContext(overlay map[string]interface{}) dependency.Context {
    47  	resources := map[string]interface{}{"state": &s.stateTracker}
    48  	for k, v := range overlay {
    49  		resources[k] = v
    50  	}
    51  	return dt.StubContext(nil, resources)
    52  }
    53  
    54  func (s *ManifoldSuite) newWorker(config restorewatcher.Config) (restorewatcher.RestoreStatusWorker, error) {
    55  	s.stub.MethodCall(s, "NewWorker", config)
    56  	if err := s.stub.NextErr(); err != nil {
    57  		return nil, err
    58  	}
    59  	w := worker.NewRunner(worker.RunnerParams{})
    60  	s.AddCleanup(func(c *gc.C) { workertest.DirtyKill(c, w) })
    61  	return restoreStatusWorker{w}, nil
    62  }
    63  
    64  type restoreStatusWorker struct {
    65  	worker.Worker
    66  }
    67  
    68  func (restoreStatusWorker) RestoreStatus() state.RestoreStatus {
    69  	panic("RestoreStatus should not be called")
    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, restorewatcher.Config{})
    96  	config := args[0].(restorewatcher.Config)
    97  
    98  	c.Assert(config, jc.DeepEquals, restorewatcher.Config{
    99  		RestoreInfoWatcher: restorewatcher.RestoreInfoWatcherShim{s.State},
   100  	})
   101  }
   102  
   103  func (s *ManifoldSuite) TestStopWorkerClosesState(c *gc.C) {
   104  	w := s.startWorkerClean(c)
   105  	defer workertest.CleanKill(c, w)
   106  
   107  	s.stateTracker.CheckCallNames(c, "Use")
   108  
   109  	workertest.CleanKill(c, w)
   110  	s.stateTracker.CheckCallNames(c, "Use", "Done")
   111  }
   112  
   113  func (s *ManifoldSuite) startWorkerClean(c *gc.C) worker.Worker {
   114  	w, err := s.manifold.Start(s.context)
   115  	c.Assert(err, jc.ErrorIsNil)
   116  	workertest.CheckAlive(c, w)
   117  	return w
   118  }
   119  
   120  type stubStateTracker struct {
   121  	testing.Stub
   122  	pool *state.StatePool
   123  }
   124  
   125  func (s *stubStateTracker) Use() (*state.StatePool, error) {
   126  	s.MethodCall(s, "Use")
   127  	return s.pool, s.NextErr()
   128  }
   129  
   130  func (s *stubStateTracker) Done() error {
   131  	s.MethodCall(s, "Done")
   132  	return s.NextErr()
   133  }
   134  
   135  func (s *stubStateTracker) Report() map[string]interface{} {
   136  	s.MethodCall(s, "Report")
   137  	return nil
   138  }