github.com/aavshr/aws-sdk-go@v1.41.3/service/kinesis/eventstream_test.go (about)

     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 kinesis
     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/aavshr/aws-sdk-go/aws"
    20  	"github.com/aavshr/aws-sdk-go/aws/awserr"
    21  	"github.com/aavshr/aws-sdk-go/aws/corehandlers"
    22  	"github.com/aavshr/aws-sdk-go/aws/request"
    23  	"github.com/aavshr/aws-sdk-go/awstesting/unit"
    24  	"github.com/aavshr/aws-sdk-go/private/protocol"
    25  	"github.com/aavshr/aws-sdk-go/private/protocol/eventstream"
    26  	"github.com/aavshr/aws-sdk-go/private/protocol/eventstream/eventstreamapi"
    27  	"github.com/aavshr/aws-sdk-go/private/protocol/eventstream/eventstreamtest"
    28  	"github.com/aavshr/aws-sdk-go/private/protocol/jsonrpc"
    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 TestSubscribeToShard_Read(t *testing.T) {
    38  	expectEvents, eventMsgs := mockSubscribeToShardReadEvents()
    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.SubscribeToShard(nil)
    53  	if err != nil {
    54  		t.Fatalf("expect no error got, %v", err)
    55  	}
    56  	defer resp.GetStream().Close()
    57  	// Trim off response output type pseudo event so only event messages remain.
    58  	expectEvents = expectEvents[1:]
    59  
    60  	var i int
    61  	for event := range resp.GetStream().Events() {
    62  		if event == nil {
    63  			t.Errorf("%d, expect event, got nil", i)
    64  		}
    65  		if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
    66  			t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
    67  		}
    68  		i++
    69  	}
    70  
    71  	if err := resp.GetStream().Err(); err != nil {
    72  		t.Errorf("expect no error, %v", err)
    73  	}
    74  }
    75  
    76  func TestSubscribeToShard_ReadClose(t *testing.T) {
    77  	_, eventMsgs := mockSubscribeToShardReadEvents()
    78  	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
    79  		eventstreamtest.ServeEventStream{
    80  			T:      t,
    81  			Events: eventMsgs,
    82  		},
    83  		true,
    84  	)
    85  	if err != nil {
    86  		t.Fatalf("expect no error, %v", err)
    87  	}
    88  	defer cleanupFn()
    89  
    90  	svc := New(sess)
    91  	resp, err := svc.SubscribeToShard(nil)
    92  	if err != nil {
    93  		t.Fatalf("expect no error got, %v", err)
    94  	}
    95  
    96  	// Assert calling Err before close does not close the stream.
    97  	resp.GetStream().Err()
    98  	select {
    99  	case _, ok := <-resp.GetStream().Events():
   100  		if !ok {
   101  			t.Fatalf("expect stream not to be closed, but was")
   102  		}
   103  	default:
   104  	}
   105  
   106  	resp.GetStream().Close()
   107  	<-resp.GetStream().Events()
   108  
   109  	if err := resp.GetStream().Err(); err != nil {
   110  		t.Errorf("expect no error, %v", err)
   111  	}
   112  }
   113  
   114  func TestSubscribeToShard_ReadUnknownEvent(t *testing.T) {
   115  	expectEvents, eventMsgs := mockSubscribeToShardReadEvents()
   116  	eventOffset := 1
   117  
   118  	unknownEvent := eventstream.Message{
   119  		Headers: eventstream.Headers{
   120  			eventstreamtest.EventMessageTypeHeader,
   121  			{
   122  				Name:  eventstreamapi.EventTypeHeader,
   123  				Value: eventstream.StringValue("UnknownEventName"),
   124  			},
   125  		},
   126  		Payload: []byte("some unknown event"),
   127  	}
   128  
   129  	eventMsgs = append(eventMsgs[:eventOffset],
   130  		append([]eventstream.Message{unknownEvent}, eventMsgs[eventOffset:]...)...)
   131  
   132  	expectEvents = append(expectEvents[:eventOffset],
   133  		append([]SubscribeToShardEventStreamEvent{
   134  			&SubscribeToShardEventStreamUnknownEvent{
   135  				Type:    "UnknownEventName",
   136  				Message: unknownEvent,
   137  			},
   138  		},
   139  			expectEvents[eventOffset:]...)...)
   140  
   141  	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
   142  		eventstreamtest.ServeEventStream{
   143  			T:      t,
   144  			Events: eventMsgs,
   145  		},
   146  		true,
   147  	)
   148  	if err != nil {
   149  		t.Fatalf("expect no error, %v", err)
   150  	}
   151  	defer cleanupFn()
   152  
   153  	svc := New(sess)
   154  	resp, err := svc.SubscribeToShard(nil)
   155  	if err != nil {
   156  		t.Fatalf("expect no error got, %v", err)
   157  	}
   158  	defer resp.GetStream().Close()
   159  	// Trim off response output type pseudo event so only event messages remain.
   160  	expectEvents = expectEvents[1:]
   161  
   162  	var i int
   163  	for event := range resp.GetStream().Events() {
   164  		if event == nil {
   165  			t.Errorf("%d, expect event, got nil", i)
   166  		}
   167  		if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) {
   168  			t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a)
   169  		}
   170  		i++
   171  	}
   172  
   173  	if err := resp.GetStream().Err(); err != nil {
   174  		t.Errorf("expect no error, %v", err)
   175  	}
   176  }
   177  
   178  func BenchmarkSubscribeToShard_Read(b *testing.B) {
   179  	_, eventMsgs := mockSubscribeToShardReadEvents()
   180  	var buf bytes.Buffer
   181  	encoder := eventstream.NewEncoder(&buf)
   182  	for _, msg := range eventMsgs {
   183  		if err := encoder.Encode(msg); err != nil {
   184  			b.Fatalf("failed to encode message, %v", err)
   185  		}
   186  	}
   187  	stream := &loopReader{source: bytes.NewReader(buf.Bytes())}
   188  
   189  	sess := unit.Session
   190  	svc := New(sess, &aws.Config{
   191  		Endpoint:               aws.String("https://example.com"),
   192  		DisableParamValidation: aws.Bool(true),
   193  	})
   194  	svc.Handlers.Send.Swap(corehandlers.SendHandler.Name,
   195  		request.NamedHandler{Name: "mockSend",
   196  			Fn: func(r *request.Request) {
   197  				r.HTTPResponse = &http.Response{
   198  					Status:     "200 OK",
   199  					StatusCode: 200,
   200  					Header:     http.Header{},
   201  					Body:       ioutil.NopCloser(stream),
   202  				}
   203  			},
   204  		},
   205  	)
   206  
   207  	resp, err := svc.SubscribeToShard(nil)
   208  	if err != nil {
   209  		b.Fatalf("failed to create request, %v", err)
   210  	}
   211  	defer resp.GetStream().Close()
   212  	b.ResetTimer()
   213  
   214  	for i := 0; i < b.N; i++ {
   215  		if err = resp.GetStream().Err(); err != nil {
   216  			b.Fatalf("expect no error, got %v", err)
   217  		}
   218  		event := <-resp.GetStream().Events()
   219  		if event == nil {
   220  			b.Fatalf("expect event, got nil, %v, %d", resp.GetStream().Err(), i)
   221  		}
   222  	}
   223  }
   224  
   225  func mockSubscribeToShardReadEvents() (
   226  	[]SubscribeToShardEventStreamEvent,
   227  	[]eventstream.Message,
   228  ) {
   229  	expectEvents := []SubscribeToShardEventStreamEvent{
   230  		&SubscribeToShardOutput{},
   231  		&SubscribeToShardEvent{
   232  			ChildShards: []*ChildShard{
   233  				{
   234  					HashKeyRange: &HashKeyRange{
   235  						EndingHashKey:   aws.String("string value goes here"),
   236  						StartingHashKey: aws.String("string value goes here"),
   237  					},
   238  					ParentShards: []*string{
   239  						aws.String("string value goes here"),
   240  						aws.String("string value goes here"),
   241  						aws.String("string value goes here"),
   242  					},
   243  					ShardId: aws.String("string value goes here"),
   244  				},
   245  				{
   246  					HashKeyRange: &HashKeyRange{
   247  						EndingHashKey:   aws.String("string value goes here"),
   248  						StartingHashKey: aws.String("string value goes here"),
   249  					},
   250  					ParentShards: []*string{
   251  						aws.String("string value goes here"),
   252  						aws.String("string value goes here"),
   253  						aws.String("string value goes here"),
   254  					},
   255  					ShardId: aws.String("string value goes here"),
   256  				},
   257  				{
   258  					HashKeyRange: &HashKeyRange{
   259  						EndingHashKey:   aws.String("string value goes here"),
   260  						StartingHashKey: aws.String("string value goes here"),
   261  					},
   262  					ParentShards: []*string{
   263  						aws.String("string value goes here"),
   264  						aws.String("string value goes here"),
   265  						aws.String("string value goes here"),
   266  					},
   267  					ShardId: aws.String("string value goes here"),
   268  				},
   269  			},
   270  			ContinuationSequenceNumber: aws.String("string value goes here"),
   271  			MillisBehindLatest:         aws.Int64(1234),
   272  			Records: []*Record{
   273  				{
   274  					ApproximateArrivalTimestamp: aws.Time(time.Unix(1396594860, 0).UTC()),
   275  					Data:                        []byte("blob value goes here"),
   276  					EncryptionType:              aws.String("string value goes here"),
   277  					PartitionKey:                aws.String("string value goes here"),
   278  					SequenceNumber:              aws.String("string value goes here"),
   279  				},
   280  				{
   281  					ApproximateArrivalTimestamp: aws.Time(time.Unix(1396594860, 0).UTC()),
   282  					Data:                        []byte("blob value goes here"),
   283  					EncryptionType:              aws.String("string value goes here"),
   284  					PartitionKey:                aws.String("string value goes here"),
   285  					SequenceNumber:              aws.String("string value goes here"),
   286  				},
   287  				{
   288  					ApproximateArrivalTimestamp: aws.Time(time.Unix(1396594860, 0).UTC()),
   289  					Data:                        []byte("blob value goes here"),
   290  					EncryptionType:              aws.String("string value goes here"),
   291  					PartitionKey:                aws.String("string value goes here"),
   292  					SequenceNumber:              aws.String("string value goes here"),
   293  				},
   294  			},
   295  		},
   296  	}
   297  
   298  	var marshalers request.HandlerList
   299  	marshalers.PushBackNamed(jsonrpc.BuildHandler)
   300  	payloadMarshaler := protocol.HandlerPayloadMarshal{
   301  		Marshalers: marshalers,
   302  	}
   303  	_ = payloadMarshaler
   304  
   305  	eventMsgs := []eventstream.Message{
   306  		{
   307  			Headers: eventstream.Headers{
   308  				eventstreamtest.EventMessageTypeHeader,
   309  				{
   310  					Name:  eventstreamapi.EventTypeHeader,
   311  					Value: eventstream.StringValue("initial-response"),
   312  				},
   313  			},
   314  			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
   315  		},
   316  		{
   317  			Headers: eventstream.Headers{
   318  				eventstreamtest.EventMessageTypeHeader,
   319  				{
   320  					Name:  eventstreamapi.EventTypeHeader,
   321  					Value: eventstream.StringValue("SubscribeToShardEvent"),
   322  				},
   323  			},
   324  			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[1]),
   325  		},
   326  	}
   327  
   328  	return expectEvents, eventMsgs
   329  }
   330  func TestSubscribeToShard_ReadException(t *testing.T) {
   331  	expectEvents := []SubscribeToShardEventStreamEvent{
   332  		&SubscribeToShardOutput{},
   333  		&InternalFailureException{
   334  			RespMetadata: protocol.ResponseMetadata{
   335  				StatusCode: 200,
   336  			},
   337  			Message_: aws.String("string value goes here"),
   338  		},
   339  	}
   340  
   341  	var marshalers request.HandlerList
   342  	marshalers.PushBackNamed(jsonrpc.BuildHandler)
   343  	payloadMarshaler := protocol.HandlerPayloadMarshal{
   344  		Marshalers: marshalers,
   345  	}
   346  
   347  	eventMsgs := []eventstream.Message{
   348  		{
   349  			Headers: eventstream.Headers{
   350  				eventstreamtest.EventMessageTypeHeader,
   351  				{
   352  					Name:  eventstreamapi.EventTypeHeader,
   353  					Value: eventstream.StringValue("initial-response"),
   354  				},
   355  			},
   356  			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[0]),
   357  		},
   358  		{
   359  			Headers: eventstream.Headers{
   360  				eventstreamtest.EventExceptionTypeHeader,
   361  				{
   362  					Name:  eventstreamapi.ExceptionTypeHeader,
   363  					Value: eventstream.StringValue("InternalFailureException"),
   364  				},
   365  			},
   366  			Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[1]),
   367  		},
   368  	}
   369  
   370  	sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t,
   371  		eventstreamtest.ServeEventStream{
   372  			T:      t,
   373  			Events: eventMsgs,
   374  		},
   375  		true,
   376  	)
   377  	if err != nil {
   378  		t.Fatalf("expect no error, %v", err)
   379  	}
   380  	defer cleanupFn()
   381  
   382  	svc := New(sess)
   383  	resp, err := svc.SubscribeToShard(nil)
   384  	if err != nil {
   385  		t.Fatalf("expect no error got, %v", err)
   386  	}
   387  
   388  	defer resp.GetStream().Close()
   389  
   390  	<-resp.GetStream().Events()
   391  
   392  	err = resp.GetStream().Err()
   393  	if err == nil {
   394  		t.Fatalf("expect err, got none")
   395  	}
   396  
   397  	expectErr := &InternalFailureException{
   398  		RespMetadata: protocol.ResponseMetadata{
   399  			StatusCode: 200,
   400  		},
   401  		Message_: aws.String("string value goes here"),
   402  	}
   403  	aerr, ok := err.(awserr.Error)
   404  	if !ok {
   405  		t.Errorf("expect exception, got %T, %#v", err, err)
   406  	}
   407  	if e, a := expectErr.Code(), aerr.Code(); e != a {
   408  		t.Errorf("expect %v, got %v", e, a)
   409  	}
   410  	if e, a := expectErr.Message(), aerr.Message(); e != a {
   411  		t.Errorf("expect %v, got %v", e, a)
   412  	}
   413  
   414  	if e, a := expectErr, aerr; !reflect.DeepEqual(e, a) {
   415  		t.Errorf("expect error %+#v, got %+#v", e, a)
   416  	}
   417  }
   418  
   419  var _ awserr.Error = (*InternalFailureException)(nil)
   420  var _ awserr.Error = (*KMSAccessDeniedException)(nil)
   421  var _ awserr.Error = (*KMSDisabledException)(nil)
   422  var _ awserr.Error = (*KMSInvalidStateException)(nil)
   423  var _ awserr.Error = (*KMSNotFoundException)(nil)
   424  var _ awserr.Error = (*KMSOptInRequired)(nil)
   425  var _ awserr.Error = (*KMSThrottlingException)(nil)
   426  var _ awserr.Error = (*ResourceInUseException)(nil)
   427  var _ awserr.Error = (*ResourceNotFoundException)(nil)
   428  
   429  type loopReader struct {
   430  	source *bytes.Reader
   431  }
   432  
   433  func (c *loopReader) Read(p []byte) (int, error) {
   434  	if c.source.Len() == 0 {
   435  		c.source.Seek(0, 0)
   436  	}
   437  
   438  	return c.source.Read(p)
   439  }