← Back to branch summary

~wallyworld/gwacl/ensure-all-roles-have-costs

« back to all changes in this revision

Viewing changes to x509dispatcher_test.go

  • Committer: Ian Booth
  • Date: 2014-12-02 00:36:45 UTC
  • Revision ID: ian.booth@canonical.com-20141202003645-ye8a5akifuf2wjk3
Ensure all regions have costs and remove custom formatting

Show diffs side-by-side

added added

removed removed

Lines of Context:
x509dispatcher_test.go
1
1
package gwacl
2
2
 
3
3
import (
4
 
    "io/ioutil"
5
 
    . "launchpad.net/gocheck"
6
 
    "net/http"
7
 
    "net/http/httptest"
8
 
    "time"
 
4
        "io/ioutil"
 
5
        . "launchpad.net/gocheck"
 
6
        "net/http"
 
7
        "net/http/httptest"
 
8
        "time"
9
9
)
10
10
 
11
11
type x509DispatcherSuite struct{}
13
13
var _ = Suite(&x509DispatcherSuite{})
14
14
 
15
15
type Request struct {
16
 
    *http.Request
17
 
    BodyContent []byte
 
16
        *http.Request
 
17
        BodyContent []byte
18
18
}
19
19
 
20
20
// makeRecordingHTTPServer creates an http server (don't forget to Close() it when done)
22
22
// channel, and finally returns the given status code.  If body is not nil, it
23
23
// will be returned as the request body.
24
24
func makeRecordingHTTPServer(requests chan *Request, status int, body []byte, headers http.Header) *httptest.Server {
25
 
    var server *httptest.Server
26
 
    returnRequest := func(w http.ResponseWriter, r *http.Request) {
27
 
        // Capture all the request body content for later inspection.
28
 
        requestBody, err := ioutil.ReadAll(r.Body)
29
 
        if err != nil {
30
 
            panic(err)
31
 
        }
32
 
        requests <- &Request{r, requestBody}
33
 
        // Set a default Location so we can test redirect loops easily.
34
 
        w.Header().Set("Location", server.URL+r.URL.Path)
35
 
        for header, values := range headers {
36
 
            for _, value := range values {
37
 
                w.Header().Set(header, value)
38
 
            }
39
 
        }
40
 
        w.WriteHeader(status)
41
 
        if body != nil {
42
 
            w.Write(body)
43
 
        }
44
 
    }
45
 
    serveMux := http.NewServeMux()
46
 
    serveMux.HandleFunc("/", returnRequest)
47
 
    server = httptest.NewServer(serveMux)
48
 
    return server
 
25
        var server *httptest.Server
 
26
        returnRequest := func(w http.ResponseWriter, r *http.Request) {
 
27
                // Capture all the request body content for later inspection.
 
28
                requestBody, err := ioutil.ReadAll(r.Body)
 
29
                if err != nil {
 
30
                        panic(err)
 
31
                }
 
32
                requests <- &Request{r, requestBody}
 
33
                // Set a default Location so we can test redirect loops easily.
 
34
                w.Header().Set("Location", server.URL+r.URL.Path)
 
35
                for header, values := range headers {
 
36
                        for _, value := range values {
 
37
                                w.Header().Set(header, value)
 
38
                        }
 
39
                }
 
40
                w.WriteHeader(status)
 
41
                if body != nil {
 
42
                        w.Write(body)
 
43
                }
 
44
        }
 
45
        serveMux := http.NewServeMux()
 
46
        serveMux.HandleFunc("/", returnRequest)
 
47
        server = httptest.NewServer(serveMux)
 
48
        return server
49
49
}
50
50
 
51
51
func (*x509DispatcherSuite) TestGetRequestDoesHTTPGET(c *C) {
52
 
    httpRequests := make(chan *Request, 1)
53
 
    server := makeRecordingHTTPServer(httpRequests, http.StatusOK, nil, nil)
54
 
    defer server.Close()
55
 
    // No real certificate needed since we're testing on http, not https.
56
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
57
 
    c.Assert(err, IsNil)
58
 
    path := "/foo/bar"
59
 
    version := "test-version"
60
 
    request := newX509RequestGET(server.URL+path, version)
61
 
 
62
 
    response, err := performX509Request(session, request)
63
 
    c.Assert(err, IsNil)
64
 
    c.Assert(response.StatusCode, Equals, http.StatusOK)
65
 
 
66
 
    httpRequest := <-httpRequests
67
 
    c.Check(httpRequest.Method, Equals, "GET")
68
 
    c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{version})
