← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/usso/usso_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/usso/usso_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENSE file for details.
 
3
 
 
4
package usso
 
5
 
 
6
import (
 
7
        "encoding/json"
 
8
        "fmt"
 
9
        "io"
 
10
        "io/ioutil"
 
11
        "net/http"
 
12
        "net/http/httptest"
 
13
        "strings"
 
14
        "testing"
 
15
 
 
16
        . "gopkg.in/check.v1"
 
17
)
 
18
 
 
19
func Test(test *testing.T) { TestingT(test) }
 
20
 
 
21
type USSOTestSuite struct{}
 
22
 
 
23
var _ = Suite(&USSOTestSuite{})
 
24
 
 
25
const (
 
26
        tokenName      = "foo"
 
27
        tokenKey       = "abcs"
 
28
        tokenSecret    = "mTBgLxtTRUdfqewqgrqsvxlijbMWkPBajgKcoZCrDwv"
 
29
        realm          = "API"
 
30
        consumerKey    = "rfyzhdQ"
 
31
        consumerSecret = "rwDkQkkdfdfdeAslkmmxAOjOAT"
 
32
        email          = "foo@bar.com"
 
33
        password       = "foobarpwd"
 
34
        otp            = "000000"
 
35
)
 
36
 
 
37
// TestProductionUbuntuSSOServerURLs tests the URLs of the production server.
 
38
func (suite *USSOTestSuite) TestProductionUbuntuSSOServerURLs(c *C) {
 
39
        tokenURL := ProductionUbuntuSSOServer.tokenURL()
 
40
        c.Assert(tokenURL, Equals, "https://login.ubuntu.com/api/v2/tokens/oauth")
 
41
}
 
42
 
 
43
// TestStagingUbuntuSSOServerURLs tests the URLs of the staging server.
 
44
func (suite *USSOTestSuite) TestStagingUbuntuSSOServerURLs(c *C) {
 
45
        tokenURL := StagingUbuntuSSOServer.tokenURL()
 
46
        c.Assert(tokenURL, Equals, "https://login.staging.ubuntu.com/api/v2/tokens/oauth")
 
47
}
 
48
 
 
49
type TestServer struct {
 
50
        *httptest.Server
 
51
        requestContent *string
 
52
}
 
53
 
 
54
// newTestServer http server to mock U1 SSO server.
 
55
func newTestServer(response, tokenDetails string, code int) *TestServer {
 
56
        var requestContent string
 
57
        handler := func(w http.ResponseWriter, r *http.Request) {
 
58
                res, err := ioutil.ReadAll(r.Body)
 
59
                if err != nil {
 
60
                        panic(err)
 
61
                }
 
62
                if strings.Contains(string(res), "WRONG") {
 
63
                        http.Error(w, "404 page not found", http.StatusNotFound)
 
64
                }
 
65
                if r.URL.String() == "/api/v2/tokens/oauth" {
 
66
                        requestContent = string(res)
 
67
                        fmt.Fprint(w, response)
 
68
                        return
 
69
                }
 
70
                if r.URL.String() == "/api/v2/tokens/oauth/abcs" {
 
71
                        fmt.Fprint(w, tokenDetails)
 
72
                        return
 
73
                } else {
 
74
                        http.Error(w, "404 page not found", http.StatusNotFound)
 
75
                        return
 
76
                }
 
77
        }
 
78
        server := httptest.NewServer(http.HandlerFunc(handler))
 
79
        return &TestServer{server, &requestContent}
 
80
}
 
81
 
 
82
func (suite *USSOTestSuite) TestGetTokenReturnsTokens(c *C) {
 
83
        // Simulate a valid Ubuntu SSO Server response.
 
84
        serverResponseData := map[string]string{
 
85
                "date_updated":    "2013-01-16 14:03:36",
 
86
                "date_created":    "2013-01-16 14:03:36",
 
87
                "href":            "/api/v2/tokens/" + tokenKey,
 
88
                "token_name":      tokenName,
 
89
                "token_key":       tokenKey,
 
90
                "token_secret":    tokenSecret,
 
91
                "consumer_key":    consumerKey,
 
92
                "consumer_secret": consumerSecret,
 
93
        }
 
94
        jsonServerResponseData, err := json.Marshal(serverResponseData)
 
95
        if err != nil {
 
96
                panic(err)
 
97
        }
 
98
        server := newTestServer(string(jsonServerResponseData), "{}", 200)
 
99
        var testSSOServer = &UbuntuSSOServer{server.URL, ""}
 
100
        defer server.Close()
 
101
 
 
102
        // The returned information is correct.
 
103
        ssodata, err := testSSOServer.GetToken(email, password, tokenName)
 
104
        c.Assert(err, IsNil)
 
105
        expectedSSOData := &SSOData{ConsumerKey: consumerKey,
 
106
                ConsumerSecret: consumerSecret, Realm: realm, TokenKey: tokenKey,
 
107
                TokenSecret: tokenSecret, TokenName: tokenName}
 
108
        c.Assert(ssodata, DeepEquals, expectedSSOData)
 
109
        // The request that the fake Ubuntu SSO Server has the credentials.
 
110
        credentials := map[string]string{
 
111
                "email":      email,
 
112
                "password":   password,
 
113
                "token_name": tokenName,
 
114
        }
 
115
        expectedRequestContent, err := json.Marshal(credentials)
 
116
        if err != nil {
 
117
                panic(err)
 
118
        }
 
119
        c.Assert(*server.requestContent, Equals, string(expectedRequestContent))
 
120
}
 
