Introduce AbuseException

Octokit.Tests/Exceptions/AbuseExceptionTests.cs

@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using System.Net;
+using Octokit.Internal;
+using Xunit;
+
+namespace Octokit.Tests.Exceptions
+{
+    public class AbuseExceptionTests
+    {
+        [Fact]
+        public void PostsAbuseMessageFromApi()
+        {
+
+            const string responseBody = "{\"message\":\"You have triggered an abuse detection mechanism. Please wait a few minutes before you try again.\"," +
+                                        "\"documentation_url\":\"https://developer.github.com/v3/#abuse-rate-limits\"}";
+
+            var response = new Response(
+                HttpStatusCode.Forbidden,
+                responseBody,
+                new Dictionary<string, string>(),
+                "application/json");
+            var abuseException = new AbuseException(response);
+
+            Assert.Equal("You have triggered an abuse detection mechanism. Please wait a few minutes before you try again.", abuseException.ApiError.Message);
+        }
+
+        [Fact]
+        public void HasDefaultMessage()
+        {
+            var response = new Response(HttpStatusCode.Forbidden, null, new Dictionary<string, string>(), "application/json");
+            var abuseException = new AbuseException(response);
+
+            Assert.Equal("Request Forbidden - Abuse Detection", abuseException.Message);
+        }
+
+        public class RetryAfterHeaderHandling
+        {
+            [Fact]
+            public void WithRetryAfterHeader_PopulatesRetryAfterSeconds()
+            {
+                var headerDictionary = new Dictionary<string, string>
+                {
+                    { "Retry-After", "30" }
+                };
+
+                var response = new Response(HttpStatusCode.Forbidden, null, headerDictionary, "application/json");
+                var abuseException = new AbuseException(response);
+
+                Assert.Equal(30, abuseException.RetryAfterSeconds);
+            }
+
+            [Fact]
+            public void NoRetryAfterHeader_RetryAfterSecondsIsSetToTheDefaultOfNull()
+            {
+                var headerDictionary = new Dictionary<string, string>();
+
+                var response = new Response(HttpStatusCode.Forbidden, null, headerDictionary, "application/json");
+                var abuseException = new AbuseException(response);
+
+                Assert.False(abuseException.RetryAfterSeconds.HasValue);
+            }
+
+            [Theory]
+            [InlineData(null)]
+            [InlineData("")]
+            [InlineData("    ")]
+            public void EmptyHeaderValue_RetryAfterSecondsDefaultsToNull(string emptyValueToTry)
+            {
+                var headerDictionary = new Dictionary<string, string>
+                {
+                    { "Retry-After", emptyValueToTry }
+                };
+
+                var response = new Response(HttpStatusCode.Forbidden, null, headerDictionary, "application/json");
+                var abuseException = new AbuseException(response);
+
+                Assert.False(abuseException.RetryAfterSeconds.HasValue);
+            }
+
+            [Fact]
+            public void NonParseableIntHeaderValue_RetryAfterSecondsDefaultsToNull()
+            {
+                var headerDictionary = new Dictionary<string, string>
+                {
+                    { "Retry-After", "ABC" }
+                };
+
+                var response = new Response(HttpStatusCode.Forbidden, null, headerDictionary, "application/json");
+                var abuseException = new AbuseException(response);
+
+                Assert.False(abuseException.RetryAfterSeconds.HasValue);
+            }
+
+            [Fact]
+            public void NegativeHeaderValue_RetryAfterSecondsDefaultsToNull()
+            {
+                var headerDictionary = new Dictionary<string, string>
+                {
+                    { "Retry-After", "-123" }
+                };
+
+                var response = new Response(HttpStatusCode.Forbidden, null, headerDictionary, "application/json");
+                var abuseException = new AbuseException(response);
+
+                Assert.False(abuseException.RetryAfterSeconds.HasValue);
+            }
+
+            [Fact]
+            public void ZeroHeaderValue_RetryAfterSecondsIsZero()
+            {
+                var headerDictionary = new Dictionary<string, string>
+                {
+                    { "Retry-After", "0" }
+                };
+
+                var response = new Response(HttpStatusCode.Forbidden, null, headerDictionary, "application/json");
+                var abuseException = new AbuseException(response);
+
+                Assert.Equal(0, abuseException.RetryAfterSeconds);
+            }
+
+        }
+    }
+}

Octokit.Tests/Http/ConnectionTests.cs

@@ -271,6 +271,108 @@ public async Task ThrowsForbiddenExceptionForUnknownForbiddenResponse()
 
                 Assert.Equal("YOU SHALL NOT PASS!", exception.Message);
             }
