Handle repeatability header params in client (#4203)

Fixes: #3936

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/src/Primitives/ScmKnownParameters.cs

@@ -34,5 +34,15 @@ public static ParameterProvider ClientOptions(CSharpType clientOptionsType)
         public static readonly ParameterProvider MatchConditionsParameter = new("matchConditions", $"The content to send as the request conditions of the request.", ClientModelPlugin.Instance.TypeFactory.MatchConditionsType(), DefaultOf(ClientModelPlugin.Instance.TypeFactory.MatchConditionsType()));
         public static readonly ParameterProvider RequestOptions = new("options", $"The request options, which can override default behaviors of the client pipeline on a per-call basis.", typeof(RequestOptions));
         public static readonly ParameterProvider BinaryContent = new("content", $"The content to send as the body of the request.", typeof(BinaryContent)) { Validation = ParameterValidationType.AssertNotNull };
+
+        // Known header parameters
+        public static readonly ParameterProvider RepeatabilityRequestId = new("repeatabilityRequestId", FormattableStringHelpers.Empty, typeof(Guid))
+        {
+            DefaultValue = Static(typeof(Guid)).Invoke(nameof(Guid.NewGuid)).Invoke(nameof(string.ToString))
+        };
+        public static readonly ParameterProvider RepeatabilityFirstSent = new("repeatabilityFirstSent", FormattableStringHelpers.Empty, typeof(DateTimeOffset))
+        {
+            DefaultValue = Static(typeof(DateTimeOffset)).Property(nameof(DateTimeOffset.Now))
+        };
     }
 }

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

@@ -4,6 +4,7 @@
 using System;
 using System.ClientModel.Primitives;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
