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

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package proxyupdater_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/proxy"
     9  	"github.com/juju/testing"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  	"gopkg.in/juju/names.v2"
    13  	"gopkg.in/juju/worker.v1"
    14  	"gopkg.in/juju/worker.v1/dependency"
    15  	dt "gopkg.in/juju/worker.v1/dependency/testing"
    16  
    17  	"github.com/juju/juju/agent"
    18  	"github.com/juju/juju/api/base"
    19  	"github.com/juju/juju/worker/proxyupdater"
    20  )
    21  
    22  type ManifoldSuite struct {
    23  	testing.IsolationSuite
    24  	config   proxyupdater.ManifoldConfig
    25  	startErr error
    26  }
    27  
    28  var _ = gc.Suite(&ManifoldSuite{})
    29  
    30  func MakeUpdateFunc(name string) func(proxy.Settings) error {
    31  	// So we can tell the difference between update funcs.
    32  	return func(proxy.Settings) error {
    33  		return errors.New(name)
    34  	}
    35  }
    36  
    37  func (s *ManifoldSuite) SetUpTest(c *gc.C) {
    38  	s.IsolationSuite.SetUpTest(c)
    39  	s.startErr = nil
    40  	s.config = proxyupdater.ManifoldConfig{
    41  		AgentName:     "agent-name",
    42  		APICallerName: "api-caller-name",
    43  		WorkerFunc: func(cfg proxyupdater.Config) (worker.Worker, error) {
    44  			if s.startErr != nil {
    45  				return nil, s.startErr
    46  			}
    47  			return &dummyWorker{config: cfg}, nil
    48  		},
    49  		ExternalUpdate:  MakeUpdateFunc("external"),
    50  		InProcessUpdate: MakeUpdateFunc("in-process"),
    51  	}
    52  }
    53  
    54  func (s *ManifoldSuite) manifold() dependency.Manifold {
    55  	return proxyupdater.Manifold(s.config)
    56  }
    57  
    58  func (s *ManifoldSuite) TestInputs(c *gc.C) {
    59  	c.Check(s.manifold().Inputs, jc.DeepEquals, []string{"agent-name", "api-caller-name"})
    60  }
    61  
    62  func (s *ManifoldSuite) TestWorkerFuncMissing(c *gc.C) {
    63  	s.config.WorkerFunc = nil
    64  	context := dt.StubContext(nil, nil)
    65  	worker, err := s.manifold().Start(context)
    66  	c.Check(worker, gc.IsNil)
    67  	c.Check(err, gc.ErrorMatches, "missing WorkerFunc not valid")
    68  }
    69  
    70  func (s *ManifoldSuite) TestInProcessUpdateMissing(c *gc.C) {
    71  	s.config.InProcessUpdate = nil
    72  	context := dt.StubContext(nil, nil)
    73  	worker, err := s.manifold().Start(context)
    74  	c.Check(worker, gc.IsNil)
    75  	c.Check(err, gc.ErrorMatches, "missing InProcessUpdate not valid")
    76  }
    77  
    78  func (s *ManifoldSuite) TestStartAgentMissing(c *gc.C) {
    79  	context := dt.StubContext(nil, map[string]interface{}{
    80  		"agent-name": dependency.ErrMissing,
    81  	})
    82  
    83  	worker, err := s.manifold().Start(context)
    84  	c.Check(worker, gc.IsNil)
    85  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    86  }
    87  
    88  func (s *ManifoldSuite) TestStartAPICallerMissing(c *gc.C) {
    89  	context := dt.StubContext(nil, map[string]interface{}{
    90  		"agent-name":      &dummyAgent{},
    91  		"api-caller-name": dependency.ErrMissing,
    92  	})
    93  
    94  	worker, err := s.manifold().Start(context)
    95  	c.Check(worker, gc.IsNil)
    96  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    97  }
    98  
    99  func (s *ManifoldSuite) TestStartError(c *gc.C) {
   100  	s.startErr = errors.New("boom")
   101  	context := dt.StubContext(nil, map[string]interface{}{
   102  		"agent-name":      &dummyAgent{},
   103  		"api-caller-name": &dummyAPICaller{},
   104  	})
   105  
   106  	worker, err := s.manifold().Start(context)
   107  	c.Check(worker, gc.IsNil)
   108  	c.Check(err, gc.ErrorMatches, "boom")
   109  }
   110  
   111  func (s *ManifoldSuite) TestStartSuccess(c *gc.C) {
   112  	context := dt.StubContext(nil, map[string]interface{}{
   113  		"agent-name":      &dummyAgent{},
   114  		"api-caller-name": &dummyAPICaller{},
   115  	})
   116  
   117  	worker, err := s.manifold().Start(context)
   118  	c.Check(err, jc.ErrorIsNil)
   119  	dummy, ok := worker.(*dummyWorker)
   120  	c.Assert(ok, jc.IsTrue)
   121  	c.Check(dummy.config.SystemdFiles, gc.DeepEquals, []string{"/etc/juju-proxy-systemd.conf"})
   122  	c.Check(dummy.config.EnvFiles, gc.DeepEquals, []string{"/etc/juju-proxy.conf"})
   123  	c.Check(dummy.config.RegistryPath, gc.Equals, `HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings`)
   124  	c.Check(dummy.config.API, gc.NotNil)
   125  	// Checking function equality is problematic, use the errors they
   126  	// return.
   127  	c.Check(dummy.config.ExternalUpdate(proxy.Settings{}), gc.ErrorMatches, "external")
   128  	c.Check(dummy.config.InProcessUpdate(proxy.Settings{}), gc.ErrorMatches, "in-process")
   129  }
   130  
   131  type dummyAgent struct {
   132  	agent.Agent
   133  }
   134  
   135  func (*dummyAgent) CurrentConfig() agent.Config {
   136  	return &dummyConfig{}
   137  }
   138  
   139  type dummyConfig struct {
   140  	agent.Config
   141  }
   142  
   143  func (*dummyConfig) Tag() names.Tag {
   144  	return names.NewMachineTag("42")
   145  }
   146  
   147  type dummyAPICaller struct {
   148  	base.APICaller
   149  }
   150  
   151  func (*dummyAPICaller) BestFacadeVersion(_ string) int {
   152  	return 42
   153  }
   154  
   155  type dummyWorker struct {
   156  	worker.Worker
   157  
   158  	config proxyupdater.Config
   159  }