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

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package modelupgrader_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/environs"
    17  	"github.com/juju/juju/worker/common"
    18  	"github.com/juju/juju/worker/gate"
    19  	"github.com/juju/juju/worker/modelupgrader"
    20  )
    21  
    22  type ManifoldSuite struct {
    23  	testing.IsolationSuite
    24  }
    25  
    26  var _ = gc.Suite(&ManifoldSuite{})
    27  
    28  func (*ManifoldSuite) TestInputs(c *gc.C) {
    29  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{
    30  		APICallerName: "boris",
    31  		EnvironName:   "nikolayevich",
    32  		GateName:      "yeltsin",
    33  	})
    34  	c.Check(manifold.Inputs, jc.DeepEquals, []string{"boris", "nikolayevich", "yeltsin"})
    35  }
    36  
    37  func (*ManifoldSuite) TestMissingAPICaller(c *gc.C) {
    38  	context := dt.StubContext(nil, map[string]interface{}{
    39  		"api-caller": dependency.ErrMissing,
    40  		"environ":    struct{ environs.Environ }{},
    41  		"gate":       struct{ gate.Unlocker }{},
    42  	})
    43  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{
    44  		APICallerName: "api-caller",
    45  		EnvironName:   "environ",
    46  		GateName:      "gate",
    47  	})
    48  
    49  	worker, err := manifold.Start(context)
    50  	c.Check(worker, gc.IsNil)
    51  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    52  }
    53  
    54  func (*ManifoldSuite) TestMissingGateName(c *gc.C) {
    55  	context := dt.StubContext(nil, map[string]interface{}{
    56  		"api-caller": struct{ base.APICaller }{},
    57  		"environ":    struct{ environs.Environ }{},
    58  		"gate":       dependency.ErrMissing,
    59  	})
    60  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{
    61  		APICallerName: "api-caller",
    62  		EnvironName:   "environ",
    63  		GateName:      "gate",
    64  	})
    65  
    66  	worker, err := manifold.Start(context)
    67  	c.Check(worker, gc.IsNil)
    68  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    69  }
    70  
    71  func (*ManifoldSuite) TestNewFacadeError(c *gc.C) {
    72  	expectAPICaller := struct{ base.APICaller }{}
    73  	expectEnviron := struct{ environs.Environ }{}
    74  	expectGate := struct{ gate.Unlocker }{}
    75  	context := dt.StubContext(nil, map[string]interface{}{
    76  		"api-caller": expectAPICaller,
    77  		"environ":    expectEnviron,
    78  		"gate":       expectGate,
    79  	})
    80  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{
    81  		APICallerName: "api-caller",
    82  		EnvironName:   "environ",
    83  		GateName:      "gate",
    84  		NewFacade: func(actual base.APICaller) (modelupgrader.Facade, error) {
    85  			c.Check(actual, gc.Equals, expectAPICaller)
    86  			return nil, errors.New("splort")
    87  		},
    88  	})
    89  
    90  	worker, err := manifold.Start(context)
    91  	c.Check(worker, gc.IsNil)
    92  	c.Check(err, gc.ErrorMatches, "splort")
    93  }
    94  
    95  func (*ManifoldSuite) TestNewWorkerError(c *gc.C) {
    96  	expectFacade := struct{ modelupgrader.Facade }{}
    97  	context := dt.StubContext(nil, map[string]interface{}{
    98  		"api-caller": struct{ base.APICaller }{},
    99  		"environ":    struct{ environs.Environ }{},
   100  		"gate":       struct{ gate.Unlocker }{},
   101  	})
   102  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{
   103  		APICallerName: "api-caller",
   104  		EnvironName:   "environ",
   105  		GateName:      "gate",
   106  		NewFacade: func(_ base.APICaller) (modelupgrader.Facade, error) {
   107  			return expectFacade, nil
   108  		},
   109  		NewWorker: func(config modelupgrader.Config) (worker.Worker, error) {
   110  			c.Check(config.Facade, gc.Equals, expectFacade)
   111  			return nil, errors.New("boof")
   112  		},
   113  		NewCredentialValidatorFacade: func(base.APICaller) (common.CredentialAPI, error) { return nil, nil },
   114  	})
   115  
   116  	worker, err := manifold.Start(context)
   117  	c.Check(worker, gc.IsNil)
   118  	c.Check(err, gc.ErrorMatches, "boof")
   119  }
   120  
   121  func (*ManifoldSuite) TestNewWorkerSuccessWithEnviron(c *gc.C) {
   122  	expectWorker := &struct{ worker.Worker }{}
   123  	expectEnviron := struct{ environs.Environ }{}
   124  	context := dt.StubContext(nil, map[string]interface{}{
   125  		"api-caller": struct{ base.APICaller }{},
   126  		"environ":    expectEnviron,
   127  		"gate":       struct{ gate.Unlocker }{},
   128  	})
   129  	var newWorkerConfig modelupgrader.Config
   130  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{
   131  		APICallerName: "api-caller",
   132  		EnvironName:   "environ",
   133  		GateName:      "gate",
   134  		NewFacade: func(_ base.APICaller) (modelupgrader.Facade, error) {
   135  			return struct{ modelupgrader.Facade }{}, nil
   136  		},
   137  		NewWorker: func(config modelupgrader.Config) (worker.Worker, error) {
   138  			newWorkerConfig = config
   139  			return expectWorker, nil
   140  		},
   141  		NewCredentialValidatorFacade: func(base.APICaller) (common.CredentialAPI, error) { return nil, nil },
   142  	})
   143  
   144  	worker, err := manifold.Start(context)
   145  	c.Check(worker, gc.Equals, expectWorker)
   146  	c.Check(err, jc.ErrorIsNil)
   147  	c.Check(newWorkerConfig.Environ, gc.Equals, expectEnviron)
   148  }
   149  
   150  func (*ManifoldSuite) TestNewWorkerSuccessWithoutEnviron(c *gc.C) {
   151  	expectWorker := &struct{ worker.Worker }{}
   152  	context := dt.StubContext(nil, map[string]interface{}{
   153  		"api-caller": struct{ base.APICaller }{},
   154  		"environ":    dependency.ErrMissing,
   155  		"gate":       struct{ gate.Unlocker }{},
   156  	})
   157  	var newWorkerConfig modelupgrader.Config
   158  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{
   159  		APICallerName: "api-caller",
   160  		EnvironName:   "environ",
   161  		GateName:      "gate",
   162  		NewFacade: func(_ base.APICaller) (modelupgrader.Facade, error) {
   163  			return struct{ modelupgrader.Facade }{}, nil
   164  		},
   165  		NewWorker: func(config modelupgrader.Config) (worker.Worker, error) {
   166  			newWorkerConfig = config
   167  			return expectWorker, nil
   168  		},
   169  		NewCredentialValidatorFacade: func(base.APICaller) (common.CredentialAPI, error) { return nil, nil },
   170  	})
   171  
   172  	worker, err := manifold.Start(context)
   173  	c.Check(worker, gc.Equals, expectWorker)
   174  	c.Check(err, jc.ErrorIsNil)
   175  	c.Check(newWorkerConfig.Environ, gc.IsNil)
   176  }
   177  
   178  func (*ManifoldSuite) TestFilterNil(c *gc.C) {
   179  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{})
   180  	err := manifold.Filter(nil)
   181  	c.Check(err, jc.ErrorIsNil)
   182  }
   183  
   184  func (*ManifoldSuite) TestFilterErrModelRemoved(c *gc.C) {
   185  	manifold := modelupgrader.Manifold(modelupgrader.ManifoldConfig{})
   186  	err := manifold.Filter(modelupgrader.ErrModelRemoved)
   187  	c.Check(err, gc.Equals, dependency.ErrUninstall)
   188  }