github.com/aavshr/aws-sdk-go@v1.41.3/service/simpledb/unmarshall_error_test.go (about)

     1  package simpledb_test
     2  
     3  import (
     4  	"bytes"
     5  	"io/ioutil"
     6  	"net/http"
     7  	"testing"
     8  
     9  	"github.com/aavshr/aws-sdk-go/aws"
    10  	"github.com/aavshr/aws-sdk-go/aws/awserr"
    11  	"github.com/aavshr/aws-sdk-go/aws/request"
    12  	"github.com/aavshr/aws-sdk-go/awstesting/unit"
    13  	"github.com/aavshr/aws-sdk-go/service/simpledb"
    14  )
    15  
    16  var statusCodeErrorTests = []struct {
    17  	scode   int
    18  	status  string
    19  	code    string
    20  	message string
    21  }{
    22  	{301, "Moved Permanently", "MovedPermanently", "Moved Permanently"},
    23  	{403, "Forbidden", "Forbidden", "Forbidden"},
    24  	{400, "Bad Request", "BadRequest", "Bad Request"},
    25  	{404, "Not Found", "NotFound", "Not Found"},
    26  	{500, "Internal Error", "InternalError", "Internal Error"},
    27  }
    28  
    29  func TestStatusCodeError(t *testing.T) {
    30  	for _, test := range statusCodeErrorTests {
    31  		s := simpledb.New(unit.Session)
    32  		s.Handlers.Send.Clear()
    33  		s.Handlers.Send.PushBack(func(r *request.Request) {
    34  			body := ioutil.NopCloser(bytes.NewReader([]byte{}))
    35  			r.HTTPResponse = &http.Response{
    36  				ContentLength: 0,
    37  				StatusCode:    test.scode,
    38  				Status:        test.status,
    39  				Body:          body,
    40  			}
    41  		})
    42  		_, err := s.CreateDomain(&simpledb.CreateDomainInput{
    43  			DomainName: aws.String("test-domain"),
    44  		})
    45  
    46  		if err == nil {
    47  			t.Fatalf("expect error, got nil")
    48  		}
    49  		if e, a := test.code, err.(awserr.Error).Code(); e != a {
    50  			t.Errorf("expect %v, got %v", e, a)
    51  		}
    52  		if e, a := test.message, err.(awserr.Error).Message(); e != a {
    53  			t.Errorf("expect %v, got %v", e, a)
    54  		}
    55  	}
    56  }
    57  
    58  var responseErrorTests = []struct {
    59  	scode     int
    60  	status    string
    61  	code      string
    62  	message   string
    63  	requestID string
    64  	errors    []struct {
    65  		code    string
    66  		message string
    67  	}
    68  }{
    69  	{
    70  		scode:     400,
    71  		status:    "Bad Request",
    72  		code:      "MissingError",
    73  		message:   "missing error code in SimpleDB XML error response",
    74  		requestID: "101",
    75  		errors:    []struct{ code, message string }{},
    76  	},
    77  	{
    78  		scode:     403,
    79  		status:    "Forbidden",
    80  		code:      "AuthFailure",
    81  		message:   "AWS was not able to validate the provided access keys.",
    82  		requestID: "1111",
    83  		errors: []struct{ code, message string }{
    84  			{"AuthFailure", "AWS was not able to validate the provided access keys."},
    85  		},
    86  	},
    87  	{
    88  		scode:     500,
    89  		status:    "Internal Error",
    90  		code:      "MissingParameter",
    91  		message:   "Message #1",
    92  		requestID: "8756",
    93  		errors: []struct{ code, message string }{
    94  			{"MissingParameter", "Message #1"},
    95  			{"InternalError", "Message #2"},
    96  		},
    97  	},
    98  }
    99  
   100  func TestResponseError(t *testing.T) {
   101  	for _, test := range responseErrorTests {
   102  		s := simpledb.New(unit.Session)
   103  		s.Handlers.Send.Clear()
   104  		s.Handlers.Send.PushBack(func(r *request.Request) {
   105  			xml := createXMLResponse(test.requestID, test.errors)
   106  			body := ioutil.NopCloser(bytes.NewReader([]byte(xml)))
   107  			r.HTTPResponse = &http.Response{
   108  				ContentLength: int64(len(xml)),
   109  				StatusCode:    test.scode,
   110  				Status:        test.status,
   111  				Body:          body,
   112  			}
   113  		})
   114  		_, err := s.CreateDomain(&simpledb.CreateDomainInput{
   115  			DomainName: aws.String("test-domain"),
   116  		})
   117  
   118  		if err == nil {
   119  			t.Fatalf("expect error, got none")
   120  		}
   121  		if e, a := test.code, err.(awserr.Error).Code(); e != a {
   122  			t.Errorf("expect %v, got %v", e, a)
   123  		}
   124  		if e, a := test.message, err.(awserr.Error).Message(); e != a {
   125  			t.Errorf("expect %v, got %v", e, a)
   126  		}
   127  		if len(test.errors) > 0 {
   128  			if e, a := test.requestID, err.(awserr.RequestFailure).RequestID(); e != a {
   129  				t.Errorf("expect %v, got %v", e, a)
   130  			}
   131  			if e, a := test.scode, err.(awserr.RequestFailure).StatusCode(); e != a {
   132  				t.Errorf("expect %v, got %v", e, a)
   133  			}
   134  		}
   135  	}
   136  }
   137  
   138  // createXMLResponse constructs an XML string that has one or more error messages in it.
   139  func createXMLResponse(requestID string, errors []struct{ code, message string }) []byte {
   140  	var buf bytes.Buffer
   141  	buf.WriteString(`<?xml version="1.0"?><Response><Errors>`)
   142  	for _, e := range errors {
   143  		buf.WriteString(`<Error><Code>`)
   144  		buf.WriteString(e.code)
   145  		buf.WriteString(`</Code><Message>`)
   146  		buf.WriteString(e.message)
   147  		buf.WriteString(`</Message></Error>`)
   148  	}
   149  	buf.WriteString(`</Errors><RequestID>`)
   150  	buf.WriteString(requestID)
   151  	buf.WriteString(`</RequestID></Response>`)
   152  	return buf.Bytes()
   153  }