121
 
 
122
// GetToken should return empty credentials and an error, if wrong account is provided.
 
123
func (suite *USSOTestSuite) TestGetTokenFails(c *C) {
 
124
        server := newTestServer("{}", "{}", 200)
 
125
        var testSSOServer = &UbuntuSSOServer{server.URL, ""}
 
126
        defer server.Close()
 
127
        ssodata, err := testSSOServer.GetToken(email, "WRONG", tokenName)
 
128
        c.Assert(err, NotNil)
 
129
        c.Assert(ssodata, IsNil)
 
130
}
 
131
 
 
132
func (suite *USSOTestSuite) TestGetTokenDetails(c *C) {
 
133
        // Simulate a valid Ubuntu SSO Server response.
 
134
        serverResponseData := map[string]string{
 
135
                "date_updated": "2013-01-16 14:03:36",
 
136
                "date_created": "2013-01-16 14:03:36",
 
137
                "href":         "/api/v2/tokens/" + tokenKey,
 
138
                "token_name":   tokenName,
 
139
                "token_key":    tokenKey,
 
140
                "consumer_key": consumerKey,
 
141
        }
 
142
        jsonServerResponseData, err := json.Marshal(serverResponseData)
 
143
        if err != nil {
 
144
                panic(err)
 
145
        }
 
146
        tokenDetails := map[string]string{
 
147
                "token_name":   tokenName,
 
148
                "date_updated": "2014-01-22T13:35:49.867",
 
149
                "token_key":    tokenKey,
 
150
                "href":         "/api/v2/tokens/oauth/JckChNpbXxPRmPkElLglSnqnjsnGseWJmNqTJCWfUtNBSsGtoG",
 
151
                "date_created": "2014-01-17T20:03:24.993",
 
152
                "consumer_key": consumerKey,
 
153
        }
 
154
        jsonTokenDetails, err := json.Marshal(tokenDetails)
 
155
        if err != nil {
 
156
                panic(err)
 
157
        }
 
158
        server := newTestServer(string(jsonServerResponseData), string(jsonTokenDetails), 200)
 
159
        var testSSOServer = &UbuntuSSOServer{server.URL, ""}
 
160
        defer server.Close()
 
161
        ssodata, err := testSSOServer.GetToken(email, password, tokenName)
 
162
        // The returned information is correct.
 
163
        token_details, err := testSSOServer.GetTokenDetails(ssodata)
 
164
        c.Assert(err, IsNil)
 
165
        //The request that the fake Ubuntu SSO Server has the token details.
 
166
        c.Assert(token_details, Equals, string(jsonTokenDetails))
 
167
}
 
168
 
 
169
func (suite *USSOTestSuite) TestGetTokenWithOTP(c *C) {
 
170
        // Simulate a valid Ubuntu SSO Server response.
 
171
        serverResponseData := map[string]string{
 
172
                "date_updated":    "2013-01-16 14:03:36",
 
173
                "date_created":    "2013-01-16 14:03:36",
 
174
                "href":            "/api/v2/tokens/" + tokenKey,
 
175
                "token_name":      tokenName,
 
176
                "token_key":       tokenKey,
 
177
                "token_secret":    tokenSecret,
 
178
                "consumer_key":    consumerKey,
 
179
                "consumer_secret": consumerSecret,
 
180
        }
 
181
        jsonServerResponseData, err := json.Marshal(serverResponseData)
 
182
        if err != nil {
 
183
                panic(err)
 
184
        }
 
185
        server := newTestServer(string(jsonServerResponseData), "{}", 200)
 
186
        var testSSOServer = &UbuntuSSOServer{server.URL, ""}
 
187
        defer server.Close()
 
188
 
 
189
        // The returned information is correct.
 
190
        ssodata, err := testSSOServer.GetTokenWithOTP(email, password, otp, tokenName)
 
191
        c.Assert(err, IsNil)
 
192
        expectedSSOData := &SSOData{ConsumerKey: consumerKey,
 
193
                ConsumerSecret: consumerSecret, Realm: realm, TokenKey: tokenKey,
 
194
                TokenSecret: tokenSecret, TokenName: tokenName}
 
195
        c.Assert(ssodata, DeepEquals, expectedSSOData)
 
196
        // The request that the fake Ubuntu SSO Server has the credentials.
 
197
        credentials := map[string]string{
 
198
                "email":      email,
 
199
                "password":   password,
 
200
                "token_name": tokenName,
 
201
                "otp":        otp,
 
202
        }
 
203
        expectedRequestContent, err := json.Marshal(credentials)
 
204
        c.Assert(err, IsNil)
 
205
        c.Assert(*server.requestContent, Equals, string(expectedRequestContent))
 
206
}
 
