1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
2
3// +build go1.10
4
5package restxmlservice
6
7import (
8	"bytes"
9	"context"
10	"io/ioutil"
11	"net/http"
12	"reflect"
13	"strings"
14	"sync"
15	"testing"
16	"time"
17
18	"github.com/aws/aws-sdk-go/aws"
19	"github.com/aws/aws-sdk-go/aws/awserr"
20	"github.com/aws/aws-sdk-go/aws/corehandlers"
21	"github.com/aws/aws-sdk-go/aws/request"
22	"github.com/aws/aws-sdk-go/awstesting/unit"
23	"github.com/aws/aws-sdk-go/private/protocol"
24	"github.com/aws/aws-sdk-go/private/protocol/eventstream"
25	"github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi"
26	"github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamtest"
27	"github.com/aws/aws-sdk-go/private/protocol/restxml"
28)
29
30var _ time.Time
31var _ awserr.Error
32var _ context.Context
33var _ sync.WaitGroup
34var _ strings.Reader
35
36func TestEmptyStream_Read(t *testing.T) {
37	expectEvents, eventMsgs := mockEmptyStreamReadEvents()
38	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
39		eventstreamtest.ServeEventStream{
40			T:      t,
41			Events: eventMsgs,
42		},
43		true,
44	)
45	if err != nil {
46		t.Fatalf("expect no error, %v", err)
47	}
48	defer cleanupFn()
49
50	svc := New(sess)
51	resp, err := svc.EmptyStream(nil)
52	if err != nil {
53		t.Fatalf("expect no error got, %v", err)
54	}
55	defer resp.GetStream().Close()
56
57	var i int
58	for event := range resp.GetStream().Events() {
59		if event == nil {
60			t.Errorf("%d, expect event, got nil", i)
61		}
62		if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
63			t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
64		}
65		i++
66	}
67
68	if err := resp.GetStream().Err(); err != nil {
69		t.Errorf("expect no error, %v", err)
70	}
71}
72
73func TestEmptyStream_ReadClose(t *testing.T) {
74	_, eventMsgs := mockEmptyStreamReadEvents()
75	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
76		eventstreamtest.ServeEventStream{
77			T:      t,
78			Events: eventMsgs,
79		},
80		true,
81	)
82	if err != nil {
83		t.Fatalf("expect no error, %v", err)
84	}
85	defer cleanupFn()
86
87	svc := New(sess)
88	resp, err := svc.EmptyStream(nil)
89	if err != nil {
90		t.Fatalf("expect no error got, %v", err)
91	}
92
93	resp.GetStream().Close()
94	<-resp.GetStream().Events()
95
96	if err := resp.GetStream().Err(); err != nil {
97		t.Errorf("expect no error, %v", err)
98	}
99}
100
101func BenchmarkEmptyStream_Read(b *testing.B) {
102	_, eventMsgs := mockEmptyStreamReadEvents()
103	var buf bytes.Buffer
104	encoder := eventstream.NewEncoder(&buf)
105	for _, msg := range eventMsgs {
106		if err := encoder.Encode(msg); err != nil {
107			b.Fatalf("failed to encode message, %v", err)
108		}
109	}
110	stream := &loopReader{source: bytes.NewReader(buf.Bytes())}
111
112	sess := unit.Session
113	svc := New(sess, &aws.Config{
114		Endpoint:               aws.String("https://example.com"),
115		DisableParamValidation: aws.Bool(true),
116	})
117	svc.Handlers.Send.Swap(corehandlers.SendHandler.Name,
118		request.NamedHandler{Name: "mockSend",
119			Fn: func(r *request.Request) {
120				r.HTTPResponse = &http.Response{
121					Status:     "200 OK",
122					StatusCode: 200,
123					Header:     http.Header{},
124					Body:       ioutil.NopCloser(stream),
125				}
126			},
127		},
128	)
129
130	resp, err := svc.EmptyStream(nil)
131	if err != nil {
132		b.Fatalf("failed to create request, %v", err)
133	}
134	defer resp.GetStream().Close()
135	b.ResetTimer()
136
137	for i := 0; i < b.N; i++ {
138		if err = resp.GetStream().Err(); err != nil {
139			b.Fatalf("expect no error, got %v", err)
140		}
141		event := <-resp.GetStream().Events()
142		if event == nil {
143			b.Fatalf("expect event, got nil, %v, %d", resp.GetStream().Err(), i)
144		}
145	}
146}
147
148func mockEmptyStreamReadEvents() (
149	[]EmptyEventStreamEvent,
150	[]eventstream.Message,
151) {
152	expectEvents := []EmptyEventStreamEvent{}
153
154	var marshalers request.HandlerList
155	marshalers.PushBackNamed(restxml.BuildHandler)
156	payloadMarshaler := protocol.HandlerPayloadMarshal{
157		Marshalers: marshalers,
158	}
159	_ = payloadMarshaler
160
161	eventMsgs := []eventstream.Message{}
162
163	return expectEvents, eventMsgs
164}
165
166func TestGetEventStream_Read(t *testing.T) {
167	expectEvents, eventMsgs := mockGetEventStreamReadEvents()
168	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
169		eventstreamtest.ServeEventStream{
170			T:      t,
171			Events: eventMsgs,
172		},
173		true,
174	)
175	if err != nil {
176		t.Fatalf("expect no error, %v", err)
177	}
178	defer cleanupFn()
179
180	svc := New(sess)
181	resp, err := svc.GetEventStream(nil)
182	if err != nil {
183		t.Fatalf("expect no error got, %v", err)
184	}
185	defer resp.GetStream().Close()
186
187	var i int
188	for event := range resp.GetStream().Events() {
189		if event == nil {
190			t.Errorf("%d, expect event, got nil", i)
191		}
192		if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
193			t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
194		}
195		i++
196	}
197
198	if err := resp.GetStream().Err(); err != nil {
199		t.Errorf("expect no error, %v", err)
200	}
201}
202
203func TestGetEventStream_ReadClose(t *testing.T) {
204	_, eventMsgs := mockGetEventStreamReadEvents()
205	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
206		eventstreamtest.ServeEventStream{
207			T:      t,
208			Events: eventMsgs,
209		},
210		true,
211	)
212	if err != nil {
213		t.Fatalf("expect no error, %v", err)
214	}
215	defer cleanupFn()
216
217	svc := New(sess)
218	resp, err := svc.GetEventStream(nil)
219	if err != nil {
220		t.Fatalf("expect no error got, %v", err)
221	}
222
223	// Assert calling Err before close does not close the stream.
224	resp.GetStream().Err()
225	select {
226	case _, ok := <-resp.GetStream().Events():
227		if !ok {
228			t.Fatalf("expect stream not to be closed, but was")
229		}
230	default:
231	}
232
233	resp.GetStream().Close()
234	<-resp.GetStream().Events()
235
236	if err := resp.GetStream().Err(); err != nil {
237		t.Errorf("expect no error, %v", err)
238	}
239}
240
241func BenchmarkGetEventStream_Read(b *testing.B) {
242	_, eventMsgs := mockGetEventStreamReadEvents()
243	var buf bytes.Buffer
244	encoder := eventstream.NewEncoder(&buf)
245	for _, msg := range eventMsgs {
246		if err := encoder.Encode(msg); err != nil {
247			b.Fatalf("failed to encode message, %v", err)
248		}
249	}
250	stream := &loopReader{source: bytes.NewReader(buf.Bytes())}
251
252	sess := unit.Session
253	svc := New(sess, &aws.Config{
254		Endpoint:               aws.String("https://example.com"),
255		DisableParamValidation: aws.Bool(true),
256	})
257	svc.Handlers.Send.Swap(corehandlers.SendHandler.Name,
258		request.NamedHandler{Name: "mockSend",
259			Fn: func(r *request.Request) {
260				r.HTTPResponse = &http.Response{
261					Status:     "200 OK",
262					StatusCode: 200,
263					Header:     http.Header{},
264					Body:       ioutil.NopCloser(stream),
265				}
266			},
267		},
268	)
269
270	resp, err := svc.GetEventStream(nil)
271	if err != nil {
272		b.Fatalf("failed to create request, %v", err)
273	}
274	defer resp.GetStream().Close()
275	b.ResetTimer()
276
277	for i := 0; i < b.N; i++ {
278		if err = resp.GetStream().Err(); err != nil {
279			b.Fatalf("expect no error, got %v", err)
280		}
281		event := <-resp.GetStream().Events()
282		if event == nil {
283			b.Fatalf("expect event, got nil, %v, %d", resp.GetStream().Err(), i)
284		}
285	}
286}
287
288func mockGetEventStreamReadEvents() (
289	[]EventStreamEvent,
290	[]eventstream.Message,
291) {
292	expectEvents := []EventStreamEvent{
293		&EmptyEvent{},
294		&ExplicitPayloadEvent{
295			LongVal: aws.Int64(1234),
296			NestedVal: &NestedShape{
297				IntVal: aws.Int64(123),
298				StrVal: aws.String("string value goes here"),
299			},
300			StringVal: aws.String("string value goes here"),
301		},
302		&HeaderOnlyEvent{
303			BlobVal:    []byte("blob value goes here"),
304			BoolVal:    aws.Bool(true),
305			ByteVal:    aws.Int64(1),
306			IntegerVal: aws.Int64(123),
307			LongVal:    aws.Int64(1234),
308			ShortVal:   aws.Int64(12),
309			StringVal:  aws.String("string value goes here"),
310			TimeVal:    aws.Time(time.Unix(1396594860, 0).UTC()),
311		},
312		&ImplicitPayloadEvent{
313			ByteVal:    aws.Int64(1),
314			IntegerVal: aws.Int64(123),
315			ShortVal:   aws.Int64(12),
316		},
317		&PayloadOnlyEvent{
318			NestedVal: &NestedShape{
319				IntVal: aws.Int64(123),
320				StrVal: aws.String("string value goes here"),
321			},
322		},
323		&PayloadOnlyBlobEvent{
324			BlobPayload: []byte("blob value goes here"),
325		},
326		&PayloadOnlyStringEvent{
327			StringPayload: aws.String("string value goes here"),
328		},
329	}
330
331	var marshalers request.HandlerList
332	marshalers.PushBackNamed(restxml.BuildHandler)
333	payloadMarshaler := protocol.HandlerPayloadMarshal{
334		Marshalers: marshalers,
335	}
336	_ = payloadMarshaler
337
338	eventMsgs := []eventstream.Message{
339		{
340			Headers: eventstream.Headers{
341				eventstreamtest.EventMessageTypeHeader,
342				{
343					Name:  eventstreamapi.EventTypeHeader,
344					Value: eventstream.StringValue("Empty"),
345				},
346			},
347		},
348		{
349			Headers: eventstream.Headers{
350				eventstreamtest.EventMessageTypeHeader,
351				{
352					Name:  eventstreamapi.EventTypeHeader,
353					Value: eventstream.StringValue("ExplicitPayload"),
354				},
355				{
356					Name:  "LongVal",
357					Value: eventstream.Int64Value(*expectEvents[1].(*ExplicitPayloadEvent).LongVal),
358				},
359				{
360					Name:  "StringVal",
361					Value: eventstream.StringValue(*expectEvents[1].(*ExplicitPayloadEvent).StringVal),
362				},
363			},
364			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[1]),
365		},
366		{
367			Headers: eventstream.Headers{
368				eventstreamtest.EventMessageTypeHeader,
369				{
370					Name:  eventstreamapi.EventTypeHeader,
371					Value: eventstream.StringValue("Headers"),
372				},
373				{
374					Name:  "BlobVal",
375					Value: eventstream.BytesValue(expectEvents[2].(*HeaderOnlyEvent).BlobVal),
376				},
377				{
378					Name:  "BoolVal",
379					Value: eventstream.BoolValue(*expectEvents[2].(*HeaderOnlyEvent).BoolVal),
380				},
381				{
382					Name:  "ByteVal",
383					Value: eventstream.Int8Value(int8(*expectEvents[2].(*HeaderOnlyEvent).ByteVal)),
384				},
385				{
386					Name:  "IntegerVal",
387					Value: eventstream.Int32Value(int32(*expectEvents[2].(*HeaderOnlyEvent).IntegerVal)),
388				},
389				{
390					Name:  "LongVal",
391					Value: eventstream.Int64Value(*expectEvents[2].(*HeaderOnlyEvent).LongVal),
392				},
393				{
394					Name:  "ShortVal",
395					Value: eventstream.Int16Value(int16(*expectEvents[2].(*HeaderOnlyEvent).ShortVal)),
396				},
397				{
398					Name:  "StringVal",
399					Value: eventstream.StringValue(*expectEvents[2].(*HeaderOnlyEvent).StringVal),
400				},
401				{
402					Name:  "TimeVal",
403					Value: eventstream.TimestampValue(*expectEvents[2].(*HeaderOnlyEvent).TimeVal),
404				},
405			},
406		},
407		{
408			Headers: eventstream.Headers{
409				eventstreamtest.EventMessageTypeHeader,
410				{
411					Name:  eventstreamapi.EventTypeHeader,
412					Value: eventstream.StringValue("ImplicitPayload"),
413				},
414				{
415					Name:  "ByteVal",
416					Value: eventstream.Int8Value(int8(*expectEvents[3].(*ImplicitPayloadEvent).ByteVal)),
417				},
418			},
419			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[3]),
420		},
421		{
422			Headers: eventstream.Headers{
423				eventstreamtest.EventMessageTypeHeader,
424				{
425					Name:  eventstreamapi.EventTypeHeader,
426					Value: eventstream.StringValue("PayloadOnly"),
427				},
428			},
429			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[4]),
430		},
431		{
432			Headers: eventstream.Headers{
433				eventstreamtest.EventMessageTypeHeader,
434				{
435					Name:  eventstreamapi.EventTypeHeader,
436					Value: eventstream.StringValue("PayloadOnlyBlob"),
437				},
438			},
439			Payload: expectEvents[5].(*PayloadOnlyBlobEvent).BlobPayload,
440		},
441		{
442			Headers: eventstream.Headers{
443				eventstreamtest.EventMessageTypeHeader,
444				{
445					Name:  eventstreamapi.EventTypeHeader,
446					Value: eventstream.StringValue("PayloadOnlyString"),
447				},
448			},
449			Payload: []byte(*expectEvents[6].(*PayloadOnlyStringEvent).StringPayload),
450		},
451	}
452
453	return expectEvents, eventMsgs
454}
455func TestGetEventStream_ReadException(t *testing.T) {
456	expectEvents := []EventStreamEvent{
457		&ExceptionEvent{
458			RespMetadata: protocol.ResponseMetadata{
459				StatusCode: 200,
460			},
461			IntVal:   aws.Int64(123),
462			Message_: aws.String("string value goes here"),
463		},
464	}
465
466	var marshalers request.HandlerList
467	marshalers.PushBackNamed(restxml.BuildHandler)
468	payloadMarshaler := protocol.HandlerPayloadMarshal{
469		Marshalers: marshalers,
470	}
471
472	eventMsgs := []eventstream.Message{
473		{
474			Headers: eventstream.Headers{
475				eventstreamtest.EventExceptionTypeHeader,
476				{
477					Name:  eventstreamapi.ExceptionTypeHeader,
478					Value: eventstream.StringValue("Exception"),
479				},
480			},
481			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
482		},
483	}
484
485	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
486		eventstreamtest.ServeEventStream{
487			T:      t,
488			Events: eventMsgs,
489		},
490		true,
491	)
492	if err != nil {
493		t.Fatalf("expect no error, %v", err)
494	}
495	defer cleanupFn()
496
497	svc := New(sess)
498	resp, err := svc.GetEventStream(nil)
499	if err != nil {
500		t.Fatalf("expect no error got, %v", err)
501	}
502
503	defer resp.GetStream().Close()
504
505	<-resp.GetStream().Events()
506
507	err = resp.GetStream().Err()
508	if err == nil {
509		t.Fatalf("expect err, got none")
510	}
511
512	expectErr := &ExceptionEvent{
513		RespMetadata: protocol.ResponseMetadata{
514			StatusCode: 200,
515		},
516		IntVal:   aws.Int64(123),
517		Message_: aws.String("string value goes here"),
518	}
519	aerr, ok := err.(awserr.Error)
520	if !ok {
521		t.Errorf("expect exception, got %T, %#v", err, err)
522	}
523	if e, a := expectErr.Code(), aerr.Code(); e != a {
524		t.Errorf("expect %v, got %v", e, a)
525	}
526	if e, a := expectErr.Message(), aerr.Message(); e != a {
527		t.Errorf("expect %v, got %v", e, a)
528	}
529
530	if e, a := expectErr, aerr; !reflect.DeepEqual(e, a) {
531		t.Errorf("expect error %+#v, got %+#v", e, a)
532	}
533}
534
535var _ awserr.Error = (*ExceptionEvent)(nil)
536var _ awserr.Error = (*ExceptionEvent2)(nil)
537
538type loopReader struct {
539	source *bytes.Reader
540}
541
542func (c *loopReader) Read(p []byte) (int, error) {
543	if c.source.Len() == 0 {
544		c.source.Seek(0, 0)
545	}
546
547	return c.source.Read(p)
548}
549