github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/worker/lease/manager_check_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/clock/testclock"
    10  	"github.com/juju/errors"
    11  	"github.com/juju/testing"
    12  	jc "github.com/juju/testing/checkers"
    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 TokenSuite struct {
    20  	testing.IsolationSuite
    21  }
    22  
    23  var _ = gc.Suite(&TokenSuite{})
    24  
    25  func (s *TokenSuite) TestSuccess(c *gc.C) {
    26  	fix := &Fixture{
    27  		leases: map[corelease.Key]corelease.Info{
    28  			key("redis"): {
    29  				Holder:   "redis/0",
    30  				Expiry:   offset(time.Second),
    31  				Trapdoor: corelease.LockedTrapdoor,
    32  			},
    33  		},
    34  	}
    35  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
    36  		token := getChecker(c, manager).Token("redis", "redis/0")
    37  		err := token.Check(0, nil)
    38  		c.Check(err, jc.ErrorIsNil)
    39  	})
    40  }
    41  
    42  func (s *TokenSuite) TestMissingRefresh_Success(c *gc.C) {
    43  	fix := &Fixture{
    44  		expectCalls: []call{{
    45  			method: "Refresh",
    46  			callback: func(leases map[corelease.Key]corelease.Info) {
    47  				leases[key("redis")] = corelease.Info{
    48  					Holder:   "redis/0",
    49  					Expiry:   offset(time.Second),
    50  					Trapdoor: corelease.LockedTrapdoor,
    51  				}
    52  			},
    53  		}},
    54  	}
    55  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
    56  		token := getChecker(c, manager).Token("redis", "redis/0")
    57  		err := token.Check(0, nil)
    58  		c.Check(err, jc.ErrorIsNil)
    59  	})
    60  }
    61  
    62  func (s *TokenSuite) TestOtherHolderRefresh_Success(c *gc.C) {
    63  	fix := &Fixture{
    64  		expectCalls: []call{{
    65  			method: "Refresh",
    66  			callback: func(leases map[corelease.Key]corelease.Info) {
    67  				leases[key("redis")] = corelease.Info{
    68  					Holder:   "redis/0",
    69  					Expiry:   offset(time.Second),
    70  					Trapdoor: corelease.LockedTrapdoor,
    71  				}
    72  			},
    73  		}},
    74  	}
    75  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
    76  		token := getChecker(c, manager).Token("redis", "redis/0")
    77  		err := token.Check(0, nil)
    78  		c.Check(err, jc.ErrorIsNil)
    79  	})
    80  }
    81  
    82  func (s *TokenSuite) TestRefresh_Failure_Missing(c *gc.C) {
    83  	fix := &Fixture{
    84  		expectCalls: []call{{
    85  			method: "Refresh",
    86  		}},
    87  	}
    88  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
    89  		token := getChecker(c, manager).Token("redis", "redis/0")
    90  		err := token.Check(0, nil)
    91  		c.Check(errors.Cause(err), gc.Equals, corelease.ErrNotHeld)
    92  	})
    93  }
    94  
    95  func (s *TokenSuite) TestRefresh_Failure_OtherHolder(c *gc.C) {
    96  	fix := &Fixture{
    97  		expectCalls: []call{{
    98  			method: "Refresh",
    99  			callback: func(leases map[corelease.Key]corelease.Info) {
   100  				leases[key("redis")] = corelease.Info{
   101  					Holder:   "redis/1",
   102  					Expiry:   offset(time.Second),
   103  					Trapdoor: corelease.LockedTrapdoor,
   104  				}
   105  			},
   106  		}},
   107  	}
   108  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   109  		token := getChecker(c, manager).Token("redis", "redis/0")
   110  		err := token.Check(0, nil)
   111  		c.Check(errors.Cause(err), gc.Equals, corelease.ErrNotHeld)
   112  	})
   113  }
   114  
   115  func (s *TokenSuite) TestRefresh_Error(c *gc.C) {
   116  	fix := &Fixture{
   117  		expectCalls: []call{{
   118  			method: "Refresh",
   119  			err:    errors.New("crunch squish"),
   120  		}},
   121  		expectDirty: true,
   122  	}
   123  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   124  		token := getChecker(c, manager).Token("redis", "redis/0")
   125  		c.Check(token.Check(0, nil), gc.ErrorMatches, "lease manager stopped")
   126  		err := manager.Wait()
   127  		c.Check(err, gc.ErrorMatches, "crunch squish")
   128  	})
   129  }
   130  
   131  func getChecker(c *gc.C, manager *lease.Manager) corelease.Checker {
   132  	checker, err := manager.Checker("namespace", "modelUUID")
   133  	c.Assert(err, jc.ErrorIsNil)
   134  	return checker
   135  }