feat(multiple-auth): added support combining auths as AND/OR groups

.editorconfig

@@ -52,10 +52,17 @@ dotnet_naming_style.pascal_case_style.capitalization             = pascal_case
 # Use PascalCase for constant fields  
 dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion
 dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols  = constant_fields
-dotnet_naming_rule.constant_fields_should_be_pascal_case.style    = pascal_case_style
+dotnet_naming_rule.constant_fields_should_be_pascal_case.style = pascal_case_style
 dotnet_naming_symbols.constant_fields.applicable_kinds            = field
 dotnet_naming_symbols.constant_fields.applicable_accessibilities  = *
 dotnet_naming_symbols.constant_fields.required_modifiers          = const
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4
+end_of_line = crlf
+dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
+dotnet_style_prefer_compound_assignment = true:suggestion
+dotnet_style_prefer_simplified_interpolation = true:suggestion
+dotnet_style_namespace_match_folder = true:suggestion
 ###############################
 # C# Coding Conventions       #
 ###############################
@@ -156,6 +163,12 @@ dotnet_diagnostic.S112.severity = none
 dotnet_diagnostic.S1699.severity = none
 # S1168: Empty arrays and collections should be returned instead of null
 dotnet_diagnostic.S1168.severity = none
+# S4830: Server certificates should be verified during SSL/TLS connection
+dotnet_diagnostic.S4830.severity = none
+# S3928: Parameter names used into ArgumentException constructors should match an existing one 
+dotnet_diagnostic.S3928.severity = none
+# S3358: Ternary operators should not be nested
+dotnet_diagnostic.S3358.severity = none
 
 # CA1707: Identifiers should not contain underscores
 dotnet_diagnostic.CA1707.severity = none
@@ -167,8 +180,6 @@ dotnet_diagnostic.CA1507.severity = none
 dotnet_diagnostic.CA1305.severity = none
 # CA1309: Use ordinal string comparison
 dotnet_diagnostic.CA1309.severity = none
-# S3358: Ternary operators should not be nested
-dotnet_diagnostic.S3358.severity = none
 # CS0659: Type overrides Object.Equals(object o) but does not override Object.GetHashCode()
 dotnet_diagnostic.CS0659.severity = none
 # CA2201: Do not raise reserved exception types
@@ -179,8 +190,11 @@ dotnet_diagnostic.CA1310.severity = none
 # JSON002: Probable JSON string detected
 dotnet_diagnostic.JSON002.severity = none
 
-# S4830: Server certificates should be verified during SSL/TLS connection
-dotnet_diagnostic.S4830.severity = none
+csharp_using_directive_placement = outside_namespace:silent
+csharp_prefer_simple_using_statement = true:suggestion
+csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_expression_bodied_lambdas = true:silent
+csharp_style_expression_bodied_local_functions = false:silent
 
 [*.vb]
 ###############################

APIMatic.Core.Test/Api/HttpGet/ApiCallGetTest.cs

@@ -167,7 +167,7 @@ public void ApiCall_GetWithBasicAuthe_OKResponse()
             var apiCall = CreateApiCall<ServerResponse>()
               .RequestBuilder(requestBuilderAction => requestBuilderAction
                   .Setup(HttpMethod.Get, url)
-              .WithAuth("global"))
+              .WithAuth("basic"))
               .ExecuteAsync();
 
             // Act

APIMatic.Core.Test/AuthenticationTest.cs