69
 
    c.Check(httpRequest.URL.String(), Equals, path)
70
 
    c.Check(httpRequest.BodyContent, HasLen, 0)
 
52
        httpRequests := make(chan *Request, 1)
 
53
        server := makeRecordingHTTPServer(httpRequests, http.StatusOK, nil, nil)
 
54
        defer server.Close()
 
55
        // No real certificate needed since we're testing on http, not https.
 
56
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
57
        c.Assert(err, IsNil)
 
58
        path := "/foo/bar"
 
59
        version := "test-version"
 
60
        request := newX509RequestGET(server.URL+path, version)
 
61
 
 
62
        response, err := performX509Request(session, request)
 
63
        c.Assert(err, IsNil)
 
64
        c.Assert(response.StatusCode, Equals, http.StatusOK)
 
65
 
 
66
        httpRequest := <-httpRequests
 
67
        c.Check(httpRequest.Method, Equals, "GET")
 
68
        c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{version})
 
69
        c.Check(httpRequest.URL.String(), Equals, path)
 
70
        c.Check(httpRequest.BodyContent, HasLen, 0)
71
71
}
72
72
 
73
73
func (*x509DispatcherSuite) TestRetryPolicyCausesRequestsToBeRetried(c *C) {
74
 
    nbRetries := 2
75
 
    nbRequests := nbRetries + 1
76
 
    httpRequests := make(chan *Request, nbRequests)
77
 
    server := makeRecordingHTTPServer(httpRequests, http.StatusConflict, nil, nil)
78
 
    defer server.Close()
79
 
    // No real certificate needed since we're testing on http, not https.
80
 
    retryPolicy := RetryPolicy{NbRetries: nbRetries, HttpStatusCodes: []int{http.StatusConflict}, Delay: time.Nanosecond}
81
 
    session, err := newX509Session("subscriptionid", "", "West US", retryPolicy)
82
 
    c.Assert(err, IsNil)
83
 
    path := "/foo/bar"
84
 
    version := "test-version"
85
 
    request := newX509RequestGET(server.URL+path, version)
86
 
 
87
 
    response, err := performX509Request(session, request)
88
 
    c.Assert(err, IsNil)
89
 
    c.Assert(response.StatusCode, Equals, http.StatusConflict)
90
 
 
91
 
    // nbRequests request were performed.
92
 
    c.Check(httpRequests, HasLen, nbRequests)
 
74
        nbRetries := 2
 
75
        nbRequests := nbRetries + 1
 
76
        httpRequests := make(chan *Request, nbRequests)
 
77
        server := makeRecordingHTTPServer(httpRequests, http.StatusConflict, nil, nil)
 
78
        defer server.Close()
 
79
        // No real certificate needed since we're testing on http, not https.
 
80
        retryPolicy := RetryPolicy{NbRetries: nbRetries, HttpStatusCodes: []int{http.StatusConflict}, Delay: time.Nanosecond}
 
81
        session, err := newX509Session("subscriptionid", "", "West US", retryPolicy)
 
82
        c.Assert(err, IsNil)
 
83
        path := "/foo/bar"
 
84
        version := "test-version"
 
85
        request := newX509RequestGET(server.URL+path, version)
 
86
 
 
87
        response, err := performX509Request(session, request)
 
88
        c.Assert(err, IsNil)
 
89
        c.Assert(response.StatusCode, Equals, http.StatusConflict)
 
90
 
 
91
        // nbRequests request were performed.
 
92
        c.Check(httpRequests, HasLen, nbRequests)
93
93
}
94
94
 
