← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/gopkg.in/macaroon-bakery.v1/bakerytest/bakerytest_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/gopkg.in/macaroon-bakery.v1/bakerytest/bakerytest_test.go
 
1
package bakerytest_test
 
2
 
 
3
import (
 
4
        "errors"
 
5
        "fmt"
 
6
        "net/http"
 
7
        "net/url"
 
8
        "sync"
 
9
 
 
10
        "github.com/juju/httprequest"
 
11
        gc "gopkg.in/check.v1"
 
12
 
 
13
        "gopkg.in/macaroon-bakery.v1/bakery"
 
14
        "gopkg.in/macaroon-bakery.v1/bakery/checkers"
 
15
        "gopkg.in/macaroon-bakery.v1/bakerytest"
 
16
        "gopkg.in/macaroon-bakery.v1/httpbakery"
 
17
)
 
18
 
 
19
type suite struct {
 
20
        client *httpbakery.Client
 
21
}
 
22
 
 
23
func (s *suite) SetUpTest(c *gc.C) {
 
24
        s.client = httpbakery.NewClient()
 
25
}
 
26
 
 
27
var _ = gc.Suite(&suite{})
 
28
 
 
29
func noCaveatChecker(_ *http.Request, cond, arg string) ([]checkers.Caveat, error) {
 
30
        return nil, nil
 
31
}
 
32
 
 
33
func (s *suite) TestDischargerSimple(c *gc.C) {
 
34
        d := bakerytest.NewDischarger(nil, noCaveatChecker)
 
35
        defer d.Close()
 
36
 
 
37
        svc, err := bakery.NewService(bakery.NewServiceParams{
 
38
                Location: "here",
 
39
                Locator:  d,
 
40
        })
 
41
        c.Assert(err, gc.IsNil)
 
42
        m, err := svc.NewMacaroon("", nil, []checkers.Caveat{{
 
43
                Location:  d.Location(),
 
44
                Condition: "something",
 
45
        }})
 
46
        c.Assert(err, gc.IsNil)
 
47
        ms, err := s.client.DischargeAll(m)
 
48
        c.Assert(err, gc.IsNil)
 
49
        c.Assert(ms, gc.HasLen, 2)
 
50
 
 
51
        err = svc.Check(ms, failChecker)
 
52
        c.Assert(err, gc.IsNil)
 
53
}
 
54
 
 
55
var failChecker = bakery.FirstPartyCheckerFunc(func(s string) error {
 
56
        return fmt.Errorf("fail %s", s)
 
57
})
 
58
 
 
59
func (s *suite) TestDischargerTwoLevels(c *gc.C) {
 
60
        d1checker := func(_ *http.Request, cond, arg string) ([]checkers.Caveat, error) {
 
61
                if cond != "xtrue" {
 
62
                        return nil, fmt.Errorf("caveat refused")
 
63
                }
 
64
                return nil, nil
 
65
        }
 
66
        d1 := bakerytest.NewDischarger(nil, d1checker)
 
67
        defer d1.Close()
 
68
        d2checker := func(_ *http.Request, cond, arg string) ([]checkers.Caveat, error) {
 
69
                return []checkers.Caveat{{
 
70
                        Location:  d1.Location(),
 
71
                        Condition: "x" + cond,
 
72
                }}, nil
 
73
        }
 
74
        d2 := bakerytest.NewDischarger(d1, d2checker)
 
75
        defer d2.Close()
 
76
        locator := bakery.PublicKeyLocatorMap{
 
77
                d1.Location(): d1.Service.PublicKey(),
 
78
                d2.Location(): d2.Service.PublicKey(),
 
79
        }
 
80
        c.Logf("map: %s", locator)
 
81
        svc, err := bakery.NewService(bakery.NewServiceParams{
 
82
                Location: "here",
 
83
                Locator:  locator,
 
84
        })
 
85
        c.Assert(err, gc.IsNil)
 
86
        m, err := svc.NewMacaroon("", nil, []checkers.Caveat{{
 
87
                Location:  d2.Location(),
 
88
                Condition: "true",
 
89
        }})
 
90
        c.Assert(err, gc.IsNil)
 
91
 
 
92
        ms, err := s.client.DischargeAll(m)
 
93
        c.Assert(err, gc.IsNil)
 
94
        c.Assert(ms, gc.HasLen, 3)
 
95
 
 
96
        err = svc.Check(ms, failChecker)
 
97
        c.Assert(err, gc.IsNil)
 
98
 
 
99
        err = svc.AddCaveat(m, checkers.Caveat{
 
100
                Location:  d2.Location(),
 
101
                Condition: "nope",
 
102
        })
 
103
        c.Assert(err, gc.IsNil)
 
104
 
 
105
        ms, err = s.client.DischargeAll(m)
 
106
        c.Assert(err, gc.ErrorMatches, `cannot get discharge from "https://[^"]*": third party refused discharge: cannot discharge: caveat refused`)
 
107
        c.Assert(ms, gc.HasLen, 0)
 
108
}
 