+
+            [Fact]
+            public async Task ThrowsAbuseExceptionForResponseWithAbuseDocumentationLink()
+            {
+                var messageText = "blahblahblah this does not matter because we are testing the URL";
+
+                var httpClient = Substitute.For<IHttpClient>();
+                IResponse response = new Response(
+                    HttpStatusCode.Forbidden,
+                    "{\"message\":\"" + messageText + "\"," +
+                    "\"documentation_url\":\"https://developer.github.com/v3/#abuse-rate-limits\"}",
+                    new Dictionary<string, string>(),
+                    "application/json");
+                httpClient.Send(Args.Request, Args.CancellationToken).Returns(Task.FromResult(response));
+                var connection = new Connection(new ProductHeaderValue("OctokitTests"),
+                    _exampleUri,
+                    Substitute.For<ICredentialStore>(),
+                    httpClient,
+                    Substitute.For<IJsonSerializer>());
+
+                await Assert.ThrowsAsync<AbuseException>(
+                    () => connection.GetResponse<string>(new Uri("endpoint", UriKind.Relative)));
+            }
+
+            [Fact]
+            public async Task ThrowsAbuseExceptionForResponseWithAbuseDescription()
+            {
+                var messageText = "You have triggered an abuse detection mechanism. Please wait a few minutes before you try again.";
+
+                var httpClient = Substitute.For<IHttpClient>();
+                IResponse response = new Response(
+                    HttpStatusCode.Forbidden,
+                    "{\"message\":\"" + messageText + "\"," +
+                    "\"documentation_url\":\"https://ThisURLDoesNotMatter.com\"}",
+                    new Dictionary<string, string>(),
+                    "application/json");
+                httpClient.Send(Args.Request, Args.CancellationToken).Returns(Task.FromResult(response));
+                var connection = new Connection(new ProductHeaderValue("OctokitTests"),
+                    _exampleUri,
+                    Substitute.For<ICredentialStore>(),
+                    httpClient,
+                    Substitute.For<IJsonSerializer>());
+
+                await Assert.ThrowsAsync<AbuseException>(
+                    () => connection.GetResponse<string>(new Uri("endpoint", UriKind.Relative)));
+            }
+
+
+            [Fact]
+            public async Task AbuseExceptionContainsTheRetryAfterHeaderAmount()
+            {
+                var messageText = "You have triggered an abuse detection mechanism. Please wait a few minutes before you try again.";
+
+                var httpClient = Substitute.For<IHttpClient>();
+                var headerDictionary = new Dictionary<string, string>
+                {
+                    { "Retry-After", "45" }
+                };
+
+                IResponse response = new Response(
+                    HttpStatusCode.Forbidden,
+                    "{\"message\":\"" + messageText + "\"," +
+                    "\"documentation_url\":\"https://ThisURLDoesNotMatter.com\"}",
+                    headerDictionary,
+                    "application/json");
+                httpClient.Send(Args.Request, Args.CancellationToken).Returns(Task.FromResult(response));
+                var connection = new Connection(new ProductHeaderValue("OctokitTests"),
+                    _exampleUri,
+                    Substitute.For<ICredentialStore>(),
+                    httpClient,
+                    Substitute.For<IJsonSerializer>());
+
+                var exception = await Assert.ThrowsAsync<AbuseException>(
+                    () => connection.GetResponse<string>(new Uri("endpoint", UriKind.Relative)));
+
+                Assert.Equal(45, exception.RetryAfterSeconds);
+            }
+
+            [Fact(Skip = "Fails due to https://github.com/octokit/octokit.net/issues/1529. The message is empty but the default message isn't displayed. However, this isn't due to the introduction of AbuseException, but rather something else.")]
+            public async Task ThrowsAbuseExceptionWithDefaultMessageForUnsafeAbuseResponse()
+            {
+                string messageText = string.Empty;
+
+                var httpClient = Substitute.For<IHttpClient>();
+                IResponse response = new Response(
+                    HttpStatusCode.Forbidden,
+                     "{\"message\":\"" + messageText + "\"," +
+                    "\"documentation_url\":\"https://developer.github.com/v3/#abuse-rate-limits\"}",
+                   new Dictionary<string, string>(),
+                    "application/json");
+                httpClient.Send(Args.Request, Args.CancellationToken).Returns(Task.FromResult(response));
+                var connection = new Connection(new ProductHeaderValue("OctokitTests"),
+                    _exampleUri,
+                    Substitute.For<ICredentialStore>(),
+                    httpClient,
+                    Substitute.For<IJsonSerializer>());
+
+                var exception = await Assert.ThrowsAsync<AbuseException>(
+                    () => connection.GetResponse<string>(new Uri("endpoint", UriKind.Relative)));
+
+                Assert.Equal("Request Forbidden - Abuse Detection", exception.Message);
+            }
         }
 
         public class TheGetHtmlMethod

Octokit.Tests/Octokit.Tests.csproj