95
95
func (*x509DispatcherSuite) TestPostRequestDoesHTTPPOST(c *C) {
96
 
    httpRequests := make(chan *Request, 1)
97
 
    requestBody := []byte{1, 2, 3}
98
 
    responseBody := []byte{4, 5, 6}
99
 
    requestContentType := "bogusContentType"
100
 
    server := makeRecordingHTTPServer(httpRequests, http.StatusOK, responseBody, nil)
101
 
    defer server.Close()
102
 
    // No real certificate needed since we're testing on http, not https.
103
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
104
 
    c.Assert(err, IsNil)
105
 
    path := "/foo/bar"
106
 
    version := "test-version"
107
 
    request := newX509RequestPOST(server.URL+path, version, requestBody, requestContentType)
108
 
 
109
 
    response, err := performX509Request(session, request)
110
 
    c.Assert(err, IsNil)
111
 
    c.Assert(response.StatusCode, Equals, http.StatusOK)
112
 
    c.Check(response.Body, DeepEquals, responseBody)
113
 
 
114
 
    httpRequest := <-httpRequests
115
 
    c.Check(httpRequest.Header[http.CanonicalHeaderKey("Content-Type")], DeepEquals, []string{requestContentType})
116
 
    c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{request.APIVersion})
117
 
    c.Check(httpRequest.Method, Equals, "POST")
118
 
    c.Check(httpRequest.URL.String(), Equals, path)
119
 
    c.Check(httpRequest.BodyContent, DeepEquals, requestBody)
 
96
        httpRequests := make(chan *Request, 1)
 
97
        requestBody := []byte{1, 2, 3}
 
98
        responseBody := []byte{4, 5, 6}
 
99
        requestContentType := "bogusContentType"
 
100
        server := makeRecordingHTTPServer(httpRequests, http.StatusOK, responseBody, nil)
 
101
        defer server.Close()
 
102
        // No real certificate needed since we're testing on http, not https.
 
103
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
104
        c.Assert(err, IsNil)
 
105
        path := "/foo/bar"
 
106
        version := "test-version"
 
107
        request := newX509RequestPOST(server.URL+path, version, requestBody, requestContentType)
 
108
 
 
109
        response, err := performX509Request(session, request)
 
110
        c.Assert(err, IsNil)
 
111
        c.Assert(response.StatusCode, Equals, http.StatusOK)
 
112
        c.Check(response.Body, DeepEquals, responseBody)
 
113
 
 
114
        httpRequest := <-httpRequests
 
115
        c.Check(httpRequest.Header[http.CanonicalHeaderKey("Content-Type")], DeepEquals, []string{requestContentType})
 
116
        c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{request.APIVersion})
 
117
        c.Check(httpRequest.Method, Equals, "POST")
 
118
        c.Check(httpRequest.URL.String(), Equals, path)
 
119
        c.Check(httpRequest.BodyContent, DeepEquals, requestBody)
120
120
}
121
121
 
122
122
func (*x509DispatcherSuite) TestDeleteRequestDoesHTTPDELETE(c *C) {
123
 
    httpRequests := make(chan *Request, 1)
124
 
    server := makeRecordingHTTPServer(httpRequests, http.StatusOK, nil, nil)
125
 
    defer server.Close()
126
 
    // No real certificate needed since we're testing on http, not https.
127
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
128
 
    c.Assert(err, IsNil)
129
 
    path := "/foo/bar"
130
 
    version := "test-version"
131
 
    request := newX509RequestDELETE(server.URL+path, version)
132
 
 
133
 
    response, err := performX509Request(session, request)
134
 
    c.Assert(err, IsNil)
135
 
    c.Assert(response.StatusCode, Equals, http.StatusOK)
136
 
 
137
 
    httpRequest := <-httpRequests
138
 
    c.Check(httpRequest.Method, Equals, "DELETE")
139
 
    c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{version})
140
 
    c.Check(httpRequest.URL.String(), Equals, path)
141
 
    c.Check(httpRequest.BodyContent, HasLen, 0)
 
123
        httpRequests := make(chan *Request, 1)
 
124
        server := makeRecordingHTTPServer(httpRequests, http.StatusOK, nil, nil)
 
125
        defer server.Close()
 
126
        // No real certificate needed since we're testing on http, not https.
 
127
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
128
        c.Assert(err, IsNil)
 
129
        path := "/foo/bar"
 
130
        version := "test-version"
 
131
        request := newX509RequestDELETE(server.URL+path, version)
 
132
 
 
133
        response, err := performX509Request(session, request)
 
134
        c.Assert(err, IsNil)
 
135
        c.Assert(response.StatusCode, Equals, http.StatusOK)
 
136
 
 
137
        httpRequest := <-httpRequests
 
