Merge lp:~rvb/gwacl/not-found-errors into lp:gwacl

[Raphaël Badin]

Propagate Azure errors, add IsNotFoundError() method.

This branch does two things:
- it adds two utility methods:
   - extendError(). This method is used to extend the message of different types of error (generic errors and ServerError errors). The goal is to be able to extend errors in a generic fashion without losing the extra information that a more specialized error might carry.
    - IsNotFoundError(). This method is a tiny utility that a third party application might use when getting an error back from gwacl to determine if the underlining Azure error is a 404 error. This is needed in the provider and I figured it would be better to provide a utility method rather than to let the caller do the casting and the comparison with a gwacl-specific redefinition of an HTTPStatus (with we have this redefinition, I don't know).
- it use the extendError() method in the methods from storage_base.go to propagate Azure-related error instead of hiding this from the caller.

One more thing: adding makeHttpResponse() is a small improvement I made to the code since creating an http.Response was done over and over again in the test code. It hads a bit of noise to the diff but once I got started and thought "hum, could I land this as a pre-req?" it was already too late… besides, the pipeline plugin does not play well with colocated branches.

This was pre-imp'ed with Jeroen.

[Gavin Panella (allenap)]

Looks okay, but I want you to consider [1] before I approve.

[1]

+func extendError(err error, message string) error {

I found the suggestion that Jeroen mentioned this morning. It's from a
thread called "Strategy for errors in Go". See what you think:

Instead of munging errors into new ones, and so losing type info, we
could store all the errors in a linked-list. I've not given it massive
amounts of thought, but perhaps it's an interesting idea.

type GWACLErrorType interface {
    Error  func() string
    Check  func(GWACLErrorType) GWACLErrorType
    Chain  func(Error) GWACLErrorType
    This   Error
    Next   GWACLErrorType
}

type GWACLError struct {
    This   Error
    Next   GWACLErrorType
}

// Satisfy the Error interface.
func (self *GWACLError) Error() string {
    if self.Next == nil {
        return self.Error()
    } else {
        return self.Error() + "; " + self.Next.Error()
    }
    panic("Being for the benefit of Go < 1.1.")
}

// Search for an error in the list. Sadly, types are not first-class
// citizens, so this just does equality testing for now, but perhaps
// something better could be dreamt up.
func (self *GWACLError) Check(err *GWACLErrorType) {
    for f := self; f = f.Next(); f != nil {
        if f == err {
            return f
        }
    }
    return nil
}

// Return a new GWACLErrorType with the current error at the head.
func (self *GWACLError) Chain(err Error) GWACLErrorType {
    return &GWACLError{err, self}
}

[2]

+    var testValues = []struct {
+        err            error
+        expectedResult bool
+    }{
...
+    }

I wasn't aware of this form. Nice to know.

review: Needs Information

[Raphaël Badin (rvb)]

> Looks okay, but I want you to consider [1] before I approve.

This looks much too big to be considered *before* this lands to be honest. An interesting idea but clearly outside the scope of this branch; the good thing about this branch is that all the extendError()/IsNotFoundError() stuff is well encapsulated so we could move to something like what you describe in the future.

A few things about the error chain idea:
- I like the general idea although I'm afraid that it might be flagged as non-idiomatic (whatever that means) because it's basically a slightly awkward implementation of a dynamic traceback being built manually :).
- Such a generic pattern, if a complete analysis prove that it's worth it, should probably live in its own project so that many projects can benefit from it.

[Gavin Panella (allenap)]

> > Looks okay, but I want you to consider [1] before I approve.
>
> This looks much too big to be considered *before* this lands to be honest.

Yeah, I guess it's *instead* of parts of this branch. Things like
IsNotFoundError can be reimplemented to use this quite easily.

> An
> interesting idea but clearly outside the scope of this branch; the good thing
> about this branch is that all the extendError()/IsNotFoundError() stuff is
> well encapsulated so we could move to something like what you describe in the
> future.

I'm not sure it's clearly outside of scope, but okay.

> A few things about the error chain idea:
> - I like the general idea although I'm afraid that it might be flagged as non-
> idiomatic (whatever that means) because it's basically a slightly awkward
> implementation of a dynamic traceback being built manually :).

