github.com/juju/juju@v0.0.0-20240327075706-a90865de2538/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  	"github.com/juju/worker/v3"
    11  	"github.com/juju/worker/v3/dependency"
    12  	dt "github.com/juju/worker/v3/dependency/testing"
    13  	gc "gopkg.in/check.v1"
    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) TestStartMissingLogger(c *gc.C) {
    83  	config := validManifoldConfig()
    84  	config.Logger = nil
    85  	checkManifoldNotValid(c, config, "nil Logger not valid")
    86  }
    87  
    88  func (*ManifoldSuite) TestStartMissingAPICaller(c *gc.C) {
    89  	context := dt.StubContext(nil, map[string]interface{}{
    90  		"api-caller": dependency.ErrMissing,
    91  	})
    92  	manifold := credentialvalidator.Manifold(validManifoldConfig())
    93  
    94  	w, err := manifold.Start(context)
    95  	c.Check(w, gc.IsNil)
    96  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    97  }
    98  
    99  func (*ManifoldSuite) TestStartNewFacadeError(c *gc.C) {
   100  	expectCaller := &stubCaller{}
   101  	context := dt.StubContext(nil, map[string]interface{}{
   102  		"api-caller": expectCaller,
   103  	})
   104  	config := validManifoldConfig()
   105  	config.NewFacade = func(caller base.APICaller) (credentialvalidator.Facade, error) {
   106  		c.Check(caller, gc.Equals, expectCaller)
   107  		return nil, errors.New("bort")
   108  	}
   109  	manifold := credentialvalidator.Manifold(config)
   110  
   111  	w, err := manifold.Start(context)
   112  	c.Check(w, gc.IsNil)
   113  	c.Check(err, gc.ErrorMatches, "bort")
   114  }
   115  
   116  func (*ManifoldSuite) TestStartNewWorkerError(c *gc.C) {
   117  	context := dt.StubContext(nil, map[string]interface{}{
   118  		"api-caller": &stubCaller{},
   119  	})
   120  	expectFacade := &struct{ credentialvalidator.Facade }{}
   121  	config := validManifoldConfig()
   122  	config.NewFacade = func(base.APICaller) (credentialvalidator.Facade, error) {
   123  		return expectFacade, nil
   124  	}
   125  	config.NewWorker = func(workerConfig credentialvalidator.Config) (worker.Worker, error) {
   126  		c.Check(workerConfig.Facade, gc.Equals, expectFacade)
   127  		return nil, errors.New("snerk")
   128  	}
   129  	manifold := credentialvalidator.Manifold(config)
   130  
   131  	w, err := manifold.Start(context)
   132  	c.Check(w, gc.IsNil)
   133  	c.Check(err, gc.ErrorMatches, "snerk")
   134  }
   135  
   136  func (*ManifoldSuite) TestStartSuccess(c *gc.C) {
   137  	context := dt.StubContext(nil, map[string]interface{}{
   138  		"api-caller": &stubCaller{},
   139  	})
   140  	expectWorker := &struct{ worker.Worker }{}
   141  	config := validManifoldConfig()
   142  	config.NewFacade = func(base.APICaller) (credentialvalidator.Facade, error) {
   143  		return &struct{ credentialvalidator.Facade }{}, nil
   144  	}
   145  	config.NewWorker = func(credentialvalidator.Config) (worker.Worker, error) {
   146  		return expectWorker, nil
   147  	}
   148  	manifold := credentialvalidator.Manifold(config)
   149  
   150  	w, err := manifold.Start(context)
   151  	c.Check(err, jc.ErrorIsNil)
   152  	c.Check(w, gc.Equals, expectWorker)
   153  }