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

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package lifeflag_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/names.v2"
    12  	"gopkg.in/juju/worker.v1"
    13  	"gopkg.in/juju/worker.v1/dependency"
    14  	dt "gopkg.in/juju/worker.v1/dependency/testing"
    15  
    16  	"github.com/juju/juju/api/base"
    17  	"github.com/juju/juju/cmd/jujud/agent/engine"
    18  	"github.com/juju/juju/core/life"
    19  	"github.com/juju/juju/worker/lifeflag"
    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 := lifeflag.Manifold(lifeflag.ManifoldConfig{
    30  		APICallerName: "boris",
    31  	})
    32  	c.Check(manifold.Inputs, jc.DeepEquals, []string{"boris"})
    33  }
    34  
    35  func (*ManifoldSuite) TestFilter(c *gc.C) {
    36  	expect := errors.New("squish")
    37  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{
    38  		Filter: func(error) error { return expect },
    39  	})
    40  	actual := manifold.Filter(errors.New("blarg"))
    41  	c.Check(actual, gc.Equals, expect)
    42  }
    43  
    44  func (*ManifoldSuite) TestOutputBadWorker(c *gc.C) {
    45  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{})
    46  	worker := struct{ worker.Worker }{}
    47  	var flag engine.Flag
    48  	err := manifold.Output(worker, &flag)
    49  	c.Check(err, gc.ErrorMatches, "expected in to implement Flag; got a .*")
    50  }
    51  
    52  func (*ManifoldSuite) TestOutputBadTarget(c *gc.C) {
    53  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{})
    54  	worker := &lifeflag.Worker{}
    55  	var flag interface{}
    56  	err := manifold.Output(worker, &flag)
    57  	c.Check(err, gc.ErrorMatches, "expected out to be a \\*Flag; got a .*")
    58  }
    59  
    60  func (*ManifoldSuite) TestOutputSuccess(c *gc.C) {
    61  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{})
    62  	worker := &lifeflag.Worker{}
    63  	var flag engine.Flag
    64  	err := manifold.Output(worker, &flag)
    65  	c.Check(err, jc.ErrorIsNil)
    66  	c.Check(flag, gc.Equals, worker)
    67  }
    68  
    69  func (*ManifoldSuite) TestMissingAPICaller(c *gc.C) {
    70  	context := dt.StubContext(nil, map[string]interface{}{
    71  		"api-caller": dependency.ErrMissing,
    72  	})
    73  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{
    74  		APICallerName: "api-caller",
    75  	})
    76  
    77  	worker, err := manifold.Start(context)
    78  	c.Check(worker, gc.IsNil)
    79  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    80  }
    81  
    82  func (*ManifoldSuite) TestNewFacadeError(c *gc.C) {
    83  	expect := struct{ base.APICaller }{}
    84  	context := dt.StubContext(nil, map[string]interface{}{
    85  		"api-caller": expect,
    86  	})
    87  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{
    88  		APICallerName: "api-caller",
    89  		NewFacade: func(actual base.APICaller) (lifeflag.Facade, error) {
    90  			c.Check(actual, gc.Equals, expect)
    91  			return nil, errors.New("splort")
    92  		},
    93  	})
    94  
    95  	worker, err := manifold.Start(context)
    96  	c.Check(worker, gc.IsNil)
    97  	c.Check(err, gc.ErrorMatches, "splort")
    98  }
    99  
   100  func (*ManifoldSuite) TestNewWorkerError(c *gc.C) {
   101  	expectFacade := struct{ lifeflag.Facade }{}
   102  	expectEntity := names.NewMachineTag("33")
   103  	context := dt.StubContext(nil, map[string]interface{}{
   104  		"api-caller": struct{ base.APICaller }{},
   105  	})
   106  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{
   107  		APICallerName: "api-caller",
   108  		Entity:        expectEntity,
   109  		Result:        life.IsNotAlive,
   110  		NewFacade: func(_ base.APICaller) (lifeflag.Facade, error) {
   111  			return expectFacade, nil
   112  		},
   113  		NewWorker: func(config lifeflag.Config) (worker.Worker, error) {
   114  			c.Check(config.Facade, gc.Equals, expectFacade)
   115  			c.Check(config.Entity, gc.Equals, expectEntity)
   116  			c.Check(config.Result, gc.NotNil) // uncomparable
   117  			return nil, errors.New("boof")
   118  		},
   119  	})
   120  
   121  	worker, err := manifold.Start(context)
   122  	c.Check(worker, gc.IsNil)
   123  	c.Check(err, gc.ErrorMatches, "boof")
   124  }
   125  
   126  func (*ManifoldSuite) TestNewWorkerSuccess(c *gc.C) {
   127  	expectWorker := &struct{ worker.Worker }{}
   128  	context := dt.StubContext(nil, map[string]interface{}{
   129  		"api-caller": struct{ base.APICaller }{},
   130  	})
   131  	manifold := lifeflag.Manifold(lifeflag.ManifoldConfig{
   132  		APICallerName: "api-caller",
   133  		NewFacade: func(_ base.APICaller) (lifeflag.Facade, error) {
   134  			return struct{ lifeflag.Facade }{}, nil
   135  		},
   136  		NewWorker: func(_ lifeflag.Config) (worker.Worker, error) {
   137  			return expectWorker, nil
   138  		},
   139  	})
   140  
   141  	worker, err := manifold.Start(context)
   142  	c.Check(worker, gc.Equals, expectWorker)
   143  	c.Check(err, jc.ErrorIsNil)
   144  }