Merge lp:~julian-edwards/gwacl/storage-test-helper into lp:gwacl

[Julian Edwards]

Refactor the makeStorageContext helper to reduce a lot of boilerplate in test code

Refactor the makeStorageContext helper some more which reduces a lot of boilerplate in test code:

 helpers_http_test.go | 13 +++
 storage_base_test.go | 167 +++++++++++++++------------------------------------
 storage_test.go | 40 +++---------
 3 files changed, 76 insertions(+), 144 deletions(-)

It also now takes http.RoundTripper as a parameter rather than TestTransport, so the TestTransport2 can also be used. We should really rename those, BTW, but not here.

[Julian Edwards (julian-edwards)]

Self approving despite the size; most of the changes are mechanical.

review: Approve

=== modified file 'helpers_http_test.go'
--- helpers_http_test.go	2013-04-30 05:13:33 +0000
+++ helpers_http_test.go	2013-06-20 04:26:28 +0000
@@ -6,6 +6,7 @@
 package gwacl
 
 import (
+    "encoding/base64"
     "fmt"
     "io"
     "io/ioutil"
@@ -77,3 +78,15 @@
 func makeResponseBody(content string) io.ReadCloser {
     return ioutil.NopCloser(strings.NewReader(content))
 }
+
+// Convenience factory to create a StorageContext with a random name and
+// random base64-encoded key.
+func makeStorageContext(transport http.RoundTripper) *StorageContext {
+    context := &StorageContext{
+        Account: MakeRandomString(10),
+        Key:     base64.StdEncoding.EncodeToString(MakeRandomByteSlice(10)),
+    }
+    context.client = &http.Client{Transport: transport}
+    return context
+}
+

=== modified file 'storage_base_test.go'
--- storage_base_test.go	2013-06-19 06:41:44 +0000
+++ storage_base_test.go	2013-06-20 04:26:28 +0000
@@ -294,15 +294,6 @@
     c.Assert(context.getClient(), Equals, context.client)
 }
 
-// Convenience factory to create a StorageContext with a random name and
-// random base64-encoded key.
-func makeStorageContext() *StorageContext {
-    return &StorageContext{
-        Account: MakeRandomString(10),
-        Key:     base64.StdEncoding.EncodeToString(MakeRandomByteSlice(10)),
-    }
-}
-
 type TestListContainers struct{}
 
 var _ = Suite(&TestListContainers{})
@@ -334,14 +325,13 @@
           </Containers>
           <NextMarker/>
         </EnumerationResults>`
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
         Body:       makeResponseBody(response_body),
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     request := &ListContainersRequest{Marker: ""}
     results, err := context.ListContainers(request)
     c.Assert(err, IsNil)
@@ -355,9 +345,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestListContainers) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     request := &ListContainersRequest{Marker: ""}
     _, err := context.ListContainers(request)
     c.Assert(err, NotNil)
@@ -369,19 +357,16 @@
         Status:     fmt.Sprintf("%d", http.StatusNotFound),
         StatusCode: http.StatusNotFound,
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     request := &ListContainersRequest{Marker: ""}
     _, err := context.ListContainers(request)
     c.Assert(err, NotNil)
 }
 
 func (suite *TestListContainers) TestListContainersBatchPassesMarker(c *C) {
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&http.Response{StatusCode: http.StatusOK, Body: Empty}, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     // Call ListContainers.  This will fail because of the empty
     // response, but no matter.  We only care about the request.
@@ -397,10 +382,9 @@
 }
 
 func (suite *TestListContainers) TestListContainersBatchDoesNotPassEmptyMarker(c *C) {
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&http.Response{StatusCode: http.StatusOK, Body: Empty}, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     // The error is OK.  We only care about the request.
     request := &ListContainersRequest{Marker: ""}
@@ -417,10 +401,9 @@
 }
 
 func (suite *TestListContainers) TestListContainersBatchEscapesMarker(c *C) {
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&http.Response{StatusCode: http.StatusOK, Body: Empty}, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     // The error is OK.  We only care about the request.
     request := &ListContainersRequest{Marker: "x&y"}
@@ -485,14 +468,14 @@
           </Blobs>
           <NextMarker />
         </EnumerationResults>`
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
         Body:       makeResponseBody(response_body),
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
+
     request := &ListBlobsRequest{Container: "container"}
     results, err := context.ListBlobs(request)
     c.Assert(err, IsNil)
@@ -508,9 +491,8 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestListBlobs) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
+
     request := &ListBlobsRequest{Container: "container"}
     _, err := context.ListBlobs(request)
     c.Assert(err, NotNil)
