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