← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/lease/manager_check_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/worker/lease/manager_check_test.go
 
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 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[string]corelease.Info{
 
28
                        "redis": corelease.Info{
 
29
                                Holder:   "redis/0",
 
30
                                Expiry:   offset(time.Second),
 
31
                                Trapdoor: corelease.LockedTrapdoor,
 
32
                        },
 
33
                },
 
34
        }
 
35
        fix.RunTest(c, func(manager *lease.Manager, _ *coretesting.Clock) {
 
36
                token := manager.Token("redis", "redis/0")
 
37
                err := token.Check(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[string]corelease.Info) {
 
47
                                leases["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, _ *coretesting.Clock) {
 
56
                token := manager.Token("redis", "redis/0")
 
57
                err := token.Check(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[string]corelease.Info) {
 
67
                                leases["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, _ *coretesting.Clock) {
 
76
                token := manager.Token("redis", "redis/0")
 
77
                err := token.Check(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, _ *coretesting.Clock) {
 
89
                token := manager.Token("redis", "redis/0")
 
90
                err := token.Check(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[string]corelease.Info) {
 
100
                                leases["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, _ *coretesting.Clock) {
 
109
                token := manager.Token("redis", "redis/0")
 
110
                err := token.Check(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, _ *coretesting.Clock) {
 
124
                token := manager.Token("redis", "redis/0")
 
125
                c.Check(token.Check(nil), gc.ErrorMatches, "lease manager stopped")
 
126
                err := manager.Wait()
 
127
                c.Check(err, gc.ErrorMatches, "crunch squish")
 
128
        })
 
129
}