framework storage notification (#14936)

Author: c2thorn

mmv1/third_party/terraform/fwprovider/framework_provider.go.tmpl

@@ -27,6 +27,7 @@ import (
     {{- if ne $.TargetVersionName "ga" }}
     "github.com/hashicorp/terraform-provider-google/google/services/firebase"
     {{- end }}
+	"github.com/hashicorp/terraform-provider-google/google/services/storage"
 
     transport_tpg "github.com/hashicorp/terraform-provider-google/google/transport"
 )
@@ -332,6 +333,7 @@ func (p *FrameworkProvider) DataSources(_ context.Context) []func() datasource.D
 func (p *FrameworkProvider) Resources(_ context.Context) []func() resource.Resource {
 	return []func() resource.Resource{
 		apigee.NewApigeeKeystoresAliasesKeyCertFileResource,
+		storage.NewStorageNotificationResource,
 	}
 }
 

mmv1/third_party/terraform/fwresource/field_helpers.go

@@ -119,3 +119,10 @@ func ReplaceVarsForFrameworkTest(prov *transport_tpg.Config, rs *terraform.Resou
 
 	return re.ReplaceAllStringFunc(linkTmpl, replaceFunc), nil
 }
+
+func FlattenStringEmptyToNull(configuredValue types.String, apiValue string) types.String {
+	if configuredValue.IsNull() && apiValue == "" {
+		return types.StringNull()
+	}
+	return types.StringValue(apiValue)
+}

mmv1/third_party/terraform/fwvalidators/framework_validators.go

@@ -9,6 +9,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
 	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
 
 	googleoauth "golang.org/x/oauth2/google"
@@ -262,3 +264,81 @@ func (v jwtValidator) ValidateString(ctx context.Context, request validator.Stri
 func JWTValidator() validator.String {
 	return jwtValidator{}
 }
+
+// stringValuesInSetValidator validates that all string elements in a set
+// are present in the configured list of valid strings.
+type stringValuesInSetValidator struct {
+	ValidStrings []string
+}
+
+func (v stringValuesInSetValidator) Description(_ context.Context) string {
+	return fmt.Sprintf("all elements must be one of: %q", v.ValidStrings)
+}
+
+func (v stringValuesInSetValidator) MarkdownDescription(ctx context.Context) string {
+	return v.Description(ctx)
+}
+
+func (v stringValuesInSetValidator) ValidateSet(ctx context.Context, req validator.SetRequest, resp *validator.SetResponse) {
+	if req.ConfigValue.IsNull() || req.ConfigValue.IsUnknown() {
+		return
+	}
+
+	valid := make(map[string]struct{}, len(v.ValidStrings))
+	for _, s := range v.ValidStrings {
+		valid[s] = struct{}{}
+	}
+
+	var elements []types.String
+	resp.Diagnostics.Append(req.ConfigValue.ElementsAs(ctx, &elements, false)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	for _, el := range elements {
+		if _, ok := valid[el.ValueString()]; !ok {
+			resp.Diagnostics.AddAttributeError(
+				req.Path,
+				"Invalid Set Element",
+				fmt.Sprintf("Element %q is not a valid value. %s.", el.ValueString(), v.Description(ctx)),
+			)
+		}
+	}
+}
+
+func StringValuesInSet(validStrings ...string) validator.Set {
+	return stringValuesInSetValidator{
+		ValidStrings: validStrings,
+	}
+}
+
+type TopicPrefixValidator struct{}
+
+func (v TopicPrefixValidator) Description(ctx context.Context) string {
+	return "ensures the topic does not start with '//pubsub.googleapis.com/'"
+}
+
+func (v TopicPrefixValidator) MarkdownDescription(ctx context.Context) string {
+	return "Ensures the topic does not start with `//pubsub.googleapis.com/`."
+}
+
+func (v TopicPrefixValidator) ValidateString(ctx context.Context, req validator.StringRequest, resp *validator.StringResponse) {
+	if req.ConfigValue.IsNull() || req.ConfigValue.IsUnknown() {
+		return
+	}
+
+	value := req.ConfigValue.ValueString()
+	forbiddenPrefix := "//pubsub.googleapis.com/"
+
+	if strings.HasPrefix(value, forbiddenPrefix) {
+		resp.Diagnostics.AddAttributeError(
+			req.Path,
+			"Invalid Topic Format",
+			fmt.Sprintf("The topic must not start with '%s', please use the format projects/{project}/topics/{topic} instead.", forbiddenPrefix),
+		)
+	}
+}
+
+func NewTopicPrefixValidator() validator.String {
+	return TopicPrefixValidator{}
+}

mmv1/third_party/terraform/fwvalidators/framework_validators_test.go

@@ -307,3 +307,141 @@ func TestBoundedDuration(t *testing.T) {
 		})
 	}
 }