We're the GWACL maintainers, so we get to say what's idiomatic. If
smooshing strings together for errors is truly what the Go mainstream
call idiomatic then I'm happy to be a freak. I don't think it is
though. They like tracebacks too, they're just having some cognitive
dissonance issues between tracebacks with panic (or what a duck would
call exceptions) and the dogmatic checking and passing of errors by
hand.

> - Such a generic pattern, if a complete analysis prove that it's worth it,
> should probably live in its own project so that many projects can benefit from
> it.

It's only 39 lines ;)

It might be generically useful, but everything has to start somewhere.
Putting it in a sub-package or just a new file is enough to get going.

review: Approve

[Raphaël Badin (rvb)]

> Yeah, I guess it's *instead* of parts of this branch. Things like
> IsNotFoundError can be reimplemented to use this quite easily.

> It might be generically useful, but everything has to start somewhere.
> Putting it in a sub-package or just a new file is enough to get going.

Sounds like a good plan. Thanks for unblocking me… I'm happy to think/talk some more about this idea next week.

=== modified file 'httperror.go'
--- httperror.go	2013-04-02 08:51:00 +0000
+++ httperror.go	2013-06-21 11:47:27 +0000
@@ -90,3 +90,37 @@
         Message:    outcome.ErrorMessage,
     }
 }
+
+// extendError returns an error whos description is the concatenation of
+// the given message plus the error string from the original error.
+// It preserves the value of the error types it knows about (currently only
+// ServerError).
+// 
+// The main purpose of this method is to offer a unified way to
+// extend the information present in errors while still not losing the
+// additioning information present on specific errors gwacl knows out to extend
+// in a more meaningful way.
+func extendError(err error, message string) error {
+    switch err := err.(type) {
+    case *ServerError:
+        returnedErr := *err
+        returnedErr.error = fmt.Errorf(message+"%v", err.error)
+        return &returnedErr
+    default:
+        return fmt.Errorf(message+"%v", err)
+    }
+    // This code cannot be reached but Go insists on having a return or a panic
+    // statement at the end of this method.  Sigh.
+    panic("invalid extendError state!")
+}
+
+// IsNotFoundError returns whether or not the given error is an error (as
+// returned by a gwacl method) which corresponds to a 'Not Found' error
+// returned by Windows Azure.
+func IsNotFoundError(err error) bool {
+    serverError, ok := err.(*ServerError)
+    if !ok {
+        return false
+    }
+    return serverError.HTTPStatus.StatusCode() == http.StatusNotFound
+}

=== modified file 'httperror_test.go'
--- httperror_test.go	2013-04-02 06:49:31 +0000
+++ httperror_test.go	2013-06-21 11:47:27 +0000
@@ -94,3 +94,41 @@
     c.Check(err.Code, Equals, code)
     c.Check(err.Message, Equals, message)
 }
