Merge pull request #587 from octokit/default-timeout-api

Set the DefaultTimeout with the Connection

Octokit.Tests/Clients/ReleasesClientTests.cs

@@ -202,6 +202,23 @@ public async Task EnsuresArgumentsNotNull()
                 await AssertEx.Throws<ArgumentNullException>(async () => await releasesClient.UploadAsset(null, uploadData));
                 await AssertEx.Throws<ArgumentNullException>(async () => await releasesClient.UploadAsset(release, null));
             }
+
+            [Fact]
+            public async Task OverrideDefaultTimeout()
+            {
+                var newTimeout = TimeSpan.FromSeconds(100);
+
+                var apiConnection = Substitute.For<IApiConnection>();
+
+                var fixture = new ReleasesClient(apiConnection);
+
+                var release = new Release { UploadUrl = "https://uploads.github.com/anything" };
+                var uploadData = new ReleaseAssetUpload { FileName = "good", ContentType = "good/good", RawData = Stream.Null, Timeout = newTimeout };
+
+                await fixture.UploadAsset(release, uploadData);
+
+                apiConnection.Received().Post<ReleaseAsset>(Arg.Any<Uri>(), uploadData.RawData, Arg.Any<String>(), uploadData.ContentType, newTimeout);
+            }
         }
 
         public class TheGetAssetMethod

Octokit/Clients/ReleasesClient.cs

@@ -159,6 +159,17 @@ public Task<ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
             Ensure.ArgumentNotNull(data, "data");
 
             var endpoint = release.UploadUrl.ExpandUriTemplate(new { name = data.FileName });
