func TestSendMessageBatchChecksumInvalid(t *testing.T) { req, _ := svc.SendMessageBatchRequest(&sqs.SendMessageBatchInput{ Entries: []*sqs.SendMessageBatchRequestEntry{ {Id: aws.String("1"), MessageBody: aws.String("test")}, {Id: aws.String("2"), MessageBody: aws.String("test")}, {Id: aws.String("3"), MessageBody: aws.String("test")}, {Id: aws.String("4"), MessageBody: aws.String("test")}, }, }) req.Handlers.Send.PushBack(func(r *request.Request) { md5 := "098f6bcd4621d373cade4e832627b4f6" body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageBatchOutput{ Successful: []*sqs.SendMessageBatchResultEntry{ {MD5OfMessageBody: &md5, MessageId: aws.String("123"), Id: aws.String("1")}, {MD5OfMessageBody: aws.String("000"), MessageId: aws.String("456"), Id: aws.String("2")}, {MD5OfMessageBody: aws.String("000"), MessageId: aws.String("789"), Id: aws.String("3")}, {MD5OfMessageBody: &md5, MessageId: aws.String("012"), Id: aws.String("4")}, }, } }) err := req.Send() assert.Error(t, err) assert.Equal(t, "InvalidChecksum", err.(awserr.Error).Code()) assert.Contains(t, err.(awserr.Error).Message(), "invalid messages: 456, 789") }
func TestValidateCRC32DoesNotMatch(t *testing.T) { req := mockCRCResponse(db, 200, "{}", "1234") assert.Error(t, req.Error) assert.Equal(t, "CRC32CheckFailed", req.Error.(awserr.Error).Code()) assert.Equal(t, 2, req.RetryCount) }
func TestBuildJSON(t *testing.T) { for _, test := range jsonTests { out, err := jsonutil.BuildJSON(test.in) if test.err != "" { assert.Error(t, err) assert.Contains(t, err.Error(), test.err) } else { assert.NoError(t, err) assert.Equal(t, string(out), test.out) } } }
func TestSendMessageChecksumNoInput(t *testing.T) { req, _ := svc.SendMessageRequest(&sqs.SendMessageInput{}) req.Handlers.Send.PushBack(func(r *request.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageOutput{} }) err := req.Send() assert.Error(t, err) assert.Equal(t, "InvalidChecksum", err.(awserr.Error).Code()) assert.Contains(t, err.(awserr.Error).Message(), "cannot compute checksum. missing body") }
func TestValidateEndpointHandlerErrorRegion(t *testing.T) { os.Clearenv() svc := awstesting.NewClient() svc.Handlers.Clear() svc.Handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler) req := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) err := req.Build() assert.Error(t, err) assert.Equal(t, aws.ErrMissingRegion, err) }
func TestCopySourceSSECustomerKeyOverHTTPError(t *testing.T) { s := s3.New(unit.Session, &aws.Config{DisableSSL: aws.Bool(true)}) req, _ := s.CopyObjectRequest(&s3.CopyObjectInput{ Bucket: aws.String("bucket"), CopySource: aws.String("bucket/source"), Key: aws.String("dest"), CopySourceSSECustomerKey: aws.String("key"), }) 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") }
func TestSendHandlerError(t *testing.T) { svc := awstesting.NewClient(&aws.Config{ HTTPClient: &http.Client{ Transport: &testSendHandlerTransport{}, }, }) svc.Handlers.Clear() svc.Handlers.Send.PushBackNamed(corehandlers.SendHandler) r := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) r.Send() assert.Error(t, r.Error) assert.NotNil(t, r.HTTPResponse) }
func TestFlattenedTraits(t *testing.T) { s := sqs.New(session.New()) _, err := s.DeleteMessageBatch(&sqs.DeleteMessageBatchInput{ QueueURL: aws.String("QUEUE"), Entries: []*sqs.DeleteMessageBatchRequestEntry{ { ID: aws.String("TEST"), ReceiptHandle: aws.String("RECEIPT"), }, }, }) assert.Error(t, err) assert.Equal(t, "InvalidAddress", err.Code()) assert.Equal(t, "The address QUEUE is not valid for this endpoint.", err.Message()) }
func TestUploadOrderSingleFailure(t *testing.T) { s, ops, _ := loggingSvc(emptyList) s.Handlers.Send.PushBack(func(r *request.Request) { r.HTTPResponse.StatusCode = 400 }) mgr := s3manager.NewUploaderWithClient(s) resp, err := mgr.Upload(&s3manager.UploadInput{ Bucket: aws.String("Bucket"), Key: aws.String("Key"), Body: bytes.NewReader(buf2MB), }) assert.Error(t, err) assert.Equal(t, []string{"PutObject"}, *ops) assert.Nil(t, resp) }
func TestSendMessageChecksumInvalid(t *testing.T) { req, _ := svc.SendMessageRequest(&sqs.SendMessageInput{ MessageBody: aws.String("test"), }) req.Handlers.Send.PushBack(func(r *request.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageOutput{ MD5OfMessageBody: aws.String("000"), MessageId: aws.String("12345"), } }) err := req.Send() assert.Error(t, err) assert.Equal(t, "InvalidChecksum", err.(awserr.Error).Code()) assert.Contains(t, err.(awserr.Error).Message(), "expected MD5 checksum '000', got '098f6bcd4621d373cade4e832627b4f6'") }
func TestUploadOrderMultiFailureOnCreate(t *testing.T) { s, ops, _ := loggingSvc(emptyList) s.Handlers.Send.PushBack(func(r *request.Request) { switch r.Data.(type) { case *s3.CreateMultipartUploadOutput: r.HTTPResponse.StatusCode = 400 } }) mgr := s3manager.NewUploaderWithClient(s) _, err := mgr.Upload(&s3manager.UploadInput{ Bucket: aws.String("Bucket"), Key: aws.String("Key"), Body: bytes.NewReader(make([]byte, 1024*1024*12)), }) assert.Error(t, err) assert.Equal(t, []string{"CreateMultipartUpload"}, *ops) }
func TestUploadOrderMultiBufferedReaderExceedTotalParts(t *testing.T) { s, ops, _ := loggingSvc([]string{"UploadPart"}) mgr := s3manager.NewUploaderWithClient(s, func(u *s3manager.Uploader) { u.Concurrency = 1 u.MaxUploadParts = 2 }) resp, err := mgr.Upload(&s3manager.UploadInput{ Bucket: aws.String("Bucket"), Key: aws.String("Key"), Body: &sizedReader{size: 1024 * 1024 * 12}, }) assert.Error(t, err) assert.Nil(t, resp) assert.Equal(t, []string{"CreateMultipartUpload", "AbortMultipartUpload"}, *ops) aerr := err.(awserr.Error) assert.Equal(t, "TotalPartsExceeded", aerr.Code()) assert.Contains(t, aerr.Message(), "configured MaxUploadParts (2)") }
func TestEC2RoleProviderFailAssume(t *testing.T) { server := initTestServer("2014-12-16T01:51:37Z", true) defer server.Close() p := &ec2rolecreds.EC2RoleProvider{ Client: ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}), } creds, err := p.Retrieve() assert.Error(t, err, "Expect error") e := err.(awserr.Error) assert.Equal(t, "ErrorCode", e.Code()) assert.Equal(t, "ErrorMsg", e.Message()) assert.Nil(t, e.OrigErr()) assert.Equal(t, "", creds.AccessKeyID, "Expect access key ID to match") assert.Equal(t, "", creds.SecretAccessKey, "Expect secret access key to match") assert.Equal(t, "", creds.SessionToken, "Expect session token to match") }
func TestRecieveMessageChecksumInvalid(t *testing.T) { req, _ := svc.ReceiveMessageRequest(&sqs.ReceiveMessageInput{}) req.Handlers.Send.PushBack(func(r *request.Request) { md5 := "098f6bcd4621d373cade4e832627b4f6" body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.ReceiveMessageOutput{ Messages: []*sqs.Message{ {Body: aws.String("test"), MD5OfBody: &md5}, {Body: aws.String("test"), MD5OfBody: aws.String("000"), MessageId: aws.String("123")}, {Body: aws.String("test"), MD5OfBody: aws.String("000"), MessageId: aws.String("456")}, {Body: aws.String("test"), MD5OfBody: &md5}, }, } }) err := req.Send() assert.Error(t, err) assert.Equal(t, "InvalidChecksum", err.(awserr.Error).Code()) assert.Contains(t, err.(awserr.Error).Message(), "invalid messages: 123, 456") }
func TestStatusCodeError(t *testing.T) { for _, test := range s3StatusCodeErrorTests { s := s3.New(unit.Session) s.Handlers.Send.Clear() s.Handlers.Send.PushBack(func(r *request.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(test.body))) r.HTTPResponse = &http.Response{ ContentLength: int64(len(test.body)), StatusCode: test.scode, Status: test.status, Body: body, } }) _, err := s.PutBucketAcl(&s3.PutBucketAclInput{ Bucket: aws.String("bucket"), ACL: aws.String("public-read"), }) assert.Error(t, err) assert.Equal(t, test.code, err.(awserr.Error).Code()) assert.Equal(t, test.message, err.(awserr.Error).Message()) } }
func TestUploadOrderMultiFailureOnComplete(t *testing.T) { s, ops, _ := loggingSvc(emptyList) s.Handlers.Send.PushBack(func(r *request.Request) { switch r.Data.(type) { case *s3.CompleteMultipartUploadOutput: r.HTTPResponse.StatusCode = 400 } }) mgr := s3manager.NewUploaderWithClient(s, func(u *s3manager.Uploader) { u.Concurrency = 1 }) _, err := mgr.Upload(&s3manager.UploadInput{ Bucket: aws.String("Bucket"), Key: aws.String("Key"), Body: bytes.NewReader(buf12MB), }) assert.Error(t, err) assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart", "UploadPart", "CompleteMultipartUpload", "AbortMultipartUpload"}, *ops) }
func TestUploadOrderMultiFailureLeaveParts(t *testing.T) { s, ops, _ := loggingSvc(emptyList) s.Handlers.Send.PushBack(func(r *request.Request) { switch data := r.Data.(type) { case *s3.UploadPartOutput: if *data.ETag == "ETAG2" { r.HTTPResponse.StatusCode = 400 } } }) mgr := s3manager.NewUploaderWithClient(s, func(u *s3manager.Uploader) { u.Concurrency = 1 u.LeavePartsOnError = true }) _, err := mgr.Upload(&s3manager.UploadInput{ Bucket: aws.String("Bucket"), Key: aws.String("Key"), Body: bytes.NewReader(make([]byte, 1024*1024*12)), }) assert.Error(t, err) assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart"}, *ops) }
func TestValidateCRC32AlreadyErrorSkip(t *testing.T) { req := mockCRCResponse(db, 400, "{}", "1234") assert.Error(t, req.Error) assert.NotEqual(t, "CRC32CheckFailed", req.Error.(awserr.Error).Code()) }
// Error asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if assert.Error(t, err, "An error was expected") { // assert.Equal(t, err, expectedError) // } // // Returns whether the assertion was successful (true) or not (false). func Error(t TestingT, err error, msgAndArgs ...interface{}) { if !assert.Error(t, err, msgAndArgs...) { t.FailNow() } }
func TestWaiterFailure(t *testing.T) { svc := &mockClient{Client: awstesting.NewClient(&aws.Config{ Region: aws.String("mock-region"), })} svc.Handlers.Send.Clear() // mock sending svc.Handlers.Unmarshal.Clear() svc.Handlers.UnmarshalMeta.Clear() svc.Handlers.ValidateResponse.Clear() reqNum := 0 resps := []*MockOutput{ { // Request 1 States: []*MockState{ {State: aws.String("pending")}, {State: aws.String("pending")}, }, }, { // Request 2 States: []*MockState{ {State: aws.String("running")}, {State: aws.String("pending")}, }, }, { // Request 3 States: []*MockState{ {State: aws.String("running")}, {State: aws.String("stopping")}, }, }, } numBuiltReq := 0 svc.Handlers.Build.PushBack(func(r *request.Request) { numBuiltReq++ }) svc.Handlers.Unmarshal.PushBack(func(r *request.Request) { if reqNum >= len(resps) { assert.Fail(t, "too many polling requests made") return } r.Data = resps[reqNum] reqNum++ }) waiterCfg := waiter.Config{ Operation: "Mock", Delay: 0, MaxAttempts: 10, Acceptors: []waiter.WaitAcceptor{ { State: "success", Matcher: "pathAll", Argument: "States[].State", Expected: "running", }, { State: "failure", Matcher: "pathAny", Argument: "States[].State", Expected: "stopping", }, }, } w := waiter.Waiter{ Client: svc, Input: &MockInput{}, Config: waiterCfg, } err := w.Wait().(awserr.Error) assert.Error(t, err) assert.Equal(t, "ResourceNotReady", err.Code()) assert.Equal(t, "failed waiting for successful resource state", err.Message()) assert.Equal(t, 3, numBuiltReq) assert.Equal(t, 3, reqNum) }