@@ -522,19 +504,17 @@
         Status:     fmt.Sprintf("%d", http.StatusNotFound),
         StatusCode: http.StatusNotFound,
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
+
     request := &ListBlobsRequest{Container: "container"}
     _, err := context.ListBlobs(request)
     c.Assert(err, NotNil)
 }
 
 func (suite *TestListBlobs) TestListBlobsPassesMarker(c *C) {
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&http.Response{StatusCode: http.StatusOK, Body: Empty}, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     // Call ListBlobs.  This will fail because of the empty
     // response, but no matter.  We only care about the request.
@@ -550,10 +530,9 @@
 }
 
 func (suite *TestListBlobs) TestListBlobsDoesNotPassEmptyMarker(c *C) {
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&http.Response{StatusCode: http.StatusOK, Body: Empty}, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     // The error is OK.  We only care about the request.
     request := &ListBlobsRequest{Container: "mycontainer"}
@@ -570,10 +549,9 @@
 }
 
 func (suite *TestListBlobs) TestListBlobsPassesPrefix(c *C) {
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&http.Response{StatusCode: http.StatusOK, Body: Empty}, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     // Call ListBlobs.  This will fail because of the empty
     // response, but no matter.  We only care about the request.
@@ -589,10 +567,9 @@
 }
 
 func (suite *TestListBlobs) TestListBlobsDoesNotPassEmptyPrefix(c *C) {
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&http.Response{StatusCode: http.StatusOK, Body: Empty}, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     // The error is OK.  We only care about the request.
     request := &ListBlobsRequest{Container: "mycontainer"}
@@ -615,13 +592,12 @@
 // The CreateContainer Storage API call returns without error when the
 // container has been created successfully.
 func (suite *TestCreateContainer) Test(c *C) {
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusCreated),
         StatusCode: http.StatusCreated,
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     container_name := MakeRandomString(10)
     err := context.CreateContainer(container_name)
     c.Assert(err, IsNil)
@@ -634,9 +610,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestCreateContainer) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     err := context.CreateContainer("container")
     c.Assert(err, NotNil)
 }
@@ -647,9 +621,7 @@
         Status:     fmt.Sprintf("%d", http.StatusNotFound),
         StatusCode: http.StatusNotFound,
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     err := context.CreateContainer("container")
     c.Assert(err, NotNil)
 }
@@ -660,9 +632,7 @@
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     err := context.CreateContainer("container")
     c.Assert(err, NotNil)
 }
@@ -673,13 +643,12 @@
 
 // Basic happy path testing.
 func (suite *TestPutPage) TestHappyPath(c *C) {
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusCreated),
         StatusCode: http.StatusCreated,
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     randomData := MakeRandomByteSlice(10)
     dataReader := bytes.NewReader(randomData)
 
@@ -709,9 +678,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestPutPage) TestError(c *C) {
     cannedError := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: cannedError}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: cannedError})
     err := context.PutPage(&PutPageRequest{
         Container: "container", Filename: "filename", StartRange: 0,
         EndRange: 512, Data: nil})
@@ -725,9 +692,7 @@
         StatusCode: 102,
         Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put blob</Message></Error>"),
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     err := context.PutPage(&PutPageRequest{
         Container: "container", Filename: "filename", StartRange: 0,
         EndRange: 512, Data: nil})
@@ -743,13 +708,13 @@
 
 // Test basic PutBlob happy path functionality.
 func (suite *TestPutBlob) TestPutBlockBlob(c *C) {
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusCreated),
         StatusCode: http.StatusCreated,
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
+
     err := context.PutBlob(&PutBlobRequest{
         Container: "container", BlobType: "block", Filename: "blobname"})
     c.Assert(err, IsNil)
@@ -763,13 +728,12 @@
 
 // PutBlob should set x-ms-blob-type to PageBlob for Page Blobs.
 func (suite *TestPutBlob) TestPutPageBlob(c *C) {
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusCreated),
         StatusCode: http.StatusCreated,
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     err := context.PutBlob(&PutBlobRequest{
         Container: "container", BlobType: "page", Filename: "blobname"})
     c.Assert(err, IsNil)
@@ -782,7 +746,7 @@
         err := recover()
         c.Assert(err, Equals, "block_type must be 'page' or 'block'")
     }()
-    context := makeStorageContext()
+    context := makeStorageContext(&TestTransport{})
     context.PutBlob(&PutBlobRequest{
         Container: "container", BlobType: "invalid-blob-type",
         Filename: "blobname"})
