vendor: update all dependencies to latest versions

vendor/github.com/aws/aws-sdk-go/service/s3/bucket_location_test.go

@@ -11,7 +11,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/awstesting/unit"
 	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
 )
 
 var s3LocationTests = []struct {
@@ -32,7 +31,10 @@ func TestGetBucketLocation(t *testing.T) {
 		})
 
 		resp, err := s.GetBucketLocation(&s3.GetBucketLocationInput{Bucket: aws.String("bucket")})
-		assert.NoError(t, err)
+		if err != nil {
+			t.Errorf("expected no error, but received %v", err)
+		}
+
 		if test.loc == "" {
 			if v := resp.LocationConstraint; v != nil {
 				t.Errorf("expect location constraint to be nil, got %s", *v)

vendor/github.com/aws/aws-sdk-go/service/s3/customizations_test.go

@@ -13,17 +13,22 @@ import (
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/awstesting/unit"
 	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
 )
 
 func assertMD5(t *testing.T, req *request.Request) {
 	err := req.Build()
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
 	b, _ := ioutil.ReadAll(req.HTTPRequest.Body)
 	out := md5.Sum(b)
-	assert.NotEmpty(t, b)
-	assert.Equal(t, base64.StdEncoding.EncodeToString(out[:]), req.HTTPRequest.Header.Get("Content-MD5"))
+	if len(b) == 0 {
+		t.Error("expected non-empty value")
+	}
+	if e, a := base64.StdEncoding.EncodeToString(out[:]), req.HTTPRequest.Header.Get("Content-MD5"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }
 
 func TestMD5InPutBucketCors(t *testing.T) {
@@ -115,7 +120,9 @@ const (
 
 func TestPutObjectMetadataWithUnicode(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		assert.Equal(t, utf8Value, r.Header.Get(metaKeyPrefix+utf8KeySuffix))
+		if e, a := utf8Value, r.Header.Get(metaKeyPrefix+utf8KeySuffix); e != a {
+			t.Errorf("expected %s, but received %s", e, a)
+		}
 	}))
 	svc := s3.New(unit.Session, &aws.Config{
 		Endpoint:   aws.String(server.URL),
@@ -133,7 +140,9 @@ func TestPutObjectMetadataWithUnicode(t *testing.T) {
 		}(),
 	})
 
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 }
 
 func TestGetObjectMetadataWithUnicode(t *testing.T) {
@@ -150,9 +159,13 @@ func TestGetObjectMetadataWithUnicode(t *testing.T) {
 		Key:    aws.String("my_key"),
 	})
 
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	resp.Body.Close()
 
-	assert.Equal(t, utf8Value, *resp.Metadata[utf8KeySuffix])
+	if e, a := utf8Value, *resp.Metadata[utf8KeySuffix]; e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 
 }

vendor/github.com/aws/aws-sdk-go/service/s3/doc.go

@@ -10,7 +10,7 @@
 //
 // Using the Client
 //
-// To Amazon Simple Storage Service with the SDK use the New function to create
+// To contact Amazon Simple Storage Service with the SDK use the New function to create
 // a new service client. With that client you can make API requests to the service.
 // These clients are safe to use concurrently.
 //

vendor/github.com/aws/aws-sdk-go/service/s3/doc_custom.go

@@ -35,7 +35,7 @@
 //
 // The s3manager package's Downloader provides concurrently downloading of Objects
 // from S3. The Downloader will write S3 Object content with an io.WriterAt.
-// Once the Downloader instance is created you can call Upload concurrently from
+// Once the Downloader instance is created you can call Download concurrently from
 // multiple goroutines safely.
 //
 //   // The session the S3 Downloader will use
@@ -56,7 +56,7 @@
 //       Key:    aws.String(myString),
 //   })
 //   if err != nil {
-//       return fmt.Errorf("failed to upload file, %v", err)
+//       return fmt.Errorf("failed to download file, %v", err)
 //   }
 //   fmt.Printf("file downloaded, %d bytes\n", n)
 //

vendor/github.com/aws/aws-sdk-go/service/s3/examples_test.go

@@ -2198,7 +2198,7 @@ func ExampleS3_UploadPartCopy_shared01() {
 	svc := s3.New(session.New())
 	input := &s3.UploadPartCopyInput{
 		Bucket:     aws.String("examplebucket"),
-		CopySource: aws.String("bucketname/sourceobjectkey"),
+		CopySource: aws.String("/bucketname/sourceobjectkey"),
 		Key:        aws.String("examplelargeobject"),
 		PartNumber: aws.Int64(1),
 		UploadId:   aws.String("exampleuoh_10OhKhT7YukE9bjzTPRiuaCotmZM_pFngJFir9OZNrSr5cWa3cq3LZSUsfjI4FI7PkP91We7Nrw--"),

vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/awstesting/unit"
 	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestAdd100Continue_Added(t *testing.T) {
@@ -22,8 +21,12 @@ func TestAdd100Continue_Added(t *testing.T) {
 
 	err := r.Sign()
 
-	assert.NoError(t, err)
-	assert.Equal(t, "100-Continue", r.HTTPRequest.Header.Get("Expect"))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if e, a := "100-Continue", r.HTTPRequest.Header.Get("Expect"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }
 
 func TestAdd100Continue_SkipDisabled(t *testing.T) {
@@ -36,8 +39,12 @@ func TestAdd100Continue_SkipDisabled(t *testing.T) {
 
 	err := r.Sign()
 
-	assert.NoError(t, err)
-	assert.Empty(t, r.HTTPRequest.Header.Get("Expect"))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if r.HTTPRequest.Header.Get("Expect") != "" {
+		t.Errorf("expected empty value, but received %s", r.HTTPRequest.Header.Get("Expect"))
+	}
 }
 
 func TestAdd100Continue_SkipNonPUT(t *testing.T) {
@@ -49,8 +56,12 @@ func TestAdd100Continue_SkipNonPUT(t *testing.T) {
 
 	err := r.Sign()
 
-	assert.NoError(t, err)
-	assert.Empty(t, r.HTTPRequest.Header.Get("Expect"))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if r.HTTPRequest.Header.Get("Expect") != "" {
+		t.Errorf("expected empty value, but received %s", r.HTTPRequest.Header.Get("Expect"))
+	}
 }
 
 func TestAdd100Continue_SkipTooSmall(t *testing.T) {
@@ -63,6 +74,10 @@ func TestAdd100Continue_SkipTooSmall(t *testing.T) {
 
 	err := r.Sign()
 
-	assert.NoError(t, err)
-	assert.Empty(t, r.HTTPRequest.Header.Get("Expect"))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if r.HTTPRequest.Header.Get("Expect") != "" {
+		t.Errorf("expected empty value, but received %s", r.HTTPRequest.Header.Get("Expect"))
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/aes_gcm_content_cipher_test.go

@@ -3,21 +3,26 @@ package s3crypto_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/service/s3/s3crypto"
 )
 
 func TestAESGCMContentCipherBuilder(t *testing.T) {
 	generator := mockGenerator{}
-	builder := s3crypto.AESGCMContentCipherBuilder(generator)
-	assert.NotNil(t, builder)
+	if builder := s3crypto.AESGCMContentCipherBuilder(generator); builder == nil {
+		t.Error("expected non-nil value")
+	}
 }
 
 func TestAESGCMContentCipherNewEncryptor(t *testing.T) {
 	generator := mockGenerator{}
 	builder := s3crypto.AESGCMContentCipherBuilder(generator)
 	cipher, err := builder.ContentCipher()
-	assert.NoError(t, err)
-	assert.NotNil(t, cipher)
+
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
+	if cipher == nil {
+		t.Errorf("expected non-nil vaue")
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/aes_gcm_test.go

@@ -5,8 +5,6 @@ import (
 	"encoding/hex"
 	"io/ioutil"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 // AES GCM
@@ -52,22 +50,32 @@ func aesgcmTest(t *testing.T, iv, key, plaintext, expected, tag []byte) {
 		IV:  iv,
 	}
 	gcm, err := newAESGCM(cd)
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
 	cipherdata := gcm.Encrypt(bytes.NewReader(plaintext))
 
 	ciphertext, err := ioutil.ReadAll(cipherdata)
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
 	// splitting tag and ciphertext
 	etag := ciphertext[len(ciphertext)-16:]
-	assert.Equal(t, etag, tag)
-	assert.Equal(t, len(ciphertext), len(expected))
-	assert.Equal(t, ciphertext, expected)
+	if !bytes.Equal(etag, tag) {
+		t.Errorf("expected tags to be equivalent")
+	}
+	if !bytes.Equal(ciphertext, expected) {
+		t.Errorf("expected ciphertext to be equivalent")
+	}
 
 	data := gcm.Decrypt(bytes.NewReader(ciphertext))
-	assert.NoError(t, err)
 	text, err := ioutil.ReadAll(data)
-	assert.NoError(t, err)
-	assert.Equal(t, len(text), len(plaintext))
-	assert.Equal(t, text, plaintext)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if !bytes.Equal(plaintext, text) {
+		t.Errorf("expected ciphertext to be equivalent")
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/cipher_test.go

@@ -5,8 +5,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/service/s3/s3crypto"
 )
 
@@ -16,8 +14,12 @@ func TestCryptoReadCloserRead(t *testing.T) {
 	rc := &s3crypto.CryptoReadCloser{Body: ioutil.NopCloser(str), Decrypter: str}
 
 	b, err := ioutil.ReadAll(rc)
-	assert.NoError(t, err)
-	assert.Equal(t, expectedStr, string(b))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if expectedStr != string(b) {
+		t.Errorf("expected %s, but received %s", expectedStr, string(b))
+	}
 }
 
 func TestCryptoReadCloserClose(t *testing.T) {
@@ -29,6 +31,10 @@ func TestCryptoReadCloserClose(t *testing.T) {
 	rc.Close()
 
 	b, err := ioutil.ReadAll(rc)
-	assert.NoError(t, err)
-	assert.Equal(t, expectedStr, string(b))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if expectedStr != string(b) {
+		t.Errorf("expected %s, but received %s", expectedStr, string(b))
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/cipher_util_test.go

@@ -8,8 +8,6 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/awstesting/unit"
 	"github.com/aws/aws-sdk-go/service/kms"
@@ -31,10 +29,17 @@ func TestWrapFactory(t *testing.T) {
 		MatDesc: `{"kms_cmk_id":""}`,
 	}
 	wrap, err := c.wrapFromEnvelope(env)
-	_, ok := wrap.(*kmsKeyHandler)
-	assert.NoError(t, err)
-	assert.NotNil(t, wrap)
-	assert.True(t, ok)
+	w, ok := wrap.(*kmsKeyHandler)
+
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if wrap == nil {
+		t.Error("expected non-nil value")
+	}
+	if !ok {
+		t.Errorf("expected kmsKeyHandler, but received %v", *w)
+	}
 }
 func TestWrapFactoryErrorNoWrap(t *testing.T) {
 	c := DecryptionClient{
@@ -52,8 +57,13 @@ func TestWrapFactoryErrorNoWrap(t *testing.T) {
 		MatDesc: `{"kms_cmk_id":""}`,
 	}
 	wrap, err := c.wrapFromEnvelope(env)
-	assert.Error(t, err)
-	assert.Nil(t, wrap)
+
+	if err == nil {
+		t.Error("expected error, but received none")
+	}
+	if wrap != nil {
+		t.Errorf("expected nil wrap value, received %v", wrap)
+	}
 }
 
 func TestWrapFactoryCustomEntry(t *testing.T) {
@@ -72,8 +82,13 @@ func TestWrapFactoryCustomEntry(t *testing.T) {
 		MatDesc: `{"kms_cmk_id":""}`,
 	}
 	wrap, err := c.wrapFromEnvelope(env)
-	assert.NoError(t, err)
-	assert.NotNil(t, wrap)
+
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if wrap == nil {
+		t.Errorf("expected nil wrap value, received %v", wrap)
+	}
 }
 
 func TestCEKFactory(t *testing.T) {
@@ -106,11 +121,15 @@ func TestCEKFactory(t *testing.T) {
 		},
 	}
 	iv, err := hex.DecodeString("0d18e06c7c725ac9e362e1ce")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	ivB64 := base64.URLEncoding.EncodeToString(iv)
 
 	cipherKey, err := hex.DecodeString("31bdadd96698c204aa9ce1448ea94ae1fb4a9a0b3c9d773b51bb1822666b8f22")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	cipherKeyB64 := base64.URLEncoding.EncodeToString(cipherKey)
 
 	env := Envelope{
@@ -122,8 +141,13 @@ func TestCEKFactory(t *testing.T) {
 	}
 	wrap, err := c.wrapFromEnvelope(env)
 	cek, err := c.cekFromEnvelope(env, wrap)
-	assert.NoError(t, err)
-	assert.NotNil(t, cek)
+
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if cek == nil {
+		t.Errorf("expected non-nil cek")
+	}
 }
 
 func TestCEKFactoryNoCEK(t *testing.T) {
@@ -156,11 +180,15 @@ func TestCEKFactoryNoCEK(t *testing.T) {
 		},
 	}
 	iv, err := hex.DecodeString("0d18e06c7c725ac9e362e1ce")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	ivB64 := base64.URLEncoding.EncodeToString(iv)
 
 	cipherKey, err := hex.DecodeString("31bdadd96698c204aa9ce1448ea94ae1fb4a9a0b3c9d773b51bb1822666b8f22")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	cipherKeyB64 := base64.URLEncoding.EncodeToString(cipherKey)
 
 	env := Envelope{
@@ -172,8 +200,13 @@ func TestCEKFactoryNoCEK(t *testing.T) {
 	}
 	wrap, err := c.wrapFromEnvelope(env)
 	cek, err := c.cekFromEnvelope(env, wrap)
-	assert.Error(t, err)
-	assert.Nil(t, cek)
+
+	if err == nil {
+		t.Error("expected error, but received none")
+	}
+	if cek != nil {
+		t.Errorf("expected nil cek value, received %v", wrap)
+	}
 }
 
 func TestCEKFactoryCustomEntry(t *testing.T) {
@@ -204,11 +237,15 @@ func TestCEKFactoryCustomEntry(t *testing.T) {
 		PadderRegistry: map[string]Padder{},
 	}
 	iv, err := hex.DecodeString("0d18e06c7c725ac9e362e1ce")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	ivB64 := base64.URLEncoding.EncodeToString(iv)
 
 	cipherKey, err := hex.DecodeString("31bdadd96698c204aa9ce1448ea94ae1fb4a9a0b3c9d773b51bb1822666b8f22")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	cipherKeyB64 := base64.URLEncoding.EncodeToString(cipherKey)
 
 	env := Envelope{
@@ -220,6 +257,11 @@ func TestCEKFactoryCustomEntry(t *testing.T) {
 	}
 	wrap, err := c.wrapFromEnvelope(env)
 	cek, err := c.cekFromEnvelope(env, wrap)
-	assert.NoError(t, err)
-	assert.NotNil(t, cek)
+
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if cek == nil {
+		t.Errorf("expected non-nil cek")
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/decryption_client_test.go

@@ -11,8 +11,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
@@ -40,7 +38,9 @@ func TestGetObjectGCM(t *testing.T) {
 	})
 
 	c := s3crypto.NewDecryptionClient(sess)
-	assert.NotNil(t, c)
+	if c == nil {
+		t.Error("expected non-nil value")
+	}
 	input := &s3.GetObjectInput{
 		Key:    aws.String("test"),
 		Bucket: aws.String("test"),
@@ -49,9 +49,14 @@ func TestGetObjectGCM(t *testing.T) {
 	req.Handlers.Send.Clear()
 	req.Handlers.Send.PushBack(func(r *request.Request) {
 		iv, err := hex.DecodeString("0d18e06c7c725ac9e362e1ce")
-		assert.NoError(t, err)
+		if err != nil {
+			t.Errorf("expected no error, but received %v", err)
+		}
+
 		b, err := hex.DecodeString("fa4362189661d163fcd6a56d8bf0405ad636ac1bbedd5cc3ee727dc2ab4a9489")
-		assert.NoError(t, err)
+		if err != nil {
+			t.Errorf("expected no error, but received %v", err)
+		}
 
 		r.HTTPResponse = &http.Response{
 			StatusCode: 200,
@@ -69,14 +74,21 @@ func TestGetObjectGCM(t *testing.T) {
 		out.Metadata["x-amz-wrap-alg"] = aws.String(s3crypto.KMSWrap)
 	})
 	err := req.Send()
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	b, err := ioutil.ReadAll(out.Body)
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	expected, err := hex.DecodeString("2db5168e932556f8089a0622981d017d")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
-	assert.Equal(t, len(expected), len(b))
-	assert.Equal(t, expected, b)
+	if !bytes.Equal(expected, b) {
+		t.Error("expected bytes to be equivalent")
+	}
 }
 
 func TestGetObjectCBC(t *testing.T) {
@@ -97,7 +109,9 @@ func TestGetObjectCBC(t *testing.T) {
 	})
 
 	c := s3crypto.NewDecryptionClient(sess)
-	assert.NotNil(t, c)
+	if c == nil {
+		t.Error("expected non-nil value")
+	}
 	input := &s3.GetObjectInput{
 		Key:    aws.String("test"),
 		Bucket: aws.String("test"),
@@ -106,9 +120,13 @@ func TestGetObjectCBC(t *testing.T) {
 	req.Handlers.Send.Clear()
 	req.Handlers.Send.PushBack(func(r *request.Request) {
 		iv, err := hex.DecodeString("9dea7621945988f96491083849b068df")
-		assert.NoError(t, err)
+		if err != nil {
+			t.Errorf("expected no error, but received %v", err)
+		}
 		b, err := hex.DecodeString("e232cd6ef50047801ee681ec30f61d53cfd6b0bca02fd03c1b234baa10ea82ac9dab8b960926433a19ce6dea08677e34")
-		assert.NoError(t, err)
+		if err != nil {
+			t.Errorf("expected no error, but received %v", err)
+		}
 
 		r.HTTPResponse = &http.Response{
 			StatusCode: 200,
@@ -125,14 +143,21 @@ func TestGetObjectCBC(t *testing.T) {
 		out.Metadata["x-amz-wrap-alg"] = aws.String(s3crypto.KMSWrap)
 	})
 	err := req.Send()
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	b, err := ioutil.ReadAll(out.Body)
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	expected, err := hex.DecodeString("0397f4f6820b1f9386f14403be5ac16e50213bd473b4874b9bcbf5f318ee686b1d")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
-	assert.Equal(t, len(expected), len(b))
-	assert.Equal(t, expected, b)
+	if !bytes.Equal(expected, b) {
+		t.Error("expected bytes to be equivalent")
+	}
 }
 
 func TestGetObjectCBC2(t *testing.T) {
@@ -153,7 +178,9 @@ func TestGetObjectCBC2(t *testing.T) {
 	})
 
 	c := s3crypto.NewDecryptionClient(sess)
-	assert.NotNil(t, c)
+	if c == nil {
+		t.Error("expected non-nil value")
+	}
 	input := &s3.GetObjectInput{
 		Key:    aws.String("test"),
 		Bucket: aws.String("test"),
@@ -162,7 +189,9 @@ func TestGetObjectCBC2(t *testing.T) {
 	req.Handlers.Send.Clear()
 	req.Handlers.Send.PushBack(func(r *request.Request) {
 		b, err := hex.DecodeString("fd0c71ecb7ed16a9bf42ea5f75501d416df608f190890c3b4d8897f24744cd7f9ea4a0b212e60634302450e1c5378f047ff753ccefe365d411c36339bf22e301fae4c3a6226719a4b93dc74c1af79d0296659b5d56c0892315f2c7cc30190220db1eaafae3920d6d9c65d0aa366499afc17af493454e141c6e0fbdeb6a990cb4")
-		assert.NoError(t, err)
+		if err != nil {
+			t.Errorf("expected no error, but received %v", err)
+		}
 
 		r.HTTPResponse = &http.Response{
 			StatusCode: 200,
@@ -180,14 +209,21 @@ func TestGetObjectCBC2(t *testing.T) {
 		out.Metadata["x-amz-wrap-alg"] = aws.String(s3crypto.KMSWrap)
 	})
 	err := req.Send()
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	b, err := ioutil.ReadAll(out.Body)
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 	expected, err := hex.DecodeString("a6ccd3482f5ce25c9ddeb69437cd0acbc0bdda2ef8696d90781de2b35704543529871b2032e68ef1c5baed1769aba8d420d1aca181341b49b8b3587a6580cdf1d809c68f06735f7735c16691f4b70c967d68fc08195b81ad71bcc4df452fd0a5799c1e1234f92f1cd929fc072167ccf9f2ac85b93170932b32")
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
-	assert.Equal(t, len(expected), len(b))
-	assert.Equal(t, expected, b)
+	if !bytes.Equal(expected, b) {
+		t.Error("expected bytes to be equivalent")
+	}
 }
 
 func TestGetObjectWithContext(t *testing.T) {

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/encryption_client.go

@@ -64,7 +64,7 @@ func NewEncryptionClient(prov client.ConfigProvider, builder ContentCipherBuilde
 //	req, out := svc.PutObjectRequest(&s3.PutObjectInput {
 //	  Key: aws.String("testKey"),
 //	  Bucket: aws.String("testBucket"),
-//	  Body: bytes.NewBuffer("test data"),
+//	  Body: strings.NewReader("test data"),
 //	})
 //	err := req.Send()
 func (c *EncryptionClient) PutObjectRequest(input *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) {

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/encryption_client_test.go

@@ -9,8 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
@@ -32,9 +30,15 @@ func TestDefaultConfigValues(t *testing.T) {
 
 	c := s3crypto.NewEncryptionClient(sess, s3crypto.AESGCMContentCipherBuilder(handler))
 
-	assert.NotNil(t, c)
-	assert.NotNil(t, c.ContentCipherBuilder)
-	assert.NotNil(t, c.SaveStrategy)
+	if c == nil {
+		t.Error("expected non-vil client value")
+	}
+	if c.ContentCipherBuilder == nil {
+		t.Error("expected non-vil content cipher builder value")
+	}
+	if c.SaveStrategy == nil {
+		t.Error("expected non-vil save strategy value")
+	}
 }
 
 func TestPutObject(t *testing.T) {
@@ -49,7 +53,9 @@ func TestPutObject(t *testing.T) {
 		Region:           aws.String("us-west-2"),
 	})
 	c := s3crypto.NewEncryptionClient(sess, cb)
-	assert.NotNil(t, c)
+	if c == nil {
+		t.Error("expected non-vil client value")
+	}
 	input := &s3.PutObjectInput{
 		Key:    aws.String("test"),
 		Bucket: aws.String("test"),
@@ -64,10 +70,16 @@ func TestPutObject(t *testing.T) {
 		}
 	})
 	err := req.Send()
-	assert.Equal(t, "stop", err.Error())
+	if e, a := "stop", err.Error(); e != a {
+		t.Errorf("expected %s error, but received %s", e, a)
+	}
 	b, err := ioutil.ReadAll(req.HTTPRequest.Body)
-	assert.NoError(t, err)
-	assert.Equal(t, expected, b)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if !bytes.Equal(expected, b) {
+		t.Error("expected bytes to be equivalent, but received otherwise")
+	}
 }
 
 func TestPutObjectWithContext(t *testing.T) {

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/hash_io_test.go

@@ -4,8 +4,6 @@ import (
 	"bytes"
 	"encoding/hex"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 // From Go stdlib encoding/sha256 test cases
@@ -13,7 +11,10 @@ func TestSHA256(t *testing.T) {
 	sha := newSHA256Writer(nil)
 	expected, _ := hex.DecodeString("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
 	b := sha.GetValue()
-	assert.Equal(t, expected, b)
+
+	if !bytes.Equal(expected, b) {
+		t.Errorf("expected equivalent sha values, but received otherwise")
+	}
 }
 
 func TestSHA256_Case2(t *testing.T) {
@@ -21,5 +22,8 @@ func TestSHA256_Case2(t *testing.T) {
 	sha.Write([]byte("hello"))
 	expected, _ := hex.DecodeString("2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824")
 	b := sha.GetValue()
-	assert.Equal(t, expected, b)
+
+	if !bytes.Equal(expected, b) {
+		t.Errorf("expected equivalent sha values, but received otherwise")
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/helper_test.go

@@ -1,9 +1,8 @@
 package s3crypto
 
 import (
+	"bytes"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestBytesReadWriteSeeker_Read(t *testing.T) {
@@ -12,9 +11,17 @@ func TestBytesReadWriteSeeker_Read(t *testing.T) {
 	buf := make([]byte, 3)
 	n, err := b.Read(buf)
 
-	assert.NoError(t, err)
-	assert.Equal(t, 3, n)
-	assert.Equal(t, expected, buf)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
+	if e, a := 3, n; e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
+
+	if !bytes.Equal(expected, buf) {
+		t.Error("expected equivalent byte slices, but received otherwise")
+	}
 }
 
 func TestBytesReadWriteSeeker_Write(t *testing.T) {
@@ -23,25 +30,53 @@ func TestBytesReadWriteSeeker_Write(t *testing.T) {
 	buf := make([]byte, 3)
 	n, err := b.Write([]byte{1, 2, 3})
 
-	assert.NoError(t, err)
-	assert.Equal(t, 3, n)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
+	if e, a := 3, n; e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
 
 	n, err = b.Read(buf)
-	assert.NoError(t, err)
-	assert.Equal(t, 3, n)
-	assert.Equal(t, expected, buf)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
+	if e, a := 3, n; e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
+
+	if !bytes.Equal(expected, buf) {
+		t.Error("expected equivalent byte slices, but received otherwise")
+	}
 }
 
 func TestBytesReadWriteSeeker_Seek(t *testing.T) {
 	b := &bytesReadWriteSeeker{[]byte{1, 2, 3}, 0}
 	expected := []byte{2, 3}
 	m, err := b.Seek(1, 0)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, int(m))
+
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
+	if e, a := 1, int(m); e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
+
 	buf := make([]byte, 3)
 	n, err := b.Read(buf)
 
-	assert.NoError(t, err)
-	assert.Equal(t, 2, n)
-	assert.Equal(t, expected, buf[:n])
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
+	if e, a := 2, n; e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
+
+	if !bytes.Equal(expected, buf[:n]) {
+		t.Error("expected equivalent byte slices, but received otherwise")
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/key_handler_test.go

@@ -2,15 +2,19 @@ package s3crypto
 
 import (
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestGenerateBytes(t *testing.T) {
 	b := generateBytes(5)
-	assert.Equal(t, 5, len(b))
+	if e, a := 5, len(b); e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
 	b = generateBytes(0)
-	assert.Equal(t, 0, len(b))
+	if e, a := 0, len(b); e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
 	b = generateBytes(1024)
-	assert.Equal(t, 1024, len(b))
+	if e, a := 1024, len(b); e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/kms_key_handler_test.go

@@ -1,15 +1,15 @@
 package s3crypto
 
 import (
+	"bytes"
 	"encoding/base64"
 	"encoding/hex"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/awstesting/unit"
 	"github.com/aws/aws-sdk-go/service/kms"
@@ -18,7 +18,9 @@ import (
 func TestBuildKMSEncryptHandler(t *testing.T) {
 	svc := kms.New(unit.Session)
 	handler := NewKMSKeyGenerator(svc, "testid")
-	assert.NotNil(t, handler)
+	if handler == nil {
+		t.Error("expected non-nil handler")
+	}
 }
 
 func TestBuildKMSEncryptHandlerWithMatDesc(t *testing.T) {
@@ -26,14 +28,19 @@ func TestBuildKMSEncryptHandlerWithMatDesc(t *testing.T) {
 	handler := NewKMSKeyGeneratorWithMatDesc(svc, "testid", MaterialDescription{
 		"Testing": aws.String("123"),
 	})
-	assert.NotNil(t, handler)
+	if handler == nil {
+		t.Error("expected non-nil handler")
+	}
 
 	kmsHandler := handler.(*kmsKeyHandler)
 	expected := MaterialDescription{
 		"kms_cmk_id": aws.String("testid"),
 		"Testing":    aws.String("123"),
 	}
-	assert.Equal(t, expected, kmsHandler.CipherData.MaterialDescription)
+
+	if !reflect.DeepEqual(expected, kmsHandler.CipherData.MaterialDescription) {
+		t.Errorf("expected %v, but received %v", expected, kmsHandler.CipherData.MaterialDescription)
+	}
 }
 
 func TestKMSGenerateCipherData(t *testing.T) {
@@ -56,11 +63,15 @@ func TestKMSGenerateCipherData(t *testing.T) {
 	ivSize := 16
 
 	cd, err := handler.GenerateCipherData(keySize, ivSize)
-	assert.NoError(t, err)
-	assert.Equal(t, keySize, len(cd.Key))
-	assert.Equal(t, ivSize, len(cd.IV))
-	assert.NotEmpty(t, cd.Key)
-	assert.NotEmpty(t, cd.IV)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if keySize != len(cd.Key) {
+		t.Errorf("expected %d, but received %d", keySize, len(cd.Key))
+	}
+	if ivSize != len(cd.IV) {
+		t.Errorf("expected %d, but received %d", ivSize, len(cd.IV))
+	}
 }
 
 func TestKMSDecrypt(t *testing.T) {
@@ -78,11 +89,18 @@ func TestKMSDecrypt(t *testing.T) {
 		Region:           aws.String("us-west-2"),
 	})
 	handler, err := (kmsKeyHandler{kms: kms.New(sess)}).decryptHandler(Envelope{MatDesc: `{"kms_cmk_id":"test"}`})
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
 	plaintextKey, err := handler.DecryptKey([]byte{1, 2, 3, 4})
-	assert.NoError(t, err)
-	assert.Equal(t, key, plaintextKey)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+
+	if !bytes.Equal(key, plaintextKey) {
+		t.Errorf("expected %v, but received %v", key, plaintextKey)
+	}
 }
 
 func TestKMSDecryptBadJSON(t *testing.T) {
@@ -101,5 +119,7 @@ func TestKMSDecryptBadJSON(t *testing.T) {
 	})
 
 	_, err := (kmsKeyHandler{kms: kms.New(sess)}).decryptHandler(Envelope{MatDesc: `{"kms_cmk_id":"test"`})
-	assert.Error(t, err)
+	if err == nil {
+		t.Errorf("expected error, but received none")
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/mat_desc_test.go

@@ -1,10 +1,9 @@
 package s3crypto
 
 import (
+	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/aws"
 )
 
@@ -13,8 +12,12 @@ func TestEncodeMaterialDescription(t *testing.T) {
 	md["foo"] = aws.String("bar")
 	b, err := md.encodeDescription()
 	expected := `{"foo":"bar"}`
-	assert.NoError(t, err)
-	assert.Equal(t, expected, string(b))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if expected != string(b) {
+		t.Errorf("expected %s, but received %s", expected, string(b))
+	}
 }
 func TestDecodeMaterialDescription(t *testing.T) {
 	md := MaterialDescription{}
@@ -23,6 +26,10 @@ func TestDecodeMaterialDescription(t *testing.T) {
 	expected := MaterialDescription{
 		"foo": aws.String("bar"),
 	}
-	assert.NoError(t, err)
-	assert.Equal(t, expected, md)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if !reflect.DeepEqual(expected, md) {
+		t.Error("expected material description to be equivalent, but received otherwise")
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3crypto/strategy_test.go

@@ -1,10 +1,9 @@
 package s3crypto_test
 
 import (
+	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/s3"
@@ -28,7 +27,9 @@ func TestHeaderV2SaveStrategy(t *testing.T) {
 	}
 	strat := s3crypto.HeaderV2SaveStrategy{}
 	err := strat.Save(env, req)
-	assert.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
 	expected := map[string]*string{
 		"X-Amz-Key-V2":                     aws.String("Foo"),
@@ -41,6 +42,7 @@ func TestHeaderV2SaveStrategy(t *testing.T) {
 		"X-Amz-Unencrypted-Content-Length": aws.String("0"),
 	}
 
-	assert.Equal(t, len(expected), len(params.Metadata))
-	assert.Equal(t, expected, params.Metadata)
+	if !reflect.DeepEqual(expected, params.Metadata) {
+		t.Errorf("expected %v, but received %v", expected, params.Metadata)
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/s3iface/interface.go

@@ -92,6 +92,10 @@ type S3API interface {
 	DeleteBucketCorsWithContext(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) (*s3.DeleteBucketCorsOutput, error)
 	DeleteBucketCorsRequest(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)
 
+	DeleteBucketEncryption(*s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error)
+	DeleteBucketEncryptionWithContext(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) (*s3.DeleteBucketEncryptionOutput, error)
+	DeleteBucketEncryptionRequest(*s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput)
+
 	DeleteBucketInventoryConfiguration(*s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error)
 	DeleteBucketInventoryConfigurationWithContext(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error)
 	DeleteBucketInventoryConfigurationRequest(*s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput)
@@ -148,6 +152,10 @@ type S3API interface {
 	GetBucketCorsWithContext(aws.Context, *s3.GetBucketCorsInput, ...request.Option) (*s3.GetBucketCorsOutput, error)
 	GetBucketCorsRequest(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)
 
+	GetBucketEncryption(*s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error)
+	GetBucketEncryptionWithContext(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) (*s3.GetBucketEncryptionOutput, error)
+	GetBucketEncryptionRequest(*s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput)
+
 	GetBucketInventoryConfiguration(*s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error)
 	GetBucketInventoryConfigurationWithContext(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error)
 	GetBucketInventoryConfigurationRequest(*s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput)
@@ -295,6 +303,10 @@ type S3API interface {
 	PutBucketCorsWithContext(aws.Context, *s3.PutBucketCorsInput, ...request.Option) (*s3.PutBucketCorsOutput, error)
 	PutBucketCorsRequest(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)
 
+	PutBucketEncryption(*s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error)
+	PutBucketEncryptionWithContext(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) (*s3.PutBucketEncryptionOutput, error)
+	PutBucketEncryptionRequest(*s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput)
+
 	PutBucketInventoryConfiguration(*s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error)
 	PutBucketInventoryConfigurationWithContext(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error)
 	PutBucketInventoryConfigurationRequest(*s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput)

vendor/github.com/aws/aws-sdk-go/service/s3/s3manager/batch.go

@@ -206,7 +206,7 @@ type BatchDelete struct {
 //		},
 //	}
 //
-//	if err := batcher.Delete(&s3manager.DeleteObjectsIterator{
+//	if err := batcher.Delete(aws.BackgroundContext(), &s3manager.DeleteObjectsIterator{
 //		Objects: objects,
 //	}); err != nil {
 //		return err
@@ -239,7 +239,7 @@ func NewBatchDeleteWithClient(client s3iface.S3API, options ...func(*BatchDelete
 //		},
 //	}
 //
-//	if err := batcher.Delete(&s3manager.DeleteObjectsIterator{
+//	if err := batcher.Delete(aws.BackgroundContext(), &s3manager.DeleteObjectsIterator{
 //		Objects: objects,
 //	}); err != nil {
 //		return err

vendor/github.com/aws/aws-sdk-go/service/s3/sse_test.go

@@ -1,13 +1,13 @@
 package s3_test
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/awstesting/unit"
 	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestSSECustomerKeyOverHTTPError(t *testing.T) {
@@ -20,9 +20,15 @@ func TestSSECustomerKeyOverHTTPError(t *testing.T) {
 	})
 	err := req.Build()
 
-	assert.Error(t, err)
-	assert.Equal(t, "ConfigError", err.(awserr.Error).Code())
-	assert.Contains(t, err.(awserr.Error).Message(), "cannot send SSE keys over HTTP")
+	if err == nil {
+		t.Error("expected an error")
+	}
+	if e, a := "ConfigError", err.(awserr.Error).Code(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if !strings.Contains(err.(awserr.Error).Message(), "cannot send SSE keys over HTTP") {
+		t.Errorf("expected error to contain 'cannot send SSE keys over HTTP', but received %s", err.(awserr.Error).Message())
+	}
 }
 
 func TestCopySourceSSECustomerKeyOverHTTPError(t *testing.T) {
@@ -35,9 +41,15 @@ func TestCopySourceSSECustomerKeyOverHTTPError(t *testing.T) {
 	})
 	err := req.Build()
 
-	assert.Error(t, err)
-	assert.Equal(t, "ConfigError", err.(awserr.Error).Code())
-	assert.Contains(t, err.(awserr.Error).Message(), "cannot send SSE keys over HTTP")
+	if err == nil {
+		t.Error("expected an error")
+	}
+	if e, a := "ConfigError", err.(awserr.Error).Code(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if !strings.Contains(err.(awserr.Error).Message(), "cannot send SSE keys over HTTP") {
+		t.Errorf("expected error to contain 'cannot send SSE keys over HTTP', but received %s", err.(awserr.Error).Message())
+	}
 }
 
 func TestComputeSSEKeys(t *testing.T) {
@@ -51,11 +63,21 @@ func TestComputeSSEKeys(t *testing.T) {
 	})
 	err := req.Build()
 
-	assert.NoError(t, err)
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key"))
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key"))
-	assert.Equal(t, "PG4LipwVIkqCKLmpjKFTHQ==", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key-md5"))
-	assert.Equal(t, "PG4LipwVIkqCKLmpjKFTHQ==", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key-md5"))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if e, a := "a2V5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "a2V5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "PG4LipwVIkqCKLmpjKFTHQ==", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key-md5"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "PG4LipwVIkqCKLmpjKFTHQ==", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key-md5"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }
 
 func TestComputeSSEKeysShortcircuit(t *testing.T) {
@@ -71,9 +93,19 @@ func TestComputeSSEKeysShortcircuit(t *testing.T) {
 	})
 	err := req.Build()
 
-	assert.NoError(t, err)
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key"))
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key"))
-	assert.Equal(t, "MD5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key-md5"))
-	assert.Equal(t, "MD5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key-md5"))
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if e, a := "a2V5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "a2V5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "MD5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key-md5"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "MD5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key-md5"); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }

vendor/github.com/aws/aws-sdk-go/service/s3/statusok_error_test.go

@@ -7,9 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/awstesting/unit"
@@ -31,10 +28,15 @@ func TestCopyObjectNoError(t *testing.T) {
 		Key:        aws.String("destination.txt"),
 	})
 
-	require.NoError(t, err)
-
-	assert.Equal(t, fmt.Sprintf(`%q`, "1da64c7f13d1e8dbeaea40b905fd586c"), *res.CopyObjectResult.ETag)
-	assert.Equal(t, lastModifiedTime, *res.CopyObjectResult.LastModified)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
+	if e, a := fmt.Sprintf(`%q`, "1da64c7f13d1e8dbeaea40b905fd586c"), *res.CopyObjectResult.ETag; e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := lastModifiedTime, *res.CopyObjectResult.LastModified; !e.Equal(a) {
+		t.Errorf("expected %v, but received %v", e, a)
+	}
 }
 
 func TestCopyObjectError(t *testing.T) {
@@ -44,11 +46,17 @@ func TestCopyObjectError(t *testing.T) {
 		Key:        aws.String("destination.txt"),
 	})
 
-	require.Error(t, err)
+	if err == nil {
+		t.Error("expected error, but received none")
+	}
 	e := err.(awserr.Error)
 
-	assert.Equal(t, "ErrorCode", e.Code())
-	assert.Equal(t, "message body", e.Message())
+	if e, a := "ErrorCode", e.Code(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "message body", e.Message(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }
 
 func TestUploadPartCopySuccess(t *testing.T) {
@@ -64,10 +72,16 @@ func TestUploadPartCopySuccess(t *testing.T) {
 		UploadId:   aws.String("uploadID"),
 	})
 
-	require.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
-	assert.Equal(t, fmt.Sprintf(`%q`, "1da64c7f13d1e8dbeaea40b905fd586c"), *res.CopyPartResult.ETag)
-	assert.Equal(t, lastModifiedTime, *res.CopyPartResult.LastModified)
+	if e, a := fmt.Sprintf(`%q`, "1da64c7f13d1e8dbeaea40b905fd586c"), *res.CopyPartResult.ETag; e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := lastModifiedTime, *res.CopyPartResult.LastModified; !e.Equal(a) {
+		t.Errorf("expected %v, but received %v", e, a)
+	}
 }
 
 func TestUploadPartCopyError(t *testing.T) {
@@ -79,11 +93,17 @@ func TestUploadPartCopyError(t *testing.T) {
 		UploadId:   aws.String("uploadID"),
 	})
 
-	require.Error(t, err)
+	if err == nil {
+		t.Error("expected an error")
+	}
 	e := err.(awserr.Error)
 
-	assert.Equal(t, "ErrorCode", e.Code())
-	assert.Equal(t, "message body", e.Message())
+	if e, a := "ErrorCode", e.Code(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "message body", e.Message(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }
 
 func TestCompleteMultipartUploadSuccess(t *testing.T) {
@@ -96,12 +116,22 @@ func TestCompleteMultipartUploadSuccess(t *testing.T) {
 		UploadId: aws.String("uploadID"),
 	})
 
-	require.NoError(t, err)
+	if err != nil {
+		t.Errorf("expected no error, but received %v", err)
+	}
 
-	assert.Equal(t, `"etagVal"`, *res.ETag)
-	assert.Equal(t, "bucketName", *res.Bucket)
-	assert.Equal(t, "keyName", *res.Key)
-	assert.Equal(t, "locationName", *res.Location)
+	if e, a := `"etagVal"`, *res.ETag; e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "bucketName", *res.Bucket; e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "keyName", *res.Key; e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "locationName", *res.Location; e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }
 
 func TestCompleteMultipartUploadError(t *testing.T) {
@@ -111,11 +141,17 @@ func TestCompleteMultipartUploadError(t *testing.T) {
 		UploadId: aws.String("uploadID"),
 	})
 
-	require.Error(t, err)
+	if err == nil {
+		t.Error("expected an error")
+	}
 	e := err.(awserr.Error)
 
-	assert.Equal(t, "ErrorCode", e.Code())
-	assert.Equal(t, "message body", e.Message())
+	if e, a := "ErrorCode", e.Code(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
+	if e, a := "message body", e.Message(); e != a {
+		t.Errorf("expected %s, but received %s", e, a)
+	}
 }
 
 func newCopyTestSvc(errMsg string) *s3.S3 {

vendor/github.com/aws/aws-sdk-go/service/s3/unmarshal_error_leak_test.go

@@ -1,7 +1,6 @@
 package s3
 
 import (
-	"github.com/stretchr/testify/assert"
 	"net/http"
 	"testing"
 
@@ -27,7 +26,15 @@ func TestUnmarhsalErrorLeak(t *testing.T) {
 	reader := req.HTTPResponse.Body.(*awstesting.ReadCloser)
 	unmarshalError(req)
 
-	assert.NotNil(t, req.Error)
-	assert.Equal(t, reader.Closed, true)
-	assert.Equal(t, reader.Size, 0)
+	if req.Error == nil {
+		t.Error("expected an error, but received none")
+	}
+
+	if !reader.Closed {
+		t.Error("expected reader to be closed")
+	}
+
+	if e, a := 0, reader.Size; e != a {
+		t.Errorf("expected %d, but received %d", e, a)
+	}
 }