+
+func (suite *httpErrorSuite) TestExtendErrorExtendsGenericError(c *C) {
+    errorString := "an-error"
+    error := fmt.Errorf(errorString)
+    additionalErrorMsg := "additional message"
+    newError := extendError(error, additionalErrorMsg)
+    c.Check(newError.Error(), Equals, fmt.Sprintf("%s%s", additionalErrorMsg, error.Error()))
+}
+
+func (suite *httpErrorSuite) TestExtendErrorExtendsServerError(c *C) {
+    description := "could not talk to server"
+    status := http.StatusGatewayTimeout
+    httpErr := newHTTPError(status, []byte{}, description)
+
+    httpServerErr, ok := httpErr.(*ServerError)
+    c.Assert(ok, Equals, true)
+    additionalErrorMsg := "additional message"
+    newError := extendError(httpErr, additionalErrorMsg)
+    newServerError, ok := httpErr.(*ServerError)
+    c.Assert(ok, Equals, true)
+    c.Check(newError.Error(), Equals, fmt.Sprintf("%s%s", additionalErrorMsg, httpErr.Error()))
+    c.Check(httpServerErr.HTTPStatus, Equals, newServerError.HTTPStatus)
+}
+
+func (suite *httpErrorSuite) TestIsNotFound(c *C) {
+    var testValues = []struct {
+        err            error
+        expectedResult bool
+    }{
+        {fmt.Errorf("generic error"), false},
+        {newHTTPError(http.StatusGatewayTimeout, []byte{}, "error"), false},
+        {newHTTPError(http.StatusOK, []byte{}, ""), false},
+        {newHTTPError(http.StatusNotFound, []byte{}, "error"), true},
+    }
+    for _, test := range testValues {
+        c.Check(IsNotFoundError(test.err), Equals, test.expectedResult)
+    }
+}

=== modified file 'storage_base.go'
--- storage_base.go	2013-06-21 01:01:35 +0000
+++ storage_base.go	2013-06-21 11:47:27 +0000
@@ -356,7 +356,8 @@
         ExpectedStatus: http.StatusOK,
     })
     if err != nil {
-        return nil, fmt.Errorf("request for containers list failed: %v", err)
+        msg := "request for containers list failed: "
+        return nil, extendError(err, msg)
     }
     return &containers, nil
 }
@@ -392,7 +393,8 @@
         ExpectedStatus: http.StatusOK,
     })
     if err != nil {
-        return nil, fmt.Errorf("request for blobs list failed: %v", err)
+        msg := "request for blobs list failed: "
+        return nil, extendError(err, msg)
     }
     return &blobs, err
 }
@@ -410,7 +412,8 @@
         ExpectedStatus: http.StatusCreated,
     })
     if err != nil {
-        return fmt.Errorf("failed to create container %s: %v", container, err)
+        msg := fmt.Sprintf("failed to create container %s: ", container)
+        return extendError(err, msg)
     }
     return nil
 }
@@ -453,7 +456,8 @@
         ExpectedStatus: http.StatusCreated,
     })
     if err != nil {
-        return fmt.Errorf("failed to create blob %s: %v", req.Filename, err)
+        msg := fmt.Sprintf("failed to create blob %s: ", req.Filename)
+        return extendError(err, msg)
     }
     return nil
 }
@@ -488,7 +492,8 @@
         ExpectedStatus: http.StatusCreated,
     })
     if err != nil {
-        return fmt.Errorf("failed to put page for file %s: %v", req.Filename, err)
+        msg := fmt.Sprintf("failed to put page for file %s: ", req.Filename)
+        return extendError(err, msg)
     }
     return nil
 }
@@ -509,7 +514,8 @@
         ExpectedStatus: http.StatusOK,
     })
     if err != nil {
-        return nil, fmt.Errorf("request for block list in file %s failed: %v", filename, err)
+        msg := fmt.Sprintf("request for block list in file %s failed: ", filename)
+        return nil, extendError(err, msg)
     }
     return &bl, nil
 }
@@ -530,7 +536,8 @@
         ExpectedStatus: http.StatusCreated,
     })
     if err != nil {
-        return fmt.Errorf("failed to put block %s for file %s: %v", id, filename, err)
+        msg := fmt.Sprintf("failed to put block %s for file %s: ", id, filename)
+        return extendError(err, msg)
     }
     return nil
 }
@@ -554,7 +561,8 @@
         ExpectedStatus: http.StatusCreated,
     })
     if err != nil {
-        return fmt.Errorf("failed to put blocklist for file %s: %v", filename, err)
+        msg := fmt.Sprintf("failed to put blocklist for file %s: ", filename)
+        return extendError(err, msg)
     }
     return nil
 }
