github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/worker/undertaker/manifold_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package undertaker_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  
    12  	"github.com/juju/juju/api/base"
    13  	"github.com/juju/juju/environs"
    14  	"github.com/juju/juju/worker"
    15  	"github.com/juju/juju/worker/dependency"
    16  	dt "github.com/juju/juju/worker/dependency/testing"
    17  	"github.com/juju/juju/worker/undertaker"
    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 := undertaker.Manifold(namesConfig())
    28  	c.Check(manifold.Inputs, jc.DeepEquals, []string{
    29  		"api-caller", "environ",
    30  	})
    31  }
    32  
    33  func (*ManifoldSuite) TestOutput(c *gc.C) {
    34  	manifold := undertaker.Manifold(namesConfig())
    35  	c.Check(manifold.Output, gc.IsNil)
    36  }
    37  
    38  func (*ManifoldSuite) TestAPICallerMissing(c *gc.C) {
    39  	resources := resourcesMissing("api-caller")
    40  	manifold := undertaker.Manifold(namesConfig())
    41  
    42  	worker, err := manifold.Start(resources.Context())
    43  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    44  	c.Check(worker, gc.IsNil)
    45  }
    46  
    47  func (*ManifoldSuite) TestEnvironMissing(c *gc.C) {
    48  	resources := resourcesMissing("environ")
    49  	manifold := undertaker.Manifold(namesConfig())
    50  
    51  	worker, err := manifold.Start(resources.Context())
    52  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    53  	c.Check(worker, gc.IsNil)
    54  }
    55  
    56  func (*ManifoldSuite) TestNewFacadeError(c *gc.C) {
    57  	resources := resourcesMissing()
    58  	config := namesConfig()
    59  	config.NewFacade = func(apiCaller base.APICaller) (undertaker.Facade, error) {
    60  		checkResource(c, apiCaller, resources, "api-caller")
    61  		return nil, errors.New("blort")
    62  	}
    63  	manifold := undertaker.Manifold(config)
    64  
    65  	worker, err := manifold.Start(resources.Context())
    66  	c.Check(err, gc.ErrorMatches, "blort")
    67  	c.Check(worker, gc.IsNil)
    68  }
    69  
    70  func (*ManifoldSuite) TestNewWorkerError(c *gc.C) {
    71  	resources := resourcesMissing()
    72  	expectFacade := &fakeFacade{}
    73  	config := namesConfig()
    74  	config.NewFacade = func(_ base.APICaller) (undertaker.Facade, error) {
    75  		return expectFacade, nil
    76  	}
    77  	config.NewWorker = func(cfg undertaker.Config) (worker.Worker, error) {
    78  		c.Check(cfg.Facade, gc.Equals, expectFacade)
    79  		checkResource(c, cfg.Environ, resources, "environ")
    80  		return nil, errors.New("lhiis")
    81  	}
    82  	manifold := undertaker.Manifold(config)
    83  
    84  	worker, err := manifold.Start(resources.Context())
    85  	c.Check(err, gc.ErrorMatches, "lhiis")
    86  	c.Check(worker, gc.IsNil)
    87  }
    88  
    89  func (*ManifoldSuite) TestNewWorkerSuccess(c *gc.C) {
    90  	expectWorker := &fakeWorker{}
    91  	config := namesConfig()
    92  	config.NewFacade = func(_ base.APICaller) (undertaker.Facade, error) {
    93  		return &fakeFacade{}, nil
    94  	}
    95  	config.NewWorker = func(_ undertaker.Config) (worker.Worker, error) {
    96  		return expectWorker, nil
    97  	}
    98  	manifold := undertaker.Manifold(config)
    99  	resources := resourcesMissing()
   100  
   101  	worker, err := manifold.Start(resources.Context())
   102  	c.Check(err, jc.ErrorIsNil)
   103  	c.Check(worker, gc.Equals, expectWorker)
   104  }
   105  
   106  func namesConfig() undertaker.ManifoldConfig {
   107  	return undertaker.ManifoldConfig{
   108  		APICallerName: "api-caller",
   109  		EnvironName:   "environ",
   110  	}
   111  }
   112  
   113  func resourcesMissing(missing ...string) dt.StubResources {
   114  	resources := dt.StubResources{
   115  		"api-caller": dt.StubResource{Output: &fakeAPICaller{}},
   116  		"environ":    dt.StubResource{Output: &fakeEnviron{}},
   117  	}
   118  	for _, name := range missing {
   119  		resources[name] = dt.StubResource{Error: dependency.ErrMissing}
   120  	}
   121  	return resources
   122  }
   123  
   124  func checkResource(c *gc.C, actual interface{}, resources dt.StubResources, name string) {
   125  	c.Check(actual, gc.Equals, resources[name].Output)
   126  }
   127  
   128  type fakeAPICaller struct {
   129  	base.APICaller
   130  }
   131  
   132  type fakeEnviron struct {
   133  	environs.Environ
   134  }
   135  
   136  type fakeFacade struct {
   137  	undertaker.Facade
   138  }
   139  
   140  type fakeWorker struct {
   141  	worker.Worker
   142  }