github.com/altoros/juju-vmware@v0.0.0-20150312064031-f19ae857ccca/leadership/leadership_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package leadership
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/lease"
    13  )
    14  
    15  func Test(t *testing.T) { gc.TestingT(t) }
    16  
    17  const (
    18  	StubServiceNm = "stub-service"
    19  	StubUnitNm    = "stub-unit/0"
    20  )
    21  
    22  var (
    23  	_                        = gc.Suite(&leadershipSuite{})
    24  	_ LeadershipLeaseManager = (*leaseStub)(nil)
    25  )
    26  
    27  type leadershipSuite struct{}
    28  
    29  type leaseStub struct {
    30  	ClaimLeaseFn            func(string, string, time.Duration) (string, error)
    31  	ReleaseLeaseFn          func(string, string) error
    32  	LeaseReleasedNotifierFn func(string) <-chan struct{}
    33  	RetrieveLeaseFn         func(string) lease.Token
    34  }
    35  
    36  func (s *leaseStub) ClaimLease(namespace, id string, forDur time.Duration) (string, error) {
    37  	if s.ClaimLeaseFn != nil {
    38  		return s.ClaimLeaseFn(namespace, id, forDur)
    39  	}
    40  	return id, nil
    41  }
    42  
    43  func (s *leaseStub) ReleaseLease(namespace, id string) error {
    44  	if s.ReleaseLeaseFn != nil {
    45  		return s.ReleaseLeaseFn(namespace, id)
    46  	}
    47  	return nil
    48  }
    49  
    50  func (s *leaseStub) LeaseReleasedNotifier(namespace string) <-chan struct{} {
    51  	if s.LeaseReleasedNotifierFn != nil {
    52  		return s.LeaseReleasedNotifierFn(namespace)
    53  	}
    54  	return nil
    55  }
    56  
    57  func (s *leaseStub) RetrieveLease(namespace string) lease.Token {
    58  	if s.RetrieveLeaseFn != nil {
    59  		return s.RetrieveLeaseFn(namespace)
    60  	}
    61  	return lease.Token{}
    62  }
    63  
    64  func (s *leadershipSuite) TestClaimLeadershipTranslation(c *gc.C) {
    65  	stub := &leaseStub{
    66  		ClaimLeaseFn: func(namespace, id string, forDur time.Duration) (string, error) {
    67  			c.Check(namespace, gc.Equals, leadershipNamespace(StubServiceNm))
    68  			c.Check(id, gc.Equals, StubUnitNm)
    69  			c.Check(forDur, gc.Equals, leadershipDuration)
    70  			return id, nil
    71  		},
    72  	}
    73  
    74  	leaderMgr := NewLeadershipManager(stub)
    75  	leadDur, err := leaderMgr.ClaimLeadership(StubServiceNm, StubUnitNm)
    76  
    77  	c.Check(leadDur, gc.Equals, leadershipDuration)
    78  	c.Check(err, gc.IsNil)
    79  }
    80  
    81  func (s *leadershipSuite) TestReleaseLeadershipTranslation(c *gc.C) {
    82  
    83  	numStubCalls := 0
    84  	stub := &leaseStub{
    85  		ReleaseLeaseFn: func(namespace, id string) error {
    86  			numStubCalls++
    87  			c.Check(namespace, gc.Equals, leadershipNamespace(StubServiceNm))
    88  			c.Check(id, gc.Equals, StubUnitNm)
    89  			return nil
    90  		},
    91  	}
    92  
    93  	leaderMgr := NewLeadershipManager(stub)
    94  	err := leaderMgr.ReleaseLeadership(StubServiceNm, StubUnitNm)
    95  
    96  	c.Check(numStubCalls, gc.Equals, 1)
    97  	c.Check(err, gc.IsNil)
    98  }
    99  
   100  func (s *leadershipSuite) TestBlockUntilLeadershipReleasedTranslation(c *gc.C) {
   101  
   102  	numStubCalls := 0
   103  	stub := &leaseStub{
   104  		LeaseReleasedNotifierFn: func(namespace string) <-chan struct{} {
   105  			numStubCalls++
   106  			c.Check(namespace, gc.Equals, leadershipNamespace(StubServiceNm))
   107  			// Send something pre-emptively so test doesn't block.
   108  			released := make(chan struct{}, 1)
   109  			released <- struct{}{}
   110  			return released
   111  		},
   112  	}
   113  
   114  	leaderMgr := NewLeadershipManager(stub)
   115  	err := leaderMgr.BlockUntilLeadershipReleased(StubServiceNm)
   116  
   117  	c.Check(numStubCalls, gc.Equals, 1)
   118  	c.Check(err, gc.IsNil)
   119  }