feat(sidekick/rust): Generate samples for LRO RPCs.

Author: amanda-tarafa

internal/sidekick/api/model.go

@@ -372,6 +372,30 @@ func (m *Method) IsSimple() bool {
 		m.OperationInfo == nil && m.DiscoveryLro == nil
 }
 
+// IsLRO returns true if the method is a long-running operation.
+func (m *Method) IsLRO() bool {
+	return m.OperationInfo != nil
+}
+
+// IsSimpleOrLRO returns true if the method is simple or a long-running operation.
+func (m *Method) IsSimpleOrLRO() bool {
+	return m.IsSimple() || m.IsLRO()
+}
+
+// LongRunningResponseType returns the response type of the long-running operation.
+func (m *Method) LongRunningResponseType() *Message {
+	if m.OperationInfo == nil {
+		return nil
+	}
+	return m.Model.State.MessageByID[m.OperationInfo.ResponseTypeID]
+}
+
+// LongRunningReturnsEmpty returns true if the long-running operation returns an empty response.
+func (m *Method) LongRunningReturnsEmpty() bool {
+	responseType := m.LongRunningResponseType()
+	return responseType != nil && responseType.ID == ".google.protobuf.Empty"
+}
+
 // 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 {

internal/sidekick/api/model_test.go

@@ -284,6 +284,121 @@ func TestIsSimpleMethod(t *testing.T) {
 	}
 }
 
+func TestIsLRO(t *testing.T) {
+	testCases := []struct {
+		name   string
+		method *Method
+		want   bool
+	}{
+		{
+			name:   "simple method is not LRO",
+			method: &Method{},
+			want:   false,
+		},
+		{
+			name:   "LRO method is LRO",
+			method: &Method{OperationInfo: &OperationInfo{}},
+			want:   true,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := tc.method.IsLRO(); got != tc.want {
+				t.Errorf("IsLRO() = %v, want %v", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestIsSimpleOrLRO(t *testing.T) {
+	testCases := []struct {
+		name   string
+		method *Method
+		want   bool
+	}{
+		{
+			name:   "simple method",
+			method: &Method{},
+			want:   true,
+		},
+		{
+			name:   "LRO method",
+			method: &Method{OperationInfo: &OperationInfo{}},
+			want:   true,
+		},
+		{
+			name:   "streaming method",
+			method: &Method{ClientSideStreaming: true},
+			want:   false,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := tc.method.IsSimpleOrLRO(); got != tc.want {
+				t.Errorf("IsSimpleOrLRO() = %v, want %v", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestLongRunningHelpers(t *testing.T) {
+	emptyMsg := &Message{ID: ".google.protobuf.Empty"}
+	responseMsg := &Message{ID: "some.response.Message"}
+	model := &API{
+		State: &APIState{
+			MessageByID: map[string]*Message{
+				emptyMsg.ID:    emptyMsg,
+				responseMsg.ID: responseMsg,
+			},
+		},
+	}
+
+	testCases := []struct {
+		name         string
+		method       *Method
+		wantResponse *Message
+		wantEmpty    bool
+	}{
+		{
+			name: "LRO with empty response",
+			method: &Method{
+				OperationInfo: &OperationInfo{ResponseTypeID: emptyMsg.ID},
+				Model:         model,
+			},
+			wantResponse: emptyMsg,
+			wantEmpty:    true,
+		},
+		{
+			name: "LRO with non-empty response",
+			method: &Method{
+				OperationInfo: &OperationInfo{ResponseTypeID: responseMsg.ID},
+				Model:         model,
+			},
+			wantResponse: responseMsg,
+			wantEmpty:    false,
+		},
+		{
+			name: "non-LRO method",
+			method: &Method{
+				Model: model,
+			},
+			wantResponse: nil,
+			wantEmpty:    false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := tc.method.LongRunningResponseType(); got != tc.wantResponse {
+				t.Errorf("LongRunningResponseType() = %v, want %v", got, tc.wantResponse)
+			}
+			if got := tc.method.LongRunningReturnsEmpty(); got != tc.wantEmpty {
+				t.Errorf("LongRunningReturnsEmpty() = %v, want %v", got, tc.wantEmpty)
+			}
+		})
+	}
+}
+
 type aipTestFixture struct {
 	resource                         *Resource
 	resourceWithoutSingular          *Resource

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

@@ -14,32 +14,21 @@ See the License for the specific language governing permissions and
 limitations under the License.
 }}
 {{#ModelCodec.GenerateRpcSamples}}
-{{#IsSimple}}
+{{#IsSimpleOrLRO}}
 ///
 /// # Example
 /// ```
 /// # use {{Service.Model.Codec.PackageNamespace}}::client::{{Service.Codec.Name}};
+{{#IsLRO}}
+/// # use lro::Poller;
+{{/IsLRO}}
 /// use {{Service.Model.Codec.PackageNamespace}}::Result;
 /// async fn sample(
 {{> /templates/common/client_method_samples/parameters}}
 /// ) -> Result<()> {
-{{#ReturnsEmpty}}
-///     client
-///         .{{Codec.Name}}()
-{{> /templates/common/client_method_samples/builder_fields}}
-///         .send()
-///         .await?;
-{{/ReturnsEmpty}}
-{{^ReturnsEmpty}}
-///     let response = client
-///         .{{Codec.Name}}()
-{{> /templates/common/client_method_samples/builder_fields}}
-///         .send()
-///         .await?;
-///     println!("response {:?}", response);
-{{/ReturnsEmpty}}
+{{> /templates/common/client_method_samples/method_call}}
 ///     Ok(())
 /// }
 /// ```
-{{/IsSimple}}
+{{/IsSimpleOrLRO}}
 {{/ModelCodec.GenerateRpcSamples}}

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

@@ -0,0 +1,51 @@
+{{!
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+}}
+{{#IsSimple}}
+{{#ReturnsEmpty}}
+///     client
+///         .{{Codec.Name}}()
+{{> /templates/common/client_method_samples/builder_fields}}
+///         .send()
+///         .await?;
+{{/ReturnsEmpty}}
+{{^ReturnsEmpty}}
+///     let response = client
+///         .{{Codec.Name}}()
+{{> /templates/common/client_method_samples/builder_fields}}
+///         .send()
+///         .await?;
+///     println!("response {:?}", response);
+{{/ReturnsEmpty}}
+{{/IsSimple}}
+{{#IsLRO}}
+{{#LongRunningReturnsEmpty}}
+///     client
+///         .{{Codec.Name}}()
+{{> /templates/common/client_method_samples/builder_fields}}
+///         .poller()
+///         .until_done()
+///         .await?;
+{{/LongRunningReturnsEmpty}}
+{{^LongRunningReturnsEmpty}}
+///     let response = client
+///         .{{Codec.Name}}()
+{{> /templates/common/client_method_samples/builder_fields}}
+///         .poller()
+///         .until_done()
+///         .await?;
+///     println!("response {:?}", response);
+{{/LongRunningReturnsEmpty}}
+{{/IsLRO}}