@@ -792,9 +756,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestPutBlob) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     err := context.PutBlob(&PutBlobRequest{
         Container: "container", BlobType: "block", Filename: "blobname"})
     c.Assert(err, NotNil)
@@ -807,9 +769,7 @@
         StatusCode: 102,
         Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put blob</Message></Error>"),
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     err := context.PutBlob(&PutBlobRequest{
         Container: "container", BlobType: "block", Filename: "blobname"})
     c.Assert(err, NotNil)
@@ -823,13 +783,12 @@
 var _ = Suite(&TestPutBlock{})
 
 func (suite *TestPutBlock) Test(c *C) {
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusCreated),
         StatusCode: http.StatusCreated,
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     blockid := "\x1b\xea\xf7Mv\xb5\xddH\xebm"
     random_data := MakeRandomByteSlice(10)
     data_reader := bytes.NewReader(random_data)
@@ -853,9 +812,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestPutBlock) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     data_reader := bytes.NewReader(MakeRandomByteSlice(10))
     err := context.PutBlock("container", "blobname", "blockid", data_reader)
     c.Assert(err, NotNil)
@@ -868,9 +825,7 @@
         StatusCode: 102,
         Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put block</Message></Error>"),
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     data_reader := bytes.NewReader(MakeRandomByteSlice(10))
     err := context.PutBlock("container", "blobname", "blockid", data_reader)
     c.Assert(err, NotNil)
@@ -884,13 +839,12 @@
 var _ = Suite(&TestPutBlockList{})
 
 func (suite *TestPutBlockList) Test(c *C) {
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusCreated),
         StatusCode: http.StatusCreated,
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     blocklist := &BlockList{}
     blocklist.Add(BlockListLatest, "b1")
     blocklist.Add(BlockListLatest, "b2")
@@ -916,9 +870,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestPutBlockList) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     blocklist := &BlockList{}
     err := context.PutBlockList("container", "blobname", blocklist)
     c.Assert(err, NotNil)
@@ -931,9 +883,7 @@
         StatusCode: 102,
         Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put blocklist</Message></Error>"),
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     blocklist := &BlockList{}
     err := context.PutBlockList("container", "blobname", blocklist)
     c.Assert(err, NotNil)
@@ -966,14 +916,13 @@
           </UncommittedBlocks>
         </BlockList>`
 
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
         Body:       makeResponseBody(response_body),
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     results, err := context.GetBlockList("container", "myfilename")
     c.Assert(err, IsNil)
     c.Check(transport.Request.URL.String(), Matches, context.getFileURL("container", "myfilename")+"?.*")
@@ -988,9 +937,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestGetBlockList) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     _, err := context.GetBlockList("container", "myfilename")
     c.Assert(err, NotNil)
 }
@@ -1001,9 +948,7 @@
         Status:     fmt.Sprintf("%d", http.StatusNotFound),
         StatusCode: http.StatusNotFound,
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     _, err := context.GetBlockList("container", "myfilename")
     c.Assert(err, NotNil)
 }
@@ -1013,13 +958,12 @@
 var _ = Suite(&TestDeleteBlob{})
 
 func (suite *TestDeleteBlob) Test(c *C) {
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusAccepted),
         StatusCode: http.StatusAccepted,
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     err := context.DeleteBlob("container", "blobname")
     c.Assert(err, IsNil)
 
@@ -1032,9 +976,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestDeleteBlob) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     err := context.DeleteBlob("container", "blobname")
     c.Assert(err, NotNil)
 }
@@ -1046,9 +988,7 @@
         StatusCode: 146,
         Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to delete blob</Message></Error>"),
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     err := context.DeleteBlob("container", "blobname")
     c.Assert(err, NotNil)
     c.Check(err, ErrorMatches, ".*146.*")
@@ -1061,7 +1001,6 @@
 var _ = Suite(&TestGetBlob{})
 
 func (suite *TestGetBlob) Test(c *C) {
-    context := makeStorageContext()
     response_body := "blob-in-a-can"
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
@@ -1069,7 +1008,7 @@
         Body:       makeResponseBody(response_body),
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     reader, err := context.GetBlob("container", "blobname")
     c.Assert(err, IsNil)
     c.Assert(reader, NotNil)
@@ -1087,9 +1026,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestGetBlob) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     reader, err := context.GetBlob("container", "blobname")
     c.Check(reader, IsNil)
     c.Assert(err, NotNil)
@@ -1102,9 +1039,7 @@
         StatusCode: 246,
         Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to get blob</Message></Error>"),
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     reader, err := context.GetBlob("container", "blobname")
     c.Check(reader, IsNil)
     c.Assert(err, NotNil)

=== modified file 'storage_test.go'
--- storage_test.go	2013-06-11 16:31:49 +0000
+++ storage_test.go	2013-06-20 04:26:28 +0000
@@ -17,14 +17,12 @@
 var _ = Suite(&testUploadBlockBlob{})
 
 func (suite *testUploadBlockBlob) TestSmallFile(c *C) {
-    context := makeStorageContext()
     transport := &TestTransport2{}
+    context := makeStorageContext(transport)
     // UploadBlockBlob uses PutBlock to upload the data.
     transport.AddExchange(makeFakeCreatedResponse(), nil)
     // UploadBlockBlob then sends the list of blocks with PutBlockList.
     transport.AddExchange(makeFakeCreatedResponse(), nil)
-    // Plug in the test transport.
-    context.client = &http.Client{Transport: transport}
     // Upload a random blob of data.
     data := uploadRandomBlob(c, context, 10)
     // There were two exchanges.
@@ -36,15 +34,13 @@
 }
 
 func (suite *testUploadBlockBlob) TestLargeFile(c *C) {
-    context := makeStorageContext()
     transport := &TestTransport2{}
+    context := makeStorageContext(transport)
     // UploadBlockBlob uses PutBlock twice to upload the data.
     transport.AddExchange(makeFakeCreatedResponse(), nil)
     transport.AddExchange(makeFakeCreatedResponse(), nil)
     // UploadBlockBlob then sends the list of blocks with PutBlockList.
     transport.AddExchange(makeFakeCreatedResponse(), nil)
-    // Plug in the test transport.
-    context.client = &http.Client{Transport: transport}
     // Upload a large random blob of data.
     data := uploadRandomBlob(c, context, 1348*1024)
     // There were three exchanges.
@@ -143,14 +139,13 @@
           </Blobs>
           <NextMarker />
         </EnumerationResults>`
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
         Body:       makeResponseBody(response_body),
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     request := &ListBlobsRequest{Container: "container"}
     results, err := context.ListAllBlobs(request)
     c.Assert(err, IsNil)
