github.com/vmware/transport-go@v1.3.4/model/message_test.go (about)

     1  package model
     2  
     3  import (
     4  	"encoding/json"
     5  	"github.com/google/uuid"
     6  	"github.com/stretchr/testify/assert"
     7  	"reflect"
     8  	"testing"
     9  )
    10  
    11  func TestMessage_CastPayloadToType_HappyPath(t *testing.T) {
    12  	// arrange
    13  	msg := getNewTestMessage()
    14  	var dest Request
    15  
    16  	// act
    17  	err := msg.CastPayloadToType(&dest)
    18  
    19  	// assert
    20  	assert.Nil(t, err)
    21  	assert.EqualValues(t, "dummy-value-coming-through", dest.Request)
    22  }
    23  
    24  func TestMessage_CastPayloadToType_BadPayload(t *testing.T) {
    25  	// arrange
    26  	msg := getNewTestMessage()
    27  	pb := msg.Payload.([]byte)
    28  	pb = append([]byte("random_bytes"), pb...)
    29  	msg.Payload = pb
    30  	var dest Request
    31  
    32  	// act
    33  	err := msg.CastPayloadToType(&dest)
    34  
    35  	// assert
    36  	assert.NotNil(t, err)
    37  	assert.Contains(t, err.Error(), "failed to unmarshal payload")
    38  	assert.NotEqual(t, "dummy-value-coming-through", dest.Request)
    39  }
    40  
    41  func TestMessage_CastPayloadToType_NonPointer(t *testing.T) {
    42  	// arrange
    43  	msg := getNewTestMessage()
    44  	var dest Request
    45  
    46  	// act
    47  	err := msg.CastPayloadToType(dest)
    48  
    49  	// assert
    50  	assert.NotNil(t, err)
    51  	assert.NotEqual(t, "dummy-value-coming-through", dest.Request)
    52  }
    53  
    54  func TestMessage_CastPayloadToType_NilPointer(t *testing.T) {
    55  	// arrange
    56  	msg := getNewTestMessage()
    57  	var dest *Request
    58  
    59  	// act
    60  	err := msg.CastPayloadToType(dest)
    61  
    62  	// assert
    63  	assert.NotNil(t, err)
    64  	assert.Nil(t, dest)
    65  }
    66  
    67  func TestMessage_CastPayloadToType_UnmarshalledResponse_ByteSlice(t *testing.T) {
    68  	// arrange
    69  	msg := getUnmarshalledResponseMessage([]byte("I am a teapot"))
    70  	dest := make([]byte, 0)
    71  
    72  	// act
    73  	err := msg.CastPayloadToType(&dest)
    74  
    75  	// assert
    76  	assert.Nil(t, err)
    77  	assert.EqualValues(t, []byte("I am a teapot"), dest)
    78  }
    79  
    80  func TestMessage_CastPayloadToType_UnmarshalledResponse_Map(t *testing.T) {
    81  	// arrange
    82  	msg := getUnmarshalledResponseMessage(map[string]interface{}{"418": "I am a teapot"})
    83  	dest := make(map[string]string)
    84  
    85  	// act
    86  	err := msg.CastPayloadToType(&dest)
    87  	val, keyFound := dest["418"]
    88  
    89  	// assert
    90  	assert.Nil(t, err)
    91  	assert.True(t, keyFound)
    92  	assert.EqualValues(t, "I am a teapot", val)
    93  }
    94  
    95  func TestMessage_CastPayloadToType_ErrorResponse(t *testing.T) {
    96  	// arrange
    97  	msg := getErrorResponseMessage()
    98  	dest := make([]byte, 0)
    99  
   100  	// act
   101  	err := msg.CastPayloadToType(&dest)
   102  
   103  	// assert
   104  	assert.NotNil(t, err)
   105  	assert.EqualValues(t, "Bad Request", err.Error())
   106  }
   107  
   108  func getNewTestMessage() *Message {
   109  	rspPayload := &Response{
   110  		Id:      &uuid.UUID{},
   111  		Payload: Request{Request: "dummy-value-coming-through"},
   112  	}
   113  
   114  	jsonEncoded, _ := json.Marshal(rspPayload)
   115  	return &Message{
   116  		Id:      &uuid.UUID{},
   117  		Channel: "test",
   118  		Payload: jsonEncoded,
   119  	}
   120  }
   121  
   122  func getUnmarshalledResponseMessage(payload interface{}) *Message {
   123  	rspPayload := &Response{
   124  		Id:      &uuid.UUID{},
   125  		Payload: payload,
   126  	}
   127  
   128  	return &Message{
   129  		Id:      &uuid.UUID{},
   130  		Channel: "test",
   131  		Payload: reflect.ValueOf(rspPayload).Interface(),
   132  	}
   133  }
   134  
   135  func getErrorResponseMessage() *Message {
   136  	rspPayload := &Response{
   137  		Id:           &uuid.UUID{},
   138  		Error:        true,
   139  		ErrorCode:    400,
   140  		ErrorMessage: "Bad Request",
   141  	}
   142  	return &Message{
   143  		Id:      &uuid.UUID{},
   144  		Channel: "test",
   145  		Payload: reflect.ValueOf(rspPayload).Interface(),
   146  	}
   147  }