Debian Codegraph @

service/transcribestreamingservice/eventstream_test.go

raw
1 // Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
2
3 //go:build go1.16
4 // +build go1.16
5
6 package transcribestreamingservice
7
8 import (
9 "bytes"
10 "context"
11 "io/ioutil"
12 "net/http"
13 "reflect"
14 "strings"
15 "sync"
16 "testing"
17 "time"
18
19 "github.com/aws/aws-sdk-go/aws"
20 "github.com/aws/aws-sdk-go/aws/awserr"
21 "github.com/aws/aws-sdk-go/aws/corehandlers"
22 "github.com/aws/aws-sdk-go/aws/request"
23 "github.com/aws/aws-sdk-go/awstesting/unit"
24 "github.com/aws/aws-sdk-go/private/protocol"
25 "github.com/aws/aws-sdk-go/private/protocol/eventstream"
26 "github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi"
27 "github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamtest"
28 "github.com/aws/aws-sdk-go/private/protocol/restjson"
29 )
30
31 var _ time.Time
32 var _ awserr.Error
33 var _ context.Context
34 var _ sync.WaitGroup
35 var _ strings.Reader
36
37 func TestStartCallAnalyticsStreamTranscription_Read(t *testing.T) {
38 expectEvents, eventMsgs := mockStartCallAnalyticsStreamTranscriptionReadEvents()
39 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
40 eventstreamtest.ServeEventStream{
41 T: t,
42 Events: eventMsgs,
43 },
44 true,
45 )
46 if err != nil {
47 t.Fatalf("expect no error, %v", err)
48 }
49 defer cleanupFn()
50
51 svc := New(sess)
52 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
53 if err != nil {
54 t.Fatalf("expect no error got, %v", err)
55 }
56 defer resp.GetStream().Close()
57
58 var i int
59 for event := range resp.GetStream().Events() {
60 if event == nil {
61 t.Errorf("%d, expect event, got nil", i)
62 }
63 if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
64 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
65 }
66 i++
67 }
68
69 if err := resp.GetStream().Err(); err != nil {
70 t.Errorf("expect no error, %v", err)
71 }
72 }
73
74 func TestStartCallAnalyticsStreamTranscription_ReadClose(t *testing.T) {
75 _, eventMsgs := mockStartCallAnalyticsStreamTranscriptionReadEvents()
76 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
77 eventstreamtest.ServeEventStream{
78 T: t,
79 Events: eventMsgs,
80 },
81 true,
82 )
83 if err != nil {
84 t.Fatalf("expect no error, %v", err)
85 }
86 defer cleanupFn()
87
88 svc := New(sess)
89 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
90 if err != nil {
91 t.Fatalf("expect no error got, %v", err)
92 }
93
94 // Assert calling Err before close does not close the stream.
95 resp.GetStream().Err()
96 select {
97 case _, ok := <-resp.GetStream().Events():
98 if !ok {
99 t.Fatalf("expect stream not to be closed, but was")
100 }
101 default:
102 }
103
104 resp.GetStream().Close()
105 <-resp.GetStream().Events()
106
107 if err := resp.GetStream().Err(); err != nil {
108 t.Errorf("expect no error, %v", err)
109 }
110 }
111
112 func TestStartCallAnalyticsStreamTranscription_ReadUnknownEvent(t *testing.T) {
113 expectEvents, eventMsgs := mockStartCallAnalyticsStreamTranscriptionReadEvents()
114 var eventOffset int
115
116 unknownEvent := eventstream.Message{
117 Headers: eventstream.Headers{
118 eventstreamtest.EventMessageTypeHeader,
119 {
120 Name: eventstreamapi.EventTypeHeader,
121 Value: eventstream.StringValue("UnknownEventName"),
122 },
123 },
124 Payload: []byte("some unknown event"),
125 }
126
127 eventMsgs = append(eventMsgs[:eventOffset],
128 append([]eventstream.Message{unknownEvent}, eventMsgs[eventOffset:]...)...)
129
130 expectEvents = append(expectEvents[:eventOffset],
131 append([]CallAnalyticsTranscriptResultStreamEvent{
132 &CallAnalyticsTranscriptResultStreamUnknownEvent{
133 Type: "UnknownEventName",
134 Message: unknownEvent,
135 },
136 },
137 expectEvents[eventOffset:]...)...)
138
139 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
140 eventstreamtest.ServeEventStream{
141 T: t,
142 Events: eventMsgs,
143 },
144 true,
145 )
146 if err != nil {
147 t.Fatalf("expect no error, %v", err)
148 }
149 defer cleanupFn()
150
151 svc := New(sess)
152 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
153 if err != nil {
154 t.Fatalf("expect no error got, %v", err)
155 }
156 defer resp.GetStream().Close()
157
158 var i int
159 for event := range resp.GetStream().Events() {
160 if event == nil {
161 t.Errorf("%d, expect event, got nil", i)
162 }
163 if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
164 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
165 }
166 i++
167 }
168
169 if err := resp.GetStream().Err(); err != nil {
170 t.Errorf("expect no error, %v", err)
171 }
172 }
173
174 func BenchmarkStartCallAnalyticsStreamTranscription_Read(b *testing.B) {
175 _, eventMsgs := mockStartCallAnalyticsStreamTranscriptionReadEvents()
176 var buf bytes.Buffer
177 encoder := eventstream.NewEncoder(&buf)
178 for _, msg := range eventMsgs {
179 if err := encoder.Encode(msg); err != nil {
180 b.Fatalf("failed to encode message, %v", err)
181 }
182 }
183 stream := &loopReader{source: bytes.NewReader(buf.Bytes())}
184
185 sess := unit.Session
186 svc := New(sess, &aws.Config{
187 Endpoint: aws.String("https://example.com"),
188 DisableParamValidation: aws.Bool(true),
189 })
190 svc.Handlers.Send.Swap(corehandlers.SendHandler.Name,
191 request.NamedHandler{Name: "mockSend",
192 Fn: func(r *request.Request) {
193 r.HTTPResponse = &http.Response{
194 Status: "200 OK",
195 StatusCode: 200,
196 Header: http.Header{},
197 Body: ioutil.NopCloser(stream),
198 }
199 },
200 },
201 )
202
203 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
204 if err != nil {
205 b.Fatalf("failed to create request, %v", err)
206 }
207 defer resp.GetStream().Close()
208 b.ResetTimer()
209
210 for i := 0; i < b.N; i++ {
211 if err = resp.GetStream().Err(); err != nil {
212 b.Fatalf("expect no error, got %v", err)
213 }
214 event := <-resp.GetStream().Events()
215 if event == nil {
216 b.Fatalf("expect event, got nil, %v, %d", resp.GetStream().Err(), i)
217 }
218 }
219 }
220
221 func mockStartCallAnalyticsStreamTranscriptionReadEvents() (
222 []CallAnalyticsTranscriptResultStreamEvent,
223 []eventstream.Message,
224 ) {
225 expectEvents := []CallAnalyticsTranscriptResultStreamEvent{
226 &CategoryEvent{
227 MatchedCategories: []*string{
228 aws.String("string value goes here"),
229 aws.String("string value goes here"),
230 aws.String("string value goes here"),
231 },
232 MatchedDetails: map[string]*PointsOfInterest{
233 "a": {
234 TimestampRanges: []*TimestampRange{
235 {
236 BeginOffsetMillis: aws.Int64(1234),
237 EndOffsetMillis: aws.Int64(1234),
238 },
239 {
240 BeginOffsetMillis: aws.Int64(1234),
241 EndOffsetMillis: aws.Int64(1234),
242 },
243 {
244 BeginOffsetMillis: aws.Int64(1234),
245 EndOffsetMillis: aws.Int64(1234),
246 },
247 },
248 },
249 "b": {
250 TimestampRanges: []*TimestampRange{
251 {
252 BeginOffsetMillis: aws.Int64(1234),
253 EndOffsetMillis: aws.Int64(1234),
254 },
255 {
256 BeginOffsetMillis: aws.Int64(1234),
257 EndOffsetMillis: aws.Int64(1234),
258 },
259 {
260 BeginOffsetMillis: aws.Int64(1234),
261 EndOffsetMillis: aws.Int64(1234),
262 },
263 },
264 },
265 "c": {
266 TimestampRanges: []*TimestampRange{
267 {
268 BeginOffsetMillis: aws.Int64(1234),
269 EndOffsetMillis: aws.Int64(1234),
270 },
271 {
272 BeginOffsetMillis: aws.Int64(1234),
273 EndOffsetMillis: aws.Int64(1234),
274 },
275 {
276 BeginOffsetMillis: aws.Int64(1234),
277 EndOffsetMillis: aws.Int64(1234),
278 },
279 },
280 },
281 },
282 },
283 &UtteranceEvent{
284 BeginOffsetMillis: aws.Int64(1234),
285 EndOffsetMillis: aws.Int64(1234),
286 Entities: []*CallAnalyticsEntity{
287 {
288 BeginOffsetMillis: aws.Int64(1234),
289 Category: aws.String("string value goes here"),
290 Confidence: aws.Float64(123.45),
291 Content: aws.String("string value goes here"),
292 EndOffsetMillis: aws.Int64(1234),
293 Type: aws.String("string value goes here"),
294 },
295 {
296 BeginOffsetMillis: aws.Int64(1234),
297 Category: aws.String("string value goes here"),
298 Confidence: aws.Float64(123.45),
299 Content: aws.String("string value goes here"),
300 EndOffsetMillis: aws.Int64(1234),
301 Type: aws.String("string value goes here"),
302 },
303 {
304 BeginOffsetMillis: aws.Int64(1234),
305 Category: aws.String("string value goes here"),
306 Confidence: aws.Float64(123.45),
307 Content: aws.String("string value goes here"),
308 EndOffsetMillis: aws.Int64(1234),
309 Type: aws.String("string value goes here"),
310 },
311 },
312 IsPartial: aws.Bool(true),
313 IssuesDetected: []*IssueDetected{
314 {
315 CharacterOffsets: &CharacterOffsets{
316 Begin: aws.Int64(123),
317 End: aws.Int64(123),
318 },
319 },
320 {
321 CharacterOffsets: &CharacterOffsets{
322 Begin: aws.Int64(123),
323 End: aws.Int64(123),
324 },
325 },
326 {
327 CharacterOffsets: &CharacterOffsets{
328 Begin: aws.Int64(123),
329 End: aws.Int64(123),
330 },
331 },
332 },
333 Items: []*CallAnalyticsItem{
334 {
335 BeginOffsetMillis: aws.Int64(1234),
336 Confidence: aws.Float64(123.45),
337 Content: aws.String("string value goes here"),
338 EndOffsetMillis: aws.Int64(1234),
339 Stable: aws.Bool(true),
340 Type: aws.String("string value goes here"),
341 VocabularyFilterMatch: aws.Bool(true),
342 },
343 {
344 BeginOffsetMillis: aws.Int64(1234),
345 Confidence: aws.Float64(123.45),
346 Content: aws.String("string value goes here"),
347 EndOffsetMillis: aws.Int64(1234),
348 Stable: aws.Bool(true),
349 Type: aws.String("string value goes here"),
350 VocabularyFilterMatch: aws.Bool(true),
351 },
352 {
353 BeginOffsetMillis: aws.Int64(1234),
354 Confidence: aws.Float64(123.45),
355 Content: aws.String("string value goes here"),
356 EndOffsetMillis: aws.Int64(1234),
357 Stable: aws.Bool(true),
358 Type: aws.String("string value goes here"),
359 VocabularyFilterMatch: aws.Bool(true),
360 },
361 },
362 ParticipantRole: aws.String("string value goes here"),
363 Sentiment: aws.String("string value goes here"),
364 Transcript: aws.String("string value goes here"),
365 UtteranceId: aws.String("string value goes here"),
366 },
367 }
368
369 var marshalers request.HandlerList
370 marshalers.PushBackNamed(restjson.BuildHandler)
371 payloadMarshaler := protocol.HandlerPayloadMarshal{
372 Marshalers: marshalers,
373 }
374 _ = payloadMarshaler
375
376 eventMsgs := []eventstream.Message{
377 {
378 Headers: eventstream.Headers{
379 eventstreamtest.EventMessageTypeHeader,
380 {
381 Name: eventstreamapi.EventTypeHeader,
382 Value: eventstream.StringValue("CategoryEvent"),
383 },
384 },
385 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
386 },
387 {
388 Headers: eventstream.Headers{
389 eventstreamtest.EventMessageTypeHeader,
390 {
391 Name: eventstreamapi.EventTypeHeader,
392 Value: eventstream.StringValue("UtteranceEvent"),
393 },
394 },
395 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[1]),
396 },
397 }
398
399 return expectEvents, eventMsgs
400 }
401 func TestStartCallAnalyticsStreamTranscription_ReadException(t *testing.T) {
402 expectEvents := []CallAnalyticsTranscriptResultStreamEvent{
403 &BadRequestException{
404 RespMetadata: protocol.ResponseMetadata{
405 StatusCode: 200,
406 },
407 Message_: aws.String("string value goes here"),
408 },
409 }
410
411 var marshalers request.HandlerList
412 marshalers.PushBackNamed(restjson.BuildHandler)
413 payloadMarshaler := protocol.HandlerPayloadMarshal{
414 Marshalers: marshalers,
415 }
416
417 eventMsgs := []eventstream.Message{
418 {
419 Headers: eventstream.Headers{
420 eventstreamtest.EventExceptionTypeHeader,
421 {
422 Name: eventstreamapi.ExceptionTypeHeader,
423 Value: eventstream.StringValue("BadRequestException"),
424 },
425 },
426 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
427 },
428 }
429
430 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
431 eventstreamtest.ServeEventStream{
432 T: t,
433 Events: eventMsgs,
434 },
435 true,
436 )
437 if err != nil {
438 t.Fatalf("expect no error, %v", err)
439 }
440 defer cleanupFn()
441
442 svc := New(sess)
443 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
444 if err != nil {
445 t.Fatalf("expect no error got, %v", err)
446 }
447
448 defer resp.GetStream().Close()
449
450 <-resp.GetStream().Events()
451
452 err = resp.GetStream().Err()
453 if err == nil {
454 t.Fatalf("expect err, got none")
455 }
456
457 expectErr := &BadRequestException{
458 RespMetadata: protocol.ResponseMetadata{
459 StatusCode: 200,
460 },
461 Message_: aws.String("string value goes here"),
462 }
463 aerr, ok := err.(awserr.Error)
464 if !ok {
465 t.Errorf("expect exception, got %T, %#v", err, err)
466 }
467 if e, a := expectErr.Code(), aerr.Code(); e != a {
468 t.Errorf("expect %v, got %v", e, a)
469 }
470 if e, a := expectErr.Message(), aerr.Message(); e != a {
471 t.Errorf("expect %v, got %v", e, a)
472 }
473
474 if e, a := expectErr, aerr; !reflect.DeepEqual(e, a) {
475 t.Errorf("expect error %+#v, got %+#v", e, a)
476 }
477 }
478
479 var _ awserr.Error = (*BadRequestException)(nil)
480 var _ awserr.Error = (*ConflictException)(nil)
481 var _ awserr.Error = (*InternalFailureException)(nil)
482 var _ awserr.Error = (*LimitExceededException)(nil)
483 var _ awserr.Error = (*ServiceUnavailableException)(nil)
484
485 func TestStartMedicalStreamTranscription_Read(t *testing.T) {
486 expectEvents, eventMsgs := mockStartMedicalStreamTranscriptionReadEvents()
487 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
488 eventstreamtest.ServeEventStream{
489 T: t,
490 Events: eventMsgs,
491 },
492 true,
493 )
494 if err != nil {
495 t.Fatalf("expect no error, %v", err)
496 }
497 defer cleanupFn()
498
499 svc := New(sess)
500 resp, err := svc.StartMedicalStreamTranscription(nil)
501 if err != nil {
502 t.Fatalf("expect no error got, %v", err)
503 }
504 defer resp.GetStream().Close()
505
506 var i int
507 for event := range resp.GetStream().Events() {
508 if event == nil {
509 t.Errorf("%d, expect event, got nil", i)
510 }
511 if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
512 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
513 }
514 i++
515 }
516
517 if err := resp.GetStream().Err(); err != nil {
518 t.Errorf("expect no error, %v", err)
519 }
520 }
521
522 func TestStartMedicalStreamTranscription_ReadClose(t *testing.T) {
523 _, eventMsgs := mockStartMedicalStreamTranscriptionReadEvents()
524 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
525 eventstreamtest.ServeEventStream{
526 T: t,
527 Events: eventMsgs,
528 },
529 true,
530 )
531 if err != nil {
532 t.Fatalf("expect no error, %v", err)
533 }
534 defer cleanupFn()
535
536 svc := New(sess)
537 resp, err := svc.StartMedicalStreamTranscription(nil)
538 if err != nil {
539 t.Fatalf("expect no error got, %v", err)
540 }
541
542 // Assert calling Err before close does not close the stream.
543 resp.GetStream().Err()
544 select {
545 case _, ok := <-resp.GetStream().Events():
546 if !ok {
547 t.Fatalf("expect stream not to be closed, but was")
548 }
549 default:
550 }
551
552 resp.GetStream().Close()
553 <-resp.GetStream().Events()
554
555 if err := resp.GetStream().Err(); err != nil {
556 t.Errorf("expect no error, %v", err)
557 }
558 }
559
560 func TestStartMedicalStreamTranscription_ReadUnknownEvent(t *testing.T) {
561 expectEvents, eventMsgs := mockStartMedicalStreamTranscriptionReadEvents()
562 var eventOffset int
563
564 unknownEvent := eventstream.Message{
565 Headers: eventstream.Headers{
566 eventstreamtest.EventMessageTypeHeader,
567 {
568 Name: eventstreamapi.EventTypeHeader,
569 Value: eventstream.StringValue("UnknownEventName"),
570 },
571 },
572 Payload: []byte("some unknown event"),
573 }
574
575 eventMsgs = append(eventMsgs[:eventOffset],
576 append([]eventstream.Message{unknownEvent}, eventMsgs[eventOffset:]...)...)
577
578 expectEvents = append(expectEvents[:eventOffset],
579 append([]MedicalTranscriptResultStreamEvent{
580 &MedicalTranscriptResultStreamUnknownEvent{
581 Type: "UnknownEventName",
582 Message: unknownEvent,
583 },
584 },
585 expectEvents[eventOffset:]...)...)
586
587 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
588 eventstreamtest.ServeEventStream{
589 T: t,
590 Events: eventMsgs,
591 },
592 true,
593 )
594 if err != nil {
595 t.Fatalf("expect no error, %v", err)
596 }
597 defer cleanupFn()
598
599 svc := New(sess)
600 resp, err := svc.StartMedicalStreamTranscription(nil)
601 if err != nil {
602 t.Fatalf("expect no error got, %v", err)
603 }
604 defer resp.GetStream().Close()
605
606 var i int
607 for event := range resp.GetStream().Events() {
608 if event == nil {
609 t.Errorf("%d, expect event, got nil", i)
610 }
611 if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
612 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
613 }
614 i++
615 }
616
617 if err := resp.GetStream().Err(); err != nil {
618 t.Errorf("expect no error, %v", err)
619 }
620 }
621
622 func BenchmarkStartMedicalStreamTranscription_Read(b *testing.B) {
623 _, eventMsgs := mockStartMedicalStreamTranscriptionReadEvents()
624 var buf bytes.Buffer
625 encoder := eventstream.NewEncoder(&buf)
626 for _, msg := range eventMsgs {
627 if err := encoder.Encode(msg); err != nil {
628 b.Fatalf("failed to encode message, %v", err)
629 }
630 }
631 stream := &loopReader{source: bytes.NewReader(buf.Bytes())}
632
633 sess := unit.Session
634 svc := New(sess, &aws.Config{
635 Endpoint: aws.String("https://example.com"),
636 DisableParamValidation: aws.Bool(true),
637 })
638 svc.Handlers.Send.Swap(corehandlers.SendHandler.Name,
639 request.NamedHandler{Name: "mockSend",
640 Fn: func(r *request.Request) {
641 r.HTTPResponse = &http.Response{
642 Status: "200 OK",
643 StatusCode: 200,
644 Header: http.Header{},
645 Body: ioutil.NopCloser(stream),
646 }
647 },
648 },
649 )
650
651 resp, err := svc.StartMedicalStreamTranscription(nil)
652 if err != nil {
653 b.Fatalf("failed to create request, %v", err)
654 }
655 defer resp.GetStream().Close()
656 b.ResetTimer()
657
658 for i := 0; i < b.N; i++ {
659 if err = resp.GetStream().Err(); err != nil {
660 b.Fatalf("expect no error, got %v", err)
661 }
662 event := <-resp.GetStream().Events()
663 if event == nil {
664 b.Fatalf("expect event, got nil, %v, %d", resp.GetStream().Err(), i)
665 }
666 }
667 }
668
669 func mockStartMedicalStreamTranscriptionReadEvents() (
670 []MedicalTranscriptResultStreamEvent,
671 []eventstream.Message,
672 ) {
673 expectEvents := []MedicalTranscriptResultStreamEvent{
674 &MedicalTranscriptEvent{
675 Transcript: &MedicalTranscript{
676 Results: []*MedicalResult{
677 {
678 Alternatives: []*MedicalAlternative{
679 {
680 Entities: []*MedicalEntity{
681 {
682 Category: aws.String("string value goes here"),
683 Confidence: aws.Float64(123.45),
684 Content: aws.String("string value goes here"),
685 EndTime: aws.Float64(123.45),
686 StartTime: aws.Float64(123.45),
687 },
688 {
689 Category: aws.String("string value goes here"),
690 Confidence: aws.Float64(123.45),
691 Content: aws.String("string value goes here"),
692 EndTime: aws.Float64(123.45),
693 StartTime: aws.Float64(123.45),
694 },
695 {
696 Category: aws.String("string value goes here"),
697 Confidence: aws.Float64(123.45),
698 Content: aws.String("string value goes here"),
699 EndTime: aws.Float64(123.45),
700 StartTime: aws.Float64(123.45),
701 },
702 },
703 Items: []*MedicalItem{
704 {
705 Confidence: aws.Float64(123.45),
706 Content: aws.String("string value goes here"),
707 EndTime: aws.Float64(123.45),
708 Speaker: aws.String("string value goes here"),
709 StartTime: aws.Float64(123.45),
710 Type: aws.String("string value goes here"),
711 },
712 {
713 Confidence: aws.Float64(123.45),
714 Content: aws.String("string value goes here"),
715 EndTime: aws.Float64(123.45),
716 Speaker: aws.String("string value goes here"),
717 StartTime: aws.Float64(123.45),
718 Type: aws.String("string value goes here"),
719 },
720 {
721 Confidence: aws.Float64(123.45),
722 Content: aws.String("string value goes here"),
723 EndTime: aws.Float64(123.45),
724 Speaker: aws.String("string value goes here"),
725 StartTime: aws.Float64(123.45),
726 Type: aws.String("string value goes here"),
727 },
728 },
729 Transcript: aws.String("string value goes here"),
730 },
731 {
732 Entities: []*MedicalEntity{
733 {
734 Category: aws.String("string value goes here"),
735 Confidence: aws.Float64(123.45),
736 Content: aws.String("string value goes here"),
737 EndTime: aws.Float64(123.45),
738 StartTime: aws.Float64(123.45),
739 },
740 {
741 Category: aws.String("string value goes here"),
742 Confidence: aws.Float64(123.45),
743 Content: aws.String("string value goes here"),
744 EndTime: aws.Float64(123.45),
745 StartTime: aws.Float64(123.45),
746 },
747 {
748 Category: aws.String("string value goes here"),
749 Confidence: aws.Float64(123.45),
750 Content: aws.String("string value goes here"),
751 EndTime: aws.Float64(123.45),
752 StartTime: aws.Float64(123.45),
753 },
754 },
755 Items: []*MedicalItem{
756 {
757 Confidence: aws.Float64(123.45),
758 Content: aws.String("string value goes here"),
759 EndTime: aws.Float64(123.45),
760 Speaker: aws.String("string value goes here"),
761 StartTime: aws.Float64(123.45),
762 Type: aws.String("string value goes here"),
763 },
764 {
765 Confidence: aws.Float64(123.45),
766 Content: aws.String("string value goes here"),
767 EndTime: aws.Float64(123.45),
768 Speaker: aws.String("string value goes here"),
769 StartTime: aws.Float64(123.45),
770 Type: aws.String("string value goes here"),
771 },
772 {
773 Confidence: aws.Float64(123.45),
774 Content: aws.String("string value goes here"),
775 EndTime: aws.Float64(123.45),
776 Speaker: aws.String("string value goes here"),
777 StartTime: aws.Float64(123.45),
778 Type: aws.String("string value goes here"),
779 },
780 },
781 Transcript: aws.String("string value goes here"),
782 },
783 {
784 Entities: []*MedicalEntity{
785 {
786 Category: aws.String("string value goes here"),
787 Confidence: aws.Float64(123.45),
788 Content: aws.String("string value goes here"),
789 EndTime: aws.Float64(123.45),
790 StartTime: aws.Float64(123.45),
791 },
792 {
793 Category: aws.String("string value goes here"),
794 Confidence: aws.Float64(123.45),
795 Content: aws.String("string value goes here"),
796 EndTime: aws.Float64(123.45),
797 StartTime: aws.Float64(123.45),
798 },
799 {
800 Category: aws.String("string value goes here"),
801 Confidence: aws.Float64(123.45),
802 Content: aws.String("string value goes here"),
803 EndTime: aws.Float64(123.45),
804 StartTime: aws.Float64(123.45),
805 },
806 },
807 Items: []*MedicalItem{
808 {
809 Confidence: aws.Float64(123.45),
810 Content: aws.String("string value goes here"),
811 EndTime: aws.Float64(123.45),
812 Speaker: aws.String("string value goes here"),
813 StartTime: aws.Float64(123.45),
814 Type: aws.String("string value goes here"),
815 },
816 {
817 Confidence: aws.Float64(123.45),
818 Content: aws.String("string value goes here"),
819 EndTime: aws.Float64(123.45),
820 Speaker: aws.String("string value goes here"),
821 StartTime: aws.Float64(123.45),
822 Type: aws.String("string value goes here"),
823 },
824 {
825 Confidence: aws.Float64(123.45),
826 Content: aws.String("string value goes here"),
827 EndTime: aws.Float64(123.45),
828 Speaker: aws.String("string value goes here"),
829 StartTime: aws.Float64(123.45),
830 Type: aws.String("string value goes here"),
831 },
832 },
833 Transcript: aws.String("string value goes here"),
834 },
835 },
836 ChannelId: aws.String("string value goes here"),
837 EndTime: aws.Float64(123.45),
838 IsPartial: aws.Bool(true),
839 ResultId: aws.String("string value goes here"),
840 StartTime: aws.Float64(123.45),
841 },
842 {
843 Alternatives: []*MedicalAlternative{
844 {
845 Entities: []*MedicalEntity{
846 {
847 Category: aws.String("string value goes here"),
848 Confidence: aws.Float64(123.45),
849 Content: aws.String("string value goes here"),
850 EndTime: aws.Float64(123.45),
851 StartTime: aws.Float64(123.45),
852 },
853 {
854 Category: aws.String("string value goes here"),
855 Confidence: aws.Float64(123.45),
856 Content: aws.String("string value goes here"),
857 EndTime: aws.Float64(123.45),
858 StartTime: aws.Float64(123.45),
859 },
860 {
861 Category: aws.String("string value goes here"),
862 Confidence: aws.Float64(123.45),
863 Content: aws.String("string value goes here"),
864 EndTime: aws.Float64(123.45),
865 StartTime: aws.Float64(123.45),
866 },
867 },
868 Items: []*MedicalItem{
869 {
870 Confidence: aws.Float64(123.45),
871 Content: aws.String("string value goes here"),
872 EndTime: aws.Float64(123.45),
873 Speaker: aws.String("string value goes here"),
874 StartTime: aws.Float64(123.45),
875 Type: aws.String("string value goes here"),
876 },
877 {
878 Confidence: aws.Float64(123.45),
879 Content: aws.String("string value goes here"),
880 EndTime: aws.Float64(123.45),
881 Speaker: aws.String("string value goes here"),
882 StartTime: aws.Float64(123.45),
883 Type: aws.String("string value goes here"),
884 },
885 {
886 Confidence: aws.Float64(123.45),
887 Content: aws.String("string value goes here"),
888 EndTime: aws.Float64(123.45),
889 Speaker: aws.String("string value goes here"),
890 StartTime: aws.Float64(123.45),
891 Type: aws.String("string value goes here"),
892 },
893 },
894 Transcript: aws.String("string value goes here"),
895 },
896 {
897 Entities: []*MedicalEntity{
898 {
899 Category: aws.String("string value goes here"),
900 Confidence: aws.Float64(123.45),
901 Content: aws.String("string value goes here"),
902 EndTime: aws.Float64(123.45),
903 StartTime: aws.Float64(123.45),
904 },
905 {
906 Category: aws.String("string value goes here"),
907 Confidence: aws.Float64(123.45),
908 Content: aws.String("string value goes here"),
909 EndTime: aws.Float64(123.45),
910 StartTime: aws.Float64(123.45),
911 },
912 {
913 Category: aws.String("string value goes here"),
914 Confidence: aws.Float64(123.45),
915 Content: aws.String("string value goes here"),
916 EndTime: aws.Float64(123.45),
917 StartTime: aws.Float64(123.45),
918 },
919 },
920 Items: []*MedicalItem{
921 {
922 Confidence: aws.Float64(123.45),
923 Content: aws.String("string value goes here"),
924 EndTime: aws.Float64(123.45),
925 Speaker: aws.String("string value goes here"),
926 StartTime: aws.Float64(123.45),
927 Type: aws.String("string value goes here"),
928 },
929 {
930 Confidence: aws.Float64(123.45),
931 Content: aws.String("string value goes here"),
932 EndTime: aws.Float64(123.45),
933 Speaker: aws.String("string value goes here"),
934 StartTime: aws.Float64(123.45),
935 Type: aws.String("string value goes here"),
936 },
937 {
938 Confidence: aws.Float64(123.45),
939 Content: aws.String("string value goes here"),
940 EndTime: aws.Float64(123.45),
941 Speaker: aws.String("string value goes here"),
942 StartTime: aws.Float64(123.45),
943 Type: aws.String("string value goes here"),
944 },
945 },
946 Transcript: aws.String("string value goes here"),
947 },
948 {
949 Entities: []*MedicalEntity{
950 {
951 Category: aws.String("string value goes here"),
952 Confidence: aws.Float64(123.45),
953 Content: aws.String("string value goes here"),
954 EndTime: aws.Float64(123.45),
955 StartTime: aws.Float64(123.45),
956 },
957 {
958 Category: aws.String("string value goes here"),
959 Confidence: aws.Float64(123.45),
960 Content: aws.String("string value goes here"),
961 EndTime: aws.Float64(123.45),
962 StartTime: aws.Float64(123.45),
963 },
964 {
965 Category: aws.String("string value goes here"),
966 Confidence: aws.Float64(123.45),
967 Content: aws.String("string value goes here"),
968 EndTime: aws.Float64(123.45),
969 StartTime: aws.Float64(123.45),
970 },
971 },
972 Items: []*MedicalItem{
973 {
974 Confidence: aws.Float64(123.45),
975 Content: aws.String("string value goes here"),
976 EndTime: aws.Float64(123.45),
977 Speaker: aws.String("string value goes here"),
978 StartTime: aws.Float64(123.45),
979 Type: aws.String("string value goes here"),
980 },
981 {
982 Confidence: aws.Float64(123.45),
983 Content: aws.String("string value goes here"),
984 EndTime: aws.Float64(123.45),
985 Speaker: aws.String("string value goes here"),
986 StartTime: aws.Float64(123.45),
987 Type: aws.String("string value goes here"),
988 },
989 {
990 Confidence: aws.Float64(123.45),
991 Content: aws.String("string value goes here"),
992 EndTime: aws.Float64(123.45),
993 Speaker: aws.String("string value goes here"),
994 StartTime: aws.Float64(123.45),
995 Type: aws.String("string value goes here"),
996 },
997 },
998 Transcript: aws.String("string value goes here"),
999 },
1000 },
1001 ChannelId: aws.String("string value goes here"),
1002 EndTime: aws.Float64(123.45),
1003 IsPartial: aws.Bool(true),
1004 ResultId: aws.String("string value goes here"),
1005 StartTime: aws.Float64(123.45),
1006 },
1007 {
1008 Alternatives: []*MedicalAlternative{
1009 {
1010 Entities: []*MedicalEntity{
1011 {
1012 Category: aws.String("string value goes here"),
1013 Confidence: aws.Float64(123.45),
1014 Content: aws.String("string value goes here"),
1015 EndTime: aws.Float64(123.45),
1016 StartTime: aws.Float64(123.45),
1017 },
1018 {
1019 Category: aws.String("string value goes here"),
1020 Confidence: aws.Float64(123.45),
1021 Content: aws.String("string value goes here"),
1022 EndTime: aws.Float64(123.45),
1023 StartTime: aws.Float64(123.45),
1024 },
1025 {
1026 Category: aws.String("string value goes here"),
1027 Confidence: aws.Float64(123.45),
1028 Content: aws.String("string value goes here"),
1029 EndTime: aws.Float64(123.45),
1030 StartTime: aws.Float64(123.45),
1031 },
1032 },
1033 Items: []*MedicalItem{
1034 {
1035 Confidence: aws.Float64(123.45),
1036 Content: aws.String("string value goes here"),
1037 EndTime: aws.Float64(123.45),
1038 Speaker: aws.String("string value goes here"),
1039 StartTime: aws.Float64(123.45),
1040 Type: aws.String("string value goes here"),
1041 },
1042 {
1043 Confidence: aws.Float64(123.45),
1044 Content: aws.String("string value goes here"),
1045 EndTime: aws.Float64(123.45),
1046 Speaker: aws.String("string value goes here"),
1047 StartTime: aws.Float64(123.45),
1048 Type: aws.String("string value goes here"),
1049 },
1050 {
1051 Confidence: aws.Float64(123.45),
1052 Content: aws.String("string value goes here"),
1053 EndTime: aws.Float64(123.45),
1054 Speaker: aws.String("string value goes here"),
1055 StartTime: aws.Float64(123.45),
1056 Type: aws.String("string value goes here"),
1057 },
1058 },
1059 Transcript: aws.String("string value goes here"),
1060 },
1061 {
1062 Entities: []*MedicalEntity{
1063 {
1064 Category: aws.String("string value goes here"),
1065 Confidence: aws.Float64(123.45),
1066 Content: aws.String("string value goes here"),
1067 EndTime: aws.Float64(123.45),
1068 StartTime: aws.Float64(123.45),
1069 },
1070 {
1071 Category: aws.String("string value goes here"),
1072 Confidence: aws.Float64(123.45),
1073 Content: aws.String("string value goes here"),
1074 EndTime: aws.Float64(123.45),
1075 StartTime: aws.Float64(123.45),
1076 },
1077 {
1078 Category: aws.String("string value goes here"),
1079 Confidence: aws.Float64(123.45),
1080 Content: aws.String("string value goes here"),
1081 EndTime: aws.Float64(123.45),
1082 StartTime: aws.Float64(123.45),
1083 },
1084 },
1085 Items: []*MedicalItem{
1086 {
1087 Confidence: aws.Float64(123.45),
1088 Content: aws.String("string value goes here"),
1089 EndTime: aws.Float64(123.45),
1090 Speaker: aws.String("string value goes here"),
1091 StartTime: aws.Float64(123.45),
1092 Type: aws.String("string value goes here"),
1093 },
1094 {
1095 Confidence: aws.Float64(123.45),
1096 Content: aws.String("string value goes here"),
1097 EndTime: aws.Float64(123.45),
1098 Speaker: aws.String("string value goes here"),
1099 StartTime: aws.Float64(123.45),
1100 Type: aws.String("string value goes here"),
1101 },
1102 {
1103 Confidence: aws.Float64(123.45),
1104 Content: aws.String("string value goes here"),
1105 EndTime: aws.Float64(123.45),
1106 Speaker: aws.String("string value goes here"),
1107 StartTime: aws.Float64(123.45),
1108 Type: aws.String("string value goes here"),
1109 },
1110 },
1111 Transcript: aws.String("string value goes here"),
1112 },
1113 {
1114 Entities: []*MedicalEntity{
1115 {
1116 Category: aws.String("string value goes here"),
1117 Confidence: aws.Float64(123.45),
1118 Content: aws.String("string value goes here"),
1119 EndTime: aws.Float64(123.45),
1120 StartTime: aws.Float64(123.45),
1121 },
1122 {
1123 Category: aws.String("string value goes here"),
1124 Confidence: aws.Float64(123.45),
1125 Content: aws.String("string value goes here"),
1126 EndTime: aws.Float64(123.45),
1127 StartTime: aws.Float64(123.45),
1128 },
1129 {
1130 Category: aws.String("string value goes here"),
1131 Confidence: aws.Float64(123.45),
1132 Content: aws.String("string value goes here"),
1133 EndTime: aws.Float64(123.45),
1134 StartTime: aws.Float64(123.45),
1135 },
1136 },
1137 Items: []*MedicalItem{
1138 {
1139 Confidence: aws.Float64(123.45),
1140 Content: aws.String("string value goes here"),
1141 EndTime: aws.Float64(123.45),
1142 Speaker: aws.String("string value goes here"),
1143 StartTime: aws.Float64(123.45),
1144 Type: aws.String("string value goes here"),
1145 },
1146 {
1147 Confidence: aws.Float64(123.45),
1148 Content: aws.String("string value goes here"),
1149 EndTime: aws.Float64(123.45),
1150 Speaker: aws.String("string value goes here"),
1151 StartTime: aws.Float64(123.45),
1152 Type: aws.String("string value goes here"),
1153 },
1154 {
1155 Confidence: aws.Float64(123.45),
1156 Content: aws.String("string value goes here"),
1157 EndTime: aws.Float64(123.45),
1158 Speaker: aws.String("string value goes here"),
1159 StartTime: aws.Float64(123.45),
1160 Type: aws.String("string value goes here"),
1161 },
1162 },
1163 Transcript: aws.String("string value goes here"),
1164 },
1165 },
1166 ChannelId: aws.String("string value goes here"),
1167 EndTime: aws.Float64(123.45),
1168 IsPartial: aws.Bool(true),
1169 ResultId: aws.String("string value goes here"),
1170 StartTime: aws.Float64(123.45),
1171 },
1172 },
1173 },
1174 },
1175 }
1176
1177 var marshalers request.HandlerList
1178 marshalers.PushBackNamed(restjson.BuildHandler)
1179 payloadMarshaler := protocol.HandlerPayloadMarshal{
1180 Marshalers: marshalers,
1181 }
1182 _ = payloadMarshaler
1183
1184 eventMsgs := []eventstream.Message{
1185 {
1186 Headers: eventstream.Headers{
1187 eventstreamtest.EventMessageTypeHeader,
1188 {
1189 Name: eventstreamapi.EventTypeHeader,
1190 Value: eventstream.StringValue("TranscriptEvent"),
1191 },
1192 },
1193 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
1194 },
1195 }
1196
1197 return expectEvents, eventMsgs
1198 }
1199 func TestStartMedicalStreamTranscription_ReadException(t *testing.T) {
1200 expectEvents := []MedicalTranscriptResultStreamEvent{
1201 &BadRequestException{
1202 RespMetadata: protocol.ResponseMetadata{
1203 StatusCode: 200,
1204 },
1205 Message_: aws.String("string value goes here"),
1206 },
1207 }
1208
1209 var marshalers request.HandlerList
1210 marshalers.PushBackNamed(restjson.BuildHandler)
1211 payloadMarshaler := protocol.HandlerPayloadMarshal{
1212 Marshalers: marshalers,
1213 }
1214
1215 eventMsgs := []eventstream.Message{
1216 {
1217 Headers: eventstream.Headers{
1218 eventstreamtest.EventExceptionTypeHeader,
1219 {
1220 Name: eventstreamapi.ExceptionTypeHeader,
1221 Value: eventstream.StringValue("BadRequestException"),
1222 },
1223 },
1224 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
1225 },
1226 }
1227
1228 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
1229 eventstreamtest.ServeEventStream{
1230 T: t,
1231 Events: eventMsgs,
1232 },
1233 true,
1234 )
1235 if err != nil {
1236 t.Fatalf("expect no error, %v", err)
1237 }
1238 defer cleanupFn()
1239
1240 svc := New(sess)
1241 resp, err := svc.StartMedicalStreamTranscription(nil)
1242 if err != nil {
1243 t.Fatalf("expect no error got, %v", err)
1244 }
1245
1246 defer resp.GetStream().Close()
1247
1248 <-resp.GetStream().Events()
1249
1250 err = resp.GetStream().Err()
1251 if err == nil {
1252 t.Fatalf("expect err, got none")
1253 }
1254
1255 expectErr := &BadRequestException{
1256 RespMetadata: protocol.ResponseMetadata{
1257 StatusCode: 200,
1258 },
1259 Message_: aws.String("string value goes here"),
1260 }
1261 aerr, ok := err.(awserr.Error)
1262 if !ok {
1263 t.Errorf("expect exception, got %T, %#v", err, err)
1264 }
1265 if e, a := expectErr.Code(), aerr.Code(); e != a {
1266 t.Errorf("expect %v, got %v", e, a)
1267 }
1268 if e, a := expectErr.Message(), aerr.Message(); e != a {
1269 t.Errorf("expect %v, got %v", e, a)
1270 }
1271
1272 if e, a := expectErr, aerr; !reflect.DeepEqual(e, a) {
1273 t.Errorf("expect error %+#v, got %+#v", e, a)
1274 }
1275 }
1276
1277 var _ awserr.Error = (*BadRequestException)(nil)
1278 var _ awserr.Error = (*ConflictException)(nil)
1279 var _ awserr.Error = (*InternalFailureException)(nil)
1280 var _ awserr.Error = (*LimitExceededException)(nil)
1281 var _ awserr.Error = (*ServiceUnavailableException)(nil)
1282
1283 func TestStartStreamTranscription_Read(t *testing.T) {
1284 expectEvents, eventMsgs := mockStartStreamTranscriptionReadEvents()
1285 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
1286 eventstreamtest.ServeEventStream{
1287 T: t,
1288 Events: eventMsgs,
1289 },
1290 true,
1291 )
1292 if err != nil {
1293 t.Fatalf("expect no error, %v", err)
1294 }
1295 defer cleanupFn()
1296
1297 svc := New(sess)
1298 resp, err := svc.StartStreamTranscription(nil)
1299 if err != nil {
1300 t.Fatalf("expect no error got, %v", err)
1301 }
1302 defer resp.GetStream().Close()
1303
1304 var i int
1305 for event := range resp.GetStream().Events() {
1306 if event == nil {
1307 t.Errorf("%d, expect event, got nil", i)
1308 }
1309 if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
1310 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
1311 }
1312 i++
1313 }
1314
1315 if err := resp.GetStream().Err(); err != nil {
1316 t.Errorf("expect no error, %v", err)
1317 }
1318 }
1319
1320 func TestStartStreamTranscription_ReadClose(t *testing.T) {
1321 _, eventMsgs := mockStartStreamTranscriptionReadEvents()
1322 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
1323 eventstreamtest.ServeEventStream{
1324 T: t,
1325 Events: eventMsgs,
1326 },
1327 true,
1328 )
1329 if err != nil {
1330 t.Fatalf("expect no error, %v", err)
1331 }
1332 defer cleanupFn()
1333
1334 svc := New(sess)
1335 resp, err := svc.StartStreamTranscription(nil)
1336 if err != nil {
1337 t.Fatalf("expect no error got, %v", err)
1338 }
1339
1340 // Assert calling Err before close does not close the stream.
1341 resp.GetStream().Err()
1342 select {
1343 case _, ok := <-resp.GetStream().Events():
1344 if !ok {
1345 t.Fatalf("expect stream not to be closed, but was")
1346 }
1347 default:
1348 }
1349
1350 resp.GetStream().Close()
1351 <-resp.GetStream().Events()
1352
1353 if err := resp.GetStream().Err(); err != nil {
1354 t.Errorf("expect no error, %v", err)
1355 }
1356 }
1357
1358 func TestStartStreamTranscription_ReadUnknownEvent(t *testing.T) {
1359 expectEvents, eventMsgs := mockStartStreamTranscriptionReadEvents()
1360 var eventOffset int
1361
1362 unknownEvent := eventstream.Message{
1363 Headers: eventstream.Headers{
1364 eventstreamtest.EventMessageTypeHeader,
1365 {
1366 Name: eventstreamapi.EventTypeHeader,
1367 Value: eventstream.StringValue("UnknownEventName"),
1368 },
1369 },
1370 Payload: []byte("some unknown event"),
1371 }
1372
1373 eventMsgs = append(eventMsgs[:eventOffset],
1374 append([]eventstream.Message{unknownEvent}, eventMsgs[eventOffset:]...)...)
1375
1376 expectEvents = append(expectEvents[:eventOffset],
1377 append([]TranscriptResultStreamEvent{
1378 &TranscriptResultStreamUnknownEvent{
1379 Type: "UnknownEventName",
1380 Message: unknownEvent,
1381 },
1382 },
1383 expectEvents[eventOffset:]...)...)
1384
1385 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
1386 eventstreamtest.ServeEventStream{
1387 T: t,
1388 Events: eventMsgs,
1389 },
1390 true,
1391 )
1392 if err != nil {
1393 t.Fatalf("expect no error, %v", err)
1394 }
1395 defer cleanupFn()
1396
1397 svc := New(sess)
1398 resp, err := svc.StartStreamTranscription(nil)
1399 if err != nil {
1400 t.Fatalf("expect no error got, %v", err)
1401 }
1402 defer resp.GetStream().Close()
1403
1404 var i int
1405 for event := range resp.GetStream().Events() {
1406 if event == nil {
1407 t.Errorf("%d, expect event, got nil", i)
1408 }
1409 if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
1410 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
1411 }
1412 i++
1413 }
1414
1415 if err := resp.GetStream().Err(); err != nil {
1416 t.Errorf("expect no error, %v", err)
1417 }
1418 }
1419
1420 func BenchmarkStartStreamTranscription_Read(b *testing.B) {
1421 _, eventMsgs := mockStartStreamTranscriptionReadEvents()
1422 var buf bytes.Buffer
1423 encoder := eventstream.NewEncoder(&buf)
1424 for _, msg := range eventMsgs {
1425 if err := encoder.Encode(msg); err != nil {
1426 b.Fatalf("failed to encode message, %v", err)
1427 }
1428 }
1429 stream := &loopReader{source: bytes.NewReader(buf.Bytes())}
1430
1431 sess := unit.Session
1432 svc := New(sess, &aws.Config{
1433 Endpoint: aws.String("https://example.com"),
1434 DisableParamValidation: aws.Bool(true),
1435 })
1436 svc.Handlers.Send.Swap(corehandlers.SendHandler.Name,
1437 request.NamedHandler{Name: "mockSend",
1438 Fn: func(r *request.Request) {
1439 r.HTTPResponse = &http.Response{
1440 Status: "200 OK",
1441 StatusCode: 200,
1442 Header: http.Header{},
1443 Body: ioutil.NopCloser(stream),
1444 }
1445 },
1446 },
1447 )
1448
1449 resp, err := svc.StartStreamTranscription(nil)
1450 if err != nil {
1451 b.Fatalf("failed to create request, %v", err)
1452 }
1453 defer resp.GetStream().Close()
1454 b.ResetTimer()
1455
1456 for i := 0; i < b.N; i++ {
1457 if err = resp.GetStream().Err(); err != nil {
1458 b.Fatalf("expect no error, got %v", err)
1459 }
1460 event := <-resp.GetStream().Events()
1461 if event == nil {
1462 b.Fatalf("expect event, got nil, %v, %d", resp.GetStream().Err(), i)
1463 }
1464 }
1465 }
1466
1467 func mockStartStreamTranscriptionReadEvents() (
1468 []TranscriptResultStreamEvent,
1469 []eventstream.Message,
1470 ) {
1471 expectEvents := []TranscriptResultStreamEvent{
1472 &TranscriptEvent{
1473 Transcript: &Transcript{
1474 Results: []*Result{
1475 {
1476 Alternatives: []*Alternative{
1477 {
1478 Entities: []*Entity{
1479 {
1480 Category: aws.String("string value goes here"),
1481 Confidence: aws.Float64(123.45),
1482 Content: aws.String("string value goes here"),
1483 EndTime: aws.Float64(123.45),
1484 StartTime: aws.Float64(123.45),
1485 Type: aws.String("string value goes here"),
1486 },
1487 {
1488 Category: aws.String("string value goes here"),
1489 Confidence: aws.Float64(123.45),
1490 Content: aws.String("string value goes here"),
1491 EndTime: aws.Float64(123.45),
1492 StartTime: aws.Float64(123.45),
1493 Type: aws.String("string value goes here"),
1494 },
1495 {
1496 Category: aws.String("string value goes here"),
1497 Confidence: aws.Float64(123.45),
1498 Content: aws.String("string value goes here"),
1499 EndTime: aws.Float64(123.45),
1500 StartTime: aws.Float64(123.45),
1501 Type: aws.String("string value goes here"),
1502 },
1503 },
1504 Items: []*Item{
1505 {
1506 Confidence: aws.Float64(123.45),
1507 Content: aws.String("string value goes here"),
1508 EndTime: aws.Float64(123.45),
1509 Speaker: aws.String("string value goes here"),
1510 Stable: aws.Bool(true),
1511 StartTime: aws.Float64(123.45),
1512 Type: aws.String("string value goes here"),
1513 VocabularyFilterMatch: aws.Bool(true),
1514 },
1515 {
1516 Confidence: aws.Float64(123.45),
1517 Content: aws.String("string value goes here"),
1518 EndTime: aws.Float64(123.45),
1519 Speaker: aws.String("string value goes here"),
1520 Stable: aws.Bool(true),
1521 StartTime: aws.Float64(123.45),
1522 Type: aws.String("string value goes here"),
1523 VocabularyFilterMatch: aws.Bool(true),
1524 },
1525 {
1526 Confidence: aws.Float64(123.45),
1527 Content: aws.String("string value goes here"),
1528 EndTime: aws.Float64(123.45),
1529 Speaker: aws.String("string value goes here"),
1530 Stable: aws.Bool(true),
1531 StartTime: aws.Float64(123.45),
1532 Type: aws.String("string value goes here"),
1533 VocabularyFilterMatch: aws.Bool(true),
1534 },
1535 },
1536 Transcript: aws.String("string value goes here"),
1537 },
1538 {
1539 Entities: []*Entity{
1540 {
1541 Category: aws.String("string value goes here"),
1542 Confidence: aws.Float64(123.45),
1543 Content: aws.String("string value goes here"),
1544 EndTime: aws.Float64(123.45),
1545 StartTime: aws.Float64(123.45),
1546 Type: aws.String("string value goes here"),
1547 },
1548 {
1549 Category: aws.String("string value goes here"),
1550 Confidence: aws.Float64(123.45),
1551 Content: aws.String("string value goes here"),
1552 EndTime: aws.Float64(123.45),
1553 StartTime: aws.Float64(123.45),
1554 Type: aws.String("string value goes here"),
1555 },
1556 {
1557 Category: aws.String("string value goes here"),
1558 Confidence: aws.Float64(123.45),
1559 Content: aws.String("string value goes here"),
1560 EndTime: aws.Float64(123.45),
1561 StartTime: aws.Float64(123.45),
1562 Type: aws.String("string value goes here"),
1563 },
1564 },
1565 Items: []*Item{
1566 {
1567 Confidence: aws.Float64(123.45),
1568 Content: aws.String("string value goes here"),
1569 EndTime: aws.Float64(123.45),
1570 Speaker: aws.String("string value goes here"),
1571 Stable: aws.Bool(true),
1572 StartTime: aws.Float64(123.45),
1573 Type: aws.String("string value goes here"),
1574 VocabularyFilterMatch: aws.Bool(true),
1575 },
1576 {
1577 Confidence: aws.Float64(123.45),
1578 Content: aws.String("string value goes here"),
1579 EndTime: aws.Float64(123.45),
1580 Speaker: aws.String("string value goes here"),
1581 Stable: aws.Bool(true),
1582 StartTime: aws.Float64(123.45),
1583 Type: aws.String("string value goes here"),
1584 VocabularyFilterMatch: aws.Bool(true),
1585 },
1586 {
1587 Confidence: aws.Float64(123.45),
1588 Content: aws.String("string value goes here"),
1589 EndTime: aws.Float64(123.45),
1590 Speaker: aws.String("string value goes here"),
1591 Stable: aws.Bool(true),
1592 StartTime: aws.Float64(123.45),
1593 Type: aws.String("string value goes here"),
1594 VocabularyFilterMatch: aws.Bool(true),
1595 },
1596 },
1597 Transcript: aws.String("string value goes here"),
1598 },
1599 {
1600 Entities: []*Entity{
1601 {
1602 Category: aws.String("string value goes here"),
1603 Confidence: aws.Float64(123.45),
1604 Content: aws.String("string value goes here"),
1605 EndTime: aws.Float64(123.45),
1606 StartTime: aws.Float64(123.45),
1607 Type: aws.String("string value goes here"),
1608 },
1609 {
1610 Category: aws.String("string value goes here"),
1611 Confidence: aws.Float64(123.45),
1612 Content: aws.String("string value goes here"),
1613 EndTime: aws.Float64(123.45),
1614 StartTime: aws.Float64(123.45),
1615 Type: aws.String("string value goes here"),
1616 },
1617 {
1618 Category: aws.String("string value goes here"),
1619 Confidence: aws.Float64(123.45),
1620 Content: aws.String("string value goes here"),
1621 EndTime: aws.Float64(123.45),
1622 StartTime: aws.Float64(123.45),
1623 Type: aws.String("string value goes here"),
1624 },
1625 },
1626 Items: []*Item{
1627 {
1628 Confidence: aws.Float64(123.45),
1629 Content: aws.String("string value goes here"),
1630 EndTime: aws.Float64(123.45),
1631 Speaker: aws.String("string value goes here"),
1632 Stable: aws.Bool(true),
1633 StartTime: aws.Float64(123.45),
1634 Type: aws.String("string value goes here"),
1635 VocabularyFilterMatch: aws.Bool(true),
1636 },
1637 {
1638 Confidence: aws.Float64(123.45),
1639 Content: aws.String("string value goes here"),
1640 EndTime: aws.Float64(123.45),
1641 Speaker: aws.String("string value goes here"),
1642 Stable: aws.Bool(true),
1643 StartTime: aws.Float64(123.45),
1644 Type: aws.String("string value goes here"),
1645 VocabularyFilterMatch: aws.Bool(true),
1646 },
1647 {
1648 Confidence: aws.Float64(123.45),
1649 Content: aws.String("string value goes here"),
1650 EndTime: aws.Float64(123.45),
1651 Speaker: aws.String("string value goes here"),
1652 Stable: aws.Bool(true),
1653 StartTime: aws.Float64(123.45),
1654 Type: aws.String("string value goes here"),
1655 VocabularyFilterMatch: aws.Bool(true),
1656 },
1657 },
1658 Transcript: aws.String("string value goes here"),
1659 },
1660 },
1661 ChannelId: aws.String("string value goes here"),
1662 EndTime: aws.Float64(123.45),
1663 IsPartial: aws.Bool(true),
1664 LanguageCode: aws.String("string value goes here"),
1665 LanguageIdentification: []*LanguageWithScore{
1666 {
1667 LanguageCode: aws.String("string value goes here"),
1668 Score: aws.Float64(123.45),
1669 },
1670 {
1671 LanguageCode: aws.String("string value goes here"),
1672 Score: aws.Float64(123.45),
1673 },
1674 {
1675 LanguageCode: aws.String("string value goes here"),
1676 Score: aws.Float64(123.45),
1677 },
1678 },
1679 ResultId: aws.String("string value goes here"),
1680 StartTime: aws.Float64(123.45),
1681 },
1682 {
1683 Alternatives: []*Alternative{
1684 {
1685 Entities: []*Entity{
1686 {
1687 Category: aws.String("string value goes here"),
1688 Confidence: aws.Float64(123.45),
1689 Content: aws.String("string value goes here"),
1690 EndTime: aws.Float64(123.45),
1691 StartTime: aws.Float64(123.45),
1692 Type: aws.String("string value goes here"),
1693 },
1694 {
1695 Category: aws.String("string value goes here"),
1696 Confidence: aws.Float64(123.45),
1697 Content: aws.String("string value goes here"),
1698 EndTime: aws.Float64(123.45),
1699 StartTime: aws.Float64(123.45),
1700 Type: aws.String("string value goes here"),
1701 },
1702 {
1703 Category: aws.String("string value goes here"),
1704 Confidence: aws.Float64(123.45),
1705 Content: aws.String("string value goes here"),
1706 EndTime: aws.Float64(123.45),
1707 StartTime: aws.Float64(123.45),
1708 Type: aws.String("string value goes here"),
1709 },
1710 },
1711 Items: []*Item{
1712 {
1713 Confidence: aws.Float64(123.45),
1714 Content: aws.String("string value goes here"),
1715 EndTime: aws.Float64(123.45),
1716 Speaker: aws.String("string value goes here"),
1717 Stable: aws.Bool(true),
1718 StartTime: aws.Float64(123.45),
1719 Type: aws.String("string value goes here"),
1720 VocabularyFilterMatch: aws.Bool(true),
1721 },
1722 {
1723 Confidence: aws.Float64(123.45),
1724 Content: aws.String("string value goes here"),
1725 EndTime: aws.Float64(123.45),
1726 Speaker: aws.String("string value goes here"),
1727 Stable: aws.Bool(true),
1728 StartTime: aws.Float64(123.45),
1729 Type: aws.String("string value goes here"),
1730 VocabularyFilterMatch: aws.Bool(true),
1731 },
1732 {
1733 Confidence: aws.Float64(123.45),
1734 Content: aws.String("string value goes here"),
1735 EndTime: aws.Float64(123.45),
1736 Speaker: aws.String("string value goes here"),
1737 Stable: aws.Bool(true),
1738 StartTime: aws.Float64(123.45),
1739 Type: aws.String("string value goes here"),
1740 VocabularyFilterMatch: aws.Bool(true),
1741 },
1742 },
1743 Transcript: aws.String("string value goes here"),
1744 },
1745 {
1746 Entities: []*Entity{
1747 {
1748 Category: aws.String("string value goes here"),
1749 Confidence: aws.Float64(123.45),
1750 Content: aws.String("string value goes here"),
1751 EndTime: aws.Float64(123.45),
1752 StartTime: aws.Float64(123.45),
1753 Type: aws.String("string value goes here"),
1754 },
1755 {
1756 Category: aws.String("string value goes here"),
1757 Confidence: aws.Float64(123.45),
1758 Content: aws.String("string value goes here"),
1759 EndTime: aws.Float64(123.45),
1760 StartTime: aws.Float64(123.45),
1761 Type: aws.String("string value goes here"),
1762 },
1763 {
1764 Category: aws.String("string value goes here"),
1765 Confidence: aws.Float64(123.45),
1766 Content: aws.String("string value goes here"),
1767 EndTime: aws.Float64(123.45),
1768 StartTime: aws.Float64(123.45),
1769 Type: aws.String("string value goes here"),
1770 },
1771 },
1772 Items: []*Item{
1773 {
1774 Confidence: aws.Float64(123.45),
1775 Content: aws.String("string value goes here"),
1776 EndTime: aws.Float64(123.45),
1777 Speaker: aws.String("string value goes here"),
1778 Stable: aws.Bool(true),
1779 StartTime: aws.Float64(123.45),
1780 Type: aws.String("string value goes here"),
1781 VocabularyFilterMatch: aws.Bool(true),
1782 },
1783 {
1784 Confidence: aws.Float64(123.45),
1785 Content: aws.String("string value goes here"),
1786 EndTime: aws.Float64(123.45),
1787 Speaker: aws.String("string value goes here"),
1788 Stable: aws.Bool(true),
1789 StartTime: aws.Float64(123.45),
1790 Type: aws.String("string value goes here"),
1791 VocabularyFilterMatch: aws.Bool(true),
1792 },
1793 {
1794 Confidence: aws.Float64(123.45),
1795 Content: aws.String("string value goes here"),
1796 EndTime: aws.Float64(123.45),
1797 Speaker: aws.String("string value goes here"),
1798 Stable: aws.Bool(true),
1799 StartTime: aws.Float64(123.45),
1800 Type: aws.String("string value goes here"),
1801 VocabularyFilterMatch: aws.Bool(true),
1802 },
1803 },
1804 Transcript: aws.String("string value goes here"),
1805 },
1806 {
1807 Entities: []*Entity{
1808 {
1809 Category: aws.String("string value goes here"),
1810 Confidence: aws.Float64(123.45),
1811 Content: aws.String("string value goes here"),
1812 EndTime: aws.Float64(123.45),
1813 StartTime: aws.Float64(123.45),
1814 Type: aws.String("string value goes here"),
1815 },
1816 {
1817 Category: aws.String("string value goes here"),
1818 Confidence: aws.Float64(123.45),
1819 Content: aws.String("string value goes here"),
1820 EndTime: aws.Float64(123.45),
1821 StartTime: aws.Float64(123.45),
1822 Type: aws.String("string value goes here"),
1823 },
1824 {
1825 Category: aws.String("string value goes here"),
1826 Confidence: aws.Float64(123.45),
1827 Content: aws.String("string value goes here"),
1828 EndTime: aws.Float64(123.45),
1829 StartTime: aws.Float64(123.45),
1830 Type: aws.String("string value goes here"),
1831 },
1832 },
1833 Items: []*Item{
1834 {
1835 Confidence: aws.Float64(123.45),
1836 Content: aws.String("string value goes here"),
1837 EndTime: aws.Float64(123.45),
1838 Speaker: aws.String("string value goes here"),
1839 Stable: aws.Bool(true),
1840 StartTime: aws.Float64(123.45),
1841 Type: aws.String("string value goes here"),
1842 VocabularyFilterMatch: aws.Bool(true),
1843 },
1844 {
1845 Confidence: aws.Float64(123.45),
1846 Content: aws.String("string value goes here"),
1847 EndTime: aws.Float64(123.45),
1848 Speaker: aws.String("string value goes here"),
1849 Stable: aws.Bool(true),
1850 StartTime: aws.Float64(123.45),
1851 Type: aws.String("string value goes here"),
1852 VocabularyFilterMatch: aws.Bool(true),
1853 },
1854 {
1855 Confidence: aws.Float64(123.45),
1856 Content: aws.String("string value goes here"),
1857 EndTime: aws.Float64(123.45),
1858 Speaker: aws.String("string value goes here"),
1859 Stable: aws.Bool(true),
1860 StartTime: aws.Float64(123.45),
1861 Type: aws.String("string value goes here"),
1862 VocabularyFilterMatch: aws.Bool(true),
1863 },
1864 },
1865 Transcript: aws.String("string value goes here"),
1866 },
1867 },
1868 ChannelId: aws.String("string value goes here"),
1869 EndTime: aws.Float64(123.45),
1870 IsPartial: aws.Bool(true),
1871 LanguageCode: aws.String("string value goes here"),
1872 LanguageIdentification: []*LanguageWithScore{
1873 {
1874 LanguageCode: aws.String("string value goes here"),
1875 Score: aws.Float64(123.45),
1876 },
1877 {
1878 LanguageCode: aws.String("string value goes here"),
1879 Score: aws.Float64(123.45),
1880 },
1881 {
1882 LanguageCode: aws.String("string value goes here"),
1883 Score: aws.Float64(123.45),
1884 },
1885 },
1886 ResultId: aws.String("string value goes here"),
1887 StartTime: aws.Float64(123.45),
1888 },
1889 {
1890 Alternatives: []*Alternative{
1891 {
1892 Entities: []*Entity{
1893 {
1894 Category: aws.String("string value goes here"),
1895 Confidence: aws.Float64(123.45),
1896 Content: aws.String("string value goes here"),
1897 EndTime: aws.Float64(123.45),
1898 StartTime: aws.Float64(123.45),
1899 Type: aws.String("string value goes here"),
1900 },
1901 {
1902 Category: aws.String("string value goes here"),
1903 Confidence: aws.Float64(123.45),
1904 Content: aws.String("string value goes here"),
1905 EndTime: aws.Float64(123.45),
1906 StartTime: aws.Float64(123.45),
1907 Type: aws.String("string value goes here"),
1908 },
1909 {
1910 Category: aws.String("string value goes here"),
1911 Confidence: aws.Float64(123.45),
1912 Content: aws.String("string value goes here"),
1913 EndTime: aws.Float64(123.45),
1914 StartTime: aws.Float64(123.45),
1915 Type: aws.String("string value goes here"),
1916 },
1917 },
1918 Items: []*Item{
1919 {
1920 Confidence: aws.Float64(123.45),
1921 Content: aws.String("string value goes here"),
1922 EndTime: aws.Float64(123.45),
1923 Speaker: aws.String("string value goes here"),
1924 Stable: aws.Bool(true),
1925 StartTime: aws.Float64(123.45),
1926 Type: aws.String("string value goes here"),
1927 VocabularyFilterMatch: aws.Bool(true),
1928 },
1929 {
1930 Confidence: aws.Float64(123.45),
1931 Content: aws.String("string value goes here"),
1932 EndTime: aws.Float64(123.45),
1933 Speaker: aws.String("string value goes here"),
1934 Stable: aws.Bool(true),
1935 StartTime: aws.Float64(123.45),
1936 Type: aws.String("string value goes here"),
1937 VocabularyFilterMatch: aws.Bool(true),
1938 },
1939 {
1940 Confidence: aws.Float64(123.45),
1941 Content: aws.String("string value goes here"),
1942 EndTime: aws.Float64(123.45),
1943 Speaker: aws.String("string value goes here"),
1944 Stable: aws.Bool(true),
1945 StartTime: aws.Float64(123.45),
1946 Type: aws.String("string value goes here"),
1947 VocabularyFilterMatch: aws.Bool(true),
1948 },
1949 },
1950 Transcript: aws.String("string value goes here"),
1951 },
1952 {
1953 Entities: []*Entity{
1954 {
1955 Category: aws.String("string value goes here"),
1956 Confidence: aws.Float64(123.45),
1957 Content: aws.String("string value goes here"),
1958 EndTime: aws.Float64(123.45),
1959 StartTime: aws.Float64(123.45),
1960 Type: aws.String("string value goes here"),
1961 },
1962 {
1963 Category: aws.String("string value goes here"),
1964 Confidence: aws.Float64(123.45),
1965 Content: aws.String("string value goes here"),
1966 EndTime: aws.Float64(123.45),
1967 StartTime: aws.Float64(123.45),
1968 Type: aws.String("string value goes here"),
1969 },
1970 {
1971 Category: aws.String("string value goes here"),
1972 Confidence: aws.Float64(123.45),
1973 Content: aws.String("string value goes here"),
1974 EndTime: aws.Float64(123.45),
1975 StartTime: aws.Float64(123.45),
1976 Type: aws.String("string value goes here"),
1977 },
1978 },
1979 Items: []*Item{
1980 {
1981 Confidence: aws.Float64(123.45),
1982 Content: aws.String("string value goes here"),
1983 EndTime: aws.Float64(123.45),
1984 Speaker: aws.String("string value goes here"),
1985 Stable: aws.Bool(true),
1986 StartTime: aws.Float64(123.45),
1987 Type: aws.String("string value goes here"),
1988 VocabularyFilterMatch: aws.Bool(true),
1989 },
1990 {
1991 Confidence: aws.Float64(123.45),
1992 Content: aws.String("string value goes here"),
1993 EndTime: aws.Float64(123.45),
1994 Speaker: aws.String("string value goes here"),
1995 Stable: aws.Bool(true),
1996 StartTime: aws.Float64(123.45),
1997 Type: aws.String("string value goes here"),
1998 VocabularyFilterMatch: aws.Bool(true),
1999 },
2000 {
2001 Confidence: aws.Float64(123.45),
2002 Content: aws.String("string value goes here"),
2003 EndTime: aws.Float64(123.45),
2004 Speaker: aws.String("string value goes here"),
2005 Stable: aws.Bool(true),
2006 StartTime: aws.Float64(123.45),
2007 Type: aws.String("string value goes here"),
2008 VocabularyFilterMatch: aws.Bool(true),
2009 },
2010 },
2011 Transcript: aws.String("string value goes here"),
2012 },
2013 {
2014 Entities: []*Entity{
2015 {
2016 Category: aws.String("string value goes here"),
2017 Confidence: aws.Float64(123.45),
2018 Content: aws.String("string value goes here"),
2019 EndTime: aws.Float64(123.45),
2020 StartTime: aws.Float64(123.45),
2021 Type: aws.String("string value goes here"),
2022 },
2023 {
2024 Category: aws.String("string value goes here"),
2025 Confidence: aws.Float64(123.45),
2026 Content: aws.String("string value goes here"),
2027 EndTime: aws.Float64(123.45),
2028 StartTime: aws.Float64(123.45),
2029 Type: aws.String("string value goes here"),
2030 },
2031 {
2032 Category: aws.String("string value goes here"),
2033 Confidence: aws.Float64(123.45),
2034 Content: aws.String("string value goes here"),
2035 EndTime: aws.Float64(123.45),
2036 StartTime: aws.Float64(123.45),
2037 Type: aws.String("string value goes here"),
2038 },
2039 },
2040 Items: []*Item{
2041 {
2042 Confidence: aws.Float64(123.45),
2043 Content: aws.String("string value goes here"),
2044 EndTime: aws.Float64(123.45),
2045 Speaker: aws.String("string value goes here"),
2046 Stable: aws.Bool(true),
2047 StartTime: aws.Float64(123.45),
2048 Type: aws.String("string value goes here"),
2049 VocabularyFilterMatch: aws.Bool(true),
2050 },
2051 {
2052 Confidence: aws.Float64(123.45),
2053 Content: aws.String("string value goes here"),
2054 EndTime: aws.Float64(123.45),
2055 Speaker: aws.String("string value goes here"),
2056 Stable: aws.Bool(true),
2057 StartTime: aws.Float64(123.45),
2058 Type: aws.String("string value goes here"),
2059 VocabularyFilterMatch: aws.Bool(true),
2060 },
2061 {
2062 Confidence: aws.Float64(123.45),
2063 Content: aws.String("string value goes here"),
2064 EndTime: aws.Float64(123.45),
2065 Speaker: aws.String("string value goes here"),
2066 Stable: aws.Bool(true),
2067 StartTime: aws.Float64(123.45),
2068 Type: aws.String("string value goes here"),
2069 VocabularyFilterMatch: aws.Bool(true),
2070 },
2071 },
2072 Transcript: aws.String("string value goes here"),
2073 },
2074 },
2075 ChannelId: aws.String("string value goes here"),
2076 EndTime: aws.Float64(123.45),
2077 IsPartial: aws.Bool(true),
2078 LanguageCode: aws.String("string value goes here"),
2079 LanguageIdentification: []*LanguageWithScore{
2080 {
2081 LanguageCode: aws.String("string value goes here"),
2082 Score: aws.Float64(123.45),
2083 },
2084 {
2085 LanguageCode: aws.String("string value goes here"),
2086 Score: aws.Float64(123.45),
2087 },
2088 {
2089 LanguageCode: aws.String("string value goes here"),
2090 Score: aws.Float64(123.45),
2091 },
2092 },
2093 ResultId: aws.String("string value goes here"),
2094 StartTime: aws.Float64(123.45),
2095 },
2096 },
2097 },
2098 },
2099 }
2100
2101 var marshalers request.HandlerList
2102 marshalers.PushBackNamed(restjson.BuildHandler)
2103 payloadMarshaler := protocol.HandlerPayloadMarshal{
2104 Marshalers: marshalers,
2105 }
2106 _ = payloadMarshaler
2107
2108 eventMsgs := []eventstream.Message{
2109 {
2110 Headers: eventstream.Headers{
2111 eventstreamtest.EventMessageTypeHeader,
2112 {
2113 Name: eventstreamapi.EventTypeHeader,
2114 Value: eventstream.StringValue("TranscriptEvent"),
2115 },
2116 },
2117 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
2118 },
2119 }
2120
2121 return expectEvents, eventMsgs
2122 }
2123 func TestStartStreamTranscription_ReadException(t *testing.T) {
2124 expectEvents := []TranscriptResultStreamEvent{
2125 &BadRequestException{
2126 RespMetadata: protocol.ResponseMetadata{
2127 StatusCode: 200,
2128 },
2129 Message_: aws.String("string value goes here"),
2130 },
2131 }
2132
2133 var marshalers request.HandlerList
2134 marshalers.PushBackNamed(restjson.BuildHandler)
2135 payloadMarshaler := protocol.HandlerPayloadMarshal{
2136 Marshalers: marshalers,
2137 }
2138
2139 eventMsgs := []eventstream.Message{
2140 {
2141 Headers: eventstream.Headers{
2142 eventstreamtest.EventExceptionTypeHeader,
2143 {
2144 Name: eventstreamapi.ExceptionTypeHeader,
2145 Value: eventstream.StringValue("BadRequestException"),
2146 },
2147 },
2148 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
2149 },
2150 }
2151
2152 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2153 eventstreamtest.ServeEventStream{
2154 T: t,
2155 Events: eventMsgs,
2156 },
2157 true,
2158 )
2159 if err != nil {
2160 t.Fatalf("expect no error, %v", err)
2161 }
2162 defer cleanupFn()
2163
2164 svc := New(sess)
2165 resp, err := svc.StartStreamTranscription(nil)
2166 if err != nil {
2167 t.Fatalf("expect no error got, %v", err)
2168 }
2169
2170 defer resp.GetStream().Close()
2171
2172 <-resp.GetStream().Events()
2173
2174 err = resp.GetStream().Err()
2175 if err == nil {
2176 t.Fatalf("expect err, got none")
2177 }
2178
2179 expectErr := &BadRequestException{
2180 RespMetadata: protocol.ResponseMetadata{
2181 StatusCode: 200,
2182 },
2183 Message_: aws.String("string value goes here"),
2184 }
2185 aerr, ok := err.(awserr.Error)
2186 if !ok {
2187 t.Errorf("expect exception, got %T, %#v", err, err)
2188 }
2189 if e, a := expectErr.Code(), aerr.Code(); e != a {
2190 t.Errorf("expect %v, got %v", e, a)
2191 }
2192 if e, a := expectErr.Message(), aerr.Message(); e != a {
2193 t.Errorf("expect %v, got %v", e, a)
2194 }
2195
2196 if e, a := expectErr, aerr; !reflect.DeepEqual(e, a) {
2197 t.Errorf("expect error %+#v, got %+#v", e, a)
2198 }
2199 }
2200
2201 var _ awserr.Error = (*BadRequestException)(nil)
2202 var _ awserr.Error = (*ConflictException)(nil)
2203 var _ awserr.Error = (*InternalFailureException)(nil)
2204 var _ awserr.Error = (*LimitExceededException)(nil)
2205 var _ awserr.Error = (*ServiceUnavailableException)(nil)
2206
2207 type loopReader struct {
2208 source *bytes.Reader
2209 }
2210
2211 func (c *loopReader) Read(p []byte) (int, error) {
2212 if c.source.Len() == 0 {
2213 c.source.Seek(0, 0)
2214 }
2215
2216 return c.source.Read(p)
2217 }
2218
2219 func TestStartCallAnalyticsStreamTranscription_Write(t *testing.T) {
2220 clientEvents, expectedClientEvents := mockStartCallAnalyticsStreamTranscriptionWriteEvents()
2221
2222 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2223 &eventstreamtest.ServeEventStream{
2224 T: t,
2225 ClientEvents: expectedClientEvents,
2226 BiDirectional: true,
2227 },
2228 true)
2229 defer cleanupFn()
2230
2231 svc := New(sess)
2232 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
2233 if err != nil {
2234 t.Fatalf("expect no error, got %v", err)
2235 }
2236
2237 stream := resp.GetStream()
2238
2239 for _, event := range clientEvents {
2240 err = stream.Send(context.Background(), event)
2241 if err != nil {
2242 t.Fatalf("expect no error, got %v", err)
2243 }
2244 }
2245
2246 if err := stream.Close(); err != nil {
2247 t.Errorf("expect no error, got %v", err)
2248 }
2249 }
2250
2251 func TestStartCallAnalyticsStreamTranscription_WriteClose(t *testing.T) {
2252 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2253 eventstreamtest.ServeEventStream{T: t, BiDirectional: true},
2254 true,
2255 )
2256 if err != nil {
2257 t.Fatalf("expect no error, %v", err)
2258 }
2259 defer cleanupFn()
2260
2261 svc := New(sess)
2262 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
2263 if err != nil {
2264 t.Fatalf("expect no error got, %v", err)
2265 }
2266
2267 // Assert calling Err before close does not close the stream.
2268 resp.GetStream().Err()
2269
2270 err = resp.GetStream().Send(context.Background(), &AudioEvent{})
2271 if err != nil {
2272 t.Fatalf("expect no error, got %v", err)
2273 }
2274
2275 resp.GetStream().Close()
2276
2277 if err := resp.GetStream().Err(); err != nil {
2278 t.Errorf("expect no error, %v", err)
2279 }
2280 }
2281
2282 func TestStartCallAnalyticsStreamTranscription_WriteError(t *testing.T) {
2283 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2284 eventstreamtest.ServeEventStream{
2285 T: t,
2286 BiDirectional: true,
2287 ForceCloseAfter: time.Millisecond * 500,
2288 },
2289 true,
2290 )
2291 if err != nil {
2292 t.Fatalf("expect no error, %v", err)
2293 }
2294 defer cleanupFn()
2295
2296 svc := New(sess)
2297 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
2298 if err != nil {
2299 t.Fatalf("expect no error got, %v", err)
2300 }
2301
2302 defer resp.GetStream().Close()
2303
2304 for {
2305 err = resp.GetStream().Send(context.Background(), &AudioEvent{})
2306 if err != nil {
2307 if strings.Contains("unable to send event", err.Error()) {
2308 t.Errorf("expected stream closed error, got %v", err)
2309 }
2310 break
2311 }
2312 }
2313 }
2314
2315 func TestStartCallAnalyticsStreamTranscription_ReadWrite(t *testing.T) {
2316 expectedServiceEvents, serviceEvents := mockStartCallAnalyticsStreamTranscriptionReadEvents()
2317 clientEvents, expectedClientEvents := mockStartCallAnalyticsStreamTranscriptionWriteEvents()
2318
2319 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2320 &eventstreamtest.ServeEventStream{
2321 T: t,
2322 ClientEvents: expectedClientEvents,
2323 Events: serviceEvents,
2324 BiDirectional: true,
2325 },
2326 true)
2327 defer cleanupFn()
2328
2329 svc := New(sess)
2330 resp, err := svc.StartCallAnalyticsStreamTranscription(nil)
2331 if err != nil {
2332 t.Fatalf("expect no error, got %v", err)
2333 }
2334
2335 stream := resp.GetStream()
2336 defer stream.Close()
2337
2338 var wg sync.WaitGroup
2339
2340 wg.Add(1)
2341 go func() {
2342 defer wg.Done()
2343 var i int
2344 for event := range resp.GetStream().Events() {
2345 if event == nil {
2346 t.Errorf("%d, expect event, got nil", i)
2347 }
2348 if e, a := expectedServiceEvents[i], event; !reflect.DeepEqual(e, a) {
2349 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
2350 }
2351 i++
2352 }
2353 }()
2354
2355 for _, event := range clientEvents {
2356 err = stream.Send(context.Background(), event)
2357 if err != nil {
2358 t.Errorf("expect no error, got %v", err)
2359 }
2360 }
2361
2362 resp.GetStream().Close()
2363
2364 wg.Wait()
2365
2366 if err := resp.GetStream().Err(); err != nil {
2367 t.Errorf("expect no error, %v", err)
2368 }
2369 }
2370
2371 func mockStartCallAnalyticsStreamTranscriptionWriteEvents() (
2372 []AudioStreamEvent,
2373 []eventstream.Message,
2374 ) {
2375 inputEvents := []AudioStreamEvent{
2376 &AudioEvent{
2377 AudioChunk: []byte("blob value goes here"),
2378 },
2379 &ConfigurationEvent{
2380 ChannelDefinitions: []*ChannelDefinition{
2381 {
2382 ChannelId: aws.Int64(123),
2383 ParticipantRole: aws.String("string value goes here"),
2384 },
2385 {
2386 ChannelId: aws.Int64(123),
2387 ParticipantRole: aws.String("string value goes here"),
2388 },
2389 {
2390 ChannelId: aws.Int64(123),
2391 ParticipantRole: aws.String("string value goes here"),
2392 },
2393 },
2394 PostCallAnalyticsSettings: &PostCallAnalyticsSettings{
2395 ContentRedactionOutput: aws.String("string value goes here"),
2396 DataAccessRoleArn: aws.String("string value goes here"),
2397 OutputEncryptionKMSKeyId: aws.String("string value goes here"),
2398 OutputLocation: aws.String("string value goes here"),
2399 },
2400 },
2401 }
2402
2403 var marshalers request.HandlerList
2404 marshalers.PushBackNamed(restjson.BuildHandler)
2405 payloadMarshaler := protocol.HandlerPayloadMarshal{
2406 Marshalers: marshalers,
2407 }
2408 _ = payloadMarshaler
2409
2410 eventMsgs := []eventstream.Message{
2411 {
2412 Headers: eventstream.Headers{
2413 eventstreamtest.EventMessageTypeHeader,
2414 {
2415 Name: ":content-type",
2416 Value: eventstream.StringValue("application/octet-stream"),
2417 },
2418 {
2419 Name: eventstreamapi.EventTypeHeader,
2420 Value: eventstream.StringValue("AudioEvent"),
2421 },
2422 },
2423 Payload: inputEvents[0].(*AudioEvent).AudioChunk,
2424 },
2425 {
2426 Headers: eventstream.Headers{
2427 eventstreamtest.EventMessageTypeHeader,
2428 {
2429 Name: eventstreamapi.EventTypeHeader,
2430 Value: eventstream.StringValue("ConfigurationEvent"),
2431 },
2432 },
2433 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, inputEvents[1]),
2434 },
2435 }
2436
2437 return inputEvents, eventMsgs
2438 }
2439
2440 func TestStartMedicalStreamTranscription_Write(t *testing.T) {
2441 clientEvents, expectedClientEvents := mockStartMedicalStreamTranscriptionWriteEvents()
2442
2443 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2444 &eventstreamtest.ServeEventStream{
2445 T: t,
2446 ClientEvents: expectedClientEvents,
2447 BiDirectional: true,
2448 },
2449 true)
2450 defer cleanupFn()
2451
2452 svc := New(sess)
2453 resp, err := svc.StartMedicalStreamTranscription(nil)
2454 if err != nil {
2455 t.Fatalf("expect no error, got %v", err)
2456 }
2457
2458 stream := resp.GetStream()
2459
2460 for _, event := range clientEvents {
2461 err = stream.Send(context.Background(), event)
2462 if err != nil {
2463 t.Fatalf("expect no error, got %v", err)
2464 }
2465 }
2466
2467 if err := stream.Close(); err != nil {
2468 t.Errorf("expect no error, got %v", err)
2469 }
2470 }
2471
2472 func TestStartMedicalStreamTranscription_WriteClose(t *testing.T) {
2473 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2474 eventstreamtest.ServeEventStream{T: t, BiDirectional: true},
2475 true,
2476 )
2477 if err != nil {
2478 t.Fatalf("expect no error, %v", err)
2479 }
2480 defer cleanupFn()
2481
2482 svc := New(sess)
2483 resp, err := svc.StartMedicalStreamTranscription(nil)
2484 if err != nil {
2485 t.Fatalf("expect no error got, %v", err)
2486 }
2487
2488 // Assert calling Err before close does not close the stream.
2489 resp.GetStream().Err()
2490
2491 err = resp.GetStream().Send(context.Background(), &AudioEvent{})
2492 if err != nil {
2493 t.Fatalf("expect no error, got %v", err)
2494 }
2495
2496 resp.GetStream().Close()
2497
2498 if err := resp.GetStream().Err(); err != nil {
2499 t.Errorf("expect no error, %v", err)
2500 }
2501 }
2502
2503 func TestStartMedicalStreamTranscription_WriteError(t *testing.T) {
2504 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2505 eventstreamtest.ServeEventStream{
2506 T: t,
2507 BiDirectional: true,
2508 ForceCloseAfter: time.Millisecond * 500,
2509 },
2510 true,
2511 )
2512 if err != nil {
2513 t.Fatalf("expect no error, %v", err)
2514 }
2515 defer cleanupFn()
2516
2517 svc := New(sess)
2518 resp, err := svc.StartMedicalStreamTranscription(nil)
2519 if err != nil {
2520 t.Fatalf("expect no error got, %v", err)
2521 }
2522
2523 defer resp.GetStream().Close()
2524
2525 for {
2526 err = resp.GetStream().Send(context.Background(), &AudioEvent{})
2527 if err != nil {
2528 if strings.Contains("unable to send event", err.Error()) {
2529 t.Errorf("expected stream closed error, got %v", err)
2530 }
2531 break
2532 }
2533 }
2534 }
2535
2536 func TestStartMedicalStreamTranscription_ReadWrite(t *testing.T) {
2537 expectedServiceEvents, serviceEvents := mockStartMedicalStreamTranscriptionReadEvents()
2538 clientEvents, expectedClientEvents := mockStartMedicalStreamTranscriptionWriteEvents()
2539
2540 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2541 &eventstreamtest.ServeEventStream{
2542 T: t,
2543 ClientEvents: expectedClientEvents,
2544 Events: serviceEvents,
2545 BiDirectional: true,
2546 },
2547 true)
2548 defer cleanupFn()
2549
2550 svc := New(sess)
2551 resp, err := svc.StartMedicalStreamTranscription(nil)
2552 if err != nil {
2553 t.Fatalf("expect no error, got %v", err)
2554 }
2555
2556 stream := resp.GetStream()
2557 defer stream.Close()
2558
2559 var wg sync.WaitGroup
2560
2561 wg.Add(1)
2562 go func() {
2563 defer wg.Done()
2564 var i int
2565 for event := range resp.GetStream().Events() {
2566 if event == nil {
2567 t.Errorf("%d, expect event, got nil", i)
2568 }
2569 if e, a := expectedServiceEvents[i], event; !reflect.DeepEqual(e, a) {
2570 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
2571 }
2572 i++
2573 }
2574 }()
2575
2576 for _, event := range clientEvents {
2577 err = stream.Send(context.Background(), event)
2578 if err != nil {
2579 t.Errorf("expect no error, got %v", err)
2580 }
2581 }
2582
2583 resp.GetStream().Close()
2584
2585 wg.Wait()
2586
2587 if err := resp.GetStream().Err(); err != nil {
2588 t.Errorf("expect no error, %v", err)
2589 }
2590 }
2591
2592 func mockStartMedicalStreamTranscriptionWriteEvents() (
2593 []AudioStreamEvent,
2594 []eventstream.Message,
2595 ) {
2596 inputEvents := []AudioStreamEvent{
2597 &AudioEvent{
2598 AudioChunk: []byte("blob value goes here"),
2599 },
2600 &ConfigurationEvent{
2601 ChannelDefinitions: []*ChannelDefinition{
2602 {
2603 ChannelId: aws.Int64(123),
2604 ParticipantRole: aws.String("string value goes here"),
2605 },
2606 {
2607 ChannelId: aws.Int64(123),
2608 ParticipantRole: aws.String("string value goes here"),
2609 },
2610 {
2611 ChannelId: aws.Int64(123),
2612 ParticipantRole: aws.String("string value goes here"),
2613 },
2614 },
2615 PostCallAnalyticsSettings: &PostCallAnalyticsSettings{
2616 ContentRedactionOutput: aws.String("string value goes here"),
2617 DataAccessRoleArn: aws.String("string value goes here"),
2618 OutputEncryptionKMSKeyId: aws.String("string value goes here"),
2619 OutputLocation: aws.String("string value goes here"),
2620 },
2621 },
2622 }
2623
2624 var marshalers request.HandlerList
2625 marshalers.PushBackNamed(restjson.BuildHandler)
2626 payloadMarshaler := protocol.HandlerPayloadMarshal{
2627 Marshalers: marshalers,
2628 }
2629 _ = payloadMarshaler
2630
2631 eventMsgs := []eventstream.Message{
2632 {
2633 Headers: eventstream.Headers{
2634 eventstreamtest.EventMessageTypeHeader,
2635 {
2636 Name: ":content-type",
2637 Value: eventstream.StringValue("application/octet-stream"),
2638 },
2639 {
2640 Name: eventstreamapi.EventTypeHeader,
2641 Value: eventstream.StringValue("AudioEvent"),
2642 },
2643 },
2644 Payload: inputEvents[0].(*AudioEvent).AudioChunk,
2645 },
2646 {
2647 Headers: eventstream.Headers{
2648 eventstreamtest.EventMessageTypeHeader,
2649 {
2650 Name: eventstreamapi.EventTypeHeader,
2651 Value: eventstream.StringValue("ConfigurationEvent"),
2652 },
2653 },
2654 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, inputEvents[1]),
2655 },
2656 }
2657
2658 return inputEvents, eventMsgs
2659 }
2660
2661 func TestStartStreamTranscription_Write(t *testing.T) {
2662 clientEvents, expectedClientEvents := mockStartStreamTranscriptionWriteEvents()
2663
2664 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2665 &eventstreamtest.ServeEventStream{
2666 T: t,
2667 ClientEvents: expectedClientEvents,
2668 BiDirectional: true,
2669 },
2670 true)
2671 defer cleanupFn()
2672
2673 svc := New(sess)
2674 resp, err := svc.StartStreamTranscription(nil)
2675 if err != nil {
2676 t.Fatalf("expect no error, got %v", err)
2677 }
2678
2679 stream := resp.GetStream()
2680
2681 for _, event := range clientEvents {
2682 err = stream.Send(context.Background(), event)
2683 if err != nil {
2684 t.Fatalf("expect no error, got %v", err)
2685 }
2686 }
2687
2688 if err := stream.Close(); err != nil {
2689 t.Errorf("expect no error, got %v", err)
2690 }
2691 }
2692
2693 func TestStartStreamTranscription_WriteClose(t *testing.T) {
2694 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2695 eventstreamtest.ServeEventStream{T: t, BiDirectional: true},
2696 true,
2697 )
2698 if err != nil {
2699 t.Fatalf("expect no error, %v", err)
2700 }
2701 defer cleanupFn()
2702
2703 svc := New(sess)
2704 resp, err := svc.StartStreamTranscription(nil)
2705 if err != nil {
2706 t.Fatalf("expect no error got, %v", err)
2707 }
2708
2709 // Assert calling Err before close does not close the stream.
2710 resp.GetStream().Err()
2711
2712 err = resp.GetStream().Send(context.Background(), &AudioEvent{})
2713 if err != nil {
2714 t.Fatalf("expect no error, got %v", err)
2715 }
2716
2717 resp.GetStream().Close()
2718
2719 if err := resp.GetStream().Err(); err != nil {
2720 t.Errorf("expect no error, %v", err)
2721 }
2722 }
2723
2724 func TestStartStreamTranscription_WriteError(t *testing.T) {
2725 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2726 eventstreamtest.ServeEventStream{
2727 T: t,
2728 BiDirectional: true,
2729 ForceCloseAfter: time.Millisecond * 500,
2730 },
2731 true,
2732 )
2733 if err != nil {
2734 t.Fatalf("expect no error, %v", err)
2735 }
2736 defer cleanupFn()
2737
2738 svc := New(sess)
2739 resp, err := svc.StartStreamTranscription(nil)
2740 if err != nil {
2741 t.Fatalf("expect no error got, %v", err)
2742 }
2743
2744 defer resp.GetStream().Close()
2745
2746 for {
2747 err = resp.GetStream().Send(context.Background(), &AudioEvent{})
2748 if err != nil {
2749 if strings.Contains("unable to send event", err.Error()) {
2750 t.Errorf("expected stream closed error, got %v", err)
2751 }
2752 break
2753 }
2754 }
2755 }
2756
2757 func TestStartStreamTranscription_ReadWrite(t *testing.T) {
2758 expectedServiceEvents, serviceEvents := mockStartStreamTranscriptionReadEvents()
2759 clientEvents, expectedClientEvents := mockStartStreamTranscriptionWriteEvents()
2760
2761 sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
2762 &eventstreamtest.ServeEventStream{
2763 T: t,
2764 ClientEvents: expectedClientEvents,
2765 Events: serviceEvents,
2766 BiDirectional: true,
2767 },
2768 true)
2769 defer cleanupFn()
2770
2771 svc := New(sess)
2772 resp, err := svc.StartStreamTranscription(nil)
2773 if err != nil {
2774 t.Fatalf("expect no error, got %v", err)
2775 }
2776
2777 stream := resp.GetStream()
2778 defer stream.Close()
2779
2780 var wg sync.WaitGroup
2781
2782 wg.Add(1)
2783 go func() {
2784 defer wg.Done()
2785 var i int
2786 for event := range resp.GetStream().Events() {
2787 if event == nil {
2788 t.Errorf("%d, expect event, got nil", i)
2789 }
2790 if e, a := expectedServiceEvents[i], event; !reflect.DeepEqual(e, a) {
2791 t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
2792 }
2793 i++
2794 }
2795 }()
2796
2797 for _, event := range clientEvents {
2798 err = stream.Send(context.Background(), event)
2799 if err != nil {
2800 t.Errorf("expect no error, got %v", err)
2801 }
2802 }
2803
2804 resp.GetStream().Close()
2805
2806 wg.Wait()
2807
2808 if err := resp.GetStream().Err(); err != nil {
2809 t.Errorf("expect no error, %v", err)
2810 }
2811 }
2812
2813 func mockStartStreamTranscriptionWriteEvents() (
2814 []AudioStreamEvent,
2815 []eventstream.Message,
2816 ) {
2817 inputEvents := []AudioStreamEvent{
2818 &AudioEvent{
2819 AudioChunk: []byte("blob value goes here"),
2820 },
2821 &ConfigurationEvent{
2822 ChannelDefinitions: []*ChannelDefinition{
2823 {
2824 ChannelId: aws.Int64(123),
2825 ParticipantRole: aws.String("string value goes here"),
2826 },
2827 {
2828 ChannelId: aws.Int64(123),
2829 ParticipantRole: aws.String("string value goes here"),
2830 },
2831 {
2832 ChannelId: aws.Int64(123),
2833 ParticipantRole: aws.String("string value goes here"),
2834 },
2835 },
2836 PostCallAnalyticsSettings: &PostCallAnalyticsSettings{
2837 ContentRedactionOutput: aws.String("string value goes here"),
2838 DataAccessRoleArn: aws.String("string value goes here"),
2839 OutputEncryptionKMSKeyId: aws.String("string value goes here"),
2840 OutputLocation: aws.String("string value goes here"),
2841 },
2842 },
2843 }
2844
2845 var marshalers request.HandlerList
2846 marshalers.PushBackNamed(restjson.BuildHandler)
2847 payloadMarshaler := protocol.HandlerPayloadMarshal{
2848 Marshalers: marshalers,
2849 }
2850 _ = payloadMarshaler
2851
2852 eventMsgs := []eventstream.Message{
2853 {
2854 Headers: eventstream.Headers{
2855 eventstreamtest.EventMessageTypeHeader,
2856 {
2857 Name: ":content-type",
2858 Value: eventstream.StringValue("application/octet-stream"),
2859 },
2860 {
2861 Name: eventstreamapi.EventTypeHeader,
2862 Value: eventstream.StringValue("AudioEvent"),
2863 },
2864 },
2865 Payload: inputEvents[0].(*AudioEvent).AudioChunk,
2866 },
2867 {
2868 Headers: eventstream.Headers{
2869 eventstreamtest.EventMessageTypeHeader,
2870 {
2871 Name: eventstreamapi.EventTypeHeader,
2872 Value: eventstream.StringValue("ConfigurationEvent"),
2873 },
2874 },
2875 Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, inputEvents[1]),
2876 },
2877 }
2878
2879 return inputEvents, eventMsgs
2880 }