@@ -0,0 +1,167 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using APIMatic.Core.Authentication;
+using APIMatic.Core.Test.MockTypes.Authentication;
+using NUnit.Framework;
+
+namespace APIMatic.Core.Test
+{
+    [TestFixture]
+    public class AuthenticationTest : TestBase
+    {
+        [Test]
+        public void Multiple_Authentication_Success()
+        {
+            var basicAuthManager = new BasicAuthManager("username", "password");
+            var globalConfiguration = new GlobalConfiguration.Builder()
+                .ServerUrls(new Dictionary<Enum, string>
+                {
+                    {MockServer.Server1, "http://my/path:3000/{one}"},
+                }, MockServer.Server1)
+                .AuthManagers(new Dictionary<string, AuthManager>()
+                {
+                    {"basic", basicAuthManager},
+                    {"header", new HeaderAuthManager("my api key", "test token")},
+                    {"query", new QueryAuthManager("my api key", "test token")}
+                })
+                .HttpConfiguration(_clientConfiguration)
+                .Build();
+
+            var request = globalConfiguration.GlobalRequestBuilder()
+                .Setup(HttpMethod.Get, "/auth")
+                .WithOrAuth(auth => auth
+                    .Add("basic")
+                    .AddAndGroup(innerGroup => innerGroup
+                        .Add("header")
+                        .Add("query")))
+                .Build();
+
+            Assert.AreEqual(basicAuthManager.GetBasicAuthHeader(), request.Headers["Authorization"]);
+            Assert.AreEqual("my api key", request.Headers["API-KEY"]);
+            Assert.AreEqual("test token", request.Headers["TOKEN"]);
+            Assert.AreEqual("my api key", request.QueryParameters["API-KEY"]);
+            Assert.AreEqual("test token", request.QueryParameters["TOKEN"]);
+        }
+
+        [Test]
+        public void Multiple_Authentication_OR_Validation_Failure()
+        {
+            var globalConfiguration = new GlobalConfiguration.Builder()
+                .ServerUrls(new Dictionary<Enum, string>
+                {
+                    {MockServer.Server1, "http://my/path:3000/{one}"},
+                }, MockServer.Server1)
+                .AuthManagers(new Dictionary<string, AuthManager>()
+                {
+                    {"basic", new BasicAuthManager("username", null)},
+                    {"header", new HeaderAuthManager("my api key", null)},
+                    {"query", new QueryAuthManager("my api key", "test token")}
+                })
+                .HttpConfiguration(_clientConfiguration)
+                .Build();
+
+            var exp = Assert.Throws<ArgumentNullException>(() => globalConfiguration.GlobalRequestBuilder()
+                .Setup(HttpMethod.Get, "/auth")
+                .WithOrAuth(auth => auth
+                    .Add("basic")
+                    .AddAndGroup(innerGroup => innerGroup
+                        .Add("header")
+                        .Add("query")))
+                .Build());
+
+            Assert.AreEqual("Following authentication credentials are required:\n" +
+                "-> Missing required header field: Authorization\n" +
+                "-> Missing required header field: TOKEN", exp.Message);
+        }
+
+        [Test]
+        public void Multiple_Authentication_AND_Validation_Failure()
+        {
+            var globalConfiguration = new GlobalConfiguration.Builder()
+                .ServerUrls(new Dictionary<Enum, string>
+                {
+                    {MockServer.Server1, "http://my/path:3000/{one}"},
+                }, MockServer.Server1)
+                .AuthManagers(new Dictionary<string, AuthManager>()
+                {
+                    {"basic", new BasicAuthManager("username", null)},
+                    {"header", new HeaderAuthManager("my api key", null)},
+                    {"query", new QueryAuthManager("my api key", "test token")}
+                })
+                .HttpConfiguration(_clientConfiguration)
+                .Build();
+
+            var exp = Assert.Throws<ArgumentNullException>(() => globalConfiguration.GlobalRequestBuilder()
+                .Setup(HttpMethod.Get, "/auth")
+                .WithAndAuth(auth => auth
+                    .Add("query")
+                    .Add("header"))
+                .Build());
+
+            Assert.AreEqual("Following authentication credentials are required:\n" +
+                "-> Missing required header field: TOKEN", exp.Message);
+        }
+
+        [Test]
+        public void Multiple_Authentication_AND_All_Missing_Validation_Failure()
+        {
+            var globalConfiguration = new GlobalConfiguration.Builder()
+                .ServerUrls(new Dictionary<Enum, string>
+                {
+                    {MockServer.Server1, "http://my/path:3000/{one}"},
+                }, MockServer.Server1)
+                .AuthManagers(new Dictionary<string, AuthManager>()
+                {
+                    {"header", new HeaderAuthManager(null, null)},
+                    {"query", new QueryAuthManager(null, null)}
+                })
+                .HttpConfiguration(_clientConfiguration)
+                .Build();
+
+            var exp = Assert.Throws<ArgumentNullException>(() => globalConfiguration.GlobalRequestBuilder()
+                .Setup(HttpMethod.Get, "/auth")
+                .WithAndAuth(auth => auth
+                    .Add("query")
+                    .Add("header"))
+                .Build());
+
+            Assert.AreEqual("Following authentication credentials are required:\n" +
+                "-> Missing required query field: API-KEY\n" +
+                "-> Missing required query field: TOKEN\n" +
+                "-> Missing required header field: API-KEY\n" +
+                "-> Missing required header field: TOKEN", exp.Message);
+        }
+
+        [Test]
+        public void Multiple_Authentication_AND_with_nested_OR_Validation_Failure()
+        {
+            var globalConfiguration = new GlobalConfiguration.Builder()
+                .ServerUrls(new Dictionary<Enum, string>
+                {
+                    {MockServer.Server1, "http://my/path:3000/{one}"},
+                }, MockServer.Server1)
+                .AuthManagers(new Dictionary<string, AuthManager>()
+                {
+                    {"basic", new BasicAuthManager("username", null)},
+                    {"header", new HeaderAuthManager("my api key", null)},
+                    {"query", new QueryAuthManager("my api key", "test token")}
+                })
+                .HttpConfiguration(_clientConfiguration)
+                .Build();
+
+            var exp = Assert.Throws<ArgumentNullException>(() => globalConfiguration.GlobalRequestBuilder()
+                .Setup(HttpMethod.Get, "/auth")
+                .WithAndAuth(auth => auth
+                    .Add("query")
+                    .AddOrGroup(innerGroup => innerGroup
+                        .Add("basic")
+                        .Add("header")))
+                .Build());
+
+            Assert.AreEqual("Following authentication credentials are required:\n" +
+                "-> Missing required header field: Authorization\n" +
+                "-> Missing required header field: TOKEN", exp.Message);
+        }
+    }
+}

