github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/worker/discoverspaces/manifold_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package discoverspaces_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/worker"
    14  	"github.com/juju/juju/worker/dependency"
    15  	dt "github.com/juju/juju/worker/dependency/testing"
    16  	"github.com/juju/juju/worker/discoverspaces"
    17  )
    18  
    19  type ManifoldSuite struct {
    20  	testing.IsolationSuite
    21  }
    22  
    23  var _ = gc.Suite(&ManifoldSuite{})
    24  
    25  func (*ManifoldSuite) TestInputsWithUnlocker(c *gc.C) {
    26  	config := namesConfig()
    27  	manifold := discoverspaces.Manifold(config)
    28  	c.Check(manifold.Inputs, jc.SameContents, []string{
    29  		"api-caller", "environ", "unlocker",
    30  	})
    31  }
    32  
    33  func (*ManifoldSuite) TestInputsWithoutUnlocker(c *gc.C) {
    34  	config := namesConfig()
    35  	config.UnlockerName = ""
    36  	manifold := discoverspaces.Manifold(config)
    37  	c.Check(manifold.Inputs, jc.SameContents, []string{
    38  		"api-caller", "environ",
    39  	})
    40  }
    41  
    42  func (*ManifoldSuite) TestOutput(c *gc.C) {
    43  	manifold := discoverspaces.Manifold(namesConfig())
    44  	c.Check(manifold.Output, gc.IsNil)
    45  }
    46  
    47  func (*ManifoldSuite) TestAPICallerMissing(c *gc.C) {
    48  	resources := resourcesMissing("api-caller")
    49  	manifold := discoverspaces.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) TestEnvironMissing(c *gc.C) {
    57  	resources := resourcesMissing("environ")
    58  	manifold := discoverspaces.Manifold(namesConfig())
    59  
    60  	worker, err := manifold.Start(resources.Context())
    61  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    62  	c.Check(worker, gc.IsNil)
    63  }
    64  
    65  func (*ManifoldSuite) TestUnlockerMissing(c *gc.C) {
    66  	resources := resourcesMissing("unlocker")
    67  	manifold := discoverspaces.Manifold(namesConfig())
    68  
    69  	worker, err := manifold.Start(resources.Context())
    70  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    71  	c.Check(worker, gc.IsNil)
    72  }
    73  
    74  func (*ManifoldSuite) TestNewFacadeError(c *gc.C) {
    75  	resources := resourcesMissing()
    76  	config := namesConfig()
    77  	config.NewFacade = func(apiCaller base.APICaller) (discoverspaces.Facade, error) {
    78  		checkResource(c, apiCaller, resources, "api-caller")
    79  		return nil, errors.New("blort")
    80  	}
    81  	manifold := discoverspaces.Manifold(config)
    82  
    83  	worker, err := manifold.Start(resources.Context())
    84  	c.Check(err, gc.ErrorMatches, "blort")
    85  	c.Check(worker, gc.IsNil)
    86  }
    87  
    88  func (*ManifoldSuite) TestNewWorkerError(c *gc.C) {
    89  	resources := resourcesMissing()
    90  	expectFacade := &fakeFacade{}
    91  	config := namesConfig()
    92  	config.NewFacade = func(_ base.APICaller) (discoverspaces.Facade, error) {
    93  		return expectFacade, nil
    94  	}
    95  	config.NewWorker = func(cfg discoverspaces.Config) (worker.Worker, error) {
    96  		c.Check(cfg.Facade, gc.Equals, expectFacade)
    97  		checkResource(c, cfg.Environ, resources, "environ")
    98  		c.Check(cfg.NewName, gc.NotNil) // uncomparable
    99  		checkResource(c, cfg.Unlocker, resources, "unlocker")
   100  		return nil, errors.New("lhiis")
   101  	}
   102  	manifold := discoverspaces.Manifold(config)
   103  
   104  	worker, err := manifold.Start(resources.Context())
   105  	c.Check(err, gc.ErrorMatches, "lhiis")
   106  	c.Check(worker, gc.IsNil)
   107  }
   108  
   109  func (*ManifoldSuite) TestNewWorkerNoUnlocker(c *gc.C) {
   110  	resources := resourcesMissing()
   111  	config := namesConfig()
   112  	config.UnlockerName = ""
   113  	config.NewFacade = func(_ base.APICaller) (discoverspaces.Facade, error) {
   114  		return &fakeFacade{}, nil
   115  	}
   116  	config.NewWorker = func(cfg discoverspaces.Config) (worker.Worker, error) {
   117  		c.Check(cfg.Unlocker, gc.IsNil)
   118  		return nil, errors.New("mrrg")
   119  	}
   120  	manifold := discoverspaces.Manifold(config)
   121  
   122  	worker, err := manifold.Start(resources.Context())
   123  	c.Check(err, gc.ErrorMatches, "mrrg")
   124  	c.Check(worker, gc.IsNil)
   125  }
   126  
   127  func (*ManifoldSuite) TestNewWorkerSuccess(c *gc.C) {
   128  	expectWorker := &fakeWorker{}
   129  	config := namesConfig()
   130  	config.NewFacade = func(_ base.APICaller) (discoverspaces.Facade, error) {
   131  		return &fakeFacade{}, nil
   132  	}
   133  	config.NewWorker = func(_ discoverspaces.Config) (worker.Worker, error) {
   134  		return expectWorker, nil
   135  	}
   136  	manifold := discoverspaces.Manifold(config)
   137  	resources := resourcesMissing()
   138  
   139  	worker, err := manifold.Start(resources.Context())
   140  	c.Check(err, jc.ErrorIsNil)
   141  	c.Check(worker, gc.Equals, expectWorker)
   142  }
   143  
   144  func namesConfig() discoverspaces.ManifoldConfig {
   145  	return discoverspaces.ManifoldConfig{
   146  		APICallerName: "api-caller",
   147  		EnvironName:   "environ",
   148  		UnlockerName:  "unlocker",
   149  	}
   150  }
   151  
   152  func resourcesMissing(missing ...string) dt.StubResources {
   153  	resources := dt.StubResources{
   154  		"api-caller": dt.StubResource{Output: &fakeAPICaller{}},
   155  		"environ":    dt.StubResource{Output: &fakeEnviron{}},
   156  		"unlocker":   dt.StubResource{Output: &fakeUnlocker{}},
   157  	}
   158  	for _, name := range missing {
   159  		resources[name] = dt.StubResource{Error: dependency.ErrMissing}
   160  	}
   161  	return resources
   162  }
   163  
   164  func checkResource(c *gc.C, actual interface{}, resources dt.StubResources, name string) {
   165  	c.Check(actual, gc.Equals, resources[name].Output)
   166  }