Refactored Requester

RiotSharp.Test/StatusRiotApiTest.cs

@@ -8,15 +8,15 @@ namespace RiotSharp.Test
     [TestClass]
     public class StatusRiotApiTest : CommonTestBase
     {
-        private static StatusRiotApi api = StatusRiotApi.GetInstance(CommonTestBase.apiKey);
+        private static StatusRiotApi api = StatusRiotApi.GetInstance(apiKey);
 
         [TestMethod]
         [TestCategory("StatusRiotApi")]
         public void GetShardStatus_Test()
         {
             EnsureCredibility(() =>
             {
-                var shardStatus = api.GetShardStatus(StatusRiotApiTestBase.summoner1and2Region);
+                var shardStatus = api.GetShardStatus(summoner1and2Region);
 
                 Assert.AreEqual(StatusRiotApiTestBase.platform.ToString().ToLower(),
                     shardStatus.RegionTag);
@@ -29,7 +29,7 @@ public void GetShardStatusAsync_Test()
         {
             EnsureCredibility(() =>
             {
-                var shardStatus = api.GetShardStatusAsync(StatusRiotApiTestBase.summoner1and2Region);
+                var shardStatus = api.GetShardStatusAsync(summoner1and2Region);
 
                 Assert.AreEqual(StatusRiotApiTestBase.platform.ToString().ToLower(),
                     shardStatus.Result.RegionTag);

RiotSharp/Http/FailedRequestHandler.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using RiotSharp.Http.Interfaces;
+
+namespace RiotSharp.Http
+{
+    public class FailedRequestHandler : IFailedRequestHandler
+    {
+        public void Handle(HttpResponseMessage message)
+        {
+            if (message.IsSuccessStatusCode)
+            {
+                return;
+            }
+            switch (message.StatusCode)
+            {
+                case HttpStatusCode.ServiceUnavailable:
+                    throw new RiotSharpException("503, Service unavailable", message.StatusCode);
+                case HttpStatusCode.InternalServerError:
+                    throw new RiotSharpException("500, Internal server error", message.StatusCode);
+                case HttpStatusCode.Unauthorized:
+                    throw new RiotSharpException("401, Unauthorized", message.StatusCode);
+                case HttpStatusCode.BadRequest:
+                    throw new RiotSharpException("400, Bad request", message.StatusCode);
+                case HttpStatusCode.NotFound:
+                    throw new RiotSharpException("404, Resource not found", message.StatusCode);
+                case HttpStatusCode.Forbidden:
+                    throw new RiotSharpException("403, Forbidden", message.StatusCode);
+                case (HttpStatusCode)429:
+                    throw new RiotSharpException("429, Rate Limit Exceeded", message.StatusCode);
+                default:
+                    throw new RiotSharpException("Unexpeced failure", message.StatusCode);
+            }
+        }
+    }
+}

RiotSharp/Http/Interfaces/IFailedRequestHandler.cs

@@ -0,0 +1,9 @@
+using System.Net.Http;
+
+namespace RiotSharp.Http.Interfaces
+{
+    public interface IFailedRequestHandler
+    {
+        void Handle(HttpResponseMessage message);
+    }
+}

RiotSharp/Http/Interfaces/IRequestClient.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RiotSharp.Http.Interfaces
+{
+    public interface IRequestClient
+    {
+        /// <summary> 
+        /// Send a get request synchronously. 
+        /// </summary> 
+        /// <param name="request"></param> 
+        /// <returns></returns> 
+        /// <exception cref="RiotSharpException">Thrown if an Http error occurs. Contains the Http error code and error message.</exception> 
+        HttpResponseMessage Get(HttpRequestMessage request);
+
+        /// <summary> 
+        /// Send a get request asynchronously. 
+        /// </summary> 
+        /// <param name="request"></param> 
+        /// <returns></returns> 
+        /// <exception cref="RiotSharpException">Thrown if an Http error occurs. Contains the Http error code and error message.</exception> 
+        Task<HttpResponseMessage> GetAsync(HttpRequestMessage request);
+
+        /// <summary> 
+        /// Send a put request synchronously. 
+        /// </summary> 
+        /// <param name="request"></param> 
+        /// <returns></returns> 
+        /// <exception cref="RiotSharpException">Thrown if an Http error occurs. Contains the Http error code and error message.</exception> 
+        HttpResponseMessage Put(HttpRequestMessage request);
+
+        /// <summary> 
+        /// Send a put request asynchronously. 
+        /// </summary> 
+        /// <param name="request"></param> 
+        /// <returns></returns> 
+        /// <exception cref="RiotSharpException">Thrown if an Http error occurs. Contains the Http error code and error message.</exception> 
+        Task<HttpResponseMessage> PutAsync(HttpRequestMessage request);
+
+        /// <summary> 
+        /// Send a post request synchronously. 
+        /// </summary> 
+        /// <param name="request"></param> 
+        /// <returns></returns> 
+        /// <exception cref="RiotSharpException">Thrown if an Http error occurs. Contains the Http error code and error message.</exception> 
+        HttpResponseMessage Post(HttpRequestMessage request);
+
+        /// <summary> 
+        /// Send a post request asynchronously. 
+        /// </summary> 
+        /// <param name="request"></param> 
+        /// <returns></returns> 
+        /// <exception cref="RiotSharpException">Thrown if an Http error occurs. Contains the Http error code and error message.</exception> 
+        Task<HttpResponseMessage> PostAsync(HttpRequestMessage request);
+    }
+}

RiotSharp/Http/Interfaces/IRequestCreator.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using RiotSharp.Misc;
+
+namespace RiotSharp.Http.Interfaces
+{
+    public interface IRequestCreator
+    {
+        HttpRequestMessage CreateGetRequest(Region region, string apiEndpoint, List<string> addedArguments, bool useHttps = true);
+    }
+}

RiotSharp/Http/Interfaces/IRequesterAlt.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using RiotSharp.Misc;
+
+namespace RiotSharp.Http.Interfaces
+{
+    public interface IRequesterAlt
+    {
+        /// <summary>
+        /// Creates and sends a get request. Deserializes the response.
+        /// </summary>
+        /// <param name="relativeUrl"></param>
+        /// <param name="region"></param>
+        /// <param name="addedArguments"></param>
+        /// <param name="useHttps"></param>
+        /// <returns>The response deserialized to the requested type</returns>
+        /// <exception cref="RiotSharpException">
+        /// Thrown if an Http error occurs. 
+        /// Contains the Http error code and error message.
+        /// </exception>
+        T Get<T>(string relativeUrl, Region region, List<string> addedArguments = null, bool useHttps = true);
+
+        /// <summary>
+        /// Creates and asynchronously sends a get request. Deserializes the response.
+        /// </summary>
+        /// <param name="relativeUrl"></param>
+        /// <param name="region"></param>
+        /// <param name="addedArguments"></param>
+        /// <param name="useHttps"></param>
+        /// <returns>The response deserialized to the requested type</returns>
+        /// <exception cref="RiotSharpException">
+        /// Thrown if an Http error occurs. 
+        /// Contains the Http error code and error message.
+        /// </exception>
+        Task<T> GetAsync<T>(string relativeUrl, Region region, List<string> addedArguments = null, bool useHttps = true);
+
+    }
+}

RiotSharp/Http/Interfaces/IResponseDeserializer.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RiotSharp.Http.Interfaces
+{
+    public interface IResponseDeserializer
+    {
+        T DeserializeTo<T>(HttpResponseMessage message);
+
+        Task<T> DeserializeToAsync<T>(HttpResponseMessage message);
+    }
+}

RiotSharp/Http/Maps/RegionPlatformMap.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Text;
+using RiotSharp.Misc;
+
+namespace RiotSharp.Http.Maps
+{
+    public static class RegionPlatformMap
+    {
+
+        private static readonly IDictionary<Region, string> Map = new Dictionary<Region, string>
+        {
+            { Region.br, "br1" },
+            { Region.eune , "eun1" },
+            { Region.euw , "euw1" },
+            { Region.jp , "jp1" },
+            { Region.kr , "kr" },
+            { Region.lan , "la1" },
+            { Region.las , "la2" },
+            { Region.na , "na1" },
+            { Region.oce , "oc1" },
+            { Region.tr , "tr1" },
+            { Region.ru , "ru" },
+            { Region.global , "global" }
+        };
+
+        public static string GetPlatform(Region region)
+            => Map.ContainsKey(region) ? Map[region] : throw new NotImplementedException("Unsupported region");
+
+        public static string GetPlatformDomain(Region region)
+            => $"{GetPlatform(region)}.api.riotgames.com";
+
+    }
+}

RiotSharp/Http/RequestClient.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using RiotSharp.Http.Interfaces;
+
+namespace RiotSharp.Http
+{
+    public class RequestClient : IRequestClient
+    {
+        private readonly HttpClient client;
+        private readonly IFailedRequestHandler failureHandler;
+
+        public RequestClient(HttpClient client, IFailedRequestHandler failureHandler)
+        {
+            this.client = client;
+            this.failureHandler = failureHandler;
+        }
+
+        public HttpResponseMessage Get(HttpRequestMessage request)
+            => GetAsync(request).Result;
+
+        public async Task<HttpResponseMessage> GetAsync(HttpRequestMessage request)
+        {
+            var response = await client.GetAsync(request.RequestUri);
+            failureHandler.Handle(response);
+            return response;
+        }
+
+        public HttpResponseMessage Put(HttpRequestMessage request)
+            => PutAsync(request).Result;
+
+        public async Task<HttpResponseMessage> PutAsync(HttpRequestMessage request)
+        {
+            var response = await client.PutAsync(request.RequestUri, request.Content);
+            failureHandler.Handle(response);
+            return response;
+        }
+
+        public HttpResponseMessage Post(HttpRequestMessage request)
+            => PostAsync(request).Result;
+
+        public async Task<HttpResponseMessage> PostAsync(HttpRequestMessage request)
+        {
+            var response = await client.PostAsync(request.RequestUri, request.Content);
+            failureHandler.Handle(response);
+            return response;
+        }
+
+    }
+}

RiotSharp/Http/RequestCreator.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using RiotSharp.Http.Interfaces;
+using RiotSharp.Http.Maps;
+using RiotSharp.Misc;
+
+namespace RiotSharp.Http
+{
+    public class RequestCreator : IRequestCreator
+    {
+        private readonly string apiKey;
+
+        public RequestCreator(string apiKey)
+        {
+            this.apiKey = apiKey;
+        }
+
+        public HttpRequestMessage CreateGetRequest(Region region, string apiEndpoint, List<string> addedArguments, bool useHttps = true)
+        {
+            var url = BuildUrl(region, apiEndpoint, addedArguments, useHttps);
+            return new HttpRequestMessage(HttpMethod.Get, url);
+        }
+
+        private string BuildUrl(Region region, string apiEndpoint, List<string> addedArguments, bool useHttps)
+        {
+            var scheme = useHttps ? "https" : "http";
+            var domain = RegionPlatformMap.GetPlatformDomain(region);
+            var arguments = BuildArgumentString(addedArguments);
+
+            return $"{scheme}://{domain}{apiEndpoint}?{arguments}";
+        }
+
+        private string BuildArgumentString(IEnumerable<string> arguments)
+            => string.Join("&", arguments.Concat(GetApiKeyParameter()).Where(IsNotEmpty));
+
+        private IEnumerable<string> GetApiKeyParameter()
+            => new[] { $"api_key={apiKey}" };
+
+        private static bool IsNotEmpty(string argument)
+            => argument != string.Empty;
+    }
+}

RiotSharp/Http/RequesterAlt.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using RiotSharp.Http.Interfaces;
+using RiotSharp.Misc;
+
+namespace RiotSharp.Http
+{
+    /// <summary>
+    /// An alternative requester without a rate limiter.
+    /// </summary>
+    public class RequesterAlt : IRequesterAlt
+    {
+        private readonly IRequestClient client;
+        private readonly IRequestCreator requestCreator;
+        private readonly IResponseDeserializer responseDeserializer;
+
+        private static List<string> NoArguments() => new List<string>();
+
+        public RequesterAlt(IRequestClient client, IRequestCreator requestCreator, IResponseDeserializer responseDeserializer)
+        {
+            this.client = client;
+            this.requestCreator = requestCreator;
+            this.responseDeserializer = responseDeserializer;
+        }
+
+        public T Get<T>(
+            string relativeUrl,
+            Region region,
+            List<string> addedArguments = null,
+            bool useHttps = true)
+        {
+            var arguments = addedArguments ?? NoArguments();
+            var request = requestCreator.CreateGetRequest(region, relativeUrl, arguments, useHttps);
+            var response = client.Get(request);
+            return responseDeserializer.DeserializeTo<T>(response);
+        }
+
+        public async Task<T> GetAsync<T>(
+            string relativeUrl,
+            Region region,
+            List<string> addedArguments = null,
+            bool useHttps = true)
+        {
+            var arguments = addedArguments ?? NoArguments();
+            var request = requestCreator.CreateGetRequest(region, relativeUrl, arguments, useHttps);
+            var response = await client.GetAsync(request);
+            return await responseDeserializer.DeserializeToAsync<T>(response);
+        }
+
+    }
+}