Fixes restsharp#625

Author: alexeyzimarev

RestSharp.Tests/UrlBuilderTests.cs

@@ -33,6 +33,19 @@ public void GET_with_empty_request_and_bare_hostname()
             Assert.AreEqual(expected, output);
         }
 
+        [Test]
+        public void GET_with_empty_base_and_query_parameters_without_encoding()
+        {
+            var request = new RestRequest("http://example.com/resource?param1=value1")
+                .AddQueryParameter("foo", "bar,baz", false);
+
+            var client = new RestClient();
+            var expected = new Uri("http://example.com/resource?param1=value1&foo=bar,baz");
+            var output = client.BuildUri(request);
+
+            Assert.AreEqual(expected, output);
+        }
+
         [Test]
         public void GET_with_empty_request_and_query_parameters_without_encoding()
         {
@@ -122,6 +135,20 @@ public void GET_with_resource_containing_slashes()
             Assert.AreEqual(expected, output);
         }
 
+        [Test]
+        public void GET_with_empty_base_and_resource_containing_tokens()
+        {
+            var request = new RestRequest("http://example.com/resource/{foo}");
+
+            request.AddUrlSegment("foo", "bar");
+
+            var client = new RestClient();
+            var expected = new Uri("http://example.com/resource/bar");
+            var output = client.BuildUri(request);
+
+            Assert.AreEqual(expected, output);
+        }
+
         [Test]
         public void GET_with_resource_containing_tokens()
         {

RestSharp/Authenticators/OAuth1Authenticator.cs

@@ -258,20 +258,22 @@ private void AddOAuthData(IRestClient client, IRestRequest request, OAuthWorkflo
             {
                 case OAuthParameterHandling.HttpAuthorizationHeader:
                     parameters.Add("oauth_signature", oauth.Signature);
-                    request.AddHeader("Authorization", GetAuthorizationHeader(parameters));
+                    request.AddOrUpdateParameter("Authorization", GetAuthorizationHeader(parameters), ParameterType.HttpHeader);
                     break;
 
                 case OAuthParameterHandling.UrlOrPostParameters:
                     parameters.Add("oauth_signature", oauth.Signature);
-                    request.Parameters.AddRange(
+                    var headers =
                         parameters.Where(p => !p.Name.IsNullOrBlank() &&
                                               (p.Name.StartsWith("oauth_") || p.Name.StartsWith("x_auth_")))
                             .Select(p => new Parameter
                             {
                                 Name = p.Name,
                                 Value = HttpUtility.UrlDecode(p.Value),
                                 Type = ParameterType.GetOrPost
-                            }));
+                            });
+                    foreach (var header in headers)
+                        request.AddOrUpdateParameter(header);
                     break;
 
                 default:

RestSharp/IRestClient.cs

@@ -84,13 +84,21 @@ RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request,
         IRestResponse<T> Deserialize<T>(IRestResponse response);
 
         /// <summary>
-        /// Allows to use a custom way to encode parameters
+        /// Allows to use a custom way to encode URL parameters
         /// </summary>
-        /// <param name="encoder">A delegate to encode parameters</param>
+        /// <param name="encoder">A delegate to encode URL parameters</param>
         /// <example>client.UseUrlEncoder(s => HttpUtility.UrlEncode(s));</example>
         /// <returns></returns>
         IRestClient UseUrlEncoder(Func<string, string> encoder);
 
+        /// <summary>
+        /// Allows to use a custom way to encode query parameters
+        /// </summary>
+        /// <param name="queryEncoder">A delegate to encode query parameters</param>
+        /// <example>client.UseUrlEncoder((s, encoding) => HttpUtility.UrlEncode(s, encoding));</example>
+        /// <returns></returns>
+        IRestClient UseQueryEncoder(Func<string, Encoding, string> queryEncoder);
+            
         IRestResponse Execute(IRestRequest request);
 
         IRestResponse Execute(IRestRequest request, Method httpMethod);

RestSharp/RestClient.cs

@@ -27,13 +27,11 @@
 using System.Net.Security;
 using System.Reflection;
 using System.Security.Cryptography.X509Certificates;
-using System.Security.Principal;
 using System.Text;
 using System.Text.RegularExpressions;
 using RestSharp.Serialization;
 using RestSharp.Serialization.Json;
 using RestSharp.Serialization.Xml;
-using RestSharp.Serializers;
 
 namespace RestSharp
 {
@@ -94,12 +92,8 @@ public RestClient(string baseUrl) : this()
         /// <param name="serializer">The custom serializer instance</param>
         /// <returns></returns>
         [Obsolete("Use the overload that accepts the delegate factory")]
-        public IRestClient UseSerializer(IRestSerializer serializer)
-        {
-            UseSerializer(() => serializer);
-
-            return this;
-        }
+        public IRestClient UseSerializer(IRestSerializer serializer) =>
+            Fluent(() => UseSerializer(() => serializer));
 
         /// <summary>
         /// Replace the default serializer with a custom one
@@ -130,15 +124,15 @@ public IRestClient UseSerializer(Func<IRestSerializer> serializerFactory)
         /// <param name="encoder">A delegate to encode parameters</param>
         /// <example>client.UseUrlEncoder(s => HttpUtility.UrlEncode(s));</example>
         /// <returns></returns>
-        public IRestClient UseUrlEncoder(Func<string, string> encoder)
-        {
-            Encode = encoder;
-            return this;
-        }
+        public IRestClient UseUrlEncoder(Func<string, string> encoder) => Fluent(() => Encode = encoder);
+
+        public IRestClient UseQueryEncoder(Func<string, Encoding, string> queryEncoder) =>
+            Fluent(() => EncodeQuery = queryEncoder);
 
         private IDictionary<string, Func<IDeserializer>> ContentHandlers { get; }
         internal IDictionary<DataFormat, IRestSerializer> Serializers { get; }
         private Func<string, string> Encode { get; set; } = s => s.UrlEncode();
+        private Func<string, Encoding, string> EncodeQuery { get; set; } = (s, encoding) => s.UrlEncode(encoding);
 
         private IList<string> AcceptTypes { get; }
 
@@ -370,10 +364,9 @@ string IRestClient.BuildUriWithoutQueryParameters(IRestRequest request)
 
         private void DoBuildUriValidations(IRestRequest request)
         {
-            if (BaseUrl == null)
-            {
-                throw new NullReferenceException("RestClient must contain a value for BaseUrl");
-            }
+            if (BaseUrl == null && !request.Resource.ToLower().StartsWith("http"))
+                throw new ArgumentOutOfRangeException(nameof(request),
+                    "Request resource doesn't contain a valid scheme for an empty client base URL");
 
             var nullValuedParams = request.Parameters
                 .Where(p => p.Type == ParameterType.UrlSegment && p.Value == null)
@@ -390,21 +383,21 @@ private void DoBuildUriValidations(IRestRequest request)
 
         private UrlSegmentParamsValues GetUrlSegmentParamsValues(IRestRequest request)
         {
-            var assembled = request.Resource;
-            var hasResource = !string.IsNullOrEmpty(assembled);
+            var assembled = BaseUrl == null ? "" : request.Resource;
+            var baseUrl = BaseUrl ?? new Uri(request.Resource);
+            
+            var hasResource = !assembled.IsEmpty();
             var parameters = request.Parameters.Where(p => p.Type == ParameterType.UrlSegment).ToList();
             parameters.AddRange(DefaultParameters.Where(p => p.Type == ParameterType.UrlSegment));
-            var builder = new UriBuilder(BaseUrl);
+            var builder = new UriBuilder(baseUrl);
 
             foreach (var parameter in parameters)
             {
                 var paramPlaceHolder = $"{{{parameter.Name}}}";
                 var paramValue = Encode(parameter.Value.ToString());
 
                 if (hasResource)
-                {
                     assembled = assembled.Replace(paramPlaceHolder, paramValue);
-                }
 
                 builder.Path = builder.Path.UrlDecode().Replace(paramPlaceHolder, paramValue);
             }
@@ -479,15 +472,15 @@ private Func<IDeserializer> GetHandler(string contentType)
             if (contentType.IsEmpty() && ContentHandlers.ContainsKey("*"))
                 return ContentHandlers["*"];
 
-            if (contentType.IsEmpty()) 
+            if (contentType.IsEmpty())
                 return ContentHandlers.First().Value;
 
             int semicolonIndex = contentType.IndexOf(';');
 
             if (semicolonIndex > -1)
                 contentType = contentType.Substring(0, semicolonIndex);
 
-            if (ContentHandlers.TryGetValue(contentType,  out var contentHandler))
+            if (ContentHandlers.TryGetValue(contentType, out var contentHandler))
                 return contentHandler;
 
             // Avoid unnecessary use of regular expressions in checking for structured syntax suffix by looking for a '+' first
@@ -512,18 +505,18 @@ private Func<IDeserializer> GetHandler(string contentType)
         private void AuthenticateIfNeeded(RestClient client, IRestRequest request) =>
             Authenticator?.Authenticate(client, request);
 
-        private static string EncodeParameters(IEnumerable<Parameter> parameters, Encoding encoding) =>
+        private string EncodeParameters(IEnumerable<Parameter> parameters, Encoding encoding) =>
             string.Join("&", parameters.Select(parameter => EncodeParameter(parameter, encoding)).ToArray());
 
-        private static string EncodeParameter(Parameter parameter, Encoding encoding) =>
-            parameter.Value == null
-                ? parameter.Type == ParameterType.QueryStringWithoutEncode
-                    ? string.Concat(parameter.Name, "=")
-                    : string.Concat(parameter.Name.UrlEncode(encoding), "=")
-                : parameter.Type == ParameterType.QueryStringWithoutEncode
-                    ? string.Concat(parameter.Name, "=", parameter.Value.ToString())
-                    : string.Concat(parameter.Name.UrlEncode(encoding), "=",
-                        parameter.Value.ToString().UrlEncode(encoding));
+        private string EncodeParameter(Parameter parameter, Encoding encoding)
+        {
+            return
+                parameter.Type == ParameterType.QueryStringWithoutEncode
+                    ? $"{parameter.Name}={StringOrEmpty(parameter.Value)}"
+                    : $"{EncodeQuery(parameter.Name, encoding)}={EncodeQuery(StringOrEmpty(parameter.Value), encoding)}";
+
+            string StringOrEmpty(object value) => value == null ? "" : value.ToString();
+        }
 
         private static readonly ParameterType[] MultiParameterTypes =
             {ParameterType.QueryString, ParameterType.GetOrPost};
@@ -550,8 +543,9 @@ internal IHttp ConfigureHttp(IRestRequest request)
             foreach (var defaultParameter in DefaultParameters)
             {
                 var parameterExists =
-                    request.Parameters.Any(p => p.Name.Equals(defaultParameter.Name, StringComparison.InvariantCultureIgnoreCase) 
-                                                && p.Type == defaultParameter.Type);
+                    request.Parameters.Any(p =>
+                        p.Name.Equals(defaultParameter.Name, StringComparison.InvariantCultureIgnoreCase)
+                        && p.Type == defaultParameter.Type);
 
                 if (AllowMultipleDefaultParametersWithSameName)
                 {
@@ -563,7 +557,8 @@ internal IHttp ConfigureHttp(IRestRequest request)
             }
 
             // Add Accept header based on registered deserializers if none has been set by the caller.
-            if (requestParameters.All(p => !string.Equals(p.Name, "accept", StringComparison.InvariantCultureIgnoreCase)))
+            if (requestParameters.All(
+                p => !string.Equals(p.Name, "accept", StringComparison.InvariantCultureIgnoreCase)))
             {
                 var accepts = string.Join(", ", AcceptTypes.ToArray());
 
@@ -743,8 +738,8 @@ private IRestResponse<T> Deserialize<T>(IRestRequest request, IRestResponse raw)
             catch (Exception ex)
             {
                 if (FailOnDeserializationError)
-                  response.ResponseStatus = ResponseStatus.Error;
-                
+                    response.ResponseStatus = ResponseStatus.Error;
+
                 response.ErrorMessage = ex.Message;
                 response.ErrorException = ex;
             }
@@ -773,6 +768,12 @@ private static bool IsWildcardStructuredSuffixSyntax(string contentType)
             return StructuredSyntaxSuffixWildcardRegex.IsMatch(contentType);
         }
 
+        private IRestClient Fluent(Action action)
+        {
+            action();
+            return this;
+        }
+
         private class UrlSegmentParamsValues
         {
             public UrlSegmentParamsValues(Uri builderUri, string assembled)

RestSharp/RestRequest.cs

@@ -61,11 +61,8 @@ public RestRequest()
         ///     Sets Method property to value of method
         /// </summary>
         /// <param name="method">Method to use for this request</param>
-        public RestRequest(Method method) : this()
-        {
-            Method = method;
-        }
-        
+        public RestRequest(Method method) : this() => Method = method;
+
         public RestRequest(string resource, Method method) : this(resource, method, DataFormat.Xml)
         {
         }