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

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package lease_test
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/juju/errors"
    10  	"github.com/juju/testing"
    11  	jc "github.com/juju/testing/checkers"
    12  	"github.com/juju/utils/clock"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	corelease "github.com/juju/juju/core/lease"
    16  	coretesting "github.com/juju/juju/testing"
    17  	"github.com/juju/juju/worker/lease"
    18  )
    19  
    20  type ValidationSuite struct {
    21  	testing.IsolationSuite
    22  }
    23  
    24  var _ = gc.Suite(&ValidationSuite{})
    25  
    26  func (s *ValidationSuite) TestMissingClient(c *gc.C) {
    27  	manager, err := lease.NewManager(lease.ManagerConfig{
    28  		Clock:     struct{ clock.Clock }{},
    29  		Secretary: struct{ lease.Secretary }{},
    30  		MaxSleep:  time.Minute,
    31  	})
    32  	c.Check(err, gc.ErrorMatches, "nil Client not valid")
    33  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    34  	c.Check(manager, gc.IsNil)
    35  }
    36  
    37  func (s *ValidationSuite) TestMissingClock(c *gc.C) {
    38  	manager, err := lease.NewManager(lease.ManagerConfig{
    39  		Client:    struct{ corelease.Client }{},
    40  		Secretary: struct{ lease.Secretary }{},
    41  		MaxSleep:  time.Minute,
    42  	})
    43  	c.Check(err, gc.ErrorMatches, "nil Clock not valid")
    44  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    45  	c.Check(manager, gc.IsNil)
    46  }
    47  
    48  func (s *ValidationSuite) TestMissingSecretary(c *gc.C) {
    49  	manager, err := lease.NewManager(lease.ManagerConfig{
    50  		Client: struct{ corelease.Client }{},
    51  		Clock:  struct{ clock.Clock }{},
    52  	})
    53  	c.Check(err, gc.ErrorMatches, "nil Secretary not valid")
    54  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    55  	c.Check(manager, gc.IsNil)
    56  }
    57  
    58  func (s *ValidationSuite) TestMissingMaxSleep(c *gc.C) {
    59  	manager, err := lease.NewManager(lease.ManagerConfig{
    60  		Client:    NewClient(nil, nil),
    61  		Secretary: struct{ lease.Secretary }{},
    62  		Clock:     coretesting.NewClock(time.Now()),
    63  	})
    64  	c.Check(err, gc.ErrorMatches, "non-positive MaxSleep not valid")
    65  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    66  	c.Check(manager, gc.IsNil)
    67  }
    68  
    69  func (s *ValidationSuite) TestNegativeMaxSleep(c *gc.C) {
    70  	manager, err := lease.NewManager(lease.ManagerConfig{
    71  		Client:    NewClient(nil, nil),
    72  		Clock:     coretesting.NewClock(time.Now()),
    73  		Secretary: struct{ lease.Secretary }{},
    74  		MaxSleep:  -time.Nanosecond,
    75  	})
    76  	c.Check(err, gc.ErrorMatches, "non-positive MaxSleep not valid")
    77  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    78  	c.Check(manager, gc.IsNil)
    79  }
    80  
    81  func (s *ValidationSuite) TestClaim_LeaseName(c *gc.C) {
    82  	fix := &Fixture{}
    83  	fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
    84  		err := manager.Claim("INVALID", "bar/0", time.Minute)
    85  		c.Check(err, gc.ErrorMatches, `cannot claim lease "INVALID": name not valid`)
    86  		c.Check(err, jc.Satisfies, errors.IsNotValid)
    87  	})
    88  }
    89  
    90  func (s *ValidationSuite) TestClaim_HolderName(c *gc.C) {
    91  	fix := &Fixture{}
    92  	fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
    93  		err := manager.Claim("foo", "INVALID", time.Minute)
    94  		c.Check(err, gc.ErrorMatches, `cannot claim lease for holder "INVALID": name not valid`)
    95  		c.Check(err, jc.Satisfies, errors.IsNotValid)
    96  	})
    97  }
    98  
    99  func (s *ValidationSuite) TestClaim_Duration(c *gc.C) {
   100  	fix := &Fixture{}
   101  	fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
   102  		err := manager.Claim("foo", "bar/0", time.Second)
   103  		c.Check(err, gc.ErrorMatches, `cannot claim lease for 1s: time not valid`)
   104  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   105  	})
   106  }
   107  
   108  func (s *ValidationSuite) TestToken_LeaseName(c *gc.C) {
   109  	fix := &Fixture{}
   110  	fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
   111  		token := manager.Token("INVALID", "bar/0")
   112  		err := token.Check(nil)
   113  		c.Check(err, gc.ErrorMatches, `cannot check lease "INVALID": name not valid`)
   114  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   115  	})
   116  }
   117  
   118  func (s *ValidationSuite) TestToken_HolderName(c *gc.C) {
   119  	fix := &Fixture{}
   120  	fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
   121  		token := manager.Token("foo", "INVALID")
   122  		err := token.Check(nil)
   123  		c.Check(err, gc.ErrorMatches, `cannot check holder "INVALID": name not valid`)
   124  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   125  	})
   126  }
   127  
   128  func (s *ValidationSuite) TestToken_OutPtr(c *gc.C) {
   129  	expectKey := "bad"
   130  	expectErr := errors.New("bad")
   131  
   132  	fix := &Fixture{
   133  		expectCalls: []call{{
   134  			method: "Refresh",
   135  			callback: func(leases map[string]corelease.Info) {
   136  				leases["redis"] = corelease.Info{
   137  					Holder: "redis/0",
   138  					Expiry: offset(time.Second),
   139  					Trapdoor: func(gotKey interface{}) error {
   140  						c.Check(gotKey, gc.Equals, &expectKey)
   141  						return expectErr
   142  					},
   143  				}
   144  			},
   145  		}},
   146  	}
   147  	fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
   148  		token := manager.Token("redis", "redis/0")
   149  		err := token.Check(&expectKey)
   150  		cause := errors.Cause(err)
   151  		c.Check(cause, gc.Equals, expectErr)
   152  	})
   153  }
   154  
   155  func (s *ValidationSuite) TestWaitUntilExpired_LeaseName(c *gc.C) {
   156  	fix := &Fixture{}
   157  	fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
   158  		err := manager.WaitUntilExpired("INVALID")
   159  		c.Check(err, gc.ErrorMatches, `cannot wait for lease "INVALID" expiry: name not valid`)
   160  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   161  	})
   162  }