feat(sidekick/rust): Generate samples for non-LRO delete RPCs (#3319)

Author: amanda-tarafa

internal/sidekick/api/model.go

@@ -188,6 +188,8 @@ type APIState struct {
 	MessageByID map[string]*Message
 	// EnumByID returns a message that is associated with the API.
 	EnumByID map[string]*Enum
+	// ResourceByType returns a resource that is associated with the API.
+	ResourceByType map[string]*Resource
 }
 
 // Service represents a service in an API.
@@ -373,7 +375,8 @@ func (m *Method) IsSimple() bool {
 // IsAIPStandard returns true if the method is one of the AIP standard methods.
 // IsAIPStandard simplifies writing mustache templates, mostly for samples.
 func (m *Method) IsAIPStandard() bool {
-	return m.AIPStandardGetInfo() != nil
+	return m.AIPStandardGetInfo() != nil ||
+		m.AIPStandardDeleteInfo() != nil
 }
 
 // AIPStandardGetInfo contains information relevant to get operations as defined by AIP-131.
@@ -413,6 +416,53 @@ func (m *Method) AIPStandardGetInfo() *AIPStandardGetInfo {
 	}
 }
 
+// AIPStandardDeleteInfo contains information relevant to delete operations as defined by AIP-135.
+type AIPStandardDeleteInfo struct {
+	// ResourceNameRequestField is the field in the method input that contains the resource name
+	// of the resource that the delete operation should delete.
+	ResourceNameRequestField *Field
+}
+
+// AIPStandardDeleteInfo returns information relevant to a delete operation as defined by AIP-135
+// if the method is such an operation.
+func (m *Method) AIPStandardDeleteInfo() *AIPStandardDeleteInfo {
+	// A delete operation is either simple or LRO.
+	if !m.IsSimple() && m.OperationInfo == nil {
+		return nil
+	}
+
+	// Standard delete methods for resource "Foo" should be named "DeleteFoo".
+	maybeSingular, found := strings.CutPrefix(strings.ToLower(m.Name), "delete")
+	if !found || maybeSingular == "" {
+		return nil
+	}
+	// The request name should be "DeleteFooRequest".
+	if m.InputType == nil ||
+		strings.ToLower(m.InputType.Name) != fmt.Sprintf("delete%srequest", maybeSingular) {
+		return nil
+	}
+
+	// Find the field in the request that is a resource reference of a resource
+	// whose singular name is maybeSingular.
+	fieldIndex := slices.IndexFunc(m.InputType.Fields, func(f *Field) bool {
+		if f.ResourceReference == nil {
+			return false
+		}
+		resource, ok := m.Model.State.ResourceByType[f.ResourceReference.Type]
+		if !ok {
+			return false
+		}
+		return strings.ToLower(resource.Singular) == maybeSingular
+	})
+	if fieldIndex == -1 {
+		return nil
+	}
+
+	return &AIPStandardDeleteInfo{
+		ResourceNameRequestField: m.InputType.Fields[fieldIndex],
+	}
+}
+
 // PathInfo contains normalized request path information.
 type PathInfo struct {
 	// The list of bindings, including the top-level binding.

internal/sidekick/api/model_test.go

@@ -303,6 +303,20 @@ func TestIsAIPStandard(t *testing.T) {
 		OutputType: output,
 	}
 
+	validDeleteMethod := &Method{
+		Name:         "DeleteSecret",
+		InputType:    &Message{Name: "DeleteSecretRequest", Fields: []*Field{{Name: "name", ResourceReference: &ResourceReference{Type: resourceType}}}},
+		ReturnsEmpty: true,
+		Model: &API{
+			ResourceDefinitions: []*Resource{resource},
+			State: &APIState{
+				ResourceByType: map[string]*Resource{
+					resourceType: resource,
+				},
+			},
+		},
+	}
+
 	// Setup for an invalid Get operation (e.g., wrong name)
 	invalidGetMethod := &Method{
 		Name:       "ListSecrets", // Not a Get method
@@ -320,6 +334,11 @@ func TestIsAIPStandard(t *testing.T) {
 			method: validGetMethod,
 			want:   true,
 		},
+		{
+			name:   "standard delete method returns true",
+			method: validDeleteMethod,
+			want:   true,
+		},
 		{
 			name:   "non-standard method returns false",
 			method: invalidGetMethod,
@@ -475,6 +494,103 @@ func TestAIPStandardGetInfo(t *testing.T) {
 	}
 }
 
+func TestAIPStandardDeleteInfo(t *testing.T) {
+	resourceType := "google.cloud.secretmanager.v1/Secret"
+	resourceNameField := &Field{
+		Name: "name",
+		ResourceReference: &ResourceReference{
+			Type: resourceType,
+		},
+	}
+	resource := &Resource{
+		Type:     resourceType,
+		Singular: "secret",
+	}
+	model := &API{
+		ResourceDefinitions: []*Resource{resource},
+		State: &APIState{
+			ResourceByType: map[string]*Resource{
+				resourceType: resource,
+			},
+		},
+	}
+
+	testCases := []struct {
+		name   string
+		method *Method
+		want   *AIPStandardDeleteInfo
+	}{
+		{
+			name: "valid simple delete",
+			method: &Method{
+				Name:         "DeleteSecret",
+				InputType:    &Message{Name: "DeleteSecretRequest", Fields: []*Field{resourceNameField}},
+				ReturnsEmpty: true,
+				Model:        model,
+			},
+			want: &AIPStandardDeleteInfo{
+				ResourceNameRequestField: resourceNameField,
+			},
+		},
+		{
+			name: "valid lro delete",
+			method: &Method{
+				Name:          "DeleteSecret",
+				InputType:     &Message{Name: "DeleteSecretRequest", Fields: []*Field{resourceNameField}},
+				OperationInfo: &OperationInfo{},
+				Model:         model,
+			},
+			want: &AIPStandardDeleteInfo{
+				ResourceNameRequestField: resourceNameField,
+			},
+		},
+		{
+			name: "incorrect method name",
+			method: &Method{
+				Name:      "RemoveSecret",
+				InputType: &Message{Name: "DeleteSecretRequest", Fields: []*Field{resourceNameField}},
+				Model:     model,
+			},
+			want: nil,
+		},
+		{
+			name: "incorrect request name",
+			method: &Method{
+				Name:      "DeleteSecret",
+				InputType: &Message{Name: "RemoveSecretRequest", Fields: []*Field{resourceNameField}},
+				Model:     model,
+			},
+			want: nil,
+		},
+		{
+			name: "resource not found in ResourceByType map",
+			method: &Method{
+				Name: "DeleteSecret",
+				InputType: &Message{
+					Name: "DeleteSecretRequest",
+					Fields: []*Field{
+						{
+							Name:              "name",
+							ResourceReference: &ResourceReference{Type: "nonexistent.googleapis.com/NonExistent"},
+						},
+					},
+				},
+				Model: model, // model's ResourceByType does not contain the nonexistent resource
+			},
+			want: nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := tc.method.AIPStandardDeleteInfo()
+			if diff := cmp.Diff(tc.want, got); diff != "" {
+				t.Errorf("AIPStandardDeleteInfo() mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
 func TestFieldTypePredicates(t *testing.T) {
 	type TestCase struct {
 		field    *Field

internal/sidekick/parser/protobuf.go

@@ -187,10 +187,11 @@ func makeAPIForProtobuf(serviceConfig *serviceconfig.Service, req *pluginpb.Code
 		enabledMixinMethods mixinMethods = make(map[string]bool)
 	)
 	state := &api.APIState{
-		ServiceByID: make(map[string]*api.Service),
-		MethodByID:  make(map[string]*api.Method),
-		MessageByID: make(map[string]*api.Message),
-		EnumByID:    make(map[string]*api.Enum),
+		ServiceByID:    make(map[string]*api.Service),
+		MethodByID:     make(map[string]*api.Method),
+		MessageByID:    make(map[string]*api.Message),
+		EnumByID:       make(map[string]*api.Enum),
+		ResourceByType: make(map[string]*api.Resource),
 	}
 	result := &api.API{
 		State: state,
@@ -488,7 +489,7 @@ func processMessage(state *api.APIState, m *descriptorpb.DescriptorProto, mFQN,
 		if opts.GetMapEntry() {
 			message.IsMap = true
 		}
-		if err := processResourceAnnotation(opts, message); err != nil {
+		if err := processResourceAnnotation(opts, message, state); err != nil {
 			return nil, err
 		}
 	}
@@ -553,7 +554,7 @@ func processMessage(state *api.APIState, m *descriptorpb.DescriptorProto, mFQN,
 	return message, nil
 }
 
-func processResourceAnnotation(opts *descriptorpb.MessageOptions, message *api.Message) error {
+func processResourceAnnotation(opts *descriptorpb.MessageOptions, message *api.Message, state *api.APIState) error {
 	if !proto.HasExtension(opts, annotations.E_Resource) {
 		return nil
 	}
@@ -568,13 +569,15 @@ func processResourceAnnotation(opts *descriptorpb.MessageOptions, message *api.M
 		return fmt.Errorf("in message %q: %w", message.ID, err)
 	}
 
-	message.Resource = &api.Resource{
+	resource := &api.Resource{
 		Type:     res.GetType(),
 		Patterns: patterns,
 		Plural:   res.GetPlural(),
 		Singular: res.GetSingular(),
 		Self:     message,
 	}
+	message.Resource = resource
+	state.ResourceByType[resource.Type] = resource
 	return nil
 }
 

internal/sidekick/parser/protobuf_test.go

@@ -1891,6 +1891,23 @@ func TestProtobuf_ResourceAnnotations(t *testing.T) {
 		}
 	})
 
+	t.Run("API.State.ResourceByType", func(t *testing.T) {
+		if _, ok := test.State.ResourceByType["library.googleapis.com/Shelf"]; ok {
+			t.Errorf("Resource 'library.googleapis.com/Shelf' should not be in ResourceByType map")
+		}
+
+		bookResource, ok := test.State.ResourceByType["library.googleapis.com/Book"]
+		if !ok {
+			t.Fatalf("Expected resource 'library.googleapis.com/Book' not found in ResourceByType map")
+		}
+		if bookResource.Type != "library.googleapis.com/Book" {
+			t.Errorf("bookResource.Type = %q; want %q", bookResource.Type, "library.googleapis.com/Book")
+		}
+		if bookResource.Self.Name != "Book" {
+			t.Errorf("bookResource.Self.Name = %q; want %q", bookResource.Self.Name, "Book")
+		}
+	})
+
 	t.Run("Message.Resource", func(t *testing.T) {
 		bookMessage, ok := test.State.MessageByID[".test.Book"]
 		if !ok {

internal/sidekick/rust/templates/common/client_method_samples/builder_fields.mustache

@@ -16,6 +16,9 @@ limitations under the License.
 {{#AIPStandardGetInfo}}
 ///         .set_{{ResourceNameRequestField.Codec.SetterName}}(resource_name)
 {{/AIPStandardGetInfo}}
+{{#AIPStandardDeleteInfo}}
+///         .set_{{ResourceNameRequestField.Codec.SetterName}}(resource_name)
+{{/AIPStandardDeleteInfo}}
 {{^IsAIPStandard}}
 ///         /* set fields */
 {{/IsAIPStandard}}

internal/sidekick/rust/templates/common/client_method_samples/parameters.mustache

@@ -17,6 +17,10 @@ limitations under the License.
 ///    client: &{{Service.Codec.Name}},
 ///    resource_name: &str
 {{/AIPStandardGetInfo}}
+{{#AIPStandardDeleteInfo}}
+///    client: &{{Service.Codec.Name}},
+///    resource_name: &str
+{{/AIPStandardDeleteInfo}}
 {{^IsAIPStandard}}
 ///    client: &{{Service.Codec.Name}}
 {{/IsAIPStandard}}