func TestOutputService4ProtocolTestListsCase2(t *testing.T) { sess := session.New() svc := NewOutputService4ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"ListMember\": [\"a\", null], \"ListMemberMap\": [{}, null, null, {}], \"ListMemberStruct\": [{}, null, null, {}]}")) req, out := svc.OutputService4TestCaseOperation2Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response jsonrpc.UnmarshalMeta(req) jsonrpc.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "a", *out.ListMember[0]) assert.Nil(t, out.ListMember[1]) assert.Nil(t, out.ListMemberMap[1]) assert.Nil(t, out.ListMemberMap[2]) assert.Nil(t, out.ListMemberStruct[1]) assert.Nil(t, out.ListMemberStruct[2]) }
func TestInvalidMustCompilePanics(t *testing.T) { defer func() { r := recover() assert.NotNil(t, r) }() MustCompile("not a valid expression") }
func TestOutputService9ProtocolTestSupportsHeaderMapsCase1(t *testing.T) { sess := session.New() svc := NewOutputService9ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{}")) req, out := svc.OutputService9TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("Content-Length", "10") req.HTTPResponse.Header.Set("X-Bam", "boo") req.HTTPResponse.Header.Set("X-Foo", "bar") // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "10", *out.AllHeaders["Content-Length"]) assert.Equal(t, "boo", *out.AllHeaders["X-Bam"]) assert.Equal(t, "bar", *out.AllHeaders["X-Foo"]) assert.Equal(t, "boo", *out.PrefixedHeaders["Bam"]) assert.Equal(t, "bar", *out.PrefixedHeaders["Foo"]) }
func TestInputService4ProtocolTestNestedBlobsCase1(t *testing.T) { sess := session.New() svc := NewInputService4ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService4TestShapeInputService4TestCaseOperation1Input{ ListParam: [][]byte{ []byte("foo"), []byte("bar"), }, } req, _ := svc.InputService4TestCaseOperation1Request(input) r := req.HTTPRequest // build request jsonrpc.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"ListParam":["Zm9v","YmFy"]}`, util.Trim(string(body))) // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers assert.Equal(t, "application/x-amz-json-1.1", r.Header.Get("Content-Type")) assert.Equal(t, "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target")) }
func TestInputService2ProtocolTestTimestampValuesCase1(t *testing.T) { sess := session.New() svc := NewInputService2ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService2TestShapeInputService2TestCaseOperation1Input{ TimeArg: aws.Time(time.Unix(1422172800, 0)), } req, _ := svc.InputService2TestCaseOperation1Request(input) r := req.HTTPRequest // build request jsonrpc.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"TimeArg":1422172800}`, util.Trim(string(body))) // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers assert.Equal(t, "application/x-amz-json-1.1", r.Header.Get("Content-Type")) assert.Equal(t, "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target")) }
func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) { sess := session.New() svc := NewOutputService1ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"Str\": \"myname\", \"Num\": 123, \"FalseBool\": false, \"TrueBool\": true, \"Float\": 1.2, \"Double\": 1.3, \"Long\": 200, \"Char\": \"a\"}")) req, out := svc.OutputService1TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("ImaHeader", "test") req.HTTPResponse.Header.Set("X-Foo", "abc") // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "a", *out.Char) assert.Equal(t, 1.3, *out.Double) assert.Equal(t, false, *out.FalseBool) assert.Equal(t, 1.2, *out.Float) assert.Equal(t, "test", *out.ImaHeader) assert.Equal(t, "abc", *out.ImaHeaderLocation) assert.Equal(t, int64(200), *out.Long) assert.Equal(t, int64(123), *out.Num) assert.Equal(t, int64(200), *out.Status) assert.Equal(t, "myname", *out.Str) assert.Equal(t, true, *out.TrueBool) }
func TestInputService5ProtocolTestRecursiveShapesCase3(t *testing.T) { sess := session.New() svc := NewInputService5ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputShape{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, }, }, } req, _ := svc.InputService5TestCaseOperation3Request(input) r := req.HTTPRequest // build request jsonrpc.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct":{"RecursiveStruct":{"RecursiveStruct":{"RecursiveStruct":{"NoRecurse":"foo"}}}}}`, util.Trim(string(body))) // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers assert.Equal(t, "application/x-amz-json-1.1", r.Header.Get("Content-Type")) assert.Equal(t, "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target")) }
func TestNewDefaultSession(t *testing.T) { s := session.New(&aws.Config{Region: aws.String("region")}) assert.Equal(t, "region", *s.Config.Region) assert.Equal(t, http.DefaultClient, s.Config.HTTPClient) assert.NotNil(t, s.Config.Logger) assert.Equal(t, aws.LogOff, *s.Config.LogLevel) }
func TestParsingErrors(t *testing.T) { assert := assert.New(t) parser := NewParser() for _, tt := range parsingErrorTests { _, err := parser.Parse(tt.expression) assert.NotNil(err, fmt.Sprintf("Expected parsing error: %s, for expression: %s", tt.msg, tt.expression)) } }
func TestLexingErrors(t *testing.T) { assert := assert.New(t) lexer := NewLexer() for _, tt := range lexingErrorTests { _, err := lexer.tokenize(tt.expression) assert.NotNil(err, fmt.Sprintf("Expected lexing error: %s", tt.msg)) } }
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 TestClientNotOverrideDefaultHTTPClientTimeout(t *testing.T) { origClient := *http.DefaultClient http.DefaultClient.Transport = &http.Transport{} defer func() { http.DefaultClient = &origClient }() svc := ec2metadata.New(session.New()) assert.Equal(t, http.DefaultClient, svc.Config.HTTPClient) tr, ok := svc.Config.HTTPClient.Transport.(*http.Transport) assert.True(t, ok) assert.NotNil(t, tr) assert.Nil(t, tr.Dial) }
func TestOutputService8ProtocolTestIgnoresExtraDataCase1(t *testing.T) { sess := session.New() svc := NewOutputService8ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"foo\": \"bar\"}")) req, out := svc.OutputService8TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used }
func TestRequestExhaustRetries(t *testing.T) { delays := []time.Duration{} sleepDelay := func(delay time.Duration) { delays = append(delays, delay) } reqNum := 0 reqs := []http.Response{ {StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)}, {StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)}, {StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)}, {StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)}, } s := awstesting.NewClient(aws.NewConfig().WithSleepDelay(sleepDelay)) s.Handlers.Validate.Clear() s.Handlers.Unmarshal.PushBack(unmarshal) s.Handlers.UnmarshalError.PushBack(unmarshalError) s.Handlers.Send.Clear() // mock sending s.Handlers.Send.PushBack(func(r *request.Request) { r.HTTPResponse = &reqs[reqNum] reqNum++ }) r := s.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) err := r.Send() assert.NotNil(t, err) if e, ok := err.(awserr.RequestFailure); ok { assert.Equal(t, 500, e.StatusCode()) } else { assert.Fail(t, "Expected error to be a service failure") } assert.Equal(t, "UnknownError", err.(awserr.Error).Code()) assert.Equal(t, "An error occurred.", err.(awserr.Error).Message()) assert.Equal(t, 3, int(r.RetryCount)) expectDelays := []struct{ min, max time.Duration }{{30, 59}, {60, 118}, {120, 236}} for i, v := range delays { min := expectDelays[i].min * time.Millisecond max := expectDelays[i].max * time.Millisecond assert.True(t, min <= v && v <= max, "Expect delay to be within range, i:%d, v:%s, min:%s, max:%s", i, v, min, max) } }
func TestOutputService11ProtocolTestStreamingPayloadCase1(t *testing.T) { sess := session.New() svc := NewOutputService11ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("abc")) req, out := svc.OutputService11TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "abc", string(out.Stream)) }
func TestOutputService2ProtocolTestBlobMembersCase1(t *testing.T) { sess := session.New() svc := NewOutputService2ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"BlobMember\": \"aGkh\", \"StructMember\": {\"foo\": \"dGhlcmUh\"}}")) req, out := svc.OutputService2TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "hi!", string(out.BlobMember)) assert.Equal(t, "there!", string(out.StructMember.Foo)) }
func TestOutputService7ProtocolTestComplexMapValuesCase1(t *testing.T) { sess := session.New() svc := NewOutputService7ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"MapMember\": {\"a\": 1398796238, \"b\": 1398796238}}")) req, out := svc.OutputService7TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, time.Unix(1.398796238e+09, 0).UTC().String(), out.MapMember["a"].String()) assert.Equal(t, time.Unix(1.398796238e+09, 0).UTC().String(), out.MapMember["b"].String()) }
func TestOutputService5ProtocolTestListsWithStructureMemberCase1(t *testing.T) { sess := session.New() svc := NewOutputService5ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"ListMember\": [{\"Foo\": \"a\"}, {\"Foo\": \"b\"}]}")) req, out := svc.OutputService5TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "a", *out.ListMember[0].Foo) assert.Equal(t, "b", *out.ListMember[1].Foo) }
func TestOutputService10ProtocolTestJSONPayloadCase1(t *testing.T) { sess := session.New() svc := NewOutputService10ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"Foo\": \"abc\"}")) req, out := svc.OutputService10TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("X-Foo", "baz") // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "abc", *out.Data.Foo) assert.Equal(t, "baz", *out.Header) }
// test that retries don't occur for 4xx status codes with a response type that can't be retried func TestRequest4xxUnretryable(t *testing.T) { s := awstesting.NewClient(aws.NewConfig().WithMaxRetries(10)) s.Handlers.Validate.Clear() s.Handlers.Unmarshal.PushBack(unmarshal) s.Handlers.UnmarshalError.PushBack(unmarshalError) s.Handlers.Send.Clear() // mock sending s.Handlers.Send.PushBack(func(r *request.Request) { r.HTTPResponse = &http.Response{StatusCode: 401, Body: body(`{"__type":"SignatureDoesNotMatch","message":"Signature does not match."}`)} }) out := &testData{} r := s.NewRequest(&request.Operation{Name: "Operation"}, nil, out) err := r.Send() assert.NotNil(t, err) if e, ok := err.(awserr.RequestFailure); ok { assert.Equal(t, 401, e.StatusCode()) } else { assert.Fail(t, "Expected error to be a service failure") } assert.Equal(t, "SignatureDoesNotMatch", err.(awserr.Error).Code()) assert.Equal(t, "Signature does not match.", err.(awserr.Error).Message()) assert.Equal(t, 0, int(r.RetryCount)) }
func TestOutputService6ProtocolTestMapsCase1(t *testing.T) { sess := session.New() svc := NewOutputService6ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"MapMember\": {\"a\": [1, 2], \"b\": [3, 4]}}")) req, out := svc.OutputService6TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, int64(1), *out.MapMember["a"][0]) assert.Equal(t, int64(2), *out.MapMember["a"][1]) assert.Equal(t, int64(3), *out.MapMember["b"][0]) assert.Equal(t, int64(4), *out.MapMember["b"][1]) }
func TestInvalidPrecompileErrors(t *testing.T) { assert := assert.New(t) _, err := Compile("not a valid expression") assert.NotNil(err) }