github.com/aavshr/aws-sdk-go@v1.41.3/private/protocol/eventstream/eventstreamapi/writer_test.go (about)

     1  //go:build go1.7
     2  // +build go1.7
     3  
     4  package eventstreamapi
     5  
     6  import (
     7  	"bytes"
     8  	"encoding/base64"
     9  	"encoding/hex"
    10  	"testing"
    11  	"time"
    12  
    13  	"github.com/aavshr/aws-sdk-go/aws"
    14  	"github.com/aavshr/aws-sdk-go/aws/request"
    15  	"github.com/aavshr/aws-sdk-go/private/protocol"
    16  	"github.com/aavshr/aws-sdk-go/private/protocol/eventstream"
    17  	"github.com/aavshr/aws-sdk-go/private/protocol/eventstream/eventstreamtest"
    18  	"github.com/aavshr/aws-sdk-go/private/protocol/restjson"
    19  )
    20  
    21  func TestEventWriter(t *testing.T) {
    22  	cases := map[string]struct {
    23  		Event         Marshaler
    24  		EncodeWrapper func(e Encoder) Encoder
    25  		TimeFunc      func() time.Time
    26  		Expect        eventstream.Message
    27  		NestedExpect  *eventstream.Message
    28  	}{
    29  		"structured event": {
    30  			Event: &eventStructured{
    31  				String: aws.String("stringfield"),
    32  				Number: aws.Int64(123),
    33  				Nested: &eventStructured{
    34  					String: aws.String("fieldstring"),
    35  					Number: aws.Int64(321),
    36  				},
    37  			},
    38  			Expect: eventstream.Message{
    39  				Headers: eventstream.Headers{
    40  					eventMessageTypeHeader,
    41  					eventstream.Header{
    42  						Name:  EventTypeHeader,
    43  						Value: eventstream.StringValue("eventStructured"),
    44  					},
    45  				},
    46  				Payload: []byte(`{"String":"stringfield","Number":123,"Nested":{"String":"fieldstring","Number":321}}`),
    47  			},
    48  		},
    49  		"signed event": {
    50  			Event: &eventStructured{
    51  				String: aws.String("stringfield"),
    52  				Number: aws.Int64(123),
    53  				Nested: &eventStructured{
    54  					String: aws.String("fieldstring"),
    55  					Number: aws.Int64(321),
    56  				},
    57  			},
    58  			EncodeWrapper: func(e Encoder) Encoder {
    59  				return NewSignEncoder(
    60  					&mockChunkSigner{
    61  						signature: "524f1d03d1d81e94a099042736d40bd9681b867321443ff58a4568e274dbd83bff",
    62  					},
    63  					e,
    64  				)
    65  			},
    66  			TimeFunc: func() time.Time {
    67  				return time.Date(2019, 1, 27, 22, 37, 54, 0, time.UTC)
    68  			},
    69  			Expect: eventstream.Message{
    70  				Headers: eventstream.Headers{
    71  					{
    72  						Name:  DateHeader,
    73  						Value: eventstream.TimestampValue(time.Date(2019, 1, 27, 22, 37, 54, 0, time.UTC)),
    74  					},
    75  					{
    76  						Name: ChunkSignatureHeader,
    77  						Value: eventstream.BytesValue(mustDecodeBytes(
    78  							hex.DecodeString("524f1d03d1d81e94a099042736d40bd9681b867321443ff58a4568e274dbd83bff"),
    79  						)),
    80  					},
    81  				},
    82  				Payload: mustDecodeBytes(base64.StdEncoding.DecodeString(
    83  					`AAAAmAAAADSl4EcNDTptZXNzYWdlLXR5cGUHAAVldmVudAs6ZXZlbnQtdHlwZQcAD2V2ZW50U3RydWN0dXJlZHsiU3RyaW5nIjoic3RyaW5nZmllbGQiLCJOdW1iZXIiOjEyMywiTmVzdGVkIjp7IlN0cmluZyI6ImZpZWxkc3RyaW5nIiwiTnVtYmVyIjozMjF9fdVW3Ow=`,
    84  				)),
    85  			},
    86  		},
    87  	}
    88  
    89  	var marshalers request.HandlerList
    90  	marshalers.PushBackNamed(restjson.BuildHandler)
    91  
    92  	var stream bytes.Buffer
    93  
    94  	decodeBuf := make([]byte, 1024)
    95  	for name, c := range cases {
    96  		t.Run(name, func(t *testing.T) {
    97  			defer swapTimeNow(c.TimeFunc)()
    98  
    99  			stream.Reset()
   100  
   101  			var encoder Encoder
   102  			encoder = eventstream.NewEncoder(&stream, eventstream.EncodeWithLogger(t))
   103  			if c.EncodeWrapper != nil {
   104  				encoder = c.EncodeWrapper(encoder)
   105  			}
   106  
   107  			eventWriter := NewEventWriter(encoder,
   108  				protocol.HandlerPayloadMarshal{
   109  					Marshalers: marshalers,
   110  				},
   111  				func(event Marshaler) (string, error) {
   112  					return "eventStructured", nil
   113  				},
   114  			)
   115  
   116  			decoder := eventstream.NewDecoder(&stream)
   117  
   118  			if err := eventWriter.WriteEvent(c.Event); err != nil {
   119  				t.Fatalf("expect no write error, got %v", err)
   120  			}
   121  
   122  			msg, err := decoder.Decode(decodeBuf)
   123  			if err != nil {
   124  				t.Fatalf("expect no decode error got, %v", err)
   125  			}
   126  
   127  			eventstreamtest.AssertMessageEqual(t, c.Expect, msg)
   128  		})
   129  	}
   130  }
   131  
   132  func BenchmarkEventWriter(b *testing.B) {
   133  	var marshalers request.HandlerList
   134  	marshalers.PushBackNamed(restjson.BuildHandler)
   135  
   136  	var stream bytes.Buffer
   137  	encoder := eventstream.NewEncoder(&stream)
   138  	eventWriter := NewEventWriter(encoder,
   139  		protocol.HandlerPayloadMarshal{
   140  			Marshalers: marshalers,
   141  		},
   142  		func(event Marshaler) (string, error) {
   143  			return "eventStructured", nil
   144  		},
   145  	)
   146  
   147  	event := &eventStructured{
   148  		String: aws.String("stringfield"),
   149  		Number: aws.Int64(123),
   150  		Nested: &eventStructured{
   151  			String: aws.String("fieldstring"),
   152  			Number: aws.Int64(321),
   153  		},
   154  	}
   155  
   156  	b.ResetTimer()
   157  	for i := 0; i < b.N; i++ {
   158  		if err := eventWriter.WriteEvent(event); err != nil {
   159  			b.Fatalf("expect no write error, got %v", err)
   160  		}
   161  	}
   162  }