← Back to branch summary

~juju-qa/ubuntu/yakkety/juju/2.0-rc3-again

« back to all changes in this revision

Viewing changes to src/launchpad.net/goose/testservices/swiftservice/service_http_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-04-24 22:34:47 UTC
  • Revision ID: package-import@ubuntu.com-20130424223447-f0qdji7ubnyo0s71
Tags: upstream-1.10.0.1
Import upstream version 1.10.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/goose/testservices/swiftservice/service_http_test.go
 
1
// Swift double testing service - HTTP API tests
 
2
 
 
3
package swiftservice
 
4
 
 
5
import (
 
6
        "bytes"
 
7
        "encoding/json"
 
8
        "io/ioutil"
 
9
        . "launchpad.net/gocheck"
 
10
        "launchpad.net/goose/swift"
 
11
        "launchpad.net/goose/testing/httpsuite"
 
12
        "launchpad.net/goose/testservices/identityservice"
 
13
        "net/http"
 
14
        "net/url"
 
15
)
 
16
 
 
17
type SwiftHTTPSuite struct {
 
18
        httpsuite.HTTPSuite
 
19
        service *Swift
 
20
        token   string
 
21
}
 
22
 
 
23
var _ = Suite(&SwiftHTTPSuite{})
 
24
 
 
25
func (s *SwiftHTTPSuite) SetUpSuite(c *C) {
 
26
        s.HTTPSuite.SetUpSuite(c)
 
27
        identityDouble := identityservice.NewUserPass()
 
28
        s.service = New(s.Server.URL, versionPath, tenantId, region, identityDouble)
 
29
        userInfo := identityDouble.AddUser("fred", "secret", "tenant")
 
30
        s.token = userInfo.Token
 
31
}
 
32
 
 
33
func (s *SwiftHTTPSuite) SetUpTest(c *C) {
 
34
        s.HTTPSuite.SetUpTest(c)
 
35
        s.service.SetupHTTP(s.Mux)
 
36
}
 
37
 
 
38
func (s *SwiftHTTPSuite) TearDownTest(c *C) {
 
39
        s.HTTPSuite.TearDownTest(c)
 
40
}
 
41
 
 
42
func (s *SwiftHTTPSuite) TearDownSuite(c *C) {
 
43
        s.HTTPSuite.TearDownSuite(c)
 
44
}
 
45
 
 
46
func (s *SwiftHTTPSuite) sendRequest(c *C, method, path string, body []byte,
 
47
        expectedStatusCode int) (resp *http.Response) {
 
48
        return s.sendRequestWithParams(c, method, path, nil, body, expectedStatusCode)
 
49
}
 
50
 
 
51
func (s *SwiftHTTPSuite) sendRequestWithParams(c *C, method, path string, params map[string]string, body []byte,
 
52
        expectedStatusCode int) (resp *http.Response) {
 
53
        var req *http.Request
 
54
        var err error
 
55
        URL := s.service.endpointURL(path)
 
56
        if len(params) > 0 {
 
57
                urlParams := make(url.Values, len(params))
 
58
                for k, v := range params {
 
59
                        urlParams.Set(k, v)
 
60
                }
 
61
                URL += "?" + urlParams.Encode()
 
62
        }
 
63
        if body != nil {
 
64
                req, err = http.NewRequest(method, URL, bytes.NewBuffer(body))
 
65
        } else {
 
66
                req, err = http.NewRequest(method, URL, nil)
 
67
        }
 
68
        c.Assert(err, IsNil)
 
69
        if s.token != "" {
 
70
                req.Header.Add("X-Auth-Token", s.token)
 
71
        }
 
72
        client := &http.DefaultClient
 
73
        resp, err = client.Do(req)
 
74
        c.Assert(err, IsNil)
 
75
        c.Assert(resp.StatusCode, Equals, expectedStatusCode)
 
76
        return resp
 
77
}
 
78
 
 
79
func (s *SwiftHTTPSuite) ensureNotContainer(name string, c *C) {
 
80
        ok := s.service.HasContainer("test")
 
81
        c.Assert(ok, Equals, false)
 
82
}
 
83
 
 
84
func (s *SwiftHTTPSuite) ensureContainer(name string, c *C) {
 
85
        s.ensureNotContainer(name, c)
 
86
        err := s.service.AddContainer("test")
 
87
        c.Assert(err, IsNil)
 
88
}
 
89
 
 
90
func (s *SwiftHTTPSuite) removeContainer(name string, c *C) {
 
91
        ok := s.service.HasContainer("test")
 
92
        c.Assert(ok, Equals, true)
 
93
        err := s.service.RemoveContainer("test")
 
94
        c.Assert(err, IsNil)
 
95
}
 
96
 
 
97
func (s *SwiftHTTPSuite) ensureNotObject(container, object string, c *C) {
 
98
        _, err := s.service.GetObject(container, object)
 
99
        c.Assert(err, Not(IsNil))
 
100
}
 