@@ -568,8 +576,10 @@
         ExpectedStatus: http.StatusAccepted,
     })
     // TODO Handle a 404 with an <Error>BlobNotFound response body silently.
+    // Now this is easy to fix with the method IsNotFoundError().
     if err != nil {
-        return fmt.Errorf("failed to delete blob %s: %v", filename, err)
+        msg := fmt.Sprintf("failed to delete blob %s: ", filename)
+        return extendError(err, msg)
     }
     return nil
 }
@@ -583,7 +593,8 @@
         ExpectedStatus: http.StatusOK,
     })
     if err != nil {
-        return nil, fmt.Errorf("failed to get blob %s: %v", filename, err)
+        msg := fmt.Sprintf("failed to get blob %s: ", filename)
+        return nil, extendError(err, msg)
     }
     return response.Body, nil
 }

=== modified file 'storage_base_test.go'
--- storage_base_test.go	2013-06-21 01:01:35 +0000
+++ storage_base_test.go	2013-06-21 11:47:27 +0000
@@ -20,6 +20,14 @@
 
 var _ = Suite(&testComposeHeaders{})
 
+func makeHttpResponse(status int, body string) *http.Response {
+    return &http.Response{
+        Status:     fmt.Sprintf("%d", status),
+        StatusCode: status,
+        Body:       makeResponseBody(body),
+    }
+}
+
 func (suite *testComposeHeaders) TestNoHeaders(c *C) {
     req, err := http.NewRequest("GET", "http://example.com", nil)
     c.Assert(err, IsNil)
@@ -301,7 +309,7 @@
 // The ListContainers Storage API call returns a ContainerEnumerationResults
 // struct on success.
 func (suite *TestListContainers) Test(c *C) {
-    response_body := `
+    responseBody := `
         <?xml version="1.0" encoding="utf-8"?>
         <EnumerationResults AccountName="http://myaccount.blob.core.windows.net">
           <Prefix>prefix-value</Prefix>
@@ -325,11 +333,7 @@
           </Containers>
           <NextMarker/>
         </EnumerationResults>`
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusOK),
-        StatusCode: http.StatusOK,
-        Body:       makeResponseBody(response_body),
-    }
+    response := makeHttpResponse(http.StatusOK, responseBody)
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     request := &ListContainersRequest{Marker: ""}
@@ -351,16 +355,16 @@
     c.Assert(err, NotNil)
 }
 
-// Server-side errors are propagated back to the caller.
-func (suite *TestListContainers) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusNotFound),
-        StatusCode: http.StatusNotFound,
-    }
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestListContainers) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
     context := makeStorageContext(&TestTransport{Response: response})
     request := &ListContainersRequest{Marker: ""}
     _, err := context.ListContainers(request)
-    c.Assert(err, NotNil)
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
 }
 
 func (suite *TestListContainers) TestListContainersBatchPassesMarker(c *C) {
@@ -424,7 +428,7 @@
 // The ListBlobs Storage API call returns a BlobEnumerationResults struct on
 // success.
 func (suite *TestListBlobs) Test(c *C) {
-    response_body := `
+    responseBody := `
         <?xml version="1.0" encoding="utf-8"?>
         <EnumerationResults ContainerName="http://myaccount.blob.core.windows.net/mycontainer">
           <Prefix>prefix</Prefix>
@@ -468,11 +472,7 @@
           </Blobs>
           <NextMarker />
         </EnumerationResults>`
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusOK),
-        StatusCode: http.StatusOK,
-        Body:       makeResponseBody(response_body),
-    }
+    response := makeHttpResponse(http.StatusOK, responseBody)
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
 
@@ -498,17 +498,16 @@
     c.Assert(err, NotNil)
 }
 
