Simplify IParamConverterManager to single two-parameter GetConverter method

Activout.RestClient.Test/ParamConverterTests.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Reflection;
+using Activout.RestClient.ParamConverter;
+using Activout.RestClient.ParamConverter.Implementation;
+using Xunit;
+
+namespace Activout.RestClient.Test
+{
+    public class ParamConverterTests
+    {
+        [Fact]
+        public void DateTimeIso8601ParamConverter_CanConvert_AcceptsDateTimeType()
+        {
+            // Arrange
+            var converter = new DateTimeIso8601ParamConverter();
+            var methodInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithDateTimeParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var parameterInfo = methodInfo.GetParameters()[0];
+
+            // Act & Assert
+            Assert.True(converter.CanConvert(typeof(DateTime), parameterInfo));
+        }
+
+        [Fact]
+        public void DateTimeIso8601ParamConverter_CanConvert_RejectsNonDateTimeType()
+        {
+            // Arrange
+            var converter = new DateTimeIso8601ParamConverter();
+            var methodInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithStringParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var parameterInfo = methodInfo.GetParameters()[0];
+
+            // Act & Assert
+            Assert.False(converter.CanConvert(typeof(string), parameterInfo));
+        }
+
+        [Fact]
+        public void ToStringParamConverter_CanConvert_AcceptsAnyType()
+        {
+            // Arrange
+            var converter = new ToStringParamConverter();
+            var stringMethodInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithStringParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var stringParameterInfo = stringMethodInfo.GetParameters()[0];
+            var intMethodInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithIntParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var intParameterInfo = intMethodInfo.GetParameters()[0];
+            var dateTimeMethodInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithDateTimeParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var dateTimeParameterInfo = dateTimeMethodInfo.GetParameters()[0];
+
+            // Act & Assert
+            Assert.True(converter.CanConvert(typeof(string), stringParameterInfo));
+            Assert.True(converter.CanConvert(typeof(int), intParameterInfo));
+            Assert.True(converter.CanConvert(typeof(DateTime), dateTimeParameterInfo));
+        }
+
+        [Fact]
+        public void ParamConverterManager_GetConverter_WithTypeAndParameterInfo_UsesCorrectConverter()
+        {
+            // Arrange
+            var manager = new ParamConverterManager();
+            var methodInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithDateTimeParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var parameterInfo = methodInfo.GetParameters()[0];
+
+            // Act
+            var converter = manager.GetConverter(typeof(DateTime), parameterInfo);
+
+            // Assert
+            Assert.NotNull(converter);
+            Assert.IsType<DateTimeIso8601ParamConverter>(converter);
+        }
+
+        [Fact]
+        public void ParamConverterManager_GetConverter_WithTypeOnly_UsesCorrectConverter()
+        {
+            // Arrange
+            var manager = new ParamConverterManager();
+            var methodInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithDateTimeParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var parameterInfo = methodInfo.GetParameters()[0];
+
+            // Act
+            var converter = manager.GetConverter(typeof(DateTime), parameterInfo);
+
+            // Assert
+            Assert.NotNull(converter);
+            Assert.IsType<DateTimeIso8601ParamConverter>(converter);
+        }
+
+        [Fact]
+        public void CustomParamConverter_CanAccessParameterInfo()
+        {
+            // Arrange
+            var converter = new TestCustomParamConverter();
+            var methodWithAttributeInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithCustomAttribute), BindingFlags.NonPublic | BindingFlags.Instance);
+            var parameterWithAttribute = methodWithAttributeInfo.GetParameters()[0];
+            var methodWithoutAttributeInfo = typeof(ParamConverterTests).GetMethod(nameof(TestMethodWithStringParam), BindingFlags.NonPublic | BindingFlags.Instance);
+            var parameterWithoutAttribute = methodWithoutAttributeInfo.GetParameters()[0];
+
+            // Act
+            var canConvertWithAttribute = converter.CanConvert(typeof(string), parameterWithAttribute);
+            var canConvertWithoutAttribute = converter.CanConvert(typeof(string), parameterWithoutAttribute);
+
+            // Assert
+            Assert.True(canConvertWithAttribute); // Should return true because parameter has TestAttribute
+            Assert.False(canConvertWithoutAttribute); // Should return false because parameter doesn't have TestAttribute
+        }
+
+        // Test method used for reflection
+        private void TestMethodWithDateTimeParam(DateTime date) { }
+
+        // Test method used for reflection
+        private void TestMethodWithStringParam(string value) { }
+
+        // Test method used for reflection
+        private void TestMethodWithIntParam(int value) { }
+
+        // Test method used for reflection
+        private void TestMethodWithCustomAttribute([TestAttribute] string value) { }
+
+        // Custom attribute for testing
+        private class TestAttribute : Attribute { }
+
+        // Custom converter for testing
+        private class TestCustomParamConverter : IParamConverter
+        {
+            public bool CanConvert(Type type, ParameterInfo parameterInfo)
+            {
+                // Only handle string types that have a TestAttribute
+                if (type != typeof(string))
+                    return false;
+
+                // Check if parameter has TestAttribute
+                return parameterInfo.GetCustomAttribute<TestAttribute>() != null;
+            }
+
+            public string ToString(object value)
+            {
+                return value?.ToString() ?? "";
+            }
+        }
+    }
+}

Activout.RestClient/Implementation/RequestHandler.cs

