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

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package migrationflag_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/migrationflag"
    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 := migrationflag.Manifold(validManifoldConfig())
    28  	c.Check(manifold.Inputs, jc.DeepEquals, []string{"api-caller"})
    29  }
    30  
    31  func (*ManifoldSuite) TestOutputBadWorker(c *gc.C) {
    32  	manifold := migrationflag.Manifold(migrationflag.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) TestOutputBadTarget(c *gc.C) {
    40  	manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
    41  	in := &migrationflag.Worker{}
    42  	var out bool
    43  	err := manifold.Output(in, &out)
    44  	c.Check(err, gc.ErrorMatches, "expected out to be a \\*Flag; got a .*")
    45  }
    46  
    47  func (*ManifoldSuite) TestOutputBadInput(c *gc.C) {
    48  	manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
    49  	in := &migrationflag.Worker{}
    50  	var out engine.Flag
    51  	err := manifold.Output(in, &out)
    52  	c.Check(err, jc.ErrorIsNil)
    53  	c.Check(out, gc.Equals, in)
    54  }
    55  
    56  func (*ManifoldSuite) TestFilterNil(c *gc.C) {
    57  	manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
    58  	err := manifold.Filter(nil)
    59  	c.Check(err, jc.ErrorIsNil)
    60  }
    61  
    62  func (*ManifoldSuite) TestFilterErrChanged(c *gc.C) {
    63  	manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
    64  	err := manifold.Filter(migrationflag.ErrChanged)
    65  	c.Check(err, gc.Equals, dependency.ErrBounce)
    66  }
    67  
    68  func (*ManifoldSuite) TestFilterOther(c *gc.C) {
    69  	manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
    70  	expect := errors.New("whatever")
    71  	actual := manifold.Filter(expect)
    72  	c.Check(actual, gc.Equals, expect)
    73  }
    74  
    75  func (*ManifoldSuite) TestStartMissingAPICallerName(c *gc.C) {
    76  	config := validManifoldConfig()
    77  	config.APICallerName = ""
    78  	checkManifoldNotValid(c, config, "empty APICallerName not valid")
    79  }
    80  
    81  func (*ManifoldSuite) TestStartMissingCheck(c *gc.C) {
    82  	config := validManifoldConfig()
    83  	config.Check = nil
    84  	checkManifoldNotValid(c, config, "nil Check not valid")
    85  }
    86  
    87  func (*ManifoldSuite) TestStartMissingNewFacade(c *gc.C) {
    88  	config := validManifoldConfig()
    89  	config.NewFacade = nil
    90  	checkManifoldNotValid(c, config, "nil NewFacade not valid")
    91  }
    92  
    93  func (*ManifoldSuite) TestStartMissingNewWorker(c *gc.C) {
    94  	config := validManifoldConfig()
    95  	config.NewWorker = nil
    96  	checkManifoldNotValid(c, config, "nil NewWorker not valid")
    97  }
    98  
    99  func (*ManifoldSuite) TestStartMissingAPICaller(c *gc.C) {
   100  	context := dt.StubContext(nil, map[string]interface{}{
   101  		"api-caller": dependency.ErrMissing,
   102  	})
   103  	manifold := migrationflag.Manifold(validManifoldConfig())
   104  
   105  	worker, err := manifold.Start(context)
   106  	c.Check(worker, gc.IsNil)
   107  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
   108  }
   109  
   110  func (*ManifoldSuite) TestStartNewFacadeError(c *gc.C) {
   111  	expectCaller := &stubCaller{}
   112  	context := dt.StubContext(nil, map[string]interface{}{
   113  		"api-caller": expectCaller,
   114  	})
   115  	config := validManifoldConfig()
   116  	config.NewFacade = func(caller base.APICaller) (migrationflag.Facade, error) {
   117  		c.Check(caller, gc.Equals, expectCaller)
   118  		return nil, errors.New("bort")
   119  	}
   120  	manifold := migrationflag.Manifold(config)
   121  
   122  	worker, err := manifold.Start(context)
   123  	c.Check(worker, gc.IsNil)
   124  	c.Check(err, gc.ErrorMatches, "bort")
   125  }
   126  
   127  func (*ManifoldSuite) TestStartNewWorkerError(c *gc.C) {
   128  	context := dt.StubContext(nil, map[string]interface{}{
   129  		"api-caller": &stubCaller{},
   130  	})
   131  	expectFacade := &struct{ migrationflag.Facade }{}
   132  	config := validManifoldConfig()
   133  	config.NewFacade = func(base.APICaller) (migrationflag.Facade, error) {
   134  		return expectFacade, nil
   135  	}
   136  	config.NewWorker = func(workerConfig migrationflag.Config) (worker.Worker, error) {
   137  		c.Check(workerConfig.Facade, gc.Equals, expectFacade)
   138  		c.Check(workerConfig.Model, gc.Equals, validUUID)
   139  		c.Check(workerConfig.Check, gc.NotNil) // uncomparable
   140  		return nil, errors.New("snerk")
   141  	}
   142  	manifold := migrationflag.Manifold(config)
   143  
   144  	worker, err := manifold.Start(context)
   145  	c.Check(worker, gc.IsNil)
   146  	c.Check(err, gc.ErrorMatches, "snerk")
   147  }
   148  
   149  func (*ManifoldSuite) TestStartSuccess(c *gc.C) {
   150  	context := dt.StubContext(nil, map[string]interface{}{
   151  		"api-caller": &stubCaller{},
   152  	})
   153  	expectWorker := &struct{ worker.Worker }{}
   154  	config := validManifoldConfig()
   155  	config.NewFacade = func(base.APICaller) (migrationflag.Facade, error) {
   156  		return &struct{ migrationflag.Facade }{}, nil
   157  	}
   158  	config.NewWorker = func(migrationflag.Config) (worker.Worker, error) {
   159  		return expectWorker, nil
   160  	}
   161  	manifold := migrationflag.Manifold(config)
   162  
   163  	worker, err := manifold.Start(context)
   164  	c.Check(err, jc.ErrorIsNil)
   165  	c.Check(worker, gc.Equals, expectWorker)
   166  }