-// Server-side errors are propagated back to the caller.
-func (suite *TestListBlobs) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusNotFound),
-        StatusCode: http.StatusNotFound,
-    }
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestListBlobs) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
     context := makeStorageContext(&TestTransport{Response: response})
-
     request := &ListBlobsRequest{Container: "container"}
     _, err := context.ListBlobs(request)
-    c.Assert(err, NotNil)
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
 }
 
 func (suite *TestListBlobs) TestListBlobsPassesMarker(c *C) {
@@ -592,10 +591,7 @@
 // The CreateContainer Storage API call returns without error when the
 // container has been created successfully.
 func (suite *TestCreateContainer) Test(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusCreated),
-        StatusCode: http.StatusCreated,
-    }
+    response := makeHttpResponse(http.StatusCreated, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     container_name := MakeRandomString(10)
@@ -617,10 +613,7 @@
 
 // Server-side errors are propagated back to the caller.
 func (suite *TestCreateContainer) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusNotFound),
-        StatusCode: http.StatusNotFound,
-    }
+    response := makeHttpResponse(http.StatusNotFound, "not found")
     context := makeStorageContext(&TestTransport{Response: response})
     err := context.CreateContainer("container")
     c.Assert(err, NotNil)
@@ -628,25 +621,30 @@
 
 // Server-side errors are propagated back to the caller.
 func (suite *TestCreateContainer) TestNotCreatedResponse(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusOK),
-        StatusCode: http.StatusOK,
-    }
+    response := makeHttpResponse(http.StatusOK, "")
     context := makeStorageContext(&TestTransport{Response: response})
     err := context.CreateContainer("container")
     c.Assert(err, NotNil)
 }
 
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestCreateContainer) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
+    context := makeStorageContext(&TestTransport{Response: response})
+    err := context.CreateContainer("container")
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
+}
+
 type TestPutPage struct{}
 
 var _ = Suite(&TestPutPage{})
 
 // Basic happy path testing.
 func (suite *TestPutPage) TestHappyPath(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusCreated),
-        StatusCode: http.StatusCreated,
-    }
+    response := makeHttpResponse(http.StatusCreated, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     randomData := MakeRandomByteSlice(10)
@@ -687,11 +685,8 @@
 
 // Server-side errors are propagated back to the caller.
 func (suite *TestPutPage) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     "102 Frotzed",
-        StatusCode: 102,
-        Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put blob</Message></Error>"),
-    }
+    responseBody := "<Error><Code>Frotzed</Code><Message>failed to put blob</Message></Error>"
+    response := makeHttpResponse(102, responseBody)
     context := makeStorageContext(&TestTransport{Response: response})
     err := context.PutPage(&PutPageRequest{
         Container: "container", Filename: "filename", StartRange: 0,
@@ -702,16 +697,26 @@
     c.Check(err, ErrorMatches, ".*failed to put blob.*")
 }
 
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestPutPage) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
+    context := makeStorageContext(&TestTransport{Response: response})
+    err := context.PutPage(&PutPageRequest{
+        Container: "container", Filename: "filename", StartRange: 0,
+        EndRange: 512, Data: nil})
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
+}
+
 type TestPutBlob struct{}
 
 var _ = Suite(&TestPutBlob{})
 
 // Test basic PutBlob happy path functionality.
 func (suite *TestPutBlob) TestPutBlockBlob(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusCreated),
