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

     1  // Copyright 2018 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package raftbackstop_test
     5  
     6  import (
     7  	"github.com/hashicorp/raft"
     8  	"github.com/juju/errors"
     9  	"github.com/juju/loggo"
    10  	"github.com/juju/pubsub"
    11  	"github.com/juju/testing"
    12  	jc "github.com/juju/testing/checkers"
    13  	gc "gopkg.in/check.v1"
    14  	"gopkg.in/juju/names.v2"
    15  	"gopkg.in/juju/worker.v1"
    16  	"gopkg.in/juju/worker.v1/dependency"
    17  	dt "gopkg.in/juju/worker.v1/dependency/testing"
    18  
    19  	"github.com/juju/juju/agent"
    20  	"github.com/juju/juju/worker/raft/raftbackstop"
    21  )
    22  
    23  type ManifoldSuite struct {
    24  	testing.IsolationSuite
    25  
    26  	manifold dependency.Manifold
    27  	context  dependency.Context
    28  	raft     *raft.Raft
    29  	logStore raft.LogStore
    30  	hub      *pubsub.StructuredHub
    31  	agent    *mockAgent
    32  	logger   loggo.Logger
    33  	worker   worker.Worker
    34  	stub     testing.Stub
    35  }
    36  
    37  var _ = gc.Suite(&ManifoldSuite{})
    38  
    39  func (s *ManifoldSuite) SetUpTest(c *gc.C) {
    40  	s.IsolationSuite.SetUpTest(c)
    41  
    42  	s.raft = &raft.Raft{}
    43  	type mockLogStore struct {
    44  		raft.LogStore
    45  	}
    46  	s.logStore = &mockLogStore{}
    47  	s.hub = &pubsub.StructuredHub{}
    48  	s.stub.ResetCalls()
    49  
    50  	type mockWorker struct {
    51  		worker.Worker
    52  	}
    53  	s.worker = &mockWorker{}
    54  	s.agent = &mockAgent{
    55  		conf: mockAgentConfig{tag: names.NewMachineTag("3")},
    56  	}
    57  	s.logger = loggo.GetLogger("raftbackstop_test")
    58  
    59  	s.context = s.newContext(nil)
    60  	s.manifold = raftbackstop.Manifold(raftbackstop.ManifoldConfig{
    61  		RaftName:       "raft",
    62  		CentralHubName: "central-hub",
    63  		AgentName:      "agent",
    64  		NewWorker:      s.newWorker,
    65  		Logger:         s.logger,
    66  	})
    67  }
    68  
    69  func (s *ManifoldSuite) newContext(overlay map[string]interface{}) dependency.Context {
    70  	resources := map[string]interface{}{
    71  		"raft":        []interface{}{s.raft, s.logStore},
    72  		"central-hub": s.hub,
    73  		"agent":       s.agent,
    74  	}
    75  	for k, v := range overlay {
    76  		resources[k] = v
    77  	}
    78  	return dt.StubContext(nil, resources)
    79  }
    80  
    81  func (s *ManifoldSuite) newWorker(config raftbackstop.Config) (worker.Worker, error) {
    82  	s.stub.MethodCall(s, "NewWorker", config)
    83  	if err := s.stub.NextErr(); err != nil {
    84  		return nil, err
    85  	}
    86  	return s.worker, nil
    87  }
    88  
    89  var expectedInputs = []string{
    90  	"raft", "central-hub", "agent",
    91  }
    92  
    93  func (s *ManifoldSuite) TestInputs(c *gc.C) {
    94  	c.Assert(s.manifold.Inputs, jc.SameContents, expectedInputs)
    95  }
    96  
    97  func (s *ManifoldSuite) TestMissingInputs(c *gc.C) {
    98  	for _, input := range expectedInputs {
    99  		context := s.newContext(map[string]interface{}{
   100  			input: dependency.ErrMissing,
   101  		})
   102  		_, err := s.manifold.Start(context)
   103  		c.Assert(errors.Cause(err), gc.Equals, dependency.ErrMissing)
   104  	}
   105  }
   106  
   107  func (s *ManifoldSuite) TestStart(c *gc.C) {
   108  	s.startWorkerClean(c)
   109  
   110  	s.stub.CheckCallNames(c, "NewWorker")
   111  	args := s.stub.Calls()[0].Args
   112  	c.Assert(args, gc.HasLen, 1)
   113  	c.Assert(args[0], gc.FitsTypeOf, raftbackstop.Config{})
   114  	config := args[0].(raftbackstop.Config)
   115  
   116  	c.Assert(config, jc.DeepEquals, raftbackstop.Config{
   117  		Raft:     s.raft,
   118  		Hub:      s.hub,
   119  		LogStore: s.logStore,
   120  		LocalID:  "3",
   121  		Logger:   s.logger,
   122  	})
   123  }
   124  
   125  func (s *ManifoldSuite) startWorkerClean(c *gc.C) worker.Worker {
   126  	w, err := s.manifold.Start(s.context)
   127  	c.Assert(err, jc.ErrorIsNil)
   128  	c.Assert(w, gc.Equals, s.worker)
   129  	return w
   130  }
   131  
   132  type mockAgent struct {
   133  	agent.Agent
   134  	conf mockAgentConfig
   135  }
   136  
   137  func (ma *mockAgent) CurrentConfig() agent.Config {
   138  	return &ma.conf
   139  }
   140  
   141  type mockAgentConfig struct {
   142  	agent.Config
   143  	tag names.Tag
   144  }
   145  
   146  func (c *mockAgentConfig) Tag() names.Tag {
   147  	return c.tag
   148  }