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

     1  // Copyright 2018 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package credentialvalidator_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  
    15  	"github.com/juju/juju/api/base"
    16  	"github.com/juju/juju/cmd/jujud/agent/engine"
    17  	"github.com/juju/juju/worker/credentialvalidator"
    18  )
    19  
    20  type ManifoldSuite struct {
    21  	testing.IsolationSuite
    22  }
    23  
    24  var _ = gc.Suite(&ManifoldSuite{})
    25  
    26  func (*ManifoldSuite) TestInputs(c *gc.C) {
    27  	manifold := credentialvalidator.Manifold(validManifoldConfig())
    28  	c.Check(manifold.Inputs, jc.DeepEquals, []string{"api-caller"})
    29  }
    30  
    31  func (*ManifoldSuite) TestOutputBadWorker(c *gc.C) {
    32  	manifold := credentialvalidator.Manifold(credentialvalidator.ManifoldConfig{})
    33  	in := &struct{ worker.Worker }{}
    34  	var out engine.Flag
    35  	err := manifold.Output(in, &out)
    36  	c.Check(err, gc.ErrorMatches, "expected in to implement Flag; got a .*")
    37  }
    38  
    39  func (*ManifoldSuite) TestFilterNil(c *gc.C) {
    40  	manifold := credentialvalidator.Manifold(credentialvalidator.ManifoldConfig{})
    41  	err := manifold.Filter(nil)
    42  	c.Check(err, jc.ErrorIsNil)
    43  }
    44  
    45  func (*ManifoldSuite) TestFilterErrChanged(c *gc.C) {
    46  	manifold := credentialvalidator.Manifold(credentialvalidator.ManifoldConfig{})
    47  	err := manifold.Filter(credentialvalidator.ErrValidityChanged)
    48  	c.Check(err, gc.Equals, dependency.ErrBounce)
    49  }
    50  
    51  func (*ManifoldSuite) TestFilterErrModelCredentialChanged(c *gc.C) {
    52  	manifold := credentialvalidator.Manifold(credentialvalidator.ManifoldConfig{})
    53  	err := manifold.Filter(credentialvalidator.ErrModelCredentialChanged)
    54  	c.Check(err, gc.Equals, dependency.ErrBounce)
    55  }
    56  
    57  func (*ManifoldSuite) TestFilterOther(c *gc.C) {
    58  	manifold := credentialvalidator.Manifold(credentialvalidator.ManifoldConfig{})
    59  	expect := errors.New("whatever")
    60  	actual := manifold.Filter(expect)
    61  	c.Check(actual, gc.Equals, expect)
    62  }
    63  
    64  func (*ManifoldSuite) TestStartMissingAPICallerName(c *gc.C) {
    65  	config := validManifoldConfig()
    66  	config.APICallerName = ""
    67  	checkManifoldNotValid(c, config, "empty APICallerName not valid")
    68  }
    69  
    70  func (*ManifoldSuite) TestStartMissingNewFacade(c *gc.C) {
    71  	config := validManifoldConfig()
    72  	config.NewFacade = nil
    73  	checkManifoldNotValid(c, config, "nil NewFacade not valid")
    74  }
    75  
    76  func (*ManifoldSuite) TestStartMissingNewWorker(c *gc.C) {
    77  	config := validManifoldConfig()
    78  	config.NewWorker = nil
    79  	checkManifoldNotValid(c, config, "nil NewWorker not valid")
    80  }
    81  
    82  func (*ManifoldSuite) TestStartMissingAPICaller(c *gc.C) {
    83  	context := dt.StubContext(nil, map[string]interface{}{
    84  		"api-caller": dependency.ErrMissing,
    85  	})
    86  	manifold := credentialvalidator.Manifold(validManifoldConfig())
    87  
    88  	w, err := manifold.Start(context)
    89  	c.Check(w, gc.IsNil)
    90  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    91  }
    92  
    93  func (*ManifoldSuite) TestStartNewFacadeError(c *gc.C) {
    94  	expectCaller := &stubCaller{}
    95  	context := dt.StubContext(nil, map[string]interface{}{
    96  		"api-caller": expectCaller,
    97  	})
    98  	config := validManifoldConfig()
    99  	config.NewFacade = func(caller base.APICaller) (credentialvalidator.Facade, error) {
   100  		c.Check(caller, gc.Equals, expectCaller)
   101  		return nil, errors.New("bort")
   102  	}
   103  	manifold := credentialvalidator.Manifold(config)
   104  
   105  	w, err := manifold.Start(context)
   106  	c.Check(w, gc.IsNil)
   107  	c.Check(err, gc.ErrorMatches, "bort")
   108  }
   109  
   110  func (*ManifoldSuite) TestStartNewWorkerError(c *gc.C) {
   111  	context := dt.StubContext(nil, map[string]interface{}{
   112  		"api-caller": &stubCaller{},
   113  	})
   114  	expectFacade := &struct{ credentialvalidator.Facade }{}
   115  	config := validManifoldConfig()
   116  	config.NewFacade = func(base.APICaller) (credentialvalidator.Facade, error) {
   117  		return expectFacade, nil
   118  	}
   119  	config.NewWorker = func(workerConfig credentialvalidator.Config) (worker.Worker, error) {
   120  		c.Check(workerConfig.Facade, gc.Equals, expectFacade)
   121  		return nil, errors.New("snerk")
   122  	}
   123  	manifold := credentialvalidator.Manifold(config)
   124  
   125  	w, err := manifold.Start(context)
   126  	c.Check(w, gc.IsNil)
   127  	c.Check(err, gc.ErrorMatches, "snerk")
   128  }
   129  
   130  func (*ManifoldSuite) TestStartSuccess(c *gc.C) {
   131  	context := dt.StubContext(nil, map[string]interface{}{
   132  		"api-caller": &stubCaller{},
   133  	})
   134  	expectWorker := &struct{ worker.Worker }{}
   135  	config := validManifoldConfig()
   136  	config.NewFacade = func(base.APICaller) (credentialvalidator.Facade, error) {
   137  		return &struct{ credentialvalidator.Facade }{}, nil
   138  	}
   139  	config.NewWorker = func(credentialvalidator.Config) (worker.Worker, error) {
   140  		return expectWorker, nil
   141  	}
   142  	manifold := credentialvalidator.Manifold(config)
   143  
   144  	w, err := manifold.Start(context)
   145  	c.Check(err, jc.ErrorIsNil)
   146  	c.Check(w, gc.Equals, expectWorker)
   147  }