-        StatusCode: http.StatusCreated,
-    }
+    response := makeHttpResponse(http.StatusCreated, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
 
@@ -728,10 +733,7 @@
 
 // PutBlob should set x-ms-blob-type to PageBlob for Page Blobs.
 func (suite *TestPutBlob) TestPutPageBlob(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusCreated),
-        StatusCode: http.StatusCreated,
-    }
+    response := makeHttpResponse(http.StatusCreated, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     err := context.PutBlob(&PutBlobRequest{
@@ -774,11 +776,8 @@
 
 // Server-side errors are propagated back to the caller.
 func (suite *TestPutBlob) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     "102 Frotzed",
-        StatusCode: 102,
-        Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put blob</Message></Error>"),
-    }
+    responseBody := "<Error><Code>Frotzed</Code><Message>failed to put blob</Message></Error>"
+    response := makeHttpResponse(102, responseBody)
     context := makeStorageContext(&TestTransport{Response: response})
     err := context.PutBlob(&PutBlobRequest{
         Container: "container", BlobType: "block", Filename: "blobname"})
@@ -788,15 +787,24 @@
     c.Check(err, ErrorMatches, ".*failed to put blob.*")
 }
 
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestPutBlob) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
+    context := makeStorageContext(&TestTransport{Response: response})
+    err := context.PutBlob(&PutBlobRequest{
+        Container: "container", BlobType: "block", Filename: "blobname"})
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
+}
+
 type TestPutBlock struct{}
 
 var _ = Suite(&TestPutBlock{})
 
 func (suite *TestPutBlock) Test(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusCreated),
-        StatusCode: http.StatusCreated,
-    }
+    response := makeHttpResponse(http.StatusCreated, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     blockid := "\x1b\xea\xf7Mv\xb5\xddH\xebm"
@@ -830,11 +838,8 @@
 
 // Server-side errors are propagated back to the caller.
 func (suite *TestPutBlock) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     "102 Frotzed",
-        StatusCode: 102,
-        Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put block</Message></Error>"),
-    }
+    responseBody := "<Error><Code>Frotzed</Code><Message>failed to put block</Message></Error>"
+    response := makeHttpResponse(102, responseBody)
     context := makeStorageContext(&TestTransport{Response: response})
     data_reader := bytes.NewReader(MakeRandomByteSlice(10))
     err := context.PutBlock("container", "blobname", "blockid", data_reader)
@@ -844,15 +849,24 @@
     c.Check(err, ErrorMatches, ".*failed to put block.*")
 }
 
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestPutBlock) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
+    context := makeStorageContext(&TestTransport{Response: response})
+    data_reader := bytes.NewReader(MakeRandomByteSlice(10))
+    err := context.PutBlock("container", "blobname", "blockid", data_reader)
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
+}
+
 type TestPutBlockList struct{}
 
 var _ = Suite(&TestPutBlockList{})
 
 func (suite *TestPutBlockList) Test(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusCreated),
-        StatusCode: http.StatusCreated,
-    }
+    response := makeHttpResponse(http.StatusCreated, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     blocklist := &BlockList{}
@@ -888,11 +902,8 @@
 
 // Server-side errors are propagated back to the caller.
 func (suite *TestPutBlockList) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     "102 Frotzed",
-        StatusCode: 102,
-        Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to put blocklist</Message></Error>"),
-    }
+    responseBody := "<Error><Code>Frotzed</Code><Message>failed to put blocklist</Message></Error>"
+    response := makeHttpResponse(102, responseBody)
     context := makeStorageContext(&TestTransport{Response: response})
     blocklist := &BlockList{}
     err := context.PutBlockList("container", "blobname", blocklist)
@@ -902,6 +913,18 @@
     c.Check(err, ErrorMatches, ".*failed to put blocklist.*")
 }
 
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestPutBlockList) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
+    context := makeStorageContext(&TestTransport{Response: response})
+    blocklist := &BlockList{}
+    err := context.PutBlockList("container", "blobname", blocklist)
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
+}
+
 type TestGetBlockList struct{}
 
 var _ = Suite(&TestGetBlockList{})
