[http-client-csharp] Fix trailing path separator for optional path parameter (#11096)

## Problem

When a route ends with an **optional** path parameter, the `/` separator
preceding that segment was emitted unconditionally, leaving a dangling
trailing slash when the value is null.

For example, `/certificates/{certificate-name}/{certificate-version}`
(with `certificate-version` optional) generated:

```csharp
uri.AppendPath(certificateName, true);
uri.AppendPath("/", false);            // emitted unconditionally
if ((certificateVersion != null))
{
    uri.AppendPath(certificateVersion, true);
}
```

So when `certificateVersion` is null the wire URL becomes
`/certificates/{name}/` instead of `/certificates/{name}`. Services
(e.g. Key Vault) and recorded test cassettes expect no trailing slash.

The existing `shouldPrependWithPathSeparator` logic only handled the
case where the preceding literal does *not* end in `/`; it missed the
case where the separator had already been written unconditionally.

## Fix

In `RestClientProvider.AddUriSegments`, when the upcoming path parameter
is optional and the preceding literal ends with `/`, defer that trailing
`/` so it is written together with the parameter value inside the null
check:

```csharp
uri.AppendPath(certificateName, true);
if ((certificateVersion != null))
{
    uri.AppendPath("/", false);
    uri.AppendPath(certificateVersion, true);
}
```

Required path parameters are unaffected.

## Tests

- Added `TestBuildCreateRequestMethodWithOptionalPathParameter` (+
golden file) covering the trailing optional-segment case.
- Updated two `ServerTemplate*` tests that relied on the test factory's
default `isRequired: false` for what were intended to be normal required
path parameters.
- Full `Microsoft.TypeSpec.Generator.ClientModel` suite passes (1440
tests).

Reported in Azure/azure-sdk-for-net#60162 (Bug A).

--generated by Copilot

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: JoshLove-msft

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/RestClientProvider.cs

@@ -717,10 +717,27 @@ private void AddUriSegments(
                 }
 
                 var path = pathSpan.Slice(0, paramIndex);
-                AppendLiteralSegment(uri, path.ToString(), statements);
                 pathSpan = pathSpan.Slice(paramIndex + 1);
                 var paramEndIndex = pathSpan.IndexOf('}');
                 var paramName = pathSpan.Slice(0, paramEndIndex).ToString();
+
+                /* An optional path parameter that is null must not leave a dangling
+                 * path separator behind. For example "/foo/{bar}/{baz}" with an absent
+                 * optional "baz" should produce "/foo/{bar}", not "/foo/{bar}/". When the
+                 * upcoming parameter is optional, defer the trailing '/' of the preceding
+                 * literal so it is only written together with the parameter value inside
+                 * the null check below.
+                 */
+                var pathLiteral = path.ToString();
+                bool separatorDeferred = false;
+                if (pathLiteral.EndsWith('/')
+                    && inputParamMap.TryGetValue(paramName, out var optionalCheckParam)
+                    && optionalCheckParam is InputPathParameter { IsRequired: false })
+                {
+                    pathLiteral = pathLiteral.Substring(0, pathLiteral.Length - 1);
+                    separatorDeferred = true;
+                }
+                AppendLiteralSegment(uri, pathLiteral, statements);
                 /* when the parameter is in operation.uri, it is client parameter
                  * It is not operation parameter and not in inputParamHash list.
                  */
@@ -766,7 +783,7 @@ private void AddUriSegments(
                     MethodBodyStatement statement;
                     if (inputParam?.IsRequired == false)
                     {
-                        bool shouldPrependWithPathSeparator = path.Length > 0 && path[^1] != '/';
+                        bool shouldPrependWithPathSeparator = separatorDeferred || (path.Length > 0 && path[^1] != '/');
                         List<MethodBodyStatement> appendPathStatements = shouldPrependWithPathSeparator
                             ? [uri.AppendPath(Literal("/"), false).Terminate(), uri.AppendPath(valueExpression, escape).Terminate()]
                             : [uri.AppendPath(valueExpression, escape).Terminate()];

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderTests.cs

@@ -3589,8 +3589,8 @@ public void ServerTemplateWithPathParameter_OnlyAppendsSegmentsAfterEndpoint()
             MockHelpers.LoadMockGenerator();
 
             var serverTemplate = "{endpoint}/{apiVersion}";
-            var apiVersionParam = InputFactory.PathParameter("apiVersion", InputPrimitiveType.String, serverUrlTemplate: serverTemplate);
-            var userIdParam = InputFactory.PathParameter("userId", InputPrimitiveType.String);
+            var apiVersionParam = InputFactory.PathParameter("apiVersion", InputPrimitiveType.String, isRequired: true, serverUrlTemplate: serverTemplate);
+            var userIdParam = InputFactory.PathParameter("userId", InputPrimitiveType.String, isRequired: true);
 
             var operation = InputFactory.Operation(
                 name: "GetUser",
@@ -3633,7 +3633,7 @@ public void ServerTemplateWithMultipleSegments_HandlesCorrectly()
             MockHelpers.LoadMockGenerator();
 
             var serverTemplate = "{endpoint}/v1/services";
-            var operationIdParam = InputFactory.PathParameter("operationId", InputPrimitiveType.String);
+            var operationIdParam = InputFactory.PathParameter("operationId", InputPrimitiveType.String, isRequired: true);
 
             var operation = InputFactory.Operation(
                 name: "GetOperation",

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/RestClientProviderTests.cs

@@ -819,6 +819,34 @@ public void TestBuildCreateRequestMethodWithPathParameters()
             Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
         }
 
+        // An optional trailing path parameter must not emit a dangling separator when null.
+        // e.g. "/certificates/{certificateName}/{certificateVersion}" with a null version
+        // should produce "/certificates/{name}", not "/certificates/{name}/".
+        [Test]
+        public void TestBuildCreateRequestMethodWithOptionalPathParameter()
+        {
+            List<InputParameter> parameters =
+            [
+                InputFactory.PathParameter("certificateName", InputPrimitiveType.String, isRequired: true),
+                InputFactory.PathParameter("certificateVersion", InputPrimitiveType.String, isRequired: false),
+            ];
+            var operation = InputFactory.Operation(
+                "getCertificate",
+                parameters: parameters,
+                uri: "/certificates/{certificateName}/{certificateVersion}");
+
+            var client = InputFactory.Client(
+                "TestClient",
+                methods: [InputFactory.BasicServiceMethod("Test", operation)]);
+
+            var clientProvider = new ClientProvider(client);
+            var restClientProvider = new MockClientProvider(client, clientProvider);
+
+            var writer = new TypeProviderWriter(restClientProvider);
+            var file = writer.Write();
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
+        }
+
         [Test]
         public void TestBuildCreateRequestMethodWithQueryInPath()
         {

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/TestData/RestClientProviderTests/TestBuildCreateRequestMethodWithOptionalPathParameter.cs

@@ -0,0 +1,28 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System.ClientModel.Primitives;
+
+namespace Sample
+{
+    public partial class TestClient
+    {
+        internal global::System.ClientModel.Primitives.PipelineMessage CreateGetCertificateRequest(string certificateName, string certificateVersion, global::System.ClientModel.Primitives.RequestOptions options)
+        {
+            global::Sample.ClientUriBuilder uri = new global::Sample.ClientUriBuilder();
+            uri.Reset(_endpoint);
+            uri.AppendPath("/certificates/", false);
+            uri.AppendPath(certificateName, true);
+            if ((certificateVersion != null))
+            {
+                uri.AppendPath("/", false);
+                uri.AppendPath(certificateVersion, true);
+            }
+            global::System.ClientModel.Primitives.PipelineMessage message = Pipeline.CreateMessage(uri.ToUri(), "GET", PipelineMessageClassifier200);
+            global::System.ClientModel.Primitives.PipelineRequest request = message.Request;
+            message.Apply(options);
+            return message;
+        }
+    }
+}