@@ -102,7 +102,7 @@ private IParamConverter[] GetParamConverters(IParamConverterManager paramConvert
             var paramConverters = new IParamConverter[_parameters.Length];
             for (var i = 0; i < _parameters.Length; i++)
             {
-                paramConverters[i] = paramConverterManager.GetConverter(_parameters[i]);
+                paramConverters[i] = paramConverterManager.GetConverter(_parameters[i].ParameterType, _parameters[i]);
             }
 
             return paramConverters;
@@ -247,12 +247,12 @@ private void SetHeaders(HttpRequestMessage request, List<KeyValuePair<string, ob
             headers.ForEach(p => request.Headers.Add(p.Key, p.Value.ToString()));
         }
 
-        private string ConvertValueToString(object value)
+        private string ConvertValueToString(object value, ParameterInfo parameterInfo)
         {
             if (value == null)
                 return null;
 
-            var converter = _context.ParamConverterManager.GetConverter(value.GetType());
+            var converter = _context.ParamConverterManager.GetConverter(value.GetType(), parameterInfo);
             return converter?.ToString(value) ?? value.ToString();
         }
 
@@ -309,7 +309,7 @@ private CancellationToken GetParams(
                             foreach (DictionaryEntry entry in dictionary)
                             {
                                 var key = entry.Key?.ToString();
-                                var value = ConvertValueToString(entry.Value);
+                                var value = ConvertValueToString(entry.Value, _parameters[i]);
                                 if (key != null && value != null)
                                 {
                                     queryParams.Add(Uri.EscapeDataString(key) + "=" + Uri.EscapeDataString(value));
@@ -330,7 +330,7 @@ private CancellationToken GetParams(
                             foreach (DictionaryEntry entry in dictionary)
                             {
                                 var key = entry.Key?.ToString();
-                                var value = ConvertValueToString(entry.Value);
+                                var value = ConvertValueToString(entry.Value, _parameters[i]);
                                 if (key != null && value != null)
                                 {
                                     formParams.Add(new KeyValuePair<string, string>(key, value));
@@ -351,7 +351,7 @@ private CancellationToken GetParams(
                             foreach (DictionaryEntry entry in dictionary)
                             {
                                 var key = entry.Key?.ToString();
-                                var value = ConvertValueToString(entry.Value);
+                                var value = ConvertValueToString(entry.Value, _parameters[i]);
                                 if (key != null && value != null)
                                 {
                                     headers.AddOrReplaceHeader(key, value, headerParamAttribute.Replace);

Activout.RestClient/ParamConverter/IParamConverter.cs

@@ -1,10 +1,11 @@
 using System;
+using System.Reflection;
 
 namespace Activout.RestClient.ParamConverter
 {
     public interface IParamConverter
     {
-        bool CanConvert(Type type);
+        bool CanConvert(Type type, ParameterInfo parameterInfo);
         string ToString(object value);
     }
 }

Activout.RestClient/ParamConverter/IParamConverterManager.cs

@@ -5,7 +5,6 @@ namespace Activout.RestClient.ParamConverter
 {
     public interface IParamConverterManager
     {
-        IParamConverter GetConverter(ParameterInfo parameterInfo);
-        IParamConverter GetConverter(Type type);
+        IParamConverter GetConverter(Type type, ParameterInfo parameterInfo);
     }
 }

Activout.RestClient/ParamConverter/Implementation/DateTimeEpochParamConverter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Reflection;
 
 namespace Activout.RestClient.ParamConverter.Implementation
 {
@@ -13,7 +14,7 @@ public static long ToUnixTime(this DateTime date)
 
     public class DateTimeEpochParamConverter : IParamConverter
     {
-        public bool CanConvert(Type type)
+        public bool CanConvert(Type type, ParameterInfo parameterInfo)
         {
             return type == typeof(DateTime);
         }

Activout.RestClient/ParamConverter/Implementation/DateTimeIso8601ParamConverter.cs

@@ -1,10 +1,11 @@
 using System;
+using System.Reflection;
 
 namespace Activout.RestClient.ParamConverter.Implementation
 {
     public class DateTimeIso8601ParamConverter : IParamConverter
     {
-        public bool CanConvert(Type type)
+        public bool CanConvert(Type type, ParameterInfo parameterInfo)
         {
             return type == typeof(DateTime);
         }

Activout.RestClient/ParamConverter/Implementation/ParamConverterManager.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Reflection;
 
 namespace Activout.RestClient.ParamConverter.Implementation
@@ -13,16 +14,11 @@ public ParamConverterManager()
             ParamConverters = new List<IParamConverter> { new DateTimeIso8601ParamConverter(), new ToStringParamConverter() };
         }
 
-        public IParamConverter GetConverter(ParameterInfo parameterInfo)
-        {
-            return GetConverter(parameterInfo.ParameterType);
-        }
-
-        public IParamConverter GetConverter(Type type)
+        public IParamConverter GetConverter(Type type, ParameterInfo parameterInfo)
         {
             foreach (var paramConverter in ParamConverters)
             {
-                if (paramConverter.CanConvert(type))
+                if (paramConverter.CanConvert(type, parameterInfo))
                 {
                     return paramConverter;
                 }

Activout.RestClient/ParamConverter/Implementation/ToStringParamConverter.cs

@@ -1,10 +1,11 @@
 using System;
+using System.Reflection;
 
 namespace Activout.RestClient.ParamConverter.Implementation
 {
     public class ToStringParamConverter : IParamConverter
     {
-        public bool CanConvert(Type type)
+        public bool CanConvert(Type type, ParameterInfo parameterInfo)
         {
             return true;
         }