add invoke impl with just completed event

Author: austinvalle

action/action.go

@@ -12,7 +12,10 @@ type Action interface {
 	// Metadata should return the full name of the action, such as examplecloud_do_thing.
 	Metadata(context.Context, MetadataRequest, *MetadataResponse)
 
-	// TODO:Actions: Eventual landing place for all required methods to implement for an action
+	// Invoke is called to run the logic of the action and update linked resources if applicable.
+	// Config, linked resource planned state, and linked resource prior state values should
+	// be read from the InvokeRequest and new linked resource state values set on the InvokeResponse.
+	Invoke(context.Context, InvokeRequest, *InvokeResponse)
 }
 
 // ActionWithConfigure is an interface type that extends Action to

action/invoke.go

@@ -0,0 +1,32 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package action
+
+import (
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
+)
+
+// InvokeRequest represents a request for the provider to invoke the action and update
+// the requested action's linked resources.
+type InvokeRequest struct {
+	// Config is the configuration the user supplied for the action.
+	Config tfsdk.Config
+
+	// TODO:Actions: Add linked resources once lifecycle/linked actions are implemented
+}
+
+// InvokeResponse represents a response to an InvokeRequest. An
+// instance of this response struct is supplied as
+// an argument to the action's Invoke function, in which the provider
+// should set values on the InvokeResponse as appropriate.
+type InvokeResponse struct {
+	// Diagnostics report errors or warnings related to invoking the action or updating
+	// the state of the requested action's linked resources. Returning an empty slice
+	// indicates a successful invocation with no warnings or errors
+	// generated.
+	Diagnostics diag.Diagnostics
+
+	// TODO:Actions: Add linked resources once lifecycle/linked actions are implemented
+}

internal/fromproto5/invokeaction.go

@@ -37,6 +37,7 @@ func InvokeActionRequest(ctx context.Context, proto5 *tfprotov5.InvokeActionRequ
 	}
 
 	fw := &fwserver.InvokeActionRequest{
+		Action:       reqAction,
 		ActionSchema: actionSchema,
 	}
 

internal/fromproto6/invokeaction.go

@@ -37,6 +37,7 @@ func InvokeActionRequest(ctx context.Context, proto6 *tfprotov6.InvokeActionRequ
 	}
 
 	fw := &fwserver.InvokeActionRequest{
+		Action:       reqAction,
 		ActionSchema: actionSchema,
 	}
 

internal/fwserver/server_invokeaction.go

@@ -6,13 +6,17 @@ package fwserver
 import (
 	"context"
 
+	"github.com/hashicorp/terraform-plugin-framework/action"
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/hashicorp/terraform-plugin-framework/internal/fwschema"
+	"github.com/hashicorp/terraform-plugin-framework/internal/logging"
 	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
 )
 
 // InvokeActionRequest is the framework server request for the InvokeAction RPC.
 type InvokeActionRequest struct {
+	Action       action.Action
 	ActionSchema fwschema.Schema
 	Config       *tfsdk.Config
 }
