Better parameter handling (#1673)

* More JSON extensions

* More explicit parameters handling

* Cleaning up authenticators

* Cleaning usings

Author: alexeyzimarev

src/RestSharp/Authenticators/AuthenticatorBase.cs

@@ -17,7 +17,7 @@ namespace RestSharp.Authenticators;
 public abstract class AuthenticatorBase : IAuthenticator {
     protected AuthenticatorBase(string token) => Token = token;
 
-    protected string Token { get; }
+    protected string Token { get; set; }
 
     protected abstract ValueTask<Parameter> GetAuthenticationParameter(string accessToken);
 

src/RestSharp/Authenticators/HttpBasicAuthenticator.cs

@@ -35,5 +35,5 @@ static string GetHeader(string username, string password, Encoding encoding)
 
     // return ;
     protected override ValueTask<Parameter> GetAuthenticationParameter(string accessToken)
-        => new(new Parameter("Authorization", $"Basic {accessToken}", ParameterType.HttpHeader));
+        => new(new Parameter(KnownHeaders.Authorization, $"Basic {accessToken}", ParameterType.HttpHeader, false));
 }

src/RestSharp/Authenticators/JwtAuthenticator.cs

@@ -18,21 +18,18 @@ namespace RestSharp.Authenticators;
 /// JSON WEB TOKEN (JWT) Authenticator class.
 /// <remarks>https://tools.ietf.org/html/draft-ietf-oauth-json-web-token</remarks>
 /// </summary>
-public class JwtAuthenticator : IAuthenticator {
-    string _authHeader = null!;
-
-    // ReSharper disable once IntroduceOptionalParameters.Global
-    public JwtAuthenticator(string accessToken) => SetBearerToken(accessToken);
+public class JwtAuthenticator : AuthenticatorBase {
+    public JwtAuthenticator(string accessToken) : base(GetToken(accessToken)) { }
 
     /// <summary>
     /// Set the new bearer token so the request gets the new header value
     /// </summary>
     /// <param name="accessToken"></param>
     [PublicAPI]
-    public void SetBearerToken(string accessToken) => _authHeader = $"Bearer {Ensure.NotEmpty(accessToken, nameof(accessToken))}";
+    public void SetBearerToken(string accessToken) => Token = GetToken(accessToken);
+
+    static string GetToken(string accessToken) => $"Bearer {Ensure.NotEmpty(accessToken, nameof(accessToken))}";
 
-    public ValueTask Authenticate(RestClient client, RestRequest request) {
-        request.AddOrUpdateParameter("Authorization", _authHeader, ParameterType.HttpHeader);
-        return default;
-    }
+    protected override ValueTask<Parameter> GetAuthenticationParameter(string accessToken)
+        => new(new Parameter(KnownHeaders.Authorization, accessToken, ParameterType.HttpHeader, false));
 }

src/RestSharp/Authenticators/OAuth/OAuth1Authenticator.cs

@@ -40,9 +40,9 @@ public class OAuth1Authenticator : IAuthenticator {
 
     public ValueTask Authenticate(RestClient client, RestRequest request) {
         var workflow = new OAuthWorkflow {
-            ConsumerKey    = ConsumerKey,
-            ConsumerSecret = ConsumerSecret,
-            // ParameterHandling  = ParameterHandling,
+            ConsumerKey        = ConsumerKey,
+            ConsumerSecret     = ConsumerSecret,
+            ParameterHandling  = ParameterHandling,
             SignatureMethod    = SignatureMethod,
             SignatureTreatment = SignatureTreatment,
             Verifier           = Verifier,
@@ -191,7 +191,7 @@ public static OAuth1Authenticator ForProtectedResource(
         };
 
     void AddOAuthData(RestClient client, RestRequest request, OAuthWorkflow workflow) {
-        var requestUrl = client.BuildUriWithoutQueryParameters(request);
+        var requestUrl = client.BuildUriWithoutQueryParameters(request).AbsoluteUri;
 
         if (requestUrl.Contains('?'))
             throw new ApplicationException(
@@ -233,7 +233,7 @@ void AddOAuthData(RestClient client, RestRequest request, OAuthWorkflow workflow
             OAuthType.AccessToken          => workflow.BuildAccessTokenSignature(method, parameters),
             OAuthType.ClientAuthentication => workflow.BuildClientAuthAccessTokenSignature(method, parameters),
             OAuthType.ProtectedResource    => workflow.BuildProtectedResourceSignature(method, parameters, url),
-            _                              => throw new ArgumentOutOfRangeException()
+            _                              => throw new ArgumentOutOfRangeException(nameof(Type))
         };
 
         oauth.Parameters.Add("oauth_signature", oauth.Signature);
@@ -242,13 +242,13 @@ void AddOAuthData(RestClient client, RestRequest request, OAuthWorkflow workflow
             OAuthParameterHandling.HttpAuthorizationHeader => CreateHeaderParameters(),
             OAuthParameterHandling.UrlOrPostParameters     => CreateUrlParameters(),
             _ =>
-                throw new ArgumentOutOfRangeException()
+                throw new ArgumentOutOfRangeException(nameof(ParameterHandling))
         };
 
         request.AddOrUpdateParameters(oauthParameters);
 
         IEnumerable<Parameter> CreateHeaderParameters()
-            => new[] { new Parameter("Authorization", GetAuthorizationHeader(), ParameterType.HttpHeader) };
+            => new[] { new Parameter(KnownHeaders.Authorization, GetAuthorizationHeader(), ParameterType.HttpHeader) };
 
         IEnumerable<Parameter> CreateUrlParameters()
             => oauth.Parameters.Select(p => new Parameter(p.Name, HttpUtility.UrlDecode(p.Value), ParameterType.GetOrPost));

src/RestSharp/Authenticators/OAuth/OAuthWorkflow.cs

@@ -14,7 +14,6 @@
 
 using System.Web;
 using RestSharp.Authenticators.OAuth.Extensions;
-using RestSharp.Extensions;
 
 namespace RestSharp.Authenticators.OAuth;
 
@@ -32,11 +31,11 @@ sealed class OAuthWorkflow {
     public string?                 SessionHandle      { get; set; }
     public OAuthSignatureMethod    SignatureMethod    { get; set; }
     public OAuthSignatureTreatment SignatureTreatment { get; set; }
-    // public OAuthParameterHandling  ParameterHandling  { get; set; }
-    public string? ClientUsername  { get; set; }
-    public string? ClientPassword  { get; set; }
-    public string? RequestTokenUrl { get; set; }
-    public string? AccessTokenUrl  { get; set; }
+    public OAuthParameterHandling  ParameterHandling  { get; set; }
+    public string?                 ClientUsername     { get; set; }
+    public string?                 ClientPassword     { get; set; }
+    public string?                 RequestTokenUrl    { get; set; }
+    public string?                 AccessTokenUrl     { get; set; }
 
     /// <summary>
     /// Generates an OAuth signature to pass to an
@@ -169,32 +168,24 @@ void ValidateProtectedResourceState() {
         Ensure.NotEmpty(ConsumerKey, nameof(ConsumerKey));
     }
 
-    WebPairCollection GenerateAuthParameters(string timestamp, string nonce) {
-        var authParameters = new WebPairCollection {
-            new("oauth_consumer_key", Ensure.NotNull(ConsumerKey, nameof(ConsumerKey))),
-            new("oauth_nonce", nonce),
-            new("oauth_signature_method", SignatureMethod.ToRequestValue()),
-            new("oauth_timestamp", timestamp),
-            new("oauth_version", Version ?? "1.0")
-        };
-
-        if (!Token.IsEmpty()) authParameters.Add(new WebPair("oauth_token", Token!, true));
-
-        if (!CallbackUrl.IsEmpty()) authParameters.Add(new WebPair("oauth_callback", CallbackUrl!, true));
-
-        if (!Verifier.IsEmpty()) authParameters.Add(new WebPair("oauth_verifier", Verifier!));
-
-        if (!SessionHandle.IsEmpty()) authParameters.Add(new WebPair("oauth_session_handle", SessionHandle!));
-
-        return authParameters;
-    }
+    WebPairCollection GenerateAuthParameters(string timestamp, string nonce)
+        => new WebPairCollection {
+                new("oauth_consumer_key", Ensure.NotNull(ConsumerKey, nameof(ConsumerKey)), true),
+                new("oauth_nonce", nonce),
+                new("oauth_signature_method", SignatureMethod.ToRequestValue()),
+                new("oauth_timestamp", timestamp),
+                new("oauth_version", Version ?? "1.0")
+            }.AddNotEmpty("oauth_token", Token!, true)
+            .AddNotEmpty("oauth_callback", CallbackUrl!, true)
+            .AddNotEmpty("oauth_verifier", Verifier!)
+            .AddNotEmpty("oauth_session_handle", SessionHandle!);
 
     WebPairCollection GenerateXAuthParameters(string timestamp, string nonce)
-        => new() {
+        => new WebPairCollection {
             new("x_auth_username", Ensure.NotNull(ClientUsername, nameof(ClientUsername))),
             new("x_auth_password", Ensure.NotNull(ClientPassword, nameof(ClientPassword))),
             new("x_auth_mode", "client_auth"),
-            new("oauth_consumer_key", Ensure.NotNull(ConsumerKey, nameof(ConsumerKey))),
+            new("oauth_consumer_key", Ensure.NotNull(ConsumerKey, nameof(ConsumerKey)), true),
             new("oauth_signature_method", SignatureMethod.ToRequestValue()),
             new("oauth_timestamp", timestamp),
             new("oauth_nonce", nonce),

src/RestSharp/Authenticators/OAuth/WebPairCollection.cs

@@ -28,6 +28,12 @@ class WebPairCollection : IList<WebPair> {
     public void AddRange(IEnumerable<WebPair> collection) => AddCollection(collection);
 
     public void Add(string name, string value) => Add(new WebPair(name, value));
+    
+    public WebPairCollection AddNotEmpty(string name, string? value, bool encode = false) {
+        if (value != null)
+            Add(new WebPair(name, value, encode));
+        return this;
+    }
 
     public void Clear() => _parameters.Clear();
 

src/RestSharp/Authenticators/OAuth2/OAuth2AuthorizationRequestHeaderAuthenticator.cs

@@ -38,5 +38,5 @@ public OAuth2AuthorizationRequestHeaderAuthenticator(string accessToken)
     public OAuth2AuthorizationRequestHeaderAuthenticator(string accessToken, string tokenType) : base(accessToken) => _tokenType = tokenType;
 
     protected override ValueTask<Parameter> GetAuthenticationParameter(string accessToken)
-        => new(new Parameter("Authorization", $"{_tokenType} {accessToken}", ParameterType.HttpHeader));
+        => new(new Parameter(KnownHeaders.Authorization, $"{_tokenType} {accessToken}", ParameterType.HttpHeader));
 }

src/RestSharp/KnownHeaders.cs

@@ -18,6 +18,7 @@
 namespace RestSharp;
 
 public static class KnownHeaders {
+    public const string Authorization      = "Authorization";
     public const string Accept             = "Accept";
     public const string Allow              = "Allow";
     public const string Expires            = "Expires";

src/RestSharp/Parameters/Parameter.cs

@@ -66,7 +66,6 @@ public Parameter(string name, object value, string contentType, ParameterType ty
     /// </summary>
     /// <returns>String</returns>
     public override string ToString() => $"{Name}={Value}";
-
 }
 
 public record XmlParameter : Parameter {

src/RestSharp/Parameters/ParametersCollection.cs

@@ -0,0 +1,72 @@
+//  Copyright © 2009-2020 John Sheehan, Andrew Young, Alexey Zimarev and RestSharp community
+// 
+// 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
+// 
+// http://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.
+// 
+
+using System.Collections;
+using System.Collections.Concurrent;
+using RestSharp.Authenticators.OAuth.Extensions;
+
+namespace RestSharp;
+
+public class ParametersCollection : IReadOnlyCollection<Parameter> {
+    readonly List<Parameter> _parameters = new();
+
+    public ParametersCollection() { }
+
+    public ParametersCollection(IEnumerable<Parameter> parameters) => _parameters.AddRange(parameters);
+
+    public ParametersCollection AddParameters(IEnumerable<Parameter> parameters) {
+        _parameters.AddRange(parameters);
+        return this;
+    }
+
+    public ParametersCollection AddParameters(ParametersCollection parameters) {
+        _parameters.AddRange(parameters);
+        return this;
+    }
+
+    public void AddParameter(Parameter parameter) => _parameters.Add(parameter);
+
+    public void RemoveParameter(string name) => _parameters.RemoveAll(x => x.Name == name);
+
+    public void RemoveParameter(Parameter parameter) => _parameters.Remove(parameter);
+
+    public bool Exists(Parameter parameter)
+        => _parameters.Any(
+            p => p.Name != null && p.Name.Equals(parameter.Name, StringComparison.InvariantCultureIgnoreCase) && p.Type == parameter.Type
+        );
+
+    public Parameter? TryFind(string parameterName) => _parameters.FirstOrDefault(x => x.Name != null && x.Name.EqualsIgnoreCase(parameterName));
+
+    internal ParametersCollection GetParameters(ParameterType parameterType) => new(_parameters.Where(x => x.Type == parameterType));
+
+    internal ParametersCollection GetQueryParameters(Method method)
+        => new(
+            method is not Method.Post and not Method.Put and not Method.Patch
+                ? _parameters
+                    .Where(
+                        p => p.Type is ParameterType.GetOrPost or ParameterType.QueryString
+                    )
+                : _parameters
+                    .Where(
+                        p => p.Type is ParameterType.QueryString
+                    )
+        );
+
+    public IEnumerator<Parameter> GetEnumerator() => _parameters.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public int Count => _parameters.Count;
+}