109
 
 
110
func (s *suite) TestInsecureSkipVerifyRestoration(c *gc.C) {
 
111
        d1 := bakerytest.NewDischarger(nil, noCaveatChecker)
 
112
        d2 := bakerytest.NewDischarger(nil, noCaveatChecker)
 
113
        d2.Close()
 
114
        c.Assert(http.DefaultTransport.(*http.Transport).TLSClientConfig.InsecureSkipVerify, gc.Equals, true)
 
115
        d1.Close()
 
116
        c.Assert(http.DefaultTransport.(*http.Transport).TLSClientConfig.InsecureSkipVerify, gc.Equals, false)
 
117
 
 
118
        // When InsecureSkipVerify is already true, it should not
 
119
        // be restored to false.
 
120
        http.DefaultTransport.(*http.Transport).TLSClientConfig.InsecureSkipVerify = true
 
121
        d3 := bakerytest.NewDischarger(nil, noCaveatChecker)
 
122
        d3.Close()
 
123
 
 
124
        c.Assert(http.DefaultTransport.(*http.Transport).TLSClientConfig.InsecureSkipVerify, gc.Equals, true)
 
125
}
 
126
 
 
127
func (s *suite) TestConcurrentDischargers(c *gc.C) {
 
128
        var wg sync.WaitGroup
 
129
        for i := 0; i < 5; i++ {
 
130
                wg.Add(1)
 
131
                go func() {
 
132
                        d := bakerytest.NewDischarger(nil, noCaveatChecker)
 
133
                        d.Close()
 
134
                        wg.Done()
 
135
                }()
 
136
        }
 
137
        wg.Wait()
 
138
        c.Assert(http.DefaultTransport.(*http.Transport).TLSClientConfig.InsecureSkipVerify, gc.Equals, false)
 
139
}
 
140
 
 
141
func (s *suite) TestInteractiveDischarger(c *gc.C) {
 
142
        var d *bakerytest.InteractiveDischarger
 
143
        d = bakerytest.NewInteractiveDischarger(nil, http.HandlerFunc(
 
144
                func(w http.ResponseWriter, r *http.Request) {
 
145
                        d.FinishInteraction(w, r, []checkers.Caveat{
 
146
                                checkers.Caveat{
 
147
                                        Condition: "test pass",
 
148
                                },
 
149
                        }, nil)
 
150
                },
 
151
        ))
 
152
        defer d.Close()
 
153
 
 
154
        svc, err := bakery.NewService(bakery.NewServiceParams{
 
155
                Location: "here",
 
156
                Locator:  d,
 
157
        })
 
158
        c.Assert(err, gc.IsNil)
 
159
        m, err := svc.NewMacaroon("", nil, []checkers.Caveat{{
 
160
                Location:  d.Location(),
 
161
                Condition: "something",
 
162
        }})
 
163
        c.Assert(err, gc.IsNil)
 
164
        client := httpbakery.NewClient()
 
165
        client.VisitWebPage = func(u *url.URL) error {
 
166
                var c httprequest.Client
 
167
                return c.Get(u.String(), nil)
 
168
        }
 
169
        ms, err := client.DischargeAll(m)
 
170
        c.Assert(err, gc.IsNil)
 
171
        c.Assert(ms, gc.HasLen, 2)
 
172
 
 
173
        var r recordingChecker
 
174
        err = svc.Check(ms, &r)
 
175
        c.Assert(err, gc.IsNil)
 
176
        c.Assert(r.caveats, gc.HasLen, 1)
 
177
        c.Assert(r.caveats[0], gc.Equals, "test pass")
 
178
}
 