138
        c.Check(httpRequest.Method, Equals, "DELETE")
 
139
        c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{version})
 
140
        c.Check(httpRequest.URL.String(), Equals, path)
 
141
        c.Check(httpRequest.BodyContent, HasLen, 0)
142
142
}
143
143
 
144
144
func (*x509DispatcherSuite) TestPutRequestDoesHTTPPUT(c *C) {
145
 
    httpRequests := make(chan *Request, 1)
146
 
    requestBody := []byte{1, 2, 3}
147
 
    responseBody := []byte{4, 5, 6}
148
 
    server := makeRecordingHTTPServer(httpRequests, http.StatusOK, responseBody, nil)
149
 
    defer server.Close()
150
 
    // No real certificate needed since we're testing on http, not https.
151
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
152
 
    c.Assert(err, IsNil)
153
 
    path := "/foo/bar"
154
 
    version := "test-version"
155
 
    request := newX509RequestPUT(server.URL+path, version, requestBody, "application/octet-stream")
156
 
 
157
 
    response, err := performX509Request(session, request)
158
 
    c.Assert(err, IsNil)
159
 
    c.Assert(response.StatusCode, Equals, http.StatusOK)
160
 
    c.Check(response.Body, DeepEquals, responseBody)
161
 
 
162
 
    httpRequest := <-httpRequests
163
 
    c.Check(httpRequest.Method, Equals, "PUT")
164
 
    c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{version})
165
 
    c.Check(httpRequest.URL.String(), Equals, path)
166
 
    c.Check(httpRequest.BodyContent, DeepEquals, requestBody)
 
145
        httpRequests := make(chan *Request, 1)
 
146
        requestBody := []byte{1, 2, 3}
 
147
        responseBody := []byte{4, 5, 6}
 
148
        server := makeRecordingHTTPServer(httpRequests, http.StatusOK, responseBody, nil)
 
149
        defer server.Close()
 
150
        // No real certificate needed since we're testing on http, not https.
 
151
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
152
        c.Assert(err, IsNil)
 
153
        path := "/foo/bar"
 
154
        version := "test-version"
 
155
        request := newX509RequestPUT(server.URL+path, version, requestBody, "application/octet-stream")
 
156
 
 
157
        response, err := performX509Request(session, request)
 
158
        c.Assert(err, IsNil)
 
159
        c.Assert(response.StatusCode, Equals, http.StatusOK)
 
160
        c.Check(response.Body, DeepEquals, responseBody)
 
161
 
 
162
        httpRequest := <-httpRequests
 
163
        c.Check(httpRequest.Method, Equals, "PUT")
 
164
        c.Check(httpRequest.Header[http.CanonicalHeaderKey("X-Ms-Version")], DeepEquals, []string{version})
 
165
        c.Check(httpRequest.URL.String(), Equals, path)
 
166
        c.Check(httpRequest.BodyContent, DeepEquals, requestBody)
167
167
}
168
168
 
169
169
func (*x509DispatcherSuite) TestRequestRegistersHeader(c *C) {
170
 
    customHeader := http.CanonicalHeaderKey("x-gwacl-test")
171
 
    customValue := []string{"present"}
172
 
    returnRequest := func(w http.ResponseWriter, r *http.Request) {
173
 
        w.Header()[customHeader] = customValue
174
 
        w.WriteHeader(http.StatusOK)
175
 
    }
176
 
    serveMux := http.NewServeMux()
177
 
    serveMux.HandleFunc("/", returnRequest)
178
 
    server := httptest.NewServer(serveMux)
179
 
    defer server.Close()
180
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
181
 
    c.Assert(err, IsNil)
182
 
    path := "/foo/bar"
183
 
    request := newX509RequestGET(server.URL+path, "testversion")
184
 
 
185
 
    response, err := performX509Request(session, request)
186
 
    c.Assert(err, IsNil)
187
 
 
188
 
    c.Check(response.Header[customHeader], DeepEquals, customValue)
 
170
        customHeader := http.CanonicalHeaderKey("x-gwacl-test")
 
171
        customValue := []string{"present"}
 
172
        returnRequest := func(w http.ResponseWriter, r *http.Request) {
 
173
                w.Header()[customHeader] = customValue
 
174
                w.WriteHeader(http.StatusOK)
 
175
        }
 
176
        serveMux := http.NewServeMux()
 
177
        serveMux.HandleFunc("/", returnRequest)
 
178
        server := httptest.NewServer(serveMux)
 
179
        defer server.Close()
 
180
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
181
        c.Assert(err, IsNil)
 
182
        path := "/foo/bar"
 
183
        request := newX509RequestGET(server.URL+path, "testversion")
 
184
 
 
185
        response, err := performX509Request(session, request)
 
186
        c.Assert(err, IsNil)
 
187
 
 
188
        c.Check(response.Header[customHeader], DeepEquals, customValue)
189
189
}
190
190
 
