Fix model in reschedule (#130)

* Add testing types

* Add testing

* Add testing input case

* Update model on reinvoke

* Remove extra line spacing

* Remove unneeded logging

Author: brianterry

cfn/cfn.go

@@ -199,7 +199,6 @@ func isMutatingAction(action string) bool {
 }
 
 func translateStatus(operationStatus handler.Status) callback.Status {
-
 	switch operationStatus {
 	case handler.Success:
 		return callback.Success
@@ -214,42 +213,39 @@ func translateStatus(operationStatus handler.Status) callback.Status {
 }
 
 func processinvoke(handlerFn handlerFunc, event *event, request handler.Request, metricsPublisher *metrics.Publisher) handler.ProgressEvent {
-
 	progEvt, err := invoke(handlerFn, request, metricsPublisher, event.Action)
-
 	if err != nil {
 		log.Printf("Handler invocation failed: %v", err)
 		return handler.NewFailedEvent(err)
 	}
 	return progEvt
-
 }
 
 func reschedule(ctx context.Context, invokeScheduler InvokeScheduler, progEvt handler.ProgressEvent, event *event) (bool, error) {
 	cusCtx, delay := marshalCallback(&progEvt)
 	ids, err := scheduler.GenerateCloudWatchIDS()
-
 	if err != nil {
 		return false, err
 	}
 	// Add IDs to recall the function with Cloudwatch events
 	event.RequestContext.CloudWatchEventsRuleName = ids.Handler
 	event.RequestContext.CloudWatchEventsTargetID = ids.Target
-
+	// Update model properties
+	m, err := encoding.Marshal(progEvt.ResourceModel)
+	if err != nil {
+		return false, err
+	}
+	event.RequestData.ResourceProperties = m
 	// Rebuild the context
 	event.RequestContext.CallbackContext = cusCtx
-
 	callbackRequest, err := json.Marshal(event)
-
 	if err != nil {
 		return false, err
 	}
 	scheResult, err := invokeScheduler.Reschedule(ctx, delay, string(callbackRequest), ids)
-
 	if err != nil {
 		return false, err
 	}
-
 	return scheResult.ComputeLocal, nil
 }
 
@@ -313,18 +309,12 @@ func makeEventFunc(h Handler) eventFunc {
 
 			progEvt := processinvoke(handlerFn, event, request, metricsPublisher)
 
-			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)
 			}
 
-			log.Printf("Handler returned  OperationStatus: %v Message: %v CallbackContext: %v Delay: %v, ErrorCode: %v  ",
-				r.OperationStatus, progEvt.Message,
-				cusCtx, delay, progEvt.HandlerErrorCode)
-
 			if !isMutatingAction(event.Action) && r.OperationStatus == handler.InProgress {
 				return re.report(event, "Response error", errors.New("READ and LIST handlers must return synchronous"), invalidRequestError)
 			}
@@ -357,23 +347,18 @@ func makeEventFunc(h Handler) eventFunc {
 // contract testing framework to invoke the resource's CRUDL handlers.
 func makeTestEventFunc(h Handler) testEventFunc {
 	return func(ctx context.Context, event *testEvent) (handler.ProgressEvent, error) {
-
 		handlerFn, err := router(event.Action, h)
-
 		if err != nil {
 			return handler.NewFailedEvent(err), err
 		}
-
 		request := handler.NewRequest(
 			event.Request.LogicalResourceIdentifier,
 			event.CallbackContext,
 			credentials.SessionFromCredentialsProvider(&event.Credentials),
 			event.Request.PreviousResourceState,
 			event.Request.DesiredResourceState,
 		)
-
 		progEvt := handlerFn(request)
-
 		return progEvt, nil
 	}
 }

cfn/cfn_test.go

@@ -10,9 +10,11 @@ import (
 	"testing"
 	"time"
 
+	"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/scheduler"
 	"github.com/aws/aws-lambda-go/lambdacontext"
+	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/cloudformation"
 )
@@ -319,3 +321,72 @@ func loadTestEvent(path string, evt *testEvent) *testEvent {
 	}
 	return evt
 }
+
+func TestMakeEventFuncModel(t *testing.T) {
+	start := time.Now()
+	future := start.Add(time.Minute * 15)
+	tc, cancel := context.WithDeadline(context.Background(), future)
+	defer cancel()
+	lc := lambdacontext.NewContext(tc, &lambdacontext.LambdaContext{})
+	f1 := func(r handler.Request) handler.ProgressEvent {
+		m := MockModel{}
+		if len(r.CallbackContext) == 1 {
+			if err := r.Unmarshal(&m); err != nil {
+				return handler.NewFailedEvent(err)
+			}
+			return handler.ProgressEvent{
+				OperationStatus: handler.Success,
+				ResourceModel:   &m,
+				Message:         "Success",
+			}
+		}
+		if err := r.Unmarshal(&m); err != nil {
+			return handler.NewFailedEvent(err)
+		}
+		m.Property2 = aws.String("change")
+		return handler.ProgressEvent{
+			OperationStatus:      handler.InProgress,
+			Message:              "In Progress",
+			CallbackDelaySeconds: 3,
+			CallbackContext:      map[string]interface{}{"foo": "bar"},
+			ResourceModel:        &m,
+		}
+	}
+	type args struct {
+		h     Handler
+		ctx   context.Context
+		event *event
+	}
+	tests := []struct {
+		name string
+		args args
+		want MockModel
+	}{
+		{"Test CREATE async local with model change", args{&MockModelHandler{f1}, lc, loadEvent("request.create2.json", &event{})}, MockModel{
+			Property1: aws.String("abc"),
+			Property2: aws.String("change"),
+		}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := makeEventFunc(tt.args.h)
+			got, err := f(tt.args.ctx, tt.args.event)
+			if err != nil {
+				t.Errorf("TestMakeEventFuncModel() = %v", err)
+				return
+			}
+			model, err := encoding.Stringify(got.ResourceModel)
+			if err != nil {
+				t.Errorf("TestMakeEventFuncModel() = %v", err)
+			}
+			wantrModel, err := encoding.Stringify(tt.want)
+			if err != nil {
+				t.Errorf("TestMakeEventFuncModel() = %v", err)
+			}
+			if wantrModel != model {
+				t.Errorf("response = %v; want %v", model, wantrModel)
+			}
+
+		})
+	}
+}

cfn/test/data/request.create2.json

@@ -0,0 +1,27 @@
+{
+    "awsAccountId": "123456789012",
+    "bearerToken": "123456",
+    "region": "us-east-1",
+    "action": "CREATE",
+    "responseEndpoint": "cloudformation.us-west-2.amazonaws.com",
+    "resourceType": "AWS::Test::TestModel",
+    "resourceTypeVersion": "1.0",
+    "requestContext": {},
+    "requestData": {
+        "callerCredentials": {
+            "accessKeyId": "IASAYK835GAIFHAHEI23",
+            "secretAccessKey": "66iOGPN5LnpZorcLr8Kh25u8AbjHVllv5/poh2O0",
+            "sessionToken": "lameHS2vQOknSHWhdFYTxm2eJc1JMn9YBNI4nV4mXue945KPL6DHfW8EsUQT5zwssYEC1NvYP9yD6Y5s5lKR3chflOHPFsIe6eqg"
+        },
+        "platformCredentials": {
+            "accessKeyId": "32IEHAHFIAG538KYASAI",
+            "secretAccessKey": "0O2hop/5vllVHjbA8u52hK8rLcroZpnL5NPGOi66",
+            "sessionToken": "gqe6eIsFPHOlfhc3RKl5s5Y6Dy9PYvN1CEYsswz5TQUsE8WfHD6LPK549euXm4Vn4INBY9nMJ1cJe2mxTYFdhWHSnkOQv2SHemal"
+        },
+        "logicalResourceId": "myBucket",
+        "resourceProperties": {
+            "property1": "abc"
+        }
+    },
+    "stackId": "arn:aws:cloudformation:us-east-1:123456789012:stack/SampleStack/e722ae60-fe62-11e8-9a0e-0ae8cc519968"
+}

cfn/types_test.go

@@ -109,3 +109,38 @@ type MockScheduler struct {
 func (m MockScheduler) Reschedule(lambdaCtx context.Context, secsFromNow int64, callbackRequest string, invocationIDS *scheduler.ScheduleIDS) (*scheduler.Result, error) {
 	return m.Result, m.Err
 }
+
+// MockModel mocks a resource model
+//
+// This implementation of the handlers is only used for testing.
+type MockModel struct {
+	Property1 *string `json:"property1,omitempty"`
+	Property2 *string `json:"property2,omitempty"`
+}
+
+// MockModelHandler is a implementation of Handler
+//
+// This implementation of the handlers is only used for testing.
+type MockModelHandler struct {
+	fn func(r handler.Request) handler.ProgressEvent
+}
+
+func (m *MockModelHandler) Create(request handler.Request) handler.ProgressEvent {
+	return m.fn(request)
+}
+
+func (m *MockModelHandler) Read(request handler.Request) handler.ProgressEvent {
+	return m.fn(request)
+}
+
+func (m *MockModelHandler) Update(request handler.Request) handler.ProgressEvent {
+	return m.fn(request)
+}
+
+func (m *MockModelHandler) Delete(request handler.Request) handler.ProgressEvent {
+	return m.fn(request)
+}
+
+func (m *MockModelHandler) List(request handler.Request) handler.ProgressEvent {
+	return m.fn(request)
+}