179
 
 
180
func (s *suite) TestLoginDischargerError(c *gc.C) {
 
181
        var d *bakerytest.InteractiveDischarger
 
182
        d = bakerytest.NewInteractiveDischarger(nil, http.HandlerFunc(
 
183
                func(w http.ResponseWriter, r *http.Request) {
 
184
                        d.FinishInteraction(w, r, nil, errors.New("test error"))
 
185
                },
 
186
        ))
 
187
        defer d.Close()
 
188
 
 
189
        svc, err := bakery.NewService(bakery.NewServiceParams{
 
190
                Location: "here",
 
191
                Locator:  d,
 
192
        })
 
193
        c.Assert(err, gc.IsNil)
 
194
        m, err := svc.NewMacaroon("", nil, []checkers.Caveat{{
 
195
                Location:  d.Location(),
 
196
                Condition: "something",
 
197
        }})
 
198
        c.Assert(err, gc.IsNil)
 
199
        client := httpbakery.NewClient()
 
200
        client.VisitWebPage = func(u *url.URL) error {
 
201
                c.Logf("visiting %s", u)
 
202
                var c httprequest.Client
 
203
                return c.Get(u.String(), nil)
 
204
        }
 
205
        _, err = client.DischargeAll(m)
 
206
        c.Assert(err, gc.ErrorMatches, `cannot get discharge from ".*": failed to acquire macaroon after waiting: third party refused discharge: test error`)
 
207
}
 
208
 
 
209
func (s *suite) TestInteractiveDischargerURL(c *gc.C) {
 
210
        var d *bakerytest.InteractiveDischarger
 
211
        d = bakerytest.NewInteractiveDischarger(nil, http.HandlerFunc(
 
212
                func(w http.ResponseWriter, r *http.Request) {
 
213
                        http.Redirect(w, r, d.URL("/redirect", r), http.StatusFound)
 
214
                },
 
215
        ))
 
216
        defer d.Close()
 
217
        d.Mux.Handle("/redirect", http.HandlerFunc(
 
218
                func(w http.ResponseWriter, r *http.Request) {
 
219
                        d.FinishInteraction(w, r, nil, nil)
 
220
                },
 
221
        ))
 
222
        svc, err := bakery.NewService(bakery.NewServiceParams{
 
223
                Location: "here",
 
224
                Locator:  d,
 
225
        })
 
226
        c.Assert(err, gc.IsNil)
 
227
        m, err := svc.NewMacaroon("", nil, []checkers.Caveat{{
 
228
                Location:  d.Location(),
 
229
                Condition: "something",
 
230
        }})
 
231
        c.Assert(err, gc.IsNil)
 
232
        client := httpbakery.NewClient()
 
233
        client.VisitWebPage = func(u *url.URL) error {
 
234
                var c httprequest.Client
 
235
                return c.Get(u.String(), nil)
 
236
        }
 
237
        ms, err := client.DischargeAll(m)
 
238
        c.Assert(err, gc.IsNil)
 
239
        c.Assert(ms, gc.HasLen, 2)
 
240
 
 
241
        err = svc.Check(ms, failChecker)
 
242
        c.Assert(err, gc.IsNil)
 
243
}
 
244
 
 
245
type recordingChecker struct {
 
246
        caveats []string
 
247
}
 
248
 
 
249
func (c *recordingChecker) CheckFirstPartyCaveat(caveat string) error {
 
250
        c.caveats = append(c.caveats, caveat)
 
251
        return nil
 
252
}