PF cross-tests for computed in sets

Author: VenelinMartinov

pkg/pf/tests/diff_set_test.go

@@ -4,15 +4,12 @@ import (
 	"context"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
 	rschema "github.com/hashicorp/terraform-plugin-framework/resource/schema"
 	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
 	"github.com/hashicorp/terraform-plugin-framework/resource/schema/setplanmodifier"
 	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
-	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
 	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/hashicorp/terraform-plugin-go/tftypes"
 	"github.com/hexops/autogold/v2"
 	"github.com/zclconf/go-cty/cty"
 
@@ -154,140 +151,182 @@ func TestDetailedDiffSet(t *testing.T) {
 		},
 	})
 
+	computedCreateFunc := func(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
+		type Nested struct {
+			Nested   types.String `tfsdk:"nested"`
+			Computed types.String `tfsdk:"computed"`
+		}
+
+		type ObjectModel struct {
+			ID   types.String `tfsdk:"id"`
+			Keys []Nested     `tfsdk:"key"`
+		}
+
+		reqObj := ObjectModel{}
+		diags := req.Plan.Get(ctx, &reqObj)
+		contract.Assertf(diags.ErrorsCount() == 0, "failed to get attribute: %v", diags)
+
+		respObj := ObjectModel{
+			ID:   types.StringValue("test-id"),
+			Keys: make([]Nested, len(reqObj.Keys)),
+		}
+
+		for i, key := range reqObj.Keys {
+			newKey := Nested{}
+			if key.Computed.IsNull() || key.Computed.IsUnknown() {
+				nestedVal := ""
+				if !key.Nested.IsNull() && !key.Nested.IsUnknown() {
+					nestedVal = key.Nested.ValueString()
+				}
+				computedVal := "computed-" + nestedVal
+				newKey.Nested = types.StringValue(nestedVal)
+				newKey.Computed = types.StringValue(computedVal)
+			} else {
+				newKey.Nested = key.Nested
+				newKey.Computed = key.Computed
+			}
+			respObj.Keys[i] = newKey
+		}
+
+		diags = resp.State.Set(ctx, &respObj)
+		contract.Assertf(diags.ErrorsCount() == 0, "failed to set attribute: %v", diags)
+	}
+
+	computedUpdateFunc := func(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
+		createResp := resource.CreateResponse{
+			State:       resp.State,
+			Diagnostics: resp.Diagnostics,
+		}
+		computedCreateFunc(ctx, resource.CreateRequest{
+			Plan:         req.Plan,
+			Config:       req.Config,
+			ProviderMeta: req.ProviderMeta,
+		}, &createResp)
+
+		resp.State = createResp.State
+		resp.Diagnostics = createResp.Diagnostics
+	}
+
 	blockSchemaWithComputed := pb.NewResource(pb.NewResourceArgs{
 		ResourceSchema: rschema.Schema{
 			Blocks: map[string]rschema.Block{
 				"key": rschema.SetNestedBlock{
 					NestedObject: rschema.NestedBlockObject{
 						Attributes: map[string]rschema.Attribute{
-							"nested":   rschema.StringAttribute{Optional: true},
-							"computed": rschema.StringAttribute{Computed: true, Optional: true},
+							"nested": rschema.StringAttribute{Optional: true},
+							"computed": rschema.StringAttribute{
+								Computed: true,
+								Optional: true,
+								PlanModifiers: []planmodifier.String{
+									stringplanmodifier.UseStateForUnknown(),
+								},
+							},
 						},
 					},
 				},
 			},
 		},
-		CreateFunc: func(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
-			resp.State = tfsdk.State(req.Plan)
-			diags := resp.State.SetAttribute(ctx, path.Root("id"), "test-id")
-			contract.Assertf(diags.ErrorsCount() == 0, "failed to set attribute: %v", diags)
-
-			keys := make([]tftypes.Value, 0)
-			diags = resp.State.GetAttribute(ctx, path.Root("key"), &keys)
-			contract.Assertf(diags.ErrorsCount() == 0, "failed to get attribute: %v", diags)
-
-			resultKeys := make([]tftypes.Value, len(keys))
-			for i, key := range keys {
-				keyMap := make(map[string]tftypes.Value)
-				if key.As(&keyMap) == nil {
-					nestedVal := ""
-					if val, ok := keyMap["nested"]; ok {
-						nestedVal = val.String()
-					}
-					computedVal := ""
-					if _, ok := keyMap["computed"]; !ok {
-						computedVal = "computed-" + nestedVal
-					} else {
-						computedVal = keyMap["computed"].String()
-					}
-					keyMap["computed"] = tftypes.NewValue(tftypes.String, computedVal)
-				}
-				resultKeys[i] = tftypes.NewValue(tftypes.Object{
-					AttributeTypes: map[string]tftypes.Type{
-						"nested":   tftypes.String,
-						"computed": tftypes.String,
+		CreateFunc: computedCreateFunc,
+		UpdateFunc: computedUpdateFunc,
+	})
+
+	blockSchemaWithComputedNoStateForUnknown := pb.NewResource(pb.NewResourceArgs{
+		ResourceSchema: rschema.Schema{
+			Blocks: map[string]rschema.Block{
+				"key": rschema.SetNestedBlock{
+					NestedObject: rschema.NestedBlockObject{
+						Attributes: map[string]rschema.Attribute{
+							"nested": rschema.StringAttribute{Optional: true},
+							"computed": rschema.StringAttribute{
+								Computed: true,
+								Optional: true,
+							},
+						},
 					},
-				}, keyMap)
-			}
+				},
+			},
+		},
+		CreateFunc: computedCreateFunc,
+		UpdateFunc: computedUpdateFunc,
+	})
+
+	blockSchemaWithComputedReplace := pb.NewResource(pb.NewResourceArgs{
+		ResourceSchema: rschema.Schema{
+			Blocks: map[string]rschema.Block{
+				"key": rschema.SetNestedBlock{
+					NestedObject: rschema.NestedBlockObject{
+						Attributes: map[string]rschema.Attribute{
+							"nested": rschema.StringAttribute{Optional: true},
+							"computed": rschema.StringAttribute{
+								Computed: true,
+								Optional: true,
+								PlanModifiers: []planmodifier.String{
+									stringplanmodifier.UseStateForUnknown(),
+								},
+							},
+						},
+					},
+					PlanModifiers: []planmodifier.Set{
+						setplanmodifier.RequiresReplace(),
+					},
+				},
+			},
+		},
+		CreateFunc: computedCreateFunc,
+		UpdateFunc: computedUpdateFunc,
+	})
 
-			diags = resp.State.SetAttribute(ctx, path.Root("key"), resultKeys)
-			contract.Assertf(diags.ErrorsCount() == 0, "failed to set attribute: %v", diags)
+	blockSchemaWithComputedNestedReplace := pb.NewResource(pb.NewResourceArgs{
+		ResourceSchema: rschema.Schema{
+			Blocks: map[string]rschema.Block{
+				"key": rschema.SetNestedBlock{
+					NestedObject: rschema.NestedBlockObject{
+						Attributes: map[string]rschema.Attribute{
+							"nested": rschema.StringAttribute{
+								Optional: true,
+								PlanModifiers: []planmodifier.String{
+									stringplanmodifier.RequiresReplace(),
+								},
+							},
+							"computed": rschema.StringAttribute{
+								Computed: true,
+								Optional: true,
+								PlanModifiers: []planmodifier.String{
+									stringplanmodifier.UseStateForUnknown(),
+								},
+							},
+						},
+					},
+				},
+			},
 		},
+		CreateFunc: computedCreateFunc,
+		UpdateFunc: computedUpdateFunc,
 	})
 
-	// blockSchemaWithComputedAndStateForUnknown := pb.NewResource(pb.NewResourceArgs{
-	// 	ResourceSchema: rschema.Schema{
-	// 		Blocks: map[string]rschema.Block{
-	// 			"key": rschema.SetNestedBlock{
-	// 				NestedObject: rschema.NestedBlockObject{
-	// 					Attributes: map[string]rschema.Attribute{
-	// 						"nested": rschema.StringAttribute{Optional: true},
-	// 						"computed": rschema.StringAttribute{
-	// 							Computed: true,
-	// 							Optional: true,
-	// 							PlanModifiers: []planmodifier.String{
-	// 								stringplanmodifier.UseStateForUnknown(),
-	// 							},
-	// 						},
-	// 					},
-	// 				},
-	// 			},
-	// 		},
-	// 	},
-	// })
-
-	// blockSchemaWithComputedReplace := pb.NewResource(pb.NewResourceArgs{
-	// 	ResourceSchema: rschema.Schema{
-	// 		Blocks: map[string]rschema.Block{
-	// 			"key": rschema.SetNestedBlock{
-	// 				NestedObject: rschema.NestedBlockObject{
-	// 					Attributes: map[string]rschema.Attribute{
-	// 						"nested":   rschema.StringAttribute{Optional: true},
-	// 						"computed": rschema.StringAttribute{Computed: true, Optional: true},
-	// 					},
-	// 				},
-	// 				PlanModifiers: []planmodifier.Set{
-	// 					setplanmodifier.RequiresReplace(),
-	// 				},
-	// 			},
-	// 		},
-	// 	},
-	// })
-
-	// blockSchemaWithComputedNestedReplace := pb.NewResource(pb.NewResourceArgs{
-	// 	ResourceSchema: rschema.Schema{
-	// 		Blocks: map[string]rschema.Block{
-	// 			"key": rschema.SetNestedBlock{
-	// 				NestedObject: rschema.NestedBlockObject{
-	// 					Attributes: map[string]rschema.Attribute{
-	// 						"nested": rschema.StringAttribute{
-	// 							Optional: true,
-	// 							PlanModifiers: []planmodifier.String{
-	// 								stringplanmodifier.RequiresReplace(),
-	// 							},
-	// 						},
-	// 						"computed": rschema.StringAttribute{
-	// 							Computed: true,
-	// 							Optional: true,
-	// 						},
-	// 					},
-	// 				},
-	// 			},
-	// 		},
-	// 	},
-	// })
-
-	// blockSchemaWithComputedAndPlanModifierRequiresReplace := pb.NewResource(pb.NewResourceArgs{
-	// 	ResourceSchema: rschema.Schema{
-	// 		Blocks: map[string]rschema.Block{
-	// 			"key": rschema.SetNestedBlock{
-	// 				NestedObject: rschema.NestedBlockObject{
-	// 					Attributes: map[string]rschema.Attribute{
-	// 						"nested": rschema.StringAttribute{Optional: true},
-	// 						"computed": rschema.StringAttribute{
-	// 							Computed: true,
-	// 							Optional: true,
-	// 							PlanModifiers: []planmodifier.String{
-	// 								stringplanmodifier.UseStateForUnknown(),
-	// 								stringplanmodifier.RequiresReplace(),
-	// 							},
-	// 						},
-	// 					},
-	// 				},
-	// 			},
-	// 		},
-	// 	},
-	// })
+	blockSchemaWithComputedComputedRequiresReplace := pb.NewResource(pb.NewResourceArgs{
+		ResourceSchema: rschema.Schema{
+			Blocks: map[string]rschema.Block{
+				"key": rschema.SetNestedBlock{
+					NestedObject: rschema.NestedBlockObject{
+						Attributes: map[string]rschema.Attribute{
+							"nested": rschema.StringAttribute{Optional: true},
+							"computed": rschema.StringAttribute{
+								Computed: true,
+								Optional: true,
+								PlanModifiers: []planmodifier.String{
+									stringplanmodifier.UseStateForUnknown(),
+									stringplanmodifier.RequiresReplace(),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		CreateFunc: computedCreateFunc,
+		UpdateFunc: computedUpdateFunc,
+	})
 
 	attrList := func(arr *[]string) cty.Value {
 		if arr == nil {
@@ -354,8 +393,18 @@ func TestDetailedDiffSet(t *testing.T) {
 		{"block requires replace", blockReplaceSchema, nestedAttrList},
 		{"block nested requires replace", blockNestedReplaceSchema, nestedAttrList},
 
+		// Computed, each state we test both the behaviour when the computed value is specified in the program and when it is not.
 		{"block with computed no replace computed", blockSchemaWithComputed, nestedAttrList},
 		{"block with computed no replace computed specified in program", blockSchemaWithComputed, nestedAttrListWithComputedSpecified},
+		{"block with computed requires replace", blockSchemaWithComputedReplace, nestedAttrList},
+		{"block with computed requires replace computed specified in program", blockSchemaWithComputedReplace, nestedAttrListWithComputedSpecified},
+		{"block with computed and nested requires replace", blockSchemaWithComputedNestedReplace, nestedAttrList},
+		{"block with computed and nested requires replace computed specified in program", blockSchemaWithComputedNestedReplace, nestedAttrListWithComputedSpecified},
+		{"block with computed and computed requires replace", blockSchemaWithComputedComputedRequiresReplace, nestedAttrList},
+		{"block with computed and computed requires replace computed specified in program", blockSchemaWithComputedComputedRequiresReplace, nestedAttrListWithComputedSpecified},
+		// Rarely used, but supported
+		{"block with computed no state for unknown", blockSchemaWithComputedNoStateForUnknown, nestedAttrList},
+		{"block with computed no state for unknown computed specified in program", blockSchemaWithComputedNoStateForUnknown, nestedAttrListWithComputedSpecified},
 	}
 
 	scenarios := []struct {

pkg/pf/tests/testdata/TestDetailedDiffSet/block_with_computed_and_computed_requires_replace/added.golden

@@ -0,0 +1,41 @@
+tfbridgetests.testOutput{
+	initialValue: &[]string{},
+	changeValue:  &[]string{"value"},
+	tfOut: `
+Terraform used the selected providers to generate the following execution
+plan. Resource actions are indicated with the following symbols:
++/- create replacement and then destroy
+
+Terraform will perform the following actions:
+
+  # testprovider_test.res must be replaced
++/- resource "testprovider_test" "res" {
+      ~ id = "test-id" -> (known after apply)
+
+      + key { # forces replacement
+          + computed = (known after apply)
+          + nested   = "value"
+        }
+    }
+
+Plan: 1 to add, 0 to change, 1 to destroy.
+
+`,
+	pulumiOut: `Previewing update (test):
+  pulumi:pulumi:Stack: (same)
+    [urn=urn:pulumi:test::project::pulumi:pulumi:Stack::project-test]
+    +-testprovider:index/test:Test: (replace)
+        [id=test-id]
+        [urn=urn:pulumi:test::project::testprovider:index/test:Test::p]
+      ~ id  : "test-id" => output<string>
+      ~ keys: [
+          + [0]: {
+                  + computed: output<string>
+                  + nested  : "value"
+                }
+        ]
+Resources:
+    +-1 to replace
+    1 unchanged
+`,
+}