@@ -24,9 +28,44 @@ type InvokeActionResponse struct {
 
 // InvokeAction implements the framework server InvokeAction RPC.
 func (s *Server) InvokeAction(ctx context.Context, req *InvokeActionRequest, resp *InvokeActionResponse) {
-	// TODO:Actions: Implementation coming soon...
-	resp.Diagnostics.AddError(
-		"InvokeAction Not Implemented",
-		"InvokeAction has not yet been implemented in terraform-plugin-framework.",
-	)
+	if req == nil {
+		return
+	}
+
+	if actionWithConfigure, ok := req.Action.(action.ActionWithConfigure); ok {
+		logging.FrameworkTrace(ctx, "Action implements ActionWithConfigure")
+
+		configureReq := action.ConfigureRequest{
+			ProviderData: s.ActionConfigureData,
+		}
+		configureResp := action.ConfigureResponse{}
+
+		logging.FrameworkTrace(ctx, "Calling provider defined Action Configure")
+		actionWithConfigure.Configure(ctx, configureReq, &configureResp)
+		logging.FrameworkTrace(ctx, "Called provider defined Action Configure")
+
+		resp.Diagnostics.Append(configureResp.Diagnostics...)
+
+		if resp.Diagnostics.HasError() {
+			return
+		}
+	}
+
+	if req.Config == nil {
+		req.Config = &tfsdk.Config{
+			Raw:    tftypes.NewValue(req.ActionSchema.Type().TerraformType(ctx), nil),
+			Schema: req.ActionSchema,
+		}
+	}
+
+	invokeReq := action.InvokeRequest{
+		Config: *req.Config,
+	}
+	invokeResp := action.InvokeResponse{}
+
+	logging.FrameworkTrace(ctx, "Calling provider defined Action Invoke")
+	req.Action.Invoke(ctx, invokeReq, &invokeResp)
+	logging.FrameworkTrace(ctx, "Called provider defined Action Invoke")
+
+	resp.Diagnostics = invokeResp.Diagnostics
 }

internal/fwserver/server_invokeaction_test.go

@@ -3,4 +3,183 @@
 
 package fwserver_test
 
-// TODO:Actions: Add unit tests once InvokeAction is implemented
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/terraform-plugin-framework/action"
+	"github.com/hashicorp/terraform-plugin-framework/action/schema"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/internal/fwserver"
+	"github.com/hashicorp/terraform-plugin-framework/internal/testing/testprovider"
+	"github.com/hashicorp/terraform-plugin-framework/provider"
+	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+)
+
+func TestServerInvokeAction(t *testing.T) {
+	t.Parallel()
+
+	testType := tftypes.Object{
+		AttributeTypes: map[string]tftypes.Type{
+			"test_required": tftypes.String,
+		},
+	}
+
+	testConfigValue := tftypes.NewValue(testType, map[string]tftypes.Value{
+		"test_required": tftypes.NewValue(tftypes.String, "test-config-value"),
+	})
+
+	testUnlinkedSchema := schema.UnlinkedSchema{
+		Attributes: map[string]schema.Attribute{
+			"test_required": schema.StringAttribute{
+				Required: true,
+			},
+		},
+	}
+
+	testUnlinkedConfig := &tfsdk.Config{
+		Raw:    testConfigValue,
+		Schema: testUnlinkedSchema,
+	}
+
+	testCases := map[string]struct {
+		server               *fwserver.Server
+		request              *fwserver.InvokeActionRequest
+		expectedResponse     *fwserver.InvokeActionResponse
+		configureProviderReq *provider.ConfigureRequest
+	}{
+		"nil": {
+			server: &fwserver.Server{
+				Provider: &testprovider.Provider{},
+			},
+			expectedResponse: &fwserver.InvokeActionResponse{},
+		},
+		"unlinked-nil-config": {
+			server: &fwserver.Server{
+				Provider: &testprovider.Provider{},
+			},
+			request: &fwserver.InvokeActionRequest{
+				ActionSchema: testUnlinkedSchema,
+				Action: &testprovider.Action{
+					InvokeMethod: func(ctx context.Context, req action.InvokeRequest, resp *action.InvokeResponse) {
+						if !req.Config.Raw.IsNull() {
+							resp.Diagnostics.AddError("Unexpected Config in action Invoke", "Expected Config to be null")
+						}
+					},
+				},
+			},
+			expectedResponse: &fwserver.InvokeActionResponse{},
+		},
+		"request-config": {
+			server: &fwserver.Server{
+				Provider: &testprovider.Provider{},
+			},
+			request: &fwserver.InvokeActionRequest{
+				Config:       testUnlinkedConfig,
+				ActionSchema: testUnlinkedSchema,
+				Action: &testprovider.Action{
+					InvokeMethod: func(ctx context.Context, req action.InvokeRequest, resp *action.InvokeResponse) {
+						var config struct {
+							TestRequired types.String `tfsdk:"test_required"`
+						}
+
+						resp.Diagnostics.Append(req.Config.Get(ctx, &config)...)
+
+						if config.TestRequired.ValueString() != "test-config-value" {
+							resp.Diagnostics.AddError("unexpected req.Config value: %s", config.TestRequired.ValueString())
+						}
+					},
+				},
+			},
+			expectedResponse: &fwserver.InvokeActionResponse{},
+		},
+		"action-configure-data": {
+			server: &fwserver.Server{
+				ActionConfigureData: "test-provider-configure-value",
+				Provider:            &testprovider.Provider{},
+			},
+			request: &fwserver.InvokeActionRequest{
+				Config:       testUnlinkedConfig,
+				ActionSchema: testUnlinkedSchema,
+				Action: &testprovider.ActionWithConfigure{
+					ConfigureMethod: func(ctx context.Context, req action.ConfigureRequest, resp *action.ConfigureResponse) {
+						providerData, ok := req.ProviderData.(string)
+
+						if !ok {
+							resp.Diagnostics.AddError(
+								"Unexpected ConfigureRequest.ProviderData",
+								fmt.Sprintf("Expected string, got: %T", req.ProviderData),
+							)
+							return
+						}
+
+						if providerData != "test-provider-configure-value" {
+							resp.Diagnostics.AddError(
+								"Unexpected ConfigureRequest.ProviderData",
+								fmt.Sprintf("Expected test-provider-configure-value, got: %q", providerData),
+							)
+						}
+					},
+					Action: &testprovider.Action{
+						InvokeMethod: func(ctx context.Context, req action.InvokeRequest, resp *action.InvokeResponse) {
+							// In practice, the Configure method would save the
+							// provider data to the Action implementation and
+							// use it here. The fact that Configure is able to
+							// read the data proves this can work.
+						},
+					},
+				},
+			},
+			expectedResponse: &fwserver.InvokeActionResponse{},
+		},
+		"response-diagnostics": {
+			server: &fwserver.Server{
+				Provider: &testprovider.Provider{},
+			},
+			request: &fwserver.InvokeActionRequest{
+				Config:       testUnlinkedConfig,
+				ActionSchema: testUnlinkedSchema,
+				Action: &testprovider.Action{
+					InvokeMethod: func(ctx context.Context, req action.InvokeRequest, resp *action.InvokeResponse) {
+						resp.Diagnostics.AddWarning("warning summary", "warning detail")
+						resp.Diagnostics.AddError("error summary", "error detail")
+					},
+				},
+			},
+			expectedResponse: &fwserver.InvokeActionResponse{
+				Diagnostics: diag.Diagnostics{
+					diag.NewWarningDiagnostic(
+						"warning summary",
+						"warning detail",
+					),
+					diag.NewErrorDiagnostic(
+						"error summary",
+						"error detail",
+					),
+				},
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			if testCase.configureProviderReq != nil {
+				configureProviderResp := &provider.ConfigureResponse{}
+				testCase.server.ConfigureProvider(context.Background(), testCase.configureProviderReq, configureProviderResp)
+			}
+
+			response := &fwserver.InvokeActionResponse{}
+			testCase.server.InvokeAction(context.Background(), testCase.request, response)
+
+			if diff := cmp.Diff(response, testCase.expectedResponse); diff != "" {
+				t.Errorf("unexpected difference: %s", diff)
+			}
+		})
+	}
+}

internal/proto5server/server_invokeaction.go

@@ -60,6 +60,8 @@ func (s *Server) InvokeAction(ctx context.Context, proto5Req *tfprotov5.InvokeAc
 		return invokeActionErrorDiagnostics(ctx, fwResp.Diagnostics)
 	}
 
+	// TODO:Actions: Create messaging call back for progress updates
+
 	s.FrameworkServer.InvokeAction(ctx, fwReq, fwResp)
 
 	// TODO:Actions: This is a stub implementation, so we aren't currently exposing any streaming mechanism to the developer.