+
+            if (data.Timeout.HasValue)
+            {
+                return ApiConnection.Post<ReleaseAsset>(
+                    endpoint,
+                    data.RawData,
+                    "application/vnd.github.v3",
+                    data.ContentType,
+                    data.Timeout.GetValueOrDefault());
+            }
+
             return ApiConnection.Post<ReleaseAsset>(
                 endpoint,
                 data.RawData,

Octokit/Helpers/Ensure.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Octokit
 {
@@ -31,6 +32,21 @@ public static void ArgumentNotNullOrEmptyString([ValidatedNotNull]string value,
 
             throw new ArgumentException("String cannot be empty", name);
         }
+
+        /// <summary>
+        /// Checks a timespan argument to ensure it is a positive value.
+        /// </summary>
+        /// <param name = "value">The argument value to check</param>
+        /// <param name = "name">The name of the argument</param>
+        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        public static void GreaterThanZero([ValidatedNotNull]TimeSpan value, string name)
+        {
+            ArgumentNotNull(value, name);
+
+            if (value.TotalMilliseconds > 0) return;
+
+            throw new ArgumentException("Timespan must be greater than zero", name);
+        }
     }
 
     [AttributeUsage(AttributeTargets.Parameter)]

Octokit/Http/ApiConnection.cs

@@ -186,6 +186,20 @@ public async Task<T> Post<T>(Uri uri, object data, string accepts, string conten
             return response.BodyAsObject;
         }
 
+        public async Task<T> Post<T>(Uri uri, object data, string accepts, string contentType, TimeSpan timeout)
+        {
+            Ensure.ArgumentNotNull(uri, "uri");
+            Ensure.ArgumentNotNull(data, "data");
+
+            var response = await Connection.Post<T>(
+                uri,
+                data,
+                accepts,
+                contentType,
+                timeout).ConfigureAwait(false);
+            return response.BodyAsObject;
+        }
+
         /// <summary>
         /// Creates or replaces the API resource at the specified URI
         /// </summary>

Octokit/Http/Connection.cs

@@ -193,6 +193,14 @@ public Task<IResponse<T>> Post<T>(Uri uri, object body, string accepts, string c
             return SendData<T>(uri, HttpMethod.Post, body, accepts, contentType, CancellationToken.None);
         }
 
+        public Task<IResponse<T>> Post<T>(Uri uri, object body, string accepts, string contentType, TimeSpan timeout)
+        {
+            Ensure.ArgumentNotNull(uri, "uri");
+            Ensure.ArgumentNotNull(body, "body");
+
+            return SendData<T>(uri, HttpMethod.Post, body, accepts, contentType, timeout, CancellationToken.None);
+        }
+
         public Task<IResponse<T>> Post<T>(Uri uri, object body, string accepts, string contentType, Uri baseAddress)
         {
             Ensure.ArgumentNotNull(uri, "uri");
@@ -223,20 +231,49 @@ Task<IResponse<T>> SendData<T>(
             object body,
             string accepts,
             string contentType,
+            TimeSpan timeout,
             CancellationToken cancellationToken,
             string twoFactorAuthenticationCode = null,
-            Uri baseAddress = null
-            )
+            Uri baseAddress = null)
         {
             Ensure.ArgumentNotNull(uri, "uri");
+            Ensure.GreaterThanZero(timeout, "timeout");
 
             var request = new Request
             {
                 Method = method,
                 BaseAddress = baseAddress ?? BaseAddress,
                 Endpoint = uri,
+                Timeout = timeout
             };
 
+            return SendDataInternal<T>(body, accepts, contentType, cancellationToken, twoFactorAuthenticationCode, request);
+        }
+
+        Task<IResponse<T>> SendData<T>(
+            Uri uri,
+            HttpMethod method,
+            object body,
+            string accepts,
+            string contentType,
+            CancellationToken cancellationToken,
+            string twoFactorAuthenticationCode = null,
+            Uri baseAddress = null)
+        {
+            Ensure.ArgumentNotNull(uri, "uri");
+
+            var request = new Request
+            {
+                Method = method,
+                BaseAddress = baseAddress ?? BaseAddress,
+                Endpoint = uri,
+            };
+
+            return SendDataInternal<T>(body, accepts, contentType, cancellationToken, twoFactorAuthenticationCode, request);
+        }
+
+        Task<IResponse<T>> SendDataInternal<T>(object body, string accepts, string contentType, CancellationToken cancellationToken, string twoFactorAuthenticationCode, Request request)
+        {
             if (!String.IsNullOrEmpty(accepts))
             {
                 request.Headers["Accept"] = accepts;
@@ -254,7 +291,7 @@ Task<IResponse<T>> SendData<T>(
                 request.ContentType = contentType ?? "application/x-www-form-urlencoded";
             }
 
-            return Run<T>(request,cancellationToken);
+            return Run<T>(request, cancellationToken);
         }
 
         /// <summary>

Octokit/Http/IApiConnection.cs

@@ -114,6 +114,19 @@ public interface IApiConnection
         /// <exception cref="ApiException">Thrown when an API error occurs.</exception>
         Task<T> Post<T>(Uri uri, object data, string accepts, string contentType);
 
+        /// <summary>
+        /// Creates a new API resource in the list at the specified URI.
+        /// </summary>
+        /// <typeparam name="T">The API resource's type.</typeparam>
+        /// <param name="uri">URI of the API resource to get</param>
+        /// <param name="data">Object that describes the new API resource; this will be serialized and used as the request's body</param>
+        /// <param name="accepts">Accept header to use for the API request</param>
+        /// <param name="contentType">Content type of the API request</param>
+        /// <param name="timeout">Timeout for the request</param>
+        /// <returns>The created API resource.</returns>
+        /// <exception cref="ApiException">Thrown when an API error occurs.</exception>
+        Task<T> Post<T>(Uri uri, object data, string accepts, string contentType, TimeSpan timeout);
+
         /// <summary>
         /// Creates or replaces the API resource at the specified URI
         /// </summary>

Octokit/Http/IConnection.cs

@@ -85,6 +85,20 @@ public interface IConnection
         /// <returns><seealso cref="IResponse"/> representing the received HTTP response</returns>
         Task<IResponse<T>> Post<T>(Uri uri, object body, string accepts, string contentType);
 
+        /// <summary>
+        /// Performs an asynchronous HTTP POST request.
+        /// Attempts to map the response body to an object of type <typeparamref name="T"/>
+        /// </summary>
+        /// <typeparam name="T">The type to map the response to</typeparam>
+        /// <param name="uri">URI endpoint to send request to</param>
+        /// <param name="body">The object to serialize as the body of the request</param>
+        /// <param name="accepts">Specifies accepted response media types.</param>
+        /// <param name="contentType">Specifies the media type of the request body</param>
+        /// <param name="timeout"></param>
+        /// <returns><seealso cref="IResponse"/> representing the received HTTP response</returns>
+        Task<IResponse<T>> Post<T>(Uri uri, object body, string accepts, string contentType, TimeSpan timeout);
+
+
         /// <summary>
         /// Performs an asynchronous HTTP POST request.
         /// Attempts to map the response body to an object of type <typeparamref name="T"/>

Octokit/Models/Response/ReleaseAssetUpload.cs

@@ -11,6 +11,7 @@ public class ReleaseAssetUpload
         public string FileName { get; set; }
         public string ContentType { get; set; }
         public Stream RawData { get; set; }
+        public TimeSpan? Timeout { get; set; }
 
         internal string DebuggerDisplay
         {