@@ -21,6 +22,13 @@ namespace Microsoft.Generator.CSharp.ClientModel.Providers
 {
     public class RestClientProvider : TypeProvider
     {
+        private const string RepeatabilityRequestIdHeader = "Repeatability-Request-ID";
+        private const string RepeatabilityFirstSentHeader = "Repeatability-First-Sent";
+        private static readonly Dictionary<string, ParameterProvider> _knownSpecialHeaderParams = new(StringComparer.OrdinalIgnoreCase)
+        {
+            { RepeatabilityRequestIdHeader, ScmKnownParameters.RepeatabilityRequestId },
+            { RepeatabilityFirstSentHeader, ScmKnownParameters.RepeatabilityFirstSent }
+        };
         private Dictionary<InputOperation, MethodProvider>? _methodCache;
         private Dictionary<InputOperation, MethodProvider> MethodCache => _methodCache ??= [];
 
@@ -186,8 +194,6 @@ private PropertyProvider GetClassifier(InputOperation operation)
 
         private IEnumerable<MethodBodyStatement> AppendHeaderParameters(ScopedApi<PipelineRequest> request, InputOperation operation, Dictionary<string, ParameterProvider> paramMap)
         {
-            //TODO handle special headers like Repeatability-First-Sent which shouldn't be params but sent as DateTimeOffset.Now.ToString("R")
-            //https://github.com/microsoft/typespec/issues/3936
             List<MethodBodyStatement> statements = new(operation.Parameters.Count);
 
             foreach (var inputParameter in operation.Parameters)
@@ -328,6 +334,11 @@ private static void GetParamInfo(Dictionary<string, ParameterProvider> paramMap,
                 valueExpression = Literal((inputParam.Type as InputLiteralType)?.Value);
                 format = ClientModelPlugin.Instance.TypeFactory.GetSerializationFormat(inputParam.Type).ToFormatSpecifier();
             }
+            else if (TryGetSpecialHeaderParam(inputParam, out var parameterProvider))
+            {
+                valueExpression = parameterProvider.DefaultValue!;
+                format = ClientModelPlugin.Instance.TypeFactory.GetSerializationFormat(inputParam.Type).ToFormatSpecifier();
+            }
             else
             {
                 var paramProvider = paramMap[inputParam.Name];
@@ -345,6 +356,17 @@ private static void GetParamInfo(Dictionary<string, ParameterProvider> paramMap,
             }
         }
 
+        private static bool TryGetSpecialHeaderParam(InputParameter inputParameter, [NotNullWhen(true)] out ParameterProvider? parameterProvider)
+        {
+            if (inputParameter.Location == RequestLocation.Header)
+            {
+                return _knownSpecialHeaderParams.TryGetValue(inputParameter.NameInRequest, out parameterProvider);
+            }
+
+            parameterProvider = null;
+            return false;
+        }
+
         internal MethodProvider GetCreateRequestMethod(InputOperation operation)
         {
             _ = Methods; // Ensure methods are built
@@ -356,7 +378,7 @@ internal static List<ParameterProvider> GetMethodParameters(InputOperation opera
             List<ParameterProvider> methodParameters = new();
             foreach (InputParameter inputParam in operation.Parameters)
             {
-                if (inputParam.Kind != InputOperationParameterKind.Method)
+                if (inputParam.Kind != InputOperationParameterKind.Method || TryGetSpecialHeaderParam(inputParam, out var _))
                     continue;
 
                 ParameterProvider? parameter = ClientModelPlugin.Instance.TypeFactory.CreateParameter(inputParam);

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/test/Providers/RestClientProviderTests.cs → packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/test/Providers/ClientProviders/RestClientProviderTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.Generator.CSharp.ClientModel.Providers;
@@ -10,7 +11,7 @@
 using Microsoft.Generator.CSharp.Tests.Common;
 using NUnit.Framework;
 
-namespace Microsoft.Generator.CSharp.ClientModel.Tests.Providers
+namespace Microsoft.Generator.CSharp.ClientModel.Tests.Providers.ClientProviders
 {
     public class RestClientProviderTests
     {
@@ -35,7 +36,15 @@ public void TestRestClientMethods(InputOperation inputOperation)
 
             var parameters = signature.Parameters;
             Assert.IsNotNull(parameters);
-            Assert.AreEqual(inputOperation.Parameters.Count + 1, parameters.Count);
+            var specialHeaderParamCount = inputOperation.Parameters.Count(p => p.Location == RequestLocation.Header);
+            Assert.AreEqual(inputOperation.Parameters.Count - specialHeaderParamCount + 1, parameters.Count);
+
+            if (specialHeaderParamCount > 0)
+            {
+                Assert.IsFalse(parameters.Any(p =>
+                    p.Name.Equals("repeatabilityFirstSent", StringComparison.OrdinalIgnoreCase) &&
+                    p.Name.Equals("repeatabilityRequestId", StringComparison.OrdinalIgnoreCase)));
+            }
         }
 
         [Test]
@@ -97,10 +106,48 @@ public void ValidateProperties()
             Assert.IsFalse(pipelineMessageClassifier2xxAnd4xx.Body.HasSetter);
         }
 
+        [TestCaseSource(nameof(GetMethodParametersTestCases))]
+        public void TestGetMethodParameters(InputOperation inputOperation)
+        {
+            var methodParameters = RestClientProvider.GetMethodParameters(inputOperation);
+
+            Assert.IsTrue(methodParameters.Count > 0);
+
+            if (inputOperation.Parameters.Any(p => p.Location == RequestLocation.Header))
+            {
+                // validate no special header parameters are in the method parameters
+                Assert.IsFalse(methodParameters.Any(p =>
+                    p.Name.Equals("repeatabilityFirstSent", StringComparison.OrdinalIgnoreCase) &&
+                    p.Name.Equals("repeatabilityRequestId", StringComparison.OrdinalIgnoreCase)));
+            }
+        }
+
+        [Test]
+        public void ValidateClientWithSpecialHeaders()
+        {
+            var clientProvider = new ClientProvider(SingleOpInputClient);
+            var restClientProvider = new MockClientProvider(SingleOpInputClient, clientProvider);
+            var writer = new TypeProviderWriter(restClientProvider);
+            var file = writer.Write();
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
+        }
+
         private readonly static InputOperation BasicOperation = InputFactory.Operation(
             "CreateMessage",
             parameters:
             [
+                InputFactory.Parameter(
+                    "repeatabilityFirstSent",
+                    new InputDateTimeType(DateTimeKnownEncoding.Rfc7231, "utcDateTime", "TypeSpec.utcDateTime", InputPrimitiveType.String),
+                    nameInRequest: "repeatability-first-sent",
+                    location: RequestLocation.Header,
+                    isRequired: false),
+                InputFactory.Parameter(
+                    "repeatabilityRequestId",
+                    InputPrimitiveType.String,
+                    nameInRequest: "repeatability-request-ID",
+                    location: RequestLocation.Header,
+                    isRequired: false),
                 InputFactory.Parameter("message", InputPrimitiveType.Boolean, isRequired: true)
             ]);
 
@@ -110,5 +157,26 @@ public void ValidateProperties()
         [
             new TestCaseData(BasicOperation)
         ];
+
+        private static IEnumerable<TestCaseData> GetMethodParametersTestCases =>
+        [
+            new TestCaseData(BasicOperation)
+        ];
+
+        private class MockClientProvider : RestClientProvider
+        {
+            public MockClientProvider(InputClient inputClient, ClientProvider clientProvider) : base(inputClient, clientProvider) { }
+
+            protected override MethodProvider[] BuildMethods()
+            {
+                return [.. base.BuildMethods()];
+            }
+
+            protected override FieldProvider[] BuildFields() => [];
+            protected override ConstructorProvider[] BuildConstructors() => [];
+            protected override PropertyProvider[] BuildProperties() => [];
+
+            protected override TypeProvider[] BuildNestedTypes() => [];
+        }
     }
 }

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/test/Providers/ClientProviders/TestData/RestClientProviderTests/ValidateClientWithSpecialHeaders.cs

@@ -0,0 +1,30 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.ClientModel;
+using System.ClientModel.Primitives;
+
+namespace sample.namespace
+{
+    /// <summary></summary>
+    public partial class TestClient
+    {
+        internal global::System.ClientModel.Primitives.PipelineMessage CreateCreateMessageRequest(global::System.ClientModel.BinaryContent content, global::System.ClientModel.Primitives.RequestOptions options)
+        {
+            global::System.ClientModel.Primitives.PipelineMessage message = Pipeline.CreateMessage();
+            message.ResponseClassifier = PipelineMessageClassifier200;
+            global::System.ClientModel.Primitives.PipelineRequest request = message.Request;
+            request.Method = "GET";
+            global::sample.namespace.ClientUriBuilder uri = new global::sample.namespace.ClientUriBuilder();
+            uri.Reset(_endpoint);
+            request.Uri = uri.ToUri();
+            request.Headers.Set("repeatability-first-sent", global::System.DateTimeOffset.Now.ToString("R"));
+            request.Headers.Set("repeatability-request-ID", global::System.Guid.NewGuid().ToString());
+            request.Content = content;
+            message.Apply(options);
+            return message;
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/test/ScmKnownParametersTests.cs

@@ -1,20 +1,44 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System;
 using Microsoft.Generator.CSharp.ClientModel.Primitives;
 using Microsoft.Generator.CSharp.Primitives;
 using NUnit.Framework;
+using static Microsoft.Generator.CSharp.Snippets.Snippet;
 
 namespace Microsoft.Generator.CSharp.ClientModel.Tests
 {
     public class ScmKnownParametersTests
     {
-        [Test]
-        public void BinaryDataParametersHasValidation()
+        [OneTimeSetUp]
+        public void Setup()
         {
             MockHelpers.LoadMockPlugin();
+
+        }
+
+        [Test]
+        public void BinaryDataParameterHasValidation()
+        {
             var parameter = ScmKnownParameters.BinaryContent;
             Assert.AreEqual(ParameterValidationType.AssertNotNull, parameter.Validation);
         }
+
+        [Test]
+        public void RepeatabilityRequestIdParamHasDefaultValue()
+        {
+            var parameter = ScmKnownParameters.RepeatabilityRequestId;
+            var expectedDefaultValue = Static(typeof(Guid)).Invoke(nameof(Guid.NewGuid)).Invoke(nameof(string.ToString));
+            Assert.AreEqual(expectedDefaultValue, parameter.DefaultValue);
+        }
+
+        [Test]
+        public void RepeatabilityFirstSentParamHasDefaultValue()
+        {
+            var parameter = ScmKnownParameters.RepeatabilityFirstSent;
+            var expectedDefaultValue = Static(typeof(DateTimeOffset)).Property(nameof(DateTimeOffset.Now));
+            Assert.AreEqual(expectedDefaultValue, parameter.DefaultValue);
+        }
     }
 }

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/test/common/InputFactory.cs

@@ -55,6 +55,7 @@ public static InputConstant Int64(long value)
         public static InputParameter Parameter(
         string name,
         InputType type,
+        string? nameInRequest = null,
         InputConstant? defaultValue = null,
         RequestLocation location = RequestLocation.Body,
         bool isRequired = false,
@@ -64,7 +65,7 @@ public static InputParameter Parameter(
         {
             return new InputParameter(
                 name,
-                name,
+                nameInRequest ?? name,
                 $"{name} description",
                 type,
                 location,

packages/http-client-csharp/generator/TestProjects/Local/Unbranded-TypeSpec/src/Generated/UnbrandedTypeSpecClient.RestClient.cs

@@ -210,7 +210,7 @@ internal PipelineMessage CreateFriendlyModelRequest(RequestOptions options)
             return message;
         }
 
-        internal PipelineMessage CreateAddTimeHeaderRequest(DateTimeOffset repeatabilityFirstSent, RequestOptions options)
+        internal PipelineMessage CreateAddTimeHeaderRequest(RequestOptions options)
         {
             PipelineMessage message = Pipeline.CreateMessage();
             message.ResponseClassifier = PipelineMessageClassifier204;
@@ -220,7 +220,7 @@ internal PipelineMessage CreateAddTimeHeaderRequest(DateTimeOffset repeatability
             uri.Reset(_endpoint);
             uri.AppendPath("/", false);
             request.Uri = uri.ToUri();
-            request.Headers.Set("Repeatability-First-Sent", repeatabilityFirstSent.ToString("R"));
+            request.Headers.Set("Repeatability-First-Sent", DateTimeOffset.Now.ToString("R"));
             message.Apply(options);
             return message;
         }

packages/http-client-csharp/generator/TestProjects/Local/Unbranded-TypeSpec/src/Generated/UnbrandedTypeSpecClient.cs

@@ -737,13 +737,12 @@ public virtual async Task<ClientResult<Friend>> FriendlyModelAsync()
         /// </item>
         /// </list>
         /// </summary>
-        /// <param name="repeatabilityFirstSent"></param>
         /// <param name="options"> The request options, which can override default behaviors of the client pipeline on a per-call basis. </param>
         /// <exception cref="ClientResultException"> Service returned a non-success status code. </exception>
         /// <returns> The response returned from the service. </returns>
-        public virtual ClientResult AddTimeHeader(DateTimeOffset repeatabilityFirstSent, RequestOptions options)
+        public virtual ClientResult AddTimeHeader(RequestOptions options)
         {
-            using PipelineMessage message = CreateAddTimeHeaderRequest(repeatabilityFirstSent, options);
+            using PipelineMessage message = CreateAddTimeHeaderRequest(options);
             return ClientResult.FromResponse(Pipeline.ProcessMessage(message, options));
         }
 
@@ -755,30 +754,27 @@ public virtual ClientResult AddTimeHeader(DateTimeOffset repeatabilityFirstSent,
         /// </item>
         /// </list>
         /// </summary>
-        /// <param name="repeatabilityFirstSent"></param>
         /// <param name="options"> The request options, which can override default behaviors of the client pipeline on a per-call basis. </param>
         /// <exception cref="ClientResultException"> Service returned a non-success status code. </exception>
         /// <returns> The response returned from the service. </returns>
-        public virtual async Task<ClientResult> AddTimeHeaderAsync(DateTimeOffset repeatabilityFirstSent, RequestOptions options)
+        public virtual async Task<ClientResult> AddTimeHeaderAsync(RequestOptions options)
         {
-            using PipelineMessage message = CreateAddTimeHeaderRequest(repeatabilityFirstSent, options);
+            using PipelineMessage message = CreateAddTimeHeaderRequest(options);
             return ClientResult.FromResponse(await Pipeline.ProcessMessageAsync(message, options).ConfigureAwait(false));
         }
 
         /// <summary> addTimeHeader. </summary>
-        /// <param name="repeatabilityFirstSent"></param>
         /// <exception cref="ClientResultException"> Service returned a non-success status code. </exception>
-        public virtual ClientResult AddTimeHeader(DateTimeOffset repeatabilityFirstSent)
+        public virtual ClientResult AddTimeHeader()
         {
-            return AddTimeHeader(repeatabilityFirstSent, null);
+            return AddTimeHeader(null);
         }
 
         /// <summary> addTimeHeader. </summary>
-        /// <param name="repeatabilityFirstSent"></param>
         /// <exception cref="ClientResultException"> Service returned a non-success status code. </exception>
-        public virtual async Task<ClientResult> AddTimeHeaderAsync(DateTimeOffset repeatabilityFirstSent)
+        public virtual async Task<ClientResult> AddTimeHeaderAsync()
         {
-            return await AddTimeHeaderAsync(repeatabilityFirstSent, null).ConfigureAwait(false);
+            return await AddTimeHeaderAsync(null).ConfigureAwait(false);
         }
 
         /// <summary>