Merge pull request #41240 from Giaco9NN/f-aws-lambda-invocation-import-support

aws_lambda_invocation: Add import support

Author: YakDriver

.changelog/41240.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+resource/aws_lambda_invocation: Add import support
+```

internal/service/lambda/exports_test.go

@@ -35,6 +35,7 @@ var (
 	LayerVersionParseResourceID                  = layerVersionParseResourceID
 	LayerVersionPermissionParseResourceID        = layerVersionPermissionParseResourceID
 	SignerServiceIsAvailable                     = signerServiceIsAvailable
+	InvocationParseResourceID                    = invocationParseResourceID
 
 	ValidFunctionName               = validFunctionName
 	ValidPermissionAction           = validPermissionAction

internal/service/lambda/invocation.go

@@ -12,6 +12,7 @@ import (
 	"log"
 	"strings"
 
+	"github.com/YakDriver/regexache"
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/service/lambda"
 	awstypes "github.com/aws/aws-sdk-go-v2/service/lambda/types"
@@ -22,9 +23,14 @@ import (
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
 	"github.com/hashicorp/terraform-provider-aws/internal/enum"
 	"github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag"
+	"github.com/hashicorp/terraform-provider-aws/internal/flex"
 	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
+const (
+	invocationResourceIDPartCount = 3
+)
+
 // @SDKResource("aws_lambda_invocation", name="Invocation")
 func resourceInvocation() *schema.Resource {
 	return &schema.Resource{
@@ -41,6 +47,19 @@ func resourceInvocation() *schema.Resource {
 				Version: 0,
 			},
 		},
+		Importer: &schema.ResourceImporter{
+			StateContext: func(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) {
+				functionName, qualifier, _, err := invocationParseResourceID(d.Id())
+				if err != nil {
+					return nil, err
+				}
+
+				d.Set("function_name", functionName)
+				d.Set("qualifier", qualifier)
+
+				return []*schema.ResourceData{d}, nil
+			},
+		},
 
 		Schema: map[string]*schema.Schema{
 			"function_name": {
@@ -205,7 +224,13 @@ func invoke(ctx context.Context, conn *lambda.Client, d *schema.ResourceData, ac
 		return sdkdiag.AppendErrorf(diags, "invoking Lambda Function (%s): %s", functionName, string(output.Payload))
 	}
 
-	d.SetId(fmt.Sprintf("%s_%s_%x", functionName, qualifier, md5.Sum(payload)))
+	resultHash := fmt.Sprintf("%x", md5.Sum(payload))
+	id, err := flex.FlattenResourceId([]string{functionName, qualifier, resultHash}, invocationResourceIDPartCount, false)
+	if err != nil {
+		return sdkdiag.AppendFromErr(diags, err)
+	}
+
+	d.SetId(id)
 	d.Set("result", string(output.Payload))
 
 	return diags
@@ -248,3 +273,26 @@ func customizeDiffInputChangeWithCRUDScope(_ context.Context, diff *schema.Resou
 	}
 	return nil
 }
+
+func invocationParseResourceID(id string) (string, string, string, error) {
+	parts, err := flex.ExpandResourceId(id, invocationResourceIDPartCount, false)
+	if err != nil {
+		return "", "", "", err
+	}
+
+	functionName := parts[0]
+	qualifier := parts[1]
+	resultHash := parts[2]
+
+	// Validate qualifier format
+	if qualifier != "$LATEST" && !regexache.MustCompile(`^[0-9]+$`).MatchString(qualifier) {
+		return "", "", "", fmt.Errorf("invalid qualifier format: %s, expected $LATEST or numeric version", qualifier)
+	}
+
+	// Validate hash format (should be MD5 - 32 hex chars)
+	if !regexache.MustCompile(`^[a-f0-9]{32}$`).MatchString(resultHash) {
+		return "", "", "", fmt.Errorf("invalid result hash format: %s, expected 32-character MD5 hash", resultHash)
+	}
+
+	return functionName, qualifier, resultHash, nil
+}

internal/service/lambda/invocation_test.go

@@ -16,10 +16,89 @@ import (
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
 	"github.com/hashicorp/terraform-provider-aws/internal/acctest"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
+	tflambda "github.com/hashicorp/terraform-provider-aws/internal/service/lambda"
 	"github.com/hashicorp/terraform-provider-aws/internal/verify"
 	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
+func TestParseRecordID(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		Input                               string
+		FunctionName, Qualifier, ResultHash string
+		ExpectError                         bool
+	}{
+		// Invalid cases
+		{"ABCDEF", "", "", "", true},
+		{"ABCDEF,42", "", "", "", true},
+		{"ABCDEF,,", "", "", "", true},
+		{"ABCDEF,invalid_qualifier,b326b5062b2f0e69046810717534cb09", "", "", "", true},
+		{"ABCDEF,42,invalid_hash", "", "", "", true},
+		// Valid cases
+		{"ABCDEF,42,b326b5062b2f0e69046810717534cb09", "ABCDEF", "42", "b326b5062b2f0e69046810717534cb09", false},
+		{"ABC_DEF,42,b326b5062b2f0e69046810717534cb09", "ABC_DEF", "42", "b326b5062b2f0e69046810717534cb09", false},
+		{"ABCDEF,$LATEST,b326b5062b2f0e69046810717534cb09", "ABCDEF", "$LATEST", "b326b5062b2f0e69046810717534cb09", false},
+		{"ABC_DEF,$LATEST,b326b5062b2f0e69046810717534cb09", "ABC_DEF", "$LATEST", "b326b5062b2f0e69046810717534cb09", false},
+		{"ABC_DEF_1234,567,b326b5062b2f0e69046810717534cb09", "ABC_DEF_1234", "567", "b326b5062b2f0e69046810717534cb09", false},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.Input, func(t *testing.T) {
+			t.Parallel()
+
+			functionName, qualifier, resultHash, err := tflambda.InvocationParseResourceID(tc.Input)
+
+			if tc.ExpectError {
+				if err == nil {
+					t.Fatalf("expected error for input: %s", tc.Input)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("unexpected error for input %s: %v", tc.Input, err)
+			}
+
+			if functionName != tc.FunctionName {
+				t.Fatalf("input: %s\nfunction_name: %s\nexpected:%s", tc.Input, functionName, tc.FunctionName)
+			}
+			if qualifier != tc.Qualifier {
+				t.Fatalf("input: %s\nqualifier: %s\nexpected:%s", tc.Input, qualifier, tc.Qualifier)
+			}
+			if resultHash != tc.ResultHash {
+				t.Fatalf("input: %s\nresult: %s\nexpected:%s", tc.Input, resultHash, tc.ResultHash)
+			}
+		})
+	}
+}
+
+func TestInvocationResourceIDCreation(t *testing.T) {
+	t.Parallel()
+
+	functionName := "my_test_function"
+	qualifier := "$LATEST"
+	resultHash := "b326b5062b2f0e69046810717534cb09"
+
+	expectedID := "my_test_function,$LATEST,b326b5062b2f0e69046810717534cb09"
+
+	// Test parsing the expected ID format
+	parsedFunctionName, parsedQualifier, parsedResultHash, err := tflambda.InvocationParseResourceID(expectedID)
+	if err != nil {
+		t.Fatalf("unexpected error parsing resource ID: %v", err)
+	}
+
+	if parsedFunctionName != functionName {
+		t.Fatalf("expected function name: %s, got: %s", functionName, parsedFunctionName)
+	}
+	if parsedQualifier != qualifier {
+		t.Fatalf("expected qualifier: %s, got: %s", qualifier, parsedQualifier)
+	}
+	if parsedResultHash != resultHash {
+		t.Fatalf("expected result hash: %s, got: %s", resultHash, parsedResultHash)
+	}
+}
+
 func TestAccLambdaInvocation_basic(t *testing.T) {
 	ctx := acctest.Context(t)
 	resourceName := "aws_lambda_invocation.test"
@@ -44,6 +123,12 @@ func TestAccLambdaInvocation_basic(t *testing.T) {
 					testAccCheckInvocationResult(resourceName, resultJSON),
 				),
 			},
+			{
+				ResourceName:            resourceName,
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"input", "lifecycle_scope", "result", "terraform_key"},
+			},
 		},
 	})
 }
@@ -66,6 +151,12 @@ func TestAccLambdaInvocation_qualifier(t *testing.T) {
 					testAccCheckInvocationResult(resourceName, `{"key1":"value1","key2":"value2","key3":"`+testData+`"}`),
 				),
 			},
+			{
+				ResourceName:            resourceName,
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"input", "lifecycle_scope", "result", "terraform_key"},
+			},
 		},
 	})
 }
@@ -153,6 +244,12 @@ func TestAccLambdaInvocation_lifecycle_scopeCRUDCreate(t *testing.T) {
 					testAccCheckInvocationResult(resourceName, resultJSON),
 				),
 			},
+			{
+				ResourceName:            resourceName,
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"input", "lifecycle_scope", "result", "terraform_key"},
+			},
 		},
 	})
 }

website/docs/r/lambda_invocation.html.markdown

@@ -181,3 +181,23 @@ The following arguments are optional:
 This resource exports the following attributes in addition to the arguments above:
 
 * `result` - String result of the Lambda function invocation.
+
+## Import
+
+In Terraform v1.5.0 and later, use an [`import` block](https://developer.hashicorp.com/terraform/language/import) to import Lambda Invocation using the `function_name,qualifier,result_hash`. For example:
+
+```terraform
+import {
+  to = aws_lambda_invocation.test_lambda
+  id = "my_test_lambda_function,$LATEST,b326b5062b2f0e69046810717534cb09"
+}
+```
+
+Using `terraform import`, import Lambda Invocation using the `function_name,qualifier,result_hash`. For example:
+
+```console
+% terraform import aws_lambda_invocation.test_lambda my_test_lambda_function,$LATEST,b326b5062b2f0e69046810717534cb09
+```
+
+Because it is not possible to retrieve previous invocations, during the next apply `terraform` will update the resource calling again the function.
+To compute the `result_hash`, it is necessary to hash it with the standard `md5` hash function.