Merge lp:~allenap/gwacl/camel-lint into lp:gwacl

[Gavin Panella]

Camel-case all variables.

I wasn't feeling too sharp, so I did this as a warm-up exercise :)

[Gavin Panella (allenap)]

Self-approving to get the pill down quickly. It hardly conflicts with current WIP too.

review: Approve

=== modified file 'helpers_apiobjects_test.go'
--- helpers_apiobjects_test.go	2013-04-30 05:13:33 +0000
+++ helpers_apiobjects_test.go	2013-06-27 13:34:32 +0000
@@ -46,14 +46,14 @@
     hostname := MakeRandomString(10)
     username := MakeRandomString(10)
     password := MakeRandomString(10)
-    disable_ssh := MakeRandomBool()
+    disableSSH := MakeRandomBool()
 
     return &LinuxProvisioningConfiguration{
         ConfigurationSetType: "LinuxProvisioningConfiguration",
         Hostname:             hostname,
         Username:             username,
         Password:             password,
-        DisableSSHPasswordAuthentication: disable_ssh}
+        DisableSSHPasswordAuthentication: disableSSH}
 }
 
 func makeOSVirtualHardDisk() *OSVirtualHardDisk {

=== modified file 'helpers_factory_test.go'
--- helpers_factory_test.go	2013-04-30 05:13:33 +0000
+++ helpers_factory_test.go	2013-06-27 13:34:32 +0000
@@ -27,8 +27,8 @@
     dest := make([]byte, length)
     for i := range dest {
         num := rand.Intn(len(chars))
-        rand_char := chars[num]
-        dest[i] = rand_char
+        randChar := chars[num]
+        dest[i] = randChar
     }
     return dest
 }

=== modified file 'storage_base.go'
--- storage_base.go	2013-06-26 13:42:49 +0000
+++ storage_base.go	2013-06-27 13:34:32 +0000
@@ -27,7 +27,7 @@
     "time"
 )
 
