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