Move stringifying encoder into response constructor (#113)

* Move stringifying encoder into response constructor

* Deal with composite types properly in the type resolver

* Complete implementation of Stringify

* Move populate into its own file and rename it Unstringify

Author: stilvoid

cfn/cfn.go

@@ -11,6 +11,7 @@ import (
 	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/callback"
 	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/cfnerr"
 	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/credentials"
+	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/encoding"
 	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/handler"
 	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/logging"
 	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/metrics"
@@ -152,6 +153,14 @@ func invoke(handlerFn handlerFunc, request handler.Request, metricsPublisher *me
 
 			// Report the work is done.
 			progEvt := handlerFn(request)
+
+			marshaled, _ := encoding.Marshal(progEvt.ResourceModel)
+			log.Printf("Received event: %s\nMessage: %s\nBody: %s",
+				progEvt.OperationStatus,
+				progEvt.Message,
+				marshaled,
+			)
+
 			elapsed := time.Since(start)
 			metricsPublisher.PublishDurationMetric(time.Now(), string(action), elapsed.Seconds()*1e3)
 			ch <- progEvt
@@ -209,6 +218,7 @@ func processinvoke(handlerFn handlerFunc, event *event, request handler.Request,
 	progEvt, err := invoke(handlerFn, request, metricsPublisher, event.Action)
 
 	if err != nil {
+		log.Printf("Handler invocation failed: %v", err)
 		return handler.NewFailedEvent(err)
 	}
 	return progEvt
@@ -306,8 +316,8 @@ func makeEventFunc(h Handler) eventFunc {
 			cusCtx, delay := marshalCallback(&progEvt)
 
 			r, err := newResponse(&progEvt, event.BearerToken)
-
 			if err != nil {
+				log.Printf("Error creating response: %v", err)
 				return re.report(event, "Response error", err, unmarshalingError)
 			}
 

cfn/cfn_test.go

@@ -276,7 +276,7 @@ func TestMakeTestEventFunc(t *testing.T) {
 			OperationStatus: handler.Success,
 			Message:         "Create complete",
 		}, false},
-		{"Test simple INVALID", args{&MockHandler{f1}, lc, loadTestEvent("test.invalid.json", &testEvent{})}, handler.ProgressEvent{
+		{"Test simple INVALID", args{&MockHandler{f1}, lc, loadTestEvent("test.INVALID.json", &testEvent{})}, handler.ProgressEvent{
 			OperationStatus: handler.Failed,
 			Message:         "InvalidRequest: No action/invalid action specified",
 		}, true},

cfn/encoding/encoding.go

@@ -1,6 +1,5 @@
 /*
-Package encoding defines custom types for strings, bools, ints, and floats
-that must be used my resource provider model structs.
+Package encoding defines types and functions used for dealing with stringified-JSON.
 */
 package encoding
 
@@ -10,6 +9,7 @@ import (
 	"strconv"
 )
 
+// String is a string type to be used when the default json marshaler/unmarshaler cannot be avoided
 type String string
 
 func NewString(ss string) *String {
@@ -36,6 +36,7 @@ func (s *String) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// Bool is a bool type to be used when the default json marshaler/unmarshaler cannot be avoided
 type Bool bool
 
 func NewBool(bb bool) *Bool {
@@ -67,6 +68,7 @@ func (b *Bool) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// Int is an int type to be used when the default json marshaler/unmarshaler cannot be avoided
 type Int int64
 
 func NewInt(ii int64) *Int {
@@ -98,6 +100,7 @@ func (i *Int) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// Float is a float type to be used when the default json marshaler/unmarshaler cannot be avoided
 type Float float64
 
 func NewFloat(ff float64) *Float {

cfn/encoding/encoding_test.go

@@ -7,138 +7,97 @@ import (
 	"github.com/aws-cloudformation/cloudformation-cli-go-plugin/cfn/encoding"
 
 	"github.com/google/go-cmp/cmp"
+
+	"github.com/aws/aws-sdk-go/aws"
 )
 
-type Model struct {
-	ModelString *encoding.String `json:"modelString,omitempty"`
-	ModelBool   *encoding.Bool   `json:"modelBool,omitempty"`
-	ModelInt    *encoding.Int    `json:"modelInt,omitempty"`
-	ModelFloat  *encoding.Float  `json:"modelFloat,omitempty"`
-	ModelSlice  []Inner          `json:"modelSlice,omitempty"`
-	ModelMap    map[string]Inner `json:"modelMap,omitempty"`
-	ModelNested json.RawMessage  `json:"embedded,omitempty"`
-}
+func TestEncoding(t *testing.T) {
+	type Nested struct {
+		SP *string  `json:",omitempty"`
+		BP *bool    `json:",omitempty"`
+		IP *int     `json:"intField,omitempty"`
+		FP *float64 `json:"floatPointer,omitempty"`
+
+		S string `json:"stringValue,omitempty"`
+		B bool   `json:",omitempty"`
+		I int
+		F float64 `json:",omitempty"`
+	}
 
-type Inner struct {
-	InnerString *encoding.String `json:"innerString,omitempty"`
-	InnerBool   *encoding.Bool   `json:"innerBool,omitempty"`
-	InnerInt    *encoding.Int    `json:"innerInt,omitempty"`
-	InnerFloat  *encoding.Float  `json:"innerFloat"` // No omitempty
-}
+	type Main struct {
+		SP *string
+		BP *bool    `json:",omitempty"`
+		IP *int     `json:",omitempty"`
+		FP *float64 `json:",omitempty"`
+		NP *Nested  `json:"nestedPointer,omitempty"`
+
+		S string `json:",omitempty"`
+		B bool   `json:"boolValue,omitempty"`
+		I int    `json:",omitempty"`
+		F float64
+		N Nested `json:",omitempty"`
+	}
 
-var model = Model{
-	ModelBool:  encoding.NewBool(false),
-	ModelInt:   encoding.NewInt(42),
-	ModelFloat: encoding.NewFloat(3.14),
-	ModelSlice: []Inner{
-		{
-			InnerString: encoding.NewString("bar"),
-			InnerInt:    encoding.NewInt(43),
-			InnerFloat:  encoding.NewFloat(6.28),
-		},
-	},
-	ModelMap: map[string]Inner{
-		"ModelMapInner": {
-			InnerString: encoding.NewString("baz"),
-			InnerBool:   encoding.NewBool(false),
-			InnerFloat:  encoding.NewFloat(9.42),
+	m := Main{
+		SP: aws.String("foo"),
+		IP: aws.Int(42),
+		NP: &Nested{
+			BP: aws.Bool(true),
+			FP: aws.Float64(3.14),
 		},
-	},
-	ModelNested: []byte(`{"innerBool":"true","innerFloat":null,"innerInt":"45"}`),
-}
 
-var stringified = map[string]interface{}{
-	"modelBool":  "false",
-	"modelInt":   "42",
-	"modelFloat": "3.14",
-	"modelSlice": []interface{}{
-		map[string]interface{}{
-			"innerString": "bar",
-			"innerInt":    "43",
-			"innerFloat":  "6.28",
-		},
-	},
-	"modelMap": map[string]interface{}{
-		"ModelMapInner": map[string]interface{}{
-			"innerString": "baz",
-			"innerBool":   "false",
-			"innerFloat":  "9.42",
+		B: true,
+		F: 2.72,
+		N: Nested{
+			S: "bar",
+			I: 54,
 		},
-	},
-	"embedded": map[string]interface{}{
-		"innerBool":  "true",
-		"innerInt":   "45",
-		"innerFloat": nil,
-	},
-}
-
-func TestString(t *testing.T) {
-	v := "Hello, world!"
-	s := encoding.NewString(v)
-
-	// Value
-	if *s.Value() != v {
-		t.Errorf("Value failed: %v", s.Value())
 	}
 
-	// Marshal
-	data, err := json.Marshal(s)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if string(data) != `"Hello, world!"` {
-		t.Error("Marshal failed: " + string(data))
-	}
-
-	// Unmarshal value
-	v = "Unmarshal me"
-	data, err = json.Marshal(v)
-	if err != nil {
-		panic(err)
-	}
+	stringMap := map[string]interface{}{
+		"SP": "foo",
+		"IP": "42",
+		"nestedPointer": map[string]interface{}{
+			"BP":           "true",
+			"I":            "0",
+			"floatPointer": "3.14",
+		},
 
-	err = json.Unmarshal(data, s)
-	if err != nil {
-		t.Error(err)
+		"boolValue": "true",
+		"F":         "2.72",
+		"N": map[string]interface{}{
+			"stringValue": "bar",
+			"I":           "54",
+		},
 	}
 
-	if *s.Value() != v {
-		t.Errorf("Unmarshal value failed: %v", s.Value())
-	}
-}
+	var err error
 
-func TestMarshal(t *testing.T) {
-	data, err := json.Marshal(model)
+	rep, err := encoding.Marshal(m)
 	if err != nil {
-		t.Error(err)
+		t.Errorf("Unexpected error: %v", err)
 	}
 
-	actual := make(map[string]interface{})
-	err = json.Unmarshal(data, &actual)
+	// Test that rep can be unmarshalled as regular JSON
+	var jsonTest map[string]interface{}
+	err = json.Unmarshal(rep, &jsonTest)
 	if err != nil {
-		t.Error(err)
+		t.Errorf("Unexpected error: %v", err)
 	}
 
-	if diff := cmp.Diff(stringified, actual); diff != "" {
-		t.Error(diff)
+	// And check it matches the expected form
+	if diff := cmp.Diff(jsonTest, stringMap); diff != "" {
+		t.Errorf(diff)
 	}
-}
 
-func TestUnmarshal(t *testing.T) {
-	data, err := json.Marshal(stringified)
+	// Now check we can get the original struct back
+	var b Main
+	err = encoding.Unmarshal(rep, &b)
 	if err != nil {
 		panic(err)
 	}
 
-	actual := Model{}
-
-	err = json.Unmarshal(data, &actual)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if diff := cmp.Diff(model, actual); diff != "" {
-		t.Error(diff)
+	if diff := cmp.Diff(m, b); diff != "" {
+		t.Errorf(diff)
 	}
 }

cfn/encoding/marshal.go

@@ -0,0 +1,15 @@
+package encoding
+
+import (
+	"encoding/json"
+)
+
+// Marshal converts a value into stringified-JSON
+func Marshal(v interface{}) ([]byte, error) {
+	stringified, err := Stringify(v)
+	if err != nil {
+		return nil, err
+	}
+
+	return json.Marshal(stringified)
+}