191
191
func (*x509DispatcherSuite) TestRequestsFollowRedirects(c *C) {
192
 
    httpRequests := make(chan *Request, 2)
193
 
    serverConflict := makeRecordingHTTPServer(httpRequests, http.StatusConflict, nil, nil)
194
 
    defer serverConflict.Close()
195
 
    redirPath := "/else/where"
196
 
    responseHeaders := make(http.Header)
197
 
    responseHeaders.Set("Location", serverConflict.URL+redirPath)
198
 
    serverRedir := makeRecordingHTTPServer(httpRequests, http.StatusTemporaryRedirect, nil, responseHeaders)
199
 
    defer serverRedir.Close()
200
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
201
 
    c.Assert(err, IsNil)
202
 
    path := "/foo/bar"
203
 
    version := "test-version"
 
192
        httpRequests := make(chan *Request, 2)
 
193
        serverConflict := makeRecordingHTTPServer(httpRequests, http.StatusConflict, nil, nil)
 
194
        defer serverConflict.Close()
 
195
        redirPath := "/else/where"
 
196
        responseHeaders := make(http.Header)
 
197
        responseHeaders.Set("Location", serverConflict.URL+redirPath)
 
198
        serverRedir := makeRecordingHTTPServer(httpRequests, http.StatusTemporaryRedirect, nil, responseHeaders)
 
199
        defer serverRedir.Close()
 
200
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
201
        c.Assert(err, IsNil)
 
202
        path := "/foo/bar"
 
203
        version := "test-version"
204
204
 
205
 
    // Test both GET and DELETE: DELETE does not normally
206
 
    // automatically follow redirects, however Azure requires
207
 
    // us to.
208
 
    requests := []*X509Request{
209
 
        newX509RequestGET(serverRedir.URL+path, version),
210
 
        newX509RequestDELETE(serverRedir.URL+path, version),
211
 
    }
212
 
    for _, request := range requests {
213
 
        response, err := performX509Request(session, request)
214
 
        c.Assert(err, IsNil)
215
 
        c.Assert(response.StatusCode, Equals, http.StatusConflict)
216
 
        c.Assert(httpRequests, HasLen, 2)
217
 
        c.Assert((<-httpRequests).URL.String(), Equals, path)
218
 
        c.Assert((<-httpRequests).URL.String(), Equals, redirPath)
219
 
    }
 
205
        // Test both GET and DELETE: DELETE does not normally
 
206
        // automatically follow redirects, however Azure requires
 
207
        // us to.
 
208
        requests := []*X509Request{
 
209
                newX509RequestGET(serverRedir.URL+path, version),
 
210
                newX509RequestDELETE(serverRedir.URL+path, version),
 
211
        }
 
212
        for _, request := range requests {
 
213
                response, err := performX509Request(session, request)
 
214
                c.Assert(err, IsNil)
 
215
                c.Assert(response.StatusCode, Equals, http.StatusConflict)
 
216
                c.Assert(httpRequests, HasLen, 2)
 
217
                c.Assert((<-httpRequests).URL.String(), Equals, path)
 
218
                c.Assert((<-httpRequests).URL.String(), Equals, redirPath)
 
219
        }
220
220
}
221
221
 