101
 
 
102
func (s *SwiftHTTPSuite) ensureObject(container, object string, data []byte, c *C) {
 
103
        s.ensureNotObject(container, object, c)
 
104
        err := s.service.AddObject(container, object, data)
 
105
        c.Assert(err, IsNil)
 
106
}
 
107
 
 
108
func (s *SwiftHTTPSuite) ensureObjectData(container, object string, data []byte, c *C) {
 
109
        objdata, err := s.service.GetObject(container, object)
 
110
        c.Assert(err, IsNil)
 
111
        c.Assert(objdata, DeepEquals, data)
 
112
}
 
113
 
 
114
func (s *SwiftHTTPSuite) removeObject(container, object string, c *C) {
 
115
        err := s.service.RemoveObject(container, object)
 
116
        c.Assert(err, IsNil)
 
117
        s.ensureNotObject(container, object, c)
 
118
}
 
119
 
 
120
func (s *SwiftHTTPSuite) TestPUTContainerMissingCreated(c *C) {
 
121
        s.ensureNotContainer("test", c)
 
122
 
 
123
        s.sendRequest(c, "PUT", "test", nil, http.StatusCreated)
 
124
 
 
125
        s.removeContainer("test", c)
 
126
}
 
127
 
 
128
func (s *SwiftHTTPSuite) TestPUTContainerExistsAccepted(c *C) {
 
129
        s.ensureContainer("test", c)
 
130
 
 
131
        s.sendRequest(c, "PUT", "test", nil, http.StatusAccepted)
 
132
 
 
133
        s.removeContainer("test", c)
 
134
}
 
135
 
 
136
func (s *SwiftHTTPSuite) TestGETContainerMissingNotFound(c *C) {
 
137
        s.ensureNotContainer("test", c)
 
138
 
 
139
        s.sendRequest(c, "GET", "test", nil, http.StatusNotFound)
 
140
 
 
141
        s.ensureNotContainer("test", c)
 
142
}
 
143
 
 
144
func (s *SwiftHTTPSuite) TestGETContainerExistsOK(c *C) {
 
145
        s.ensureContainer("test", c)
 
146
        data := []byte("test data")
 
147
        s.ensureObject("test", "obj", data, c)
 
148
 
 
149
        resp := s.sendRequest(c, "GET", "test", nil, http.StatusOK)
 
150
 
 
151
        defer resp.Body.Close()
 
152
        body, err := ioutil.ReadAll(resp.Body)
 
153
        c.Assert(err, IsNil)
 
154
        var containerData []swift.ContainerContents
 
155
        err = json.Unmarshal(body, &containerData)
 
156
        c.Assert(err, IsNil)
 
157
        c.Assert(len(containerData), Equals, 1)
 
158
        c.Assert(containerData[0].Name, Equals, "obj")
 
159
 
 
160
        s.removeContainer("test", c)
 
161
}
 
162
 
 
163
func (s *SwiftHTTPSuite) TestGETContainerWithPrefix(c *C) {
 
164
        s.ensureContainer("test", c)
 
165
        data := []byte("test data")
 
166
        s.ensureObject("test", "foo", data, c)
 
167
        s.ensureObject("test", "foobar", data, c)
 
168
 
 
169
        resp := s.sendRequestWithParams(c, "GET", "test", map[string]string{"prefix": "foob"}, nil, http.StatusOK)
 
170
 
 
171
        defer resp.Body.Close()
 
172
        body, err := ioutil.ReadAll(resp.Body)
 
173
        c.Assert(err, IsNil)
 
174
        var containerData []swift.ContainerContents
 
175
        err = json.Unmarshal(body, &containerData)
 
176
        c.Assert(err, IsNil)
 
177
        c.Assert(len(containerData), Equals, 1)
 
178
        c.Assert(containerData[0].Name, Equals, "foobar")
 
179
 
 
180
        s.removeContainer("test", c)
 
181
}
 
182
 
 
183
func (s *SwiftHTTPSuite) TestDELETEContainerMissingNotFound(c *C) {
 
184
        s.ensureNotContainer("test", c)
 
185
 
 
186
        s.sendRequest(c, "DELETE", "test", nil, http.StatusNotFound)
 
187
}
 
188
 
 
189
func (s *SwiftHTTPSuite) TestDELETEContainerExistsNoContent(c *C) {
 
190
        s.ensureContainer("test", c)
 
191
 
 
192
        s.sendRequest(c, "DELETE", "test", nil, http.StatusNoContent)
 
193
 
 
194
        s.ensureNotContainer("test", c)
 
195
}
 