@@ -166,9 +161,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *testListAllBlobs) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     request := &ListBlobsRequest{Container: "container"}
     _, err := context.ListAllBlobs(request)
     c.Assert(err, NotNil)
@@ -180,9 +173,7 @@
         Status:     fmt.Sprintf("%d", http.StatusNotFound),
         StatusCode: http.StatusNotFound,
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     request := &ListBlobsRequest{Container: "container"}
     _, err := context.ListAllBlobs(request)
     c.Assert(err, NotNil)
@@ -218,11 +209,10 @@
             </EnumerationResults>
         `, lastBlob)),
     }
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&firstBatch, nil)
     transport.AddExchange(&lastBatch, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     request := &ListBlobsRequest{Container: "mycontainer"}
     blobs, err := context.ListAllBlobs(request)
@@ -264,14 +254,13 @@
           </Containers>
           <NextMarker/>
         </EnumerationResults>`
-    context := makeStorageContext()
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
         Body:       makeResponseBody(response_body),
     }
     transport := &TestTransport{Response: response}
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(transport)
     results, err := context.ListAllContainers()
     c.Assert(err, IsNil)
     c.Check(transport.Request.URL.String(), Equals, fmt.Sprintf(
@@ -284,9 +273,7 @@
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *testListAllContainers) TestError(c *C) {
     error := fmt.Errorf("canned-error")
-    transport := &TestTransport{Error: error}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Error: error})
     _, err := context.ListAllContainers()
     c.Assert(err, NotNil)
 }
@@ -297,9 +284,7 @@
         Status:     fmt.Sprintf("%d", http.StatusNotFound),
         StatusCode: http.StatusNotFound,
     }
-    transport := &TestTransport{Response: response}
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: transport}
+    context := makeStorageContext(&TestTransport{Response: response})
     _, err := context.ListAllContainers()
     c.Assert(err, NotNil)
 }
@@ -336,11 +321,10 @@
             </EnumerationResults>
         `, lastContainer)),
     }
-    transport := TestTransport2{}
+    transport := &TestTransport2{}
     transport.AddExchange(&firstBatch, nil)
     transport.AddExchange(&lastBatch, nil)
-    context := makeStorageContext()
-    context.client = &http.Client{Transport: &transport}
+    context := makeStorageContext(transport)
 
     containers, err := context.ListAllContainers()
     c.Assert(err, IsNil)