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