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

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package gate_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  	"gopkg.in/juju/worker.v1/workertest"
    15  
    16  	"github.com/juju/juju/cmd/jujud/agent/engine"
    17  	"github.com/juju/juju/worker/gate"
    18  )
    19  
    20  type FlagSuite struct {
    21  	testing.IsolationSuite
    22  }
    23  
    24  var _ = gc.Suite(&FlagSuite{})
    25  
    26  func (*FlagSuite) TestManifoldInputs(c *gc.C) {
    27  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{
    28  		GateName: "emperrasque",
    29  	})
    30  	c.Check(manifold.Inputs, jc.DeepEquals, []string{"emperrasque"})
    31  }
    32  
    33  func (*FlagSuite) TestManifoldOutputBadWorker(c *gc.C) {
    34  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{})
    35  	in := &dummyWorker{}
    36  	var out engine.Flag
    37  	err := manifold.Output(in, &out)
    38  	c.Check(err, gc.ErrorMatches, `expected in to implement Flag; got a .*`)
    39  	c.Check(out, gc.IsNil)
    40  }
    41  
    42  func (*FlagSuite) TestManifoldOutputBadTarget(c *gc.C) {
    43  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{})
    44  	in := &gate.Flag{}
    45  	var out interface{}
    46  	err := manifold.Output(in, &out)
    47  	c.Check(err, gc.ErrorMatches, `expected out to be a \*Flag; got a .*`)
    48  	c.Check(out, gc.IsNil)
    49  }
    50  
    51  func (*FlagSuite) TestManifoldOutputSuccess(c *gc.C) {
    52  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{})
    53  	in := &gate.Flag{}
    54  	var out engine.Flag
    55  	err := manifold.Output(in, &out)
    56  	c.Check(err, jc.ErrorIsNil)
    57  	c.Check(out, gc.Equals, in)
    58  }
    59  
    60  func (*FlagSuite) TestManifoldFilterCatchesErrUnlocked(c *gc.C) {
    61  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{})
    62  	err := manifold.Filter(errors.Trace(gate.ErrUnlocked))
    63  	c.Check(err, gc.Equals, dependency.ErrBounce)
    64  }
    65  
    66  func (*FlagSuite) TestManifoldFilterLeavesOtherErrors(c *gc.C) {
    67  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{})
    68  	expect := errors.New("burble")
    69  	actual := manifold.Filter(expect)
    70  	c.Check(actual, gc.Equals, expect)
    71  }
    72  
    73  func (*FlagSuite) TestManifoldFilterLeavesNil(c *gc.C) {
    74  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{})
    75  	err := manifold.Filter(nil)
    76  	c.Check(err, jc.ErrorIsNil)
    77  }
    78  
    79  func (*FlagSuite) TestManifoldStartGateMissing(c *gc.C) {
    80  	context := dt.StubContext(nil, map[string]interface{}{
    81  		"some-gate": dependency.ErrMissing,
    82  	})
    83  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{
    84  		GateName: "some-gate",
    85  	})
    86  	worker, err := manifold.Start(context)
    87  	c.Check(worker, gc.IsNil)
    88  	c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
    89  }
    90  
    91  func (*FlagSuite) TestManifoldStartError(c *gc.C) {
    92  	expect := &dummyWaiter{}
    93  	context := dt.StubContext(nil, map[string]interface{}{
    94  		"some-gate": expect,
    95  	})
    96  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{
    97  		GateName: "some-gate",
    98  		NewWorker: func(actual gate.Waiter) (worker.Worker, error) {
    99  			c.Check(actual, gc.Equals, expect)
   100  			return nil, errors.New("gronk")
   101  		},
   102  	})
   103  	worker, err := manifold.Start(context)
   104  	c.Check(worker, gc.IsNil)
   105  	c.Check(err, gc.ErrorMatches, "gronk")
   106  }
   107  
   108  func (*FlagSuite) TestManifoldStartSuccess(c *gc.C) {
   109  	context := dt.StubContext(nil, map[string]interface{}{
   110  		"some-gate": &dummyWaiter{},
   111  	})
   112  	expect := &dummyWorker{}
   113  	manifold := gate.FlagManifold(gate.FlagManifoldConfig{
   114  		GateName: "some-gate",
   115  		NewWorker: func(_ gate.Waiter) (worker.Worker, error) {
   116  			return expect, nil
   117  		},
   118  	})
   119  	worker, err := manifold.Start(context)
   120  	c.Assert(err, jc.ErrorIsNil)
   121  	c.Check(worker, gc.Equals, expect)
   122  }
   123  
   124  func (*FlagSuite) TestFlagUnlocked(c *gc.C) {
   125  	lock := gate.AlreadyUnlocked{}
   126  	worker, err := gate.NewFlag(lock)
   127  	c.Assert(err, jc.ErrorIsNil)
   128  	defer workertest.CleanKill(c, worker)
   129  	workertest.CheckAlive(c, worker)
   130  	c.Check(worker.Check(), jc.IsTrue)
   131  }
   132  
   133  func (*FlagSuite) TestFlagLocked(c *gc.C) {
   134  	lock := gate.NewLock()
   135  	worker, err := gate.NewFlag(lock)
   136  	c.Assert(err, jc.ErrorIsNil)
   137  	defer workertest.CleanKill(c, worker)
   138  	workertest.CheckAlive(c, worker)
   139  	c.Check(worker.Check(), jc.IsFalse)
   140  }
   141  
   142  func (*FlagSuite) TestFlagUnlockError(c *gc.C) {
   143  	lock := gate.NewLock()
   144  	worker, err := gate.NewFlag(lock)
   145  	c.Assert(err, jc.ErrorIsNil)
   146  	defer workertest.DirtyKill(c, worker)
   147  	workertest.CheckAlive(c, worker)
   148  	lock.Unlock()
   149  	err = workertest.CheckKilled(c, worker)
   150  	c.Check(err, gc.Equals, gate.ErrUnlocked)
   151  }
   152  
   153  type dummyWorker struct{ worker.Worker }
   154  type dummyWaiter struct{ gate.Lock }