222
222
func (*x509DispatcherSuite) TestRedirectRewindsBody(c *C) {
223
 
    httpRequests := make(chan *Request, 2)
224
 
    serverConflict := makeRecordingHTTPServer(httpRequests, http.StatusConflict, nil, nil)
225
 
    defer serverConflict.Close()
226
 
    redirPath := "/else/where"
227
 
    responseHeaders := make(http.Header)
228
 
    responseHeaders.Set("Location", serverConflict.URL+redirPath)
229
 
    serverRedir := makeRecordingHTTPServer(httpRequests, http.StatusTemporaryRedirect, nil, responseHeaders)
230
 
    defer serverRedir.Close()
231
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
232
 
    c.Assert(err, IsNil)
233
 
    path := "/foo/bar"
234
 
    version := "test-version"
235
 
    content := []byte("ponies")
236
 
    contentType := "text/plain"
 
223
        httpRequests := make(chan *Request, 2)
 
224
        serverConflict := makeRecordingHTTPServer(httpRequests, http.StatusConflict, nil, nil)
 
225
        defer serverConflict.Close()
 
226
        redirPath := "/else/where"
 
227
        responseHeaders := make(http.Header)
 
228
        responseHeaders.Set("Location", serverConflict.URL+redirPath)
 
229
        serverRedir := makeRecordingHTTPServer(httpRequests, http.StatusTemporaryRedirect, nil, responseHeaders)
 
230
        defer serverRedir.Close()
 
231
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
232
        c.Assert(err, IsNil)
 
233
        path := "/foo/bar"
 
234
        version := "test-version"
 
235
        content := []byte("ponies")
 
236
        contentType := "text/plain"
237
237
 
238
 
    request := newX509RequestPOST(serverRedir.URL+path, version, content, contentType)
239
 
    response, err := performX509Request(session, request)
240
 
    c.Assert(err, IsNil)
241
 
    c.Assert(response.StatusCode, Equals, http.StatusConflict)
242
 
    c.Assert(httpRequests, HasLen, 2)
243
 
    c.Assert((<-httpRequests).BodyContent, DeepEquals, content)
244
 
    c.Assert((<-httpRequests).BodyContent, DeepEquals, content)
 
238
        request := newX509RequestPOST(serverRedir.URL+path, version, content, contentType)
 
239
        response, err := performX509Request(session, request)
 
240
        c.Assert(err, IsNil)
 
241
        c.Assert(response.StatusCode, Equals, http.StatusConflict)
 
242
        c.Assert(httpRequests, HasLen, 2)
 
243
        c.Assert((<-httpRequests).BodyContent, DeepEquals, content)
 
244
        c.Assert((<-httpRequests).BodyContent, DeepEquals, content)
245
245
}
246
246
 
247
247
func (*x509DispatcherSuite) TestRequestsLimitRedirects(c *C) {
248
 
    httpRequests := make(chan *Request, 10)
249
 
    serverRedir := makeRecordingHTTPServer(httpRequests, http.StatusTemporaryRedirect, nil, nil)
250
 
    defer serverRedir.Close()
251
 
    session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
252
 
    c.Assert(err, IsNil)
253
 
    path := "/foo/bar"
254
 
    version := "test-version"
255
 
    request := newX509RequestGET(serverRedir.URL+path, version)
 
248
        httpRequests := make(chan *Request, 10)
 
249
        serverRedir := makeRecordingHTTPServer(httpRequests, http.StatusTemporaryRedirect, nil, nil)
 
250
        defer serverRedir.Close()
 
251
        session, err := newX509Session("subscriptionid", "", "West US", NoRetryPolicy)
 
252
        c.Assert(err, IsNil)
 
253
        path := "/foo/bar"
 
254
        version := "test-version"
 
255
        request := newX509RequestGET(serverRedir.URL+path, version)
256
256
 
257
 
    response, err := performX509Request(session, request)
258
 
    c.Assert(err, ErrorMatches, "stopped after 10 redirects")
259
 
    c.Assert(response, IsNil)
260
 
    c.Assert(httpRequests, HasLen, 10)
261
 
    close(httpRequests)
262
 
    for req := range httpRequests {
263
 
        c.Assert(req.URL.String(), Equals, path)
264
 
    }
 
257
        response, err := performX509Request(session, request)
 
258
        c.Assert(err, ErrorMatches, "stopped after 10 redirects")
 
259
        c.Assert(response, IsNil)
 
260
        c.Assert(httpRequests, HasLen, 10)
 
261
        close(httpRequests)
 
262
        for req := range httpRequests {
 
263
                c.Assert(req.URL.String(), Equals, path)
 
264
        }
265
265
}