-var headers_to_sign = []string{
+var headersToSign = []string{
     "Content-Encoding",
     "Content-Language",
     "Content-Length",
@@ -42,32 +42,32 @@
 }
 
 // Calculate the value required for an Authorization header.
-func composeAuthHeader(req *http.Request, account_name, account_key string) string {
-    signable := composeStringToSign(req, account_name)
+func composeAuthHeader(req *http.Request, accountName, accountKey string) string {
+    signable := composeStringToSign(req, accountName)
     // Allegedly, this is already UTF8 encoded.
-    decoded_key, err := base64.StdEncoding.DecodeString(account_key)
+    decodedKey, err := base64.StdEncoding.DecodeString(accountKey)
     if err != nil {
         panic(fmt.Errorf("invalid account key: %s", err))
     }
-    hash := hmac.New(sha256.New, decoded_key)
+    hash := hmac.New(sha256.New, decodedKey)
     _, err = hash.Write([]byte(signable))
     if err != nil {
         panic(fmt.Errorf("failed to write hash: %s", err))
     }
     var hashed []byte
     hashed = hash.Sum(hashed)
-    b64_hashed := base64.StdEncoding.EncodeToString(hashed)
-    return fmt.Sprintf("SharedKey %s:%s", account_name, b64_hashed)
+    b64Hashed := base64.StdEncoding.EncodeToString(hashed)
+    return fmt.Sprintf("SharedKey %s:%s", accountName, b64Hashed)
 }
 
 // Calculate the string that needs to be HMAC signed.  It is comprised of
-// the headers in headers_to_sign, x-ms-* headers and the URI params.
-func composeStringToSign(req *http.Request, account_name string) string {
+// the headers in headersToSign, x-ms-* headers and the URI params.
+func composeStringToSign(req *http.Request, accountName string) string {
     // TODO: whitespace should be normalised in value strings.
     return fmt.Sprintf(
         "%s\n%s%s%s", req.Method, composeHeaders(req),
         composeCanonicalizedHeaders(req),
-        composeCanonicalizedResource(req, account_name))
+        composeCanonicalizedResource(req, accountName))
 }
 
 // toLowerKeys lower cases all map keys. If two keys exist, that differ
@@ -103,8 +103,8 @@
 // Calculate the headers required in the string to sign.
 func composeHeaders(req *http.Request) string {
     var result []string
-    for _, header_name := range headers_to_sign {
-        result = append(result, req.Header.Get(header_name)+"\n")
+    for _, headerName := range headersToSign {
+        result = append(result, req.Header.Get(headerName)+"\n")
     }
     return strings.Join(result, "")
 }
@@ -112,10 +112,10 @@
 // Calculate the x-ms-* headers, encode as for encodeParams.
 func composeCanonicalizedHeaders(req *http.Request) string {
     var results []string
-    for header_name, values := range req.Header {
-        header_name = strings.ToLower(header_name)
-        if strings.HasPrefix(header_name, "x-ms-") {
-            results = append(results, fmt.Sprintf("%v:%s\n", header_name, strings.Join(values, ",")))
+    for headerName, values := range req.Header {
+        headerName = strings.ToLower(headerName)
+        if strings.HasPrefix(headerName, "x-ms-") {
+            results = append(results, fmt.Sprintf("%v:%s\n", headerName, strings.Join(values, ",")))
         }
     }
     sort.Strings(results)
@@ -125,27 +125,27 @@
 // Calculate the URI params and encode them in the string.
 // See http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx
 // for details of this encoding.
-func composeCanonicalizedResource(req *http.Request, account_name string) string {
+func composeCanonicalizedResource(req *http.Request, accountName string) string {
     path := req.URL.Path
     if !strings.HasPrefix(path, "/") {
         path = "/" + path
     }
 
     values := req.URL.Query()
-    values_lower := toLowerKeys(values)
-    param_string := encodeParams(values_lower)
+    valuesLower := toLowerKeys(values)
+    paramString := encodeParams(valuesLower)
 
-    result := "/" + account_name + path
-    if param_string != "" {
-        result += "\n" + param_string
+    result := "/" + accountName + path
+    if paramString != "" {
+        result += "\n" + paramString
     }
 
     return result
 }
 
-// Take the passed ms_version string and add it to the request headers.
-func addVersionHeader(req *http.Request, ms_version string) {
-    req.Header.Set("x-ms-version", ms_version)
+// Take the passed msVersion string and add it to the request headers.
+func addVersionHeader(req *http.Request, msVersion string) {
+    req.Header.Set("x-ms-version", msVersion)
 }
 
 // Calculate the mD5sum and content length for the request payload and add
@@ -191,8 +191,8 @@
 }
 
 // StorageContext keeps track of the mandatory parameters required to send a
-// request to the storage services API.  It also has an http Client so that
-// the client is only created once for all requests.
+// request to the storage services API.  It also has an HTTP Client to allow
+// overriding for custom behaviour, during testing for example.
 type StorageContext struct {
     Account string
     // Access key: access will be anonymous if the key is the empty string.
@@ -200,8 +200,9 @@
     client *http.Client
 }
 
-// getClient is used when sending a request.  If called with an existing client
-// it will replace the once in the context structure which is useful for tests.
+// getClient is used when sending a request. If a custom client is specified
+// in context.client it is returned, otherwise net.http.DefaultClient is
+// returned.
 func (context *StorageContext) getClient() *http.Client {
     if context.client == nil {
         return http.DefaultClient
@@ -272,12 +273,12 @@
 // The "res" parameter is typically an XML struct that will deserialize the
 // raw XML into the struct data.  The http Response object is returned.
 //
-// If the response's HTTP status code is not the same as "expected_status"
+// If the response's HTTP status code is not the same as "expectedStatus"
 // then an HTTPError will be returned as the error.  When the returned error
 // is an HTTPError, the request response is also returned.  In other error
 // cases, the returned response may be the one received from the server or
 // it may be nil.
-func (context *StorageContext) send(req *http.Request, res Deserializer, expected_status HTTPStatus) (*http.Response, error) {
+func (context *StorageContext) send(req *http.Request, res Deserializer, expectedStatus HTTPStatus) (*http.Response, error) {
     client := context.getClient()
     resp, err := client.Do(req)
     if err != nil {
@@ -286,7 +287,7 @@
 
     var data []byte
 
-    if resp.StatusCode != int(expected_status) {
+    if resp.StatusCode != int(expectedStatus) {
         if resp.Body != nil {
             data, err = ioutil.ReadAll(resp.Body)
             if err != nil {
@@ -445,7 +446,7 @@
     case "block":
         blobType = "BlockBlob"
     default:
-        panic("block_type must be 'page' or 'block'")
+        panic("blockType must be 'page' or 'block'")
     }
 
     extraHeaders := http.Header{}
@@ -536,11 +537,11 @@
 // Send a request to create a new block.  The request payload contains the
 // data block to upload.
 func (context *StorageContext) PutBlock(container, filename, id string, data io.Reader) error {
-    base64_id := base64.StdEncoding.EncodeToString([]byte(id))
+    base64ID := base64.StdEncoding.EncodeToString([]byte(id))
     uri := addURLQueryParams(
         context.GetFileURL(container, filename),
         "comp", "block",
-        "blockid", base64_id)
+        "blockid", base64ID)
     _, err := context.performRequest(requestParams{
         Method:         "PUT",
         URL:            uri,
@@ -564,12 +565,12 @@
     if err != nil {
         return err
     }
-    data_reader := bytes.NewReader(data)
+    dataReader := bytes.NewReader(data)
 
     _, err = context.performRequest(requestParams{
         Method:         "PUT",
         URL:            uri,
-        Body:           data_reader,
+        Body:           dataReader,
         APIVersion:     "2012-02-12",
         ExpectedStatus: http.StatusCreated,
     })

=== modified file 'storage_base_test.go'
--- storage_base_test.go	2013-06-25 00:51:32 +0000
+++ storage_base_test.go	2013-06-27 13:34:32 +0000
@@ -43,9 +43,9 @@
     c.Assert(err, IsNil)
 
     var items []string
-    for i, header_name := range headers_to_sign {
+    for i, headerName := range headersToSign {
         v := fmt.Sprintf("%d", i)
-        req.Header.Set(header_name, v)
+        req.Header.Set(headerName, v)
         items = append(items, v+"\n")
     }
     expected := strings.Join(items, "")
@@ -75,9 +75,9 @@
     c.Assert(err, IsNil)
     path := MakeRandomString(10)
     req.URL.Path = path
-    account_name := MakeRandomString(10)
-    observed := composeCanonicalizedResource(req, account_name)
-    expected := "/" + account_name + "/" + path
+    accountName := MakeRandomString(10)
+    observed := composeCanonicalizedResource(req, accountName)
+    expected := "/" + accountName + "/" + path
     c.Assert(observed, Equals, expected)
 }
 
@@ -86,9 +86,9 @@
     req, err := http.NewRequest("GET", fmt.Sprintf("http://example.com/%s", path), nil)
     c.Assert(err, IsNil)
 
-    account_name := MakeRandomString(10)
-    observed := composeCanonicalizedResource(req, account_name)
-    expected := "/" + account_name + "/" + path
+    accountName := MakeRandomString(10)
+    observed := composeCanonicalizedResource(req, accountName)
+    expected := "/" + accountName + "/" + path
     c.Assert(observed, Equals, expected)
 }
 
@@ -97,9 +97,9 @@
         "GET", "http://example.com/?Kevin=Perry&foo=bar", nil)
     c.Assert(err, IsNil)
 
-    account_name := MakeRandomString(10)
-    observed := composeCanonicalizedResource(req, account_name)
-    expected := "/" + account_name + "/\n" + "foo:bar" + "\n" + "kevin:Perry"
+    accountName := MakeRandomString(10)
+    observed := composeCanonicalizedResource(req, accountName)
+    expected := "/" + accountName + "/\n" + "foo:bar" + "\n" + "kevin:Perry"
     c.Assert(observed, Equals, expected)
 }
 
@@ -152,8 +152,8 @@
     req, err := http.NewRequest(
         "GET", "http://example.com/mypath?Kevin=Perry&foo=bar", nil)
     c.Assert(err, IsNil)
-    for i, header_name := range headers_to_sign {
-        req.Header.Set(header_name, fmt.Sprintf("%v", i))
+    for i, headerName := range headersToSign {
+        req.Header.Set(headerName, fmt.Sprintf("%v", i))
     }
     req.Header.Set("x-ms-testing", "foo")
     expected := "GET\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\nx-ms-testing:foo\n/myaccount/mypath\nfoo:bar\nkevin:Perry"
@@ -235,16 +235,16 @@
     req, err := http.NewRequest("GET", "http://example.com/", nil)
     c.Assert(err, IsNil)
     addContentHeaders(req)
-    _, length_present := req.Header[http.CanonicalHeaderKey("Content-Length")]
-    c.Assert(length_present, Equals, false)
+    _, lengthPresent := req.Header[http.CanonicalHeaderKey("Content-Length")]
+    c.Assert(lengthPresent, Equals, false)
 }
 
 func (suite *TestRequestHeaders) TestContentHeaderWithNoBody(c *C) {
     req, err := http.NewRequest("PUT", "http://example.com/", nil)
     c.Assert(err, IsNil)
     addContentHeaders(req)
-    _, md5_present := req.Header[http.CanonicalHeaderKey("Content-MD5")]
-    c.Check(md5_present, Equals, false)
+    _, md5Present := req.Header[http.CanonicalHeaderKey("Content-MD5")]
+    c.Check(md5Present, Equals, false)
     content := req.Header.Get("Content-Length")
     c.Check(content, Equals, "0")
 }
@@ -255,9 +255,9 @@
     c.Assert(req.Header.Get("Date"), Equals, "")
     addDateHeader(req)
     observed := req.Header.Get("Date")
-    observed_time, err := time.Parse(time.RFC1123, observed)
+    observedTime, err := time.Parse(time.RFC1123, observed)
     c.Assert(err, IsNil)
-    difference := time.Now().UTC().Sub(observed_time)
+    difference := time.Now().UTC().Sub(observedTime)
     if difference.Minutes() > 1.0 {
         c.FailNow()
     }
@@ -606,12 +606,12 @@
     response := makeHttpResponse(http.StatusCreated, "")
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
-    container_name := MakeRandomString(10)
-    err := context.CreateContainer(container_name)
+    containerName := MakeRandomString(10)
+    err := context.CreateContainer(containerName)
     c.Assert(err, IsNil)
     c.Check(transport.Request.URL.String(), Equals, fmt.Sprintf(
         "http://%s.blob.core.windows.net/%s?restype=container",
-        context.Account, container_name))
+        context.Account, containerName))
     c.Check(transport.Request.Header.Get("Authorization"), Not(Equals), "")
 }
 
@@ -787,7 +787,7 @@
 func (suite *TestPutBlob) TestBlobType(c *C) {
     defer func() {
         err := recover()
-        c.Assert(err, Equals, "block_type must be 'page' or 'block'")
+        c.Assert(err, Equals, "blockType must be 'page' or 'block'")
     }()
     context := makeStorageContext(&TestTransport{})
     context.PutBlob(&PutBlobRequest{
@@ -839,31 +839,31 @@
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
     blockid := "\x1b\xea\xf7Mv\xb5\xddH\xebm"
-    random_data := MakeRandomByteSlice(10)
-    data_reader := bytes.NewReader(random_data)
-    err := context.PutBlock("container", "blobname", blockid, data_reader)
+    randomData := MakeRandomByteSlice(10)
+    dataReader := bytes.NewReader(randomData)
+    err := context.PutBlock("container", "blobname", blockid, dataReader)
     c.Assert(err, IsNil)
 
     // The blockid should have been base64 encoded and url escaped.
-    base64_id := base64.StdEncoding.EncodeToString([]byte(blockid))
+    base64ID := base64.StdEncoding.EncodeToString([]byte(blockid))
     c.Check(transport.Request.URL.String(), Matches, context.GetFileURL("container", "blobname")+"?.*")
     c.Check(transport.Request.URL.Query(), DeepEquals, url.Values{
         "comp":    {"block"},
-        "blockid": {base64_id},
+        "blockid": {base64ID},
     })
     c.Check(transport.Request.Header.Get("Authorization"), Not(Equals), "")
 
     data, err := ioutil.ReadAll(transport.Request.Body)
     c.Assert(err, IsNil)
-    c.Check(data, DeepEquals, random_data)
+    c.Check(data, DeepEquals, randomData)
 }
 
 // Client-side errors from the HTTP client are propagated back to the caller.
 func (suite *TestPutBlock) TestError(c *C) {
     error := fmt.Errorf("canned-error")
     context := makeStorageContext(&TestTransport{Error: error})
-    data_reader := bytes.NewReader(MakeRandomByteSlice(10))
-    err := context.PutBlock("container", "blobname", "blockid", data_reader)
+    dataReader := bytes.NewReader(MakeRandomByteSlice(10))
+    err := context.PutBlock("container", "blobname", "blockid", dataReader)
     c.Assert(err, NotNil)
 }
 
@@ -872,8 +872,8 @@
     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)
+    dataReader := bytes.NewReader(MakeRandomByteSlice(10))
+    err := context.PutBlock("container", "blobname", "blockid", dataReader)
     c.Assert(err, NotNil)
     c.Check(err, ErrorMatches, ".*102.*")
     c.Check(err, ErrorMatches, ".*Frotzed.*")
@@ -885,8 +885,8 @@
 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)
+    dataReader := bytes.NewReader(MakeRandomByteSlice(10))
+    err := context.PutBlock("container", "blobname", "blockid", dataReader)
     serverError, ok := err.(*ServerError)
     c.Check(ok, Equals, true)
     c.Check(serverError.HTTPStatus.StatusCode(), Equals, http.StatusNotFound)

=== modified file 'storage_test.go'
--- storage_test.go	2013-06-26 13:15:58 +0000
+++ storage_test.go	2013-06-27 13:34:32 +0000
@@ -105,7 +105,7 @@
 // The ListAllBlobs Storage API call returns a BlobEnumerationResults struct
 // on success.
 func (suite *testListAllBlobs) 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>
@@ -152,7 +152,7 @@
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
-        Body:       makeResponseBody(response_body),
+        Body:       makeResponseBody(responseBody),
     }
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
@@ -240,7 +240,7 @@
 // The ListAllContainers Storage API call returns a ContainerEnumerationResults
 // struct on success.
 func (suite *testListAllContainers) 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>
@@ -267,7 +267,7 @@
     response := &http.Response{
         Status:     fmt.Sprintf("%d", http.StatusOK),
         StatusCode: http.StatusOK,
-        Body:       makeResponseBody(response_body),
+        Body:       makeResponseBody(responseBody),
     }
     transport := &TestTransport{Response: response}
     context := makeStorageContext(transport)
@@ -373,10 +373,10 @@
     c.Check(
         transport.Exchanges[0].Request.Header.Get("x-ms-blob-type"),
         Equals, "PageBlob")
-    expected_size := fmt.Sprintf("%d", VHD_SIZE)
+    expectedSize := fmt.Sprintf("%d", VHD_SIZE)
     c.Check(
         transport.Exchanges[0].Request.Header.Get("x-ms-blob-content-length"),
-        Equals, expected_size)
+        Equals, expectedSize)
 
     // Check the PutPage for the footer exchange.
     data, err := ioutil.ReadAll(transport.Exchanges[1].Request.Body)
@@ -384,10 +384,10 @@
     expectedData, err := base64.StdEncoding.DecodeString(VHD_FOOTER)
     c.Assert(err, IsNil)
     c.Check(data, DeepEquals, expectedData)
-    expected_range := fmt.Sprintf("bytes=%d-%d", VHD_SIZE-512, VHD_SIZE-1)
+    expectedRange := fmt.Sprintf("bytes=%d-%d", VHD_SIZE-512, VHD_SIZE-1)
     c.Check(
         transport.Exchanges[1].Request.Header.Get("x-ms-range"),
-        Equals, expected_range)
+        Equals, expectedRange)
 
     // Check the PutPage for the data exchange.
     data, err = ioutil.ReadAll(transport.Exchanges[2].Request.Body)

=== modified file 'x509session.go'
--- x509session.go	2013-04-30 05:36:03 +0000
+++ x509session.go	2013-06-27 13:34:32 +0000
@@ -30,16 +30,16 @@
     if strings.HasPrefix(path, "/") {
         panic(fmt.Errorf("got absolute API path '%s' instead of relative one", path))
     }
-    azure_url, err := url.Parse(AZURE_URL)
+    azureURL, err := url.Parse(AZURE_URL)
     if err != nil {
         panic(err)
     }
     escapedID := url.QueryEscape(session.subscriptionId)
-    path_url, err := url.Parse(escapedID + "/" + path)
+    pathURL, err := url.Parse(escapedID + "/" + path)
     if err != nil {
         panic(err)
     }
-    return azure_url.ResolveReference(path_url).String()
+    return azureURL.ResolveReference(pathURL).String()
 }
 
 // _X509Dispatcher is the function used to dispatch requests.  We call the

=== modified file 'xmlobjects.go'
--- xmlobjects.go	2013-06-26 09:05:55 +0000
+++ xmlobjects.go	2013-06-27 13:34:32 +0000
@@ -651,8 +651,8 @@
 
 // Add a BlockListItem to a BlockList.
 func (s *BlockList) Add(blockType BlockListType, blockID string) {
-    base64_id := base64.StdEncoding.EncodeToString([]byte(blockID))
-    item := NewBlockListItem(blockType, base64_id)
+    base64ID := base64.StdEncoding.EncodeToString([]byte(blockID))
+    item := NewBlockListItem(blockType, base64ID)
     s.Items = append(s.Items, item)
 }
 

=== modified file 'xmlobjects_test.go'
--- xmlobjects_test.go	2013-06-26 10:44:48 +0000
+++ xmlobjects_test.go	2013-06-27 13:34:32 +0000
@@ -498,7 +498,7 @@
 
 func (suite *xmlSuite) TestCreateStorageServiceInput(c *C) {
     s := makeCreateStorageServiceInput()
-    ext_property := s.ExtendedProperties[0]
+    extProperty := s.ExtendedProperties[0]
     xml, err := s.Serialize()
     c.Assert(err, IsNil)
     template := dedent.Dedent(`
@@ -517,8 +517,8 @@
           </ExtendedProperties>
         </CreateStorageServiceInput>`)
     expected := fmt.Sprintf(template, s.ServiceName, s.Label, s.Description,
-        s.Location, s.AffinityGroup, s.GeoReplicationEnabled, ext_property.Name,
-        ext_property.Value)
+        s.Location, s.AffinityGroup, s.GeoReplicationEnabled, extProperty.Name,
+        extProperty.Value)
     c.Assert(xml, Equals, expected)
 }
 
@@ -527,7 +527,7 @@
 //
 
 func (suite *xmlSuite) TestStorageServicesUnmarshal(c *C) {
-    input_template := `
+    inputTemplate := `
         <?xml version="1.0" encoding="utf-8"?>
         <StorageServices xmlns="http://schemas.microsoft.com/windowsazure">
           <StorageService>
@@ -568,24 +568,24 @@
     affinity := MakeRandomString(10)
     label := MakeRandomString(10)
     status := MakeRandomString(10)
-    blob_endpoint := MakeRandomString(10)
-    queue_endpoint := MakeRandomString(10)
-    table_endpoint := MakeRandomString(10)
-    geo_repl := BoolToString(MakeRandomBool())
-    geo_region := MakeRandomString(10)
-    status_primary := MakeRandomString(10)
-    failover_time := MakeRandomString(10)
-    geo_sec_region := MakeRandomString(10)
-    status_sec := MakeRandomString(10)
-    p1_name := MakeRandomString(10)
-    p1_val := MakeRandomString(10)
-    p2_name := MakeRandomString(10)
-    p2_val := MakeRandomString(10)
+    blobEndpoint := MakeRandomString(10)
+    queueEndpoint := MakeRandomString(10)
+    tableEndpoint := MakeRandomString(10)
+    geoRepl := BoolToString(MakeRandomBool())
+    geoRegion := MakeRandomString(10)
+    statusPrimary := MakeRandomString(10)
+    failoverTime := MakeRandomString(10)
+    geoSecRegion := MakeRandomString(10)
+    statusSec := MakeRandomString(10)
+    p1Name := MakeRandomString(10)
+    p1Val := MakeRandomString(10)
+    p2Name := MakeRandomString(10)
+    p2Val := MakeRandomString(10)
 
-    input := fmt.Sprintf(input_template, url, servicename, desc, affinity,
-        label, status, blob_endpoint, queue_endpoint, table_endpoint, geo_repl,
-        geo_region, status_primary, failover_time, geo_sec_region, status_sec,
-        p1_name, p1_val, p2_name, p2_val)
+    input := fmt.Sprintf(inputTemplate, url, servicename, desc, affinity,
+        label, status, blobEndpoint, queueEndpoint, tableEndpoint, geoRepl,
+        geoRegion, statusPrimary, failoverTime, geoSecRegion, statusSec,
+        p1Name, p1Val, p2Name, p2Val)
     data := []byte(input)
 
     services := &StorageServices{}
@@ -602,24 +602,24 @@
     c.Check(s.AffinityGroup, Equals, affinity)
     c.Check(s.Label, Equals, label)
     c.Check(s.Status, Equals, status)
-    c.Check(s.GeoReplicationEnabled, Equals, geo_repl)
-    c.Check(s.GeoPrimaryRegion, Equals, geo_region)
-    c.Check(s.StatusOfPrimary, Equals, status_primary)
-    c.Check(s.LastGeoFailoverTime, Equals, failover_time)
-    c.Check(s.GeoSecondaryRegion, Equals, geo_sec_region)
-    c.Check(s.StatusOfSecondary, Equals, status_sec)
+    c.Check(s.GeoReplicationEnabled, Equals, geoRepl)
+    c.Check(s.GeoPrimaryRegion, Equals, geoRegion)
+    c.Check(s.StatusOfPrimary, Equals, statusPrimary)
+    c.Check(s.LastGeoFailoverTime, Equals, failoverTime)
+    c.Check(s.GeoSecondaryRegion, Equals, geoSecRegion)
+    c.Check(s.StatusOfSecondary, Equals, statusSec)
 
     endpoints := s.Endpoints
     c.Check(len(endpoints), Equals, 3)
-    c.Check(endpoints[0], Equals, blob_endpoint)
-    c.Check(endpoints[1], Equals, queue_endpoint)
-    c.Check(endpoints[2], Equals, table_endpoint)
+    c.Check(endpoints[0], Equals, blobEndpoint)
+    c.Check(endpoints[1], Equals, queueEndpoint)
+    c.Check(endpoints[2], Equals, tableEndpoint)
 
     properties := s.ExtendedProperties
-    c.Check(properties[0].Name, Equals, p1_name)
-    c.Check(properties[0].Value, Equals, p1_val)
-    c.Check(properties[1].Name, Equals, p2_name)
-    c.Check(properties[1].Value, Equals, p2_val)
+    c.Check(properties[0].Name, Equals, p1Name)
+    c.Check(properties[0].Value, Equals, p1Val)
+    c.Check(properties[1].Name, Equals, p2Name)
+    c.Check(properties[1].Value, Equals, p2Val)
 }
 
 func (suite *xmlSuite) TestBlobEnumerationResuts(c *C) {
@@ -999,13 +999,13 @@
 }
 
 func (suite *xmlSuite) TestBlockListSerialize(c *C) {
-    block_list := &BlockList{
+    blockList := &BlockList{
         XMLName: xml.Name{Local: "BlockList"},
     }
-    block_list.Add(BlockListCommitted, "first-base64-encoded-block-id")
-    block_list.Add(BlockListUncommitted, "second-base64-encoded-block-id")
-    block_list.Add(BlockListLatest, "third-base64-encoded-block-id")
-    observed, err := block_list.Serialize()
+    blockList.Add(BlockListCommitted, "first-base64-encoded-block-id")
+    blockList.Add(BlockListUncommitted, "second-base64-encoded-block-id")
+    blockList.Add(BlockListLatest, "third-base64-encoded-block-id")
+    observed, err := blockList.Serialize()
     c.Assert(err, IsNil)
     expected := dedent.Dedent(`
         <BlockList>