github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/worker/lease/manager_claim_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  	gc "gopkg.in/check.v1"
    13  
    14  	corelease "github.com/juju/juju/core/lease"
    15  	"github.com/juju/juju/worker/lease"
    16  )
    17  
    18  type ClaimSuite struct {
    19  	testing.IsolationSuite
    20  }
    21  
    22  var _ = gc.Suite(&ClaimSuite{})
    23  
    24  func (s *ClaimSuite) TestClaimLease_Success(c *gc.C) {
    25  	fix := &Fixture{
    26  		expectCalls: []call{{
    27  			method: "ClaimLease",
    28  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
    29  		}},
    30  	}
    31  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
    32  		err := manager.Claim("redis", "redis/0", time.Minute)
    33  		c.Check(err, jc.ErrorIsNil)
    34  	})
    35  }
    36  
    37  func (s *ClaimSuite) TestClaimLease_Success_SameHolder(c *gc.C) {
    38  	fix := &Fixture{
    39  		expectCalls: []call{{
    40  			method: "ClaimLease",
    41  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
    42  			err:    corelease.ErrInvalid,
    43  			callback: func(leases map[string]corelease.Info) {
    44  				leases["redis"] = corelease.Info{
    45  					Holder: "redis/0",
    46  					Expiry: offset(time.Second),
    47  				}
    48  			},
    49  		}, {
    50  			method: "ExtendLease",
    51  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
    52  		}},
    53  	}
    54  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
    55  		err := manager.Claim("redis", "redis/0", time.Minute)
    56  		c.Check(err, jc.ErrorIsNil)
    57  	})
    58  }
    59  
    60  func (s *ClaimSuite) TestClaimLease_Failure_OtherHolder(c *gc.C) {
    61  	fix := &Fixture{
    62  		expectCalls: []call{{
    63  			method: "ClaimLease",
    64  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
    65  			err:    corelease.ErrInvalid,
    66  			callback: func(leases map[string]corelease.Info) {
    67  				leases["redis"] = corelease.Info{
    68  					Holder: "redis/1",
    69  					Expiry: offset(time.Second),
    70  				}
    71  			},
    72  		}},
    73  	}
    74  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
    75  		err := manager.Claim("redis", "redis/0", time.Minute)
    76  		c.Check(err, gc.Equals, corelease.ErrClaimDenied)
    77  	})
    78  }
    79  
    80  func (s *ClaimSuite) TestClaimLease_Failure_Error(c *gc.C) {
    81  	fix := &Fixture{
    82  		expectCalls: []call{{
    83  			method: "ClaimLease",
    84  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
    85  			err:    errors.New("lol borken"),
    86  		}},
    87  		expectDirty: true,
    88  	}
    89  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
    90  		err := manager.Claim("redis", "redis/0", time.Minute)
    91  		c.Check(err, gc.ErrorMatches, "lease manager stopped")
    92  		err = manager.Wait()
    93  		c.Check(err, gc.ErrorMatches, "lol borken")
    94  	})
    95  }
    96  
    97  func (s *ClaimSuite) TestExtendLease_Success(c *gc.C) {
    98  	fix := &Fixture{
    99  		leases: map[string]corelease.Info{
   100  			"redis": corelease.Info{
   101  				Holder: "redis/0",
   102  				Expiry: offset(time.Second),
   103  			},
   104  		},
   105  		expectCalls: []call{{
   106  			method: "ExtendLease",
   107  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
   108  		}},
   109  	}
   110  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
   111  		err := manager.Claim("redis", "redis/0", time.Minute)
   112  		c.Check(err, jc.ErrorIsNil)
   113  	})
   114  }
   115  
   116  func (s *ClaimSuite) TestExtendLease_Success_Expired(c *gc.C) {
   117  	fix := &Fixture{
   118  		leases: map[string]corelease.Info{
   119  			"redis": corelease.Info{
   120  				Holder: "redis/0",
   121  				Expiry: offset(time.Second),
   122  			},
   123  		},
   124  		expectCalls: []call{{
   125  			method: "ExtendLease",
   126  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
   127  			err:    corelease.ErrInvalid,
   128  			callback: func(leases map[string]corelease.Info) {
   129  				delete(leases, "redis")
   130  			},
   131  		}, {
   132  			method: "ClaimLease",
   133  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
   134  		}},
   135  	}
   136  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
   137  		err := manager.Claim("redis", "redis/0", time.Minute)
   138  		c.Check(err, jc.ErrorIsNil)
   139  	})
   140  }
   141  
   142  func (s *ClaimSuite) TestExtendLease_Failure_OtherHolder(c *gc.C) {
   143  	fix := &Fixture{
   144  		leases: map[string]corelease.Info{
   145  			"redis": corelease.Info{
   146  				Holder: "redis/0",
   147  				Expiry: offset(time.Second),
   148  			},
   149  		},
   150  		expectCalls: []call{{
   151  			method: "ExtendLease",
   152  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
   153  			err:    corelease.ErrInvalid,
   154  			callback: func(leases map[string]corelease.Info) {
   155  				leases["redis"] = corelease.Info{
   156  					Holder: "redis/1",
   157  					Expiry: offset(time.Second),
   158  				}
   159  			},
   160  		}},
   161  	}
   162  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
   163  		err := manager.Claim("redis", "redis/0", time.Minute)
   164  		c.Check(err, gc.Equals, corelease.ErrClaimDenied)
   165  	})
   166  }
   167  
   168  func (s *ClaimSuite) TestExtendLease_Failure_Error(c *gc.C) {
   169  	fix := &Fixture{
   170  		leases: map[string]corelease.Info{
   171  			"redis": corelease.Info{
   172  				Holder: "redis/0",
   173  				Expiry: offset(time.Second),
   174  			},
   175  		},
   176  		expectCalls: []call{{
   177  			method: "ExtendLease",
   178  			args:   []interface{}{"redis", corelease.Request{"redis/0", time.Minute}},
   179  			err:    errors.New("boom splat"),
   180  		}},
   181  		expectDirty: true,
   182  	}
   183  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
   184  		err := manager.Claim("redis", "redis/0", time.Minute)
   185  		c.Check(err, gc.ErrorMatches, "lease manager stopped")
   186  		err = manager.Wait()
   187  		c.Check(err, gc.ErrorMatches, "boom splat")
   188  	})
   189  }
   190  
   191  func (s *ClaimSuite) TestOtherHolder_Failure(c *gc.C) {
   192  	fix := &Fixture{
   193  		leases: map[string]corelease.Info{
   194  			"redis": corelease.Info{
   195  				Holder: "redis/1",
   196  				Expiry: offset(time.Second),
   197  			},
   198  		},
   199  	}
   200  	fix.RunTest(c, func(manager *lease.Manager, _ *testing.Clock) {
   201  		err := manager.Claim("redis", "redis/0", time.Minute)
   202  		c.Check(err, gc.Equals, corelease.ErrClaimDenied)
   203  	})
   204  }