207
 
 
208
func (suite *USSOTestSuite) TestTokenValidity(c *C) {
 
209
        // Simulate a valid Ubuntu SSO Server response.
 
210
        serverResponseData := map[string]string{
 
211
                "date_updated": "2013-01-16 14:03:36",
 
212
                "date_created": "2013-01-16 14:03:36",
 
213
                "href":         "/api/v2/tokens/" + tokenKey,
 
214
                "token_name":   tokenName,
 
215
                "token_key":    tokenKey,
 
216
                "consumer_key": consumerKey,
 
217
        }
 
218
        jsonServerResponseData, err := json.Marshal(serverResponseData)
 
219
        if err != nil {
 
220
                panic(err)
 
221
        }
 
222
        tokenDetails := map[string]string{
 
223
                "token_name":   tokenName,
 
224
                "date_updated": "2014-01-22T13:35:49.867",
 
225
                "token_key":    tokenKey,
 
226
                "href":         "/api/v2/tokens/oauth/JckChNpbXxPRmPkElLglSnqnjsnGseWJmNqTJCWfUtNBSsGtoG",
 
227
                "date_created": "2014-01-17T20:03:24.993",
 
228
                "consumer_key": consumerKey,
 
229
        }
 
230
        jsonTokenDetails, err := json.Marshal(tokenDetails)
 
231
        if err != nil {
 
232
                panic(err)
 
233
        }
 
234
        server := newTestServer(string(jsonServerResponseData), string(jsonTokenDetails), 200)
 
235
        var testSSOServer = &UbuntuSSOServer{server.URL, ""}
 
236
        defer server.Close()
 
237
        ssodata, err := testSSOServer.GetToken(email, password, tokenName)
 
238
        // The returned information is correct.
 
239
        token_details, err := testSSOServer.GetTokenDetails(ssodata)
 
240
        c.Assert(err, IsNil)
 
241
        //The request that the fake Ubuntu SSO Server has the token details.
 
242
        c.Assert(token_details, Equals, string(jsonTokenDetails))
 
243
        validity, err := testSSOServer.IsTokenValid(ssodata)
 
244
        c.Assert(validity, Equals, true)
 
245
}
 
246
 
 
247
// Check invalid token
 
248
func (suite *USSOTestSuite) TestInvalidToken(c *C) {
 
249
        server := newTestServer("{}", "{}", 200)
 
250
        var testSSOServer = &UbuntuSSOServer{server.URL, ""}
 
251
        defer server.Close()
 
252
        ssodata := SSOData{"WRONG", "", "", "", "", ""}
 
253
        validity, err := testSSOServer.IsTokenValid(&ssodata)
 
254
        c.Assert(err, NotNil)
 
255
        c.Assert(validity, Equals, false)
 
256
}
 
257
 
 
258
var getErrorTests = []struct {
 
259
        about       string
 
260
        status      string
 
261
        body        io.Reader
 
262
        expectCode  string
 
263
        expectError string
 
264
}{{
 
265
        about:       "valid error",
 
266
        body:        strings.NewReader(`{"message": "test error"}`),
 
267
        expectError: `test error`,
 
268
}, {
 
269
        about:       "valid error with code",
 
270
        body:        strings.NewReader(`{"message": "test error", "code": "ERROR"}`),
 
271
        expectCode:  "ERROR",
 
272
        expectError: `test error`,
 
273
}, {
 
274
        about:       "valid error with extra",
 
275
        body:        strings.NewReader(`{"message": "test error", "extra": {"ext": "thing"}}`),
 
276
        expectError: `test error \(ext: thing\)`,
 
277
}, {
 
278
        about:       "bad json",
 
279
        status:      "500 Internal Server Error",
 
280
        body:        strings.NewReader(`{"message": "test error"`),
 
281
        expectCode:  "500 Internal Server Error",
 
282
        expectError: `{"message": "test error"`,
 
283
}, {
 
284
        about:       "bad reader",
 
285
        status:      "500 Internal Server Error",
 
286
        body:        errorReader{fmt.Errorf("test read error")},
 
287
        expectCode:  "500 Internal Server Error",
 
288
        expectError: `500 Internal Server Error`,
 
289
}}
 
290
 
 
291
func (suite *USSOTestSuite) TestGetError(c *C) {
 
292
        for i, test := range getErrorTests {
 
293
                c.Logf("%d. %s", i, test.about)
 
294
                resp := &http.Response{
 
295
                        Status: test.status,
 
296
                        Body:   ioutil.NopCloser(test.body),
 
297
                }
 
298
                err := getError(resp)
 
299
                c.Assert(err.Code, Equals, test.expectCode)
 
300
                c.Assert(err, ErrorMatches, test.expectError)
 
301
        }
 
302
}
 
303
 
 
304
type errorReader struct {
 
305
        Err error
 
306
}
 
307
 
 
308
func (r errorReader) Read(b []byte) (int, error) {
 
309
        return 0, r.Err
 
310
}