196
 
 
197
func (s *SwiftHTTPSuite) TestPUTObjectMissingCreated(c *C) {
 
198
        s.ensureContainer("test", c)
 
199
        s.ensureNotObject("test", "obj", c)
 
200
 
 
201
        data := []byte("test data")
 
202
        s.sendRequest(c, "PUT", "test/obj", data, http.StatusCreated)
 
203
 
 
204
        s.ensureObjectData("test", "obj", data, c)
 
205
        s.removeContainer("test", c)
 
206
}
 
207
 
 
208
func (s *SwiftHTTPSuite) TestPUTObjectExistsCreated(c *C) {
 
209
        data := []byte("test data")
 
210
        s.ensureContainer("test", c)
 
211
        s.ensureObject("test", "obj", data, c)
 
212
 
 
213
        newdata := []byte("new test data")
 
214
        s.sendRequest(c, "PUT", "test/obj", newdata, http.StatusCreated)
 
215
 
 
216
        s.ensureObjectData("test", "obj", newdata, c)
 
217
        s.removeContainer("test", c)
 
218
}
 
219
 
 
220
func (s *SwiftHTTPSuite) TestPUTObjectContainerMissingNotFound(c *C) {
 
221
        s.ensureNotContainer("test", c)
 
222
 
 
223
        data := []byte("test data")
 
224
        s.sendRequest(c, "PUT", "test/obj", data, http.StatusNotFound)
 
225
 
 
226
        s.ensureNotContainer("test", c)
 
227
}
 
228
 
 
229
func (s *SwiftHTTPSuite) TestGETObjectMissingNotFound(c *C) {
 
230
        s.ensureContainer("test", c)
 
231
        s.ensureNotObject("test", "obj", c)
 
232
 
 
233
        s.sendRequest(c, "GET", "test/obj", nil, http.StatusNotFound)
 
234
 
 
235
        s.removeContainer("test", c)
 
236
}
 
237
 
 
238
func (s *SwiftHTTPSuite) TestGETObjectContainerMissingNotFound(c *C) {
 
239
        s.ensureNotContainer("test", c)
 
240
 
 
241
        s.sendRequest(c, "GET", "test/obj", nil, http.StatusNotFound)
 
242
 
 
243
        s.ensureNotContainer("test", c)
 
244
}
 
245
 
 
246
func (s *SwiftHTTPSuite) TestGETObjectExistsOK(c *C) {
 
247
        data := []byte("test data")
 
248
        s.ensureContainer("test", c)
 
249
        s.ensureObject("test", "obj", data, c)
 
250
 
 
251
        resp := s.sendRequest(c, "GET", "test/obj", nil, http.StatusOK)
 
252
 
 
253
        s.ensureObjectData("test", "obj", data, c)
 
254
 
 
255
        defer resp.Body.Close()
 
256
        body, err := ioutil.ReadAll(resp.Body)
 
257
        c.Assert(err, IsNil)
 
258
        c.Assert(body, DeepEquals, data)
 
259
 
 
260
        s.removeContainer("test", c)
 
261
}
 
262
 
 
263
func (s *SwiftHTTPSuite) TestDELETEObjectMissingNotFound(c *C) {
 
264
        s.ensureContainer("test", c)
 
265
        s.ensureNotObject("test", "obj", c)
 
266
 
 
267
        s.sendRequest(c, "DELETE", "test/obj", nil, http.StatusNotFound)
 
268
 
 
269
        s.removeContainer("test", c)
 
270
}
 
271
 
 
272
func (s *SwiftHTTPSuite) TestDELETEObjectContainerMissingNotFound(c *C) {
 
273
        s.ensureNotContainer("test", c)
 
274
 
 
275
        s.sendRequest(c, "DELETE", "test/obj", nil, http.StatusNotFound)
 
276
 
 
277
        s.ensureNotContainer("test", c)
 
278
}
 
279
 
 
280
func (s *SwiftHTTPSuite) TestDELETEObjectExistsNoContent(c *C) {
 
281
        data := []byte("test data")
 
282
        s.ensureContainer("test", c)
 
283
        s.ensureObject("test", "obj", data, c)
 
284
 
 
285
        s.sendRequest(c, "DELETE", "test/obj", nil, http.StatusNoContent)
 
286
 
 
287
        s.removeContainer("test", c)
 
288
}
 
289
 
 
290
func (s *SwiftHTTPSuite) TestUnauthorizedFails(c *C) {
 
291
        oldtoken := s.token
 
292
        defer func() {
 
293
                s.token = oldtoken
 
294
        }()
 
295
        // TODO(wallyworld) - 2013-02-11 bug=1121682
 
296
        // until ACLs are supported, empty tokens are assumed to be used when we need to access a public container.
 
297
        // token = ""
 
298
        // s.sendRequest(c, "GET", "test", nil, http.StatusUnauthorized)
 
299
 
 
300
        s.token = "invalid"
 
301
        s.sendRequest(c, "PUT", "test", nil, http.StatusUnauthorized)
 
302
 
 
303
        s.sendRequest(c, "DELETE", "test", nil, http.StatusUnauthorized)
 
304
}