APIMatic.Core.Test/MockTypes/Authentication/BasicAuthManager.cs

@@ -10,7 +10,7 @@ namespace APIMatic.Core.Test.MockTypes.Authentication
     /// <summary>
     /// BasicAuthManager Class.
     /// </summary>
-    internal class BasicAuthManager : AuthManager, IBasicAuthCredentials
+    public class BasicAuthManager : AuthManager
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="IrisBasicAuthManager"/> class.
@@ -22,7 +22,7 @@ public BasicAuthManager(string username, string password)
             BasicAuthUserName = username;
             BasicAuthPassword = password;
             Parameters(paramBuilder => paramBuilder
-                .Header(header => header.Setup("Authorization", GetBasicAuthHeader())));
+                .Header(header => header.Setup("Authorization", GetBasicAuthHeader()).Required()));
         }
 
         /// <summary>
@@ -35,20 +35,12 @@ public BasicAuthManager(string username, string password)
         /// </summary>
         public string BasicAuthPassword { get; }
 
-        /// <summary>
-        /// Check if credentials match.
-        /// </summary>
-        /// <param name="basicAuthUserName"> The string value for credentials.</param>
-        /// <param name="basicAuthPassword"> The string value for credentials.</param>
-        /// <returns> True if credentials matched.</returns>
-        public bool Equals(string basicAuthUserName, string basicAuthPassword)
-        {
-            return basicAuthUserName.Equals(BasicAuthUserName)
-                    && basicAuthPassword.Equals(BasicAuthPassword);
-        }
-
-        private string GetBasicAuthHeader()
+        public string GetBasicAuthHeader()
         {
+            if (BasicAuthUserName == null || BasicAuthPassword == null)
+            {
+                return null;
+            }
             var authCredentials = BasicAuthUserName + ":" + BasicAuthPassword;
             var data = Encoding.ASCII.GetBytes(authCredentials);
             return "Basic " + Convert.ToBase64String(data);

APIMatic.Core.Test/MockTypes/Authentication/HeaderAuthManager.cs

@@ -0,0 +1,20 @@
+// <copyright file="HeaderAuthManager.cs" company="APIMatic">
+// Copyright (c) APIMatic. All rights reserved.
+// </copyright>
+using APIMatic.Core.Authentication;
+
+namespace APIMatic.Core.Test.MockTypes.Authentication
+{
+    /// <summary>
+    /// QueryAuthManager Class.
+    /// </summary>
+    public class HeaderAuthManager : AuthManager
+    {
+        public HeaderAuthManager(string apiKey, string token)
+        {
+            Parameters(paramBuilder => paramBuilder
+                .Header(header => header.Setup("API-KEY", apiKey).Required())
+                .Header(header => header.Setup("TOKEN", token).Required()));
+        }
+    }
+}

APIMatic.Core.Test/MockTypes/Authentication/QueryAuthManager.cs

@@ -0,0 +1,20 @@
+// <copyright file="QueryAuthManager.cs" company="APIMatic">
+// Copyright (c) APIMatic. All rights reserved.
+// </copyright>
+using APIMatic.Core.Authentication;
+
+namespace APIMatic.Core.Test.MockTypes.Authentication
+{
+    /// <summary>
+    /// QueryAuthManager Class.
+    /// </summary>
+    public class QueryAuthManager : AuthManager
+    {
+        public QueryAuthManager(string apiKey, string token)
+        {
+            Parameters(paramBuilder => paramBuilder
+                .Query(query => query.Setup("API-KEY", apiKey).Required())
+                .Query(query => query.Setup("TOKEN", token).Required()));
+        }
+    }
+}

APIMatic.Core.Test/TestBase.cs

@@ -22,23 +22,21 @@ protected enum MockServer { Server1, Server2 }
             AutoFlush = true
         };
 
-        private static readonly ICoreHttpClientConfiguration _clientConfiguration = new CoreHttpClientConfiguration.Builder()
+        protected static readonly ICoreHttpClientConfiguration _clientConfiguration = new CoreHttpClientConfiguration.Builder()
             .HttpClientInstance(new HttpClient(handlerMock))
             .NumberOfRetries(numberOfRetries)
             .Build();
 
-        private static readonly BasicAuthManager _basicAuthManager = new(_basicAuthUserName, _basicAuthPassword);
-
         private static GlobalConfiguration globalConfiguration;
 
         protected static Lazy<GlobalConfiguration> LazyGlobalConfiguration => new(() => globalConfiguration ??= new GlobalConfiguration.Builder()
             .ServerUrls(new Dictionary<Enum, string>
             {
-                { MockServer.Server1, "http://my/path:3000/{one}"},
-                { MockServer.Server2, "https://my/path/{two}"}
+                {MockServer.Server1, "http://my/path:3000/{one}"},
+                {MockServer.Server2, "https://my/path/{two}"}
             }, MockServer.Server1)
             .AuthManagers(new Dictionary<string, AuthManager> {
-                        {"global", _basicAuthManager}
+                {"basic", new BasicAuthManager(_basicAuthUserName, _basicAuthPassword)}
             })
             .HttpConfiguration(_clientConfiguration)
             .Parameters(p => p