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