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