+
+func TestStringValuesInSetValidator(t *testing.T) {
+	t.Parallel()
+
+	// Define the set of valid strings for the validator
+	validStrings := []string{"APPLE", "BANANA", "CHERRY"}
+
+	stringSet := func(elems []string) types.Set {
+		if elems == nil {
+			return types.SetNull(types.StringType)
+		}
+		val, diags := types.SetValueFrom(context.Background(), types.StringType, elems)
+		if diags.HasError() {
+			t.Fatalf("Failed to create test set: %v", diags)
+		}
+		return val
+	}
+
+	cases := map[string]struct {
+		ConfigValue        types.Set
+		ExpectedErrorCount int
+	}{
+		"valid set with one element": {
+			ConfigValue:        stringSet([]string{"APPLE"}),
+			ExpectedErrorCount: 0,
+		},
+		"valid set with multiple elements": {
+			ConfigValue:        stringSet([]string{"BANANA", "CHERRY"}),
+			ExpectedErrorCount: 0,
+		},
+		"valid empty set": {
+			ConfigValue:        stringSet([]string{}),
+			ExpectedErrorCount: 0,
+		},
+		"null set is valid": {
+			ConfigValue:        stringSet(nil),
+			ExpectedErrorCount: 0,
+		},
+		"unknown set is valid": {
+			ConfigValue:        types.SetUnknown(types.StringType),
+			ExpectedErrorCount: 0,
+		},
+		"invalid set with one element": {
+			ConfigValue:        stringSet([]string{"DURIAN"}),
+			ExpectedErrorCount: 1,
+		},
+		"invalid set with multiple elements": {
+			ConfigValue:        stringSet([]string{"DURIAN", "ELDERBERRY"}),
+			ExpectedErrorCount: 2,
+		},
+		"set with mixed valid and invalid elements": {
+			ConfigValue:        stringSet([]string{"APPLE", "DURIAN", "CHERRY"}),
+			ExpectedErrorCount: 1,
+		},
+	}
+
+	for tn, tc := range cases {
+		tn, tc := tn, tc
+		t.Run(tn, func(t *testing.T) {
+			t.Parallel()
+
+			req := validator.SetRequest{
+				Path:        path.Root("test_attribute"),
+				ConfigValue: tc.ConfigValue,
+			}
+			resp := &validator.SetResponse{
+				Diagnostics: diag.Diagnostics{},
+			}
+			v := fwvalidators.StringValuesInSet(validStrings...)
+
+			v.ValidateSet(context.Background(), req, resp)
+
+			if resp.Diagnostics.ErrorsCount() != tc.ExpectedErrorCount {
+				t.Errorf("Expected %d errors, but got %d. Errors: %v", tc.ExpectedErrorCount, resp.Diagnostics.ErrorsCount(), resp.Diagnostics.Errors())
+			}
+		})
+	}
+}
+
+func TestTopicPrefixValidator(t *testing.T) {
+	t.Parallel()
+
+	type testCase struct {
+		value         types.String
+		expectError   bool
+		errorContains string
+	}
+
+	tests := map[string]testCase{
+		"valid topic format": {
+			value:       types.StringValue("projects/my-project/topics/my-topic"),
+			expectError: false,
+		},
+		"invalid topic format - starts with pubsub prefix": {
+			value:         types.StringValue("//pubsub.googleapis.com/projects/my-project/topics/my-topic"),
+			expectError:   true,
+			errorContains: "The topic must not start with '//pubsub.googleapis.com/', please use the format projects/{project}/topics/{topic} instead.",
+		},
+	}
+
+	for name, test := range tests {
+		name, test := name, test
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			request := validator.StringRequest{
+				Path:           path.Root("test_topic"),
+				PathExpression: path.MatchRoot("test_topic"),
+				ConfigValue:    test.value,
+			}
+			response := validator.StringResponse{}
+			v := fwvalidators.NewTopicPrefixValidator()
+
+			v.ValidateString(context.Background(), request, &response)
+
+			if test.expectError && !response.Diagnostics.HasError() {
+				t.Errorf("expected error, got none for value: %q", test.value.ValueString())
+			}
+
+			if !test.expectError && response.Diagnostics.HasError() {
+				t.Errorf("got unexpected error for value: %q: %s", test.value.ValueString(), response.Diagnostics.Errors())
+			}
+
+			if test.errorContains != "" {
+				foundError := false
+				for _, err := range response.Diagnostics.Errors() {
+					if err.Detail() == test.errorContains {
+						foundError = true
+						break
+					}
+				}
+				if !foundError {
+					t.Errorf("expected error with detail %q, got none", test.errorContains)
+				}
+			}
+		})
+	}
+}

mmv1/third_party/terraform/provider/provider_mmv1_resources.go.tmpl

@@ -439,7 +439,6 @@ var handwrittenResources = map[string]*schema.Resource{
 	"google_storage_bucket_object":                 storage.ResourceStorageBucketObject(),
 	"google_storage_object_acl":                    storage.ResourceStorageObjectAcl(),
 	"google_storage_default_object_acl":            storage.ResourceStorageDefaultObjectAcl(),
-	"google_storage_notification":                  storage.ResourceStorageNotification(),
 	"google_storage_transfer_job":                  storagetransfer.ResourceStorageTransferJob(),
 	"google_tags_location_tag_binding":             tags.ResourceTagsLocationTagBinding(),
 	// ####### END handwritten resources ###########