@@ -145,6 +145,7 @@
     <Compile Include="Clients\UserEmailsClientTests.cs" />
     <Compile Include="Clients\WatchedClientTests.cs" />
     <Compile Include="Clients\FollowersClientTests.cs" />
+    <Compile Include="Exceptions\AbuseExceptionTests.cs" />
     <Compile Include="Exceptions\ApiErrorTests.cs" />
     <Compile Include="Exceptions\ApiExceptionTests.cs" />
     <Compile Include="Exceptions\ApiValidationExceptionTests.cs" />

Octokit/Exceptions/AbuseException.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Net;
+using System.Runtime.Serialization;
+using System.Security;
+
+namespace Octokit
+{
+    /// <summary>
+    /// Represents a subset of the HTTP 403 - Forbidden response returned from the API when the forbidden response is related to an abuse detection mechanism.
+    /// Containts the amount of seconds after which it's safe to retry the request.
+    /// </summary>
+#if !NETFX_CORE
+    [Serializable]
+#endif
+    [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors",
+        Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
+    public class AbuseException : ForbiddenException
+    {
+        private readonly int? RetrySecondsDefault = null;
+        /// <summary>
+        /// Constructs an instance of AbuseException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        public AbuseException(IResponse response) : this(response, null)
+        {
+        }
+
+        /// <summary>
+        /// Constructs an instance of AbuseException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
+        public AbuseException(IResponse response, Exception innerException)
+            : base(response, innerException)
+        {
+            Debug.Assert(response != null && response.StatusCode == HttpStatusCode.Forbidden,
+                "AbuseException created with wrong status code");
+
+            SetRetryAfterSeconds(response);
+        }
+
+        private void SetRetryAfterSeconds(IResponse response)
+        {
+            string secondsValue;
+
+            // ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
+            if (response.Headers.TryGetValue("Retry-After", out secondsValue))
+            {
+                RetryAfterSeconds = ParseRetryAfterSeconds(secondsValue);
+            }
+
+            else
+            {
+                RetryAfterSeconds = RetrySecondsDefault;
+            }
+        }
+
+        private int? ParseRetryAfterSeconds(string retryAfterString)
+        {
+            if (string.IsNullOrWhiteSpace(retryAfterString))
+            {
+                return RetrySecondsDefault;
+            }
+
+            int retrySeconds;
+            if (int.TryParse(retryAfterString, out retrySeconds))
+            {
+                return retrySeconds < 0 ? RetrySecondsDefault : retrySeconds;
+            }
+
+            return RetrySecondsDefault;
+        }
+
+        public int? RetryAfterSeconds { get; private set; }
+
+        public override string Message
+        {
+            get { return ApiErrorMessageSafe ?? "Request Forbidden - Abuse Detection"; }
+        }
+
+#if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of AbuseException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
+        protected AbuseException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+
+        [SecurityCritical]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue("RetryAfterSeconds", RetryAfterSeconds);
+        }
+
+#endif
+    }
+}

Octokit/Http/Connection.cs

@@ -611,11 +611,23 @@ static Exception GetExceptionForUnauthorized(IResponse response)
         static Exception GetExceptionForForbidden(IResponse response)
         {
             string body = response.Body as string ?? "";
-            return body.Contains("rate limit exceeded")
-                ? new RateLimitExceededException(response)
-                : body.Contains("number of login attempts exceeded")
-                    ? new LoginAttemptsExceededException(response)
-                    : new ForbiddenException(response);
+
+            if (body.Contains("rate limit exceeded"))
+            {
+                return new RateLimitExceededException(response);
+            }
+
+            if (body.Contains("number of login attempts exceeded"))
+            {
+                return new LoginAttemptsExceededException(response);
+            }
+
+            if (body.Contains("abuse-rate-limits") || body.Contains("abuse detection mechanism"))
+            {
+                return new AbuseException(response);                
+            }
+
+            return new ForbiddenException(response);
         }
 
         internal static TwoFactorType ParseTwoFactorType(IResponse restResponse)

Octokit/Octokit-Mono.csproj

@@ -504,6 +504,7 @@
     <Compile Include="Clients\RepositoryTrafficClient.cs" />
     <Compile Include="Helpers\ExcludeFromPaginationConventionTest.cs" />
     <Compile Include="Models\Request\IssueCommentRequest.cs" />
+    <Compile Include="Exceptions\AbuseException.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
 </Project>

Octokit/Octokit-MonoAndroid.csproj

@@ -515,6 +515,7 @@
     <Compile Include="Clients\RepositoryTrafficClient.cs" />
     <Compile Include="Helpers\ExcludeFromPaginationConventionTest.cs" />
     <Compile Include="Models\Request\IssueCommentRequest.cs" />
+    <Compile Include="Exceptions\AbuseException.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Novell\Novell.MonoDroid.CSharp.targets" />
 </Project>