@@ -909,7 +932,7 @@
 // The GetBlockList Storage API call returns a GetBlockList struct on
 // success.
 func (suite *TestGetBlockList) Test(c *C) {
-    response_body := `
+    responseBody := `
         <?xml version="1.0" encoding="utf-8"?>
         <BlockList>
           <CommittedBlocks>
@@ -926,11 +949,7 @@
           </UncommittedBlocks>
         </BlockList>`
 
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusOK),
-        StatusCode: http.StatusOK,
-        Body:       makeResponseBody(response_body),
-    }
+    response := makeHttpResponse(http.StatusOK, responseBody)
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     results, err := context.GetBlockList("container", "myfilename")
@@ -952,15 +971,15 @@
     c.Assert(err, NotNil)
 }
 
-// Server-side errors are propagated back to the caller.
-func (suite *TestGetBlockList) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusNotFound),
-        StatusCode: http.StatusNotFound,
-    }
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestGetBlockList) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
     context := makeStorageContext(&TestTransport{Response: response})
-    _, err := context.GetBlockList("container", "myfilename")
-    c.Assert(err, NotNil)
+    _, err := context.GetBlockList("container", "blobname")
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
 }
 
 type TestDeleteBlob struct{}
@@ -968,10 +987,7 @@
 var _ = Suite(&TestDeleteBlob{})
 
 func (suite *TestDeleteBlob) Test(c *C) {
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusAccepted),
-        StatusCode: http.StatusAccepted,
-    }
+    response := makeHttpResponse(http.StatusAccepted, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     err := context.DeleteBlob("container", "blobname")
@@ -991,13 +1007,21 @@
     c.Assert(err, NotNil)
 }
 
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestDeleteBlob) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
+    context := makeStorageContext(&TestTransport{Response: response})
+    err := context.DeleteBlob("container", "blobname")
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
+}
+
 // Server-side errors are propagated back to the caller.
 func (suite *TestDeleteBlob) TestErrorResponse(c *C) {
-    response := &http.Response{
-        Status:     "146 Frotzed",
-        StatusCode: 146,
-        Body:       makeResponseBody("<Error><Code>Frotzed</Code><Message>failed to delete blob</Message></Error>"),
-    }
+    responseBody := "<Error><Code>Frotzed</Code><Message>failed to delete blob</Message></Error>"
+    response := makeHttpResponse(146, responseBody)
     context := makeStorageContext(&TestTransport{Response: response})
     err := context.DeleteBlob("container", "blobname")
     c.Assert(err, NotNil)
@@ -1011,12 +1035,8 @@
 var _ = Suite(&TestGetBlob{})
 
 func (suite *TestGetBlob) Test(c *C) {
-    response_body := "blob-in-a-can"
-    response := &http.Response{
-        Status:     fmt.Sprintf("%d", http.StatusOK),
-        StatusCode: http.StatusOK,
-        Body:       makeResponseBody(response_body),
-    }
+    responseBody := "blob-in-a-can"
+    response := makeHttpResponse(http.StatusOK, responseBody)
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     reader, err := context.GetBlob("container", "blobname")
@@ -1030,7 +1050,7 @@
 
     data, err := ioutil.ReadAll(reader)
     c.Assert(err, IsNil)
-    c.Check(string(data), Equals, response_body)
+    c.Check(string(data), Equals, responseBody)
 }
 
 // Client-side errors from the HTTP client are propagated back to the caller.
@@ -1042,6 +1062,20 @@
     c.Assert(err, NotNil)
 }
 
+// Azure HTTP errors (for instance 404 responses) are propagated back to
+// the caller as ServerError objects.
+func (suite *TestGetBlob) TestServerError(c *C) {
+    response := makeHttpResponse(http.StatusNotFound, "not found")
+    context := makeStorageContext(&TestTransport{Response: response})
+    reader, err := context.GetBlob("container", "blobname")
+    c.Check(reader, IsNil)
+    c.Assert(err, NotNil)
+    serverError, ok := err.(*ServerError)
+    c.Check(ok, Equals, true)
+    c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)
+    c.Check(IsNotFoundError(err), Equals, true)
+}
+
 // Server-side errors are propagated back to the caller.
 func (suite *TestGetBlob) TestErrorResponse(c *C) {
     response := &http.Response{