Issue 369: Change default behavior of an HTTP request

Src/GoogleApis.Tests/Apis/Requests/ClientServiceRequestTest.cs

 /*
 Copyright 2011 Google Inc
 
 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
@@ skipping 12 matching lines @@
 using System.Net.Http.Headers;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 using Ionic.Zlib;
 using NUnit.Framework;
 
 using Google.Apis.Discovery;
 using Google.Apis.Http;
-using Google.Apis.Logging;
 using Google.Apis.Requests;
 using Google.Apis.Services;
 using Google.Apis.Testing;
 using Google.Apis.Util;
 
 
 namespace Google.Apis.Tests.Apis.Requests
 {
 /// <summary> Tests for the <see cref="Google.Apis.Requests.ClientServiceReq
uest"/>. </summary>
 [TestFixture]
 public class ClientServiceRequestTest
 {
 [TestFixtureSetUp]
 public void SetUp()
 {
 // Uncomment to enable logging during tests
- // ApplicationContext.RegisterLogger(new Log4NetLogger());
+ // ApplicationContext.RegisterLogger(new Google.Apis.Logging.Log4Net
 Logger());
 }
 
 /// <summary> Helper method to get a string from the stream. </summary>
 private static string ExtractStringFromStream(Stream stream)
 {
 var buffer = new byte[1000];
 var len = stream.Read(buffer, 0, 1000);
 return Encoding.UTF8.GetString(buffer, 0, len);
 }
 
 /// <summary> A mock response class. </summary>
 class MockResponse : IDirectResponseSchema
 {
 [Newtonsoft.Json.JsonPropertyAttribute("etag")]
 public string ETag { get; set; }
 
 [Newtonsoft.Json.JsonPropertyAttribute("name")]
 public string Name { get; set; }
 
 [Newtonsoft.Json.JsonPropertyAttribute("id")]
 public int Id { get; set; }
 
 public override bool Equals(object obj)
 {
 var other = obj as MockResponse;
 return (other != null && other.ETag == ETag && other.Name == Nam
e && other.Id == Id);
 }
+
+public override int GetHashCode()
+{
+return (ETag ?? string.Empty).GetHashCode() ^ (Name ?? string.Em
pty).GetHashCode() Id;
+}
 }
 
 /// <summary> A mock request class. </summary>
 class MockRequest : IDirectResponseSchema
 {
 [Newtonsoft.Json.JsonPropertyAttribute("etag")]
 public string ETag { get; set; }
 
 [Newtonsoft.Json.JsonPropertyAttribute("long_name")]
 public string Name { get; set; }
 
 public override bool Equals(object obj)
 {
 var other = obj as MockRequest;
 return (other != null && other.ETag == ETag && other.Name == Nam
e);
+}
+
+public override int GetHashCode()
+{
+return (ETag ?? string.Empty).GetHashCode() ^ (Name ?? string.Em
pty).GetHashCode();
 }
 }
 
 /// <summary> A mock service request which returns <see cref="MockRespon
se"/>. </summary>
 class TestClientServiceRequest : ClientServiceRequest<MockResponse>
 {
 /// <summary> Gets or sets a request number. It's used on concurrent
tests. </summary>
 public int CallNum { get; set; }
 private string httpMethod;
 private object body;
 
 public TestClientServiceRequest(IClientService service, string httpM
ethod, object body)
 : base(service)
 {
 this.httpMethod = httpMethod;
 this.body = body;
-
- _requestParameters = new Dictionary<string, IParameter>();
+ InitParameters();
 }
 
 public override string MethodName
 {
 get { return httpMethod; }
 }
 
 public override string RestPath
 {
 get { return "restPath" CallNum; }
 }
 
 public override string HttpMethod
 {
 get { return httpMethod; }
 }
 
 protected override object GetBody()
 {
 return body;
 }
 }
 
 /// <summary> A mock message handler which returns an error. </summary>
 class ErrorMessageHanlder : CountableMessageHandler
 {
 public string ExpectedError =
 @"Message[Login Required] Location[Authorization - header] Reaso
n[required] Domain[global]";
 
- protected override async Task<HttpResponseMessage> SendAsyncCore(Htt
 pRequestMessage request,
+ protected override Task<HttpResponseMessage> SendAsyncCore(HttpReque
 stMessage request,
 CancellationToken cancellationToken)
 {
-var response = new HttpResponseMessage();
 var error = @"{
 ""error"": {
 ""errors"": [
 {
 ""domain"": ""global"",
 ""reason"": ""required"",
 ""message"": ""Login Required"",
 ""locationType"": ""header"",
 ""location"": ""Authorization""
 }
 ],
 ""code"": 401,
 ""message"": ""Login Required""
 }
 }";
- response.Content = new StringContent(error);
- response.StatusCode = System.Net.HttpStatusCode.Unauthorized;
- return response;
+
+ var response = new HttpResponseMessage
+ {
+ Content = new StringContent(error),
+ StatusCode = System.Net.HttpStatusCode.Unauthorized
+ };
+
+ TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompleti
 onSource<HttpResponseMessage>();
+ tcs.SetResult(response);
+ return tcs.Task;
 }
 }
 
 /// <summary> Tests message handler which tests the content on the reque
st and the response. </summary>
 class TestBodyMessageHnalder : CountableMessageHandler
 {
 /// <summary> Gets or sets indication is GZip is eanbled. </summary>
 public bool GZipEnabled { get; set; }
 
 /// <summary> Gets or sets the expected request object. </summary>
@@ skipping 67 matching lines @@
 
 /// <summary> A message handler which returns an Http response message o
r throw an exception. </summary>
 class MockMessageHandler : CountableMessageHandler
 {
 private bool ThrowException { get; set; }
 public MockMessageHandler(bool throwException = false)
 {
 ThrowException = throwException;
 }
 
- protected override async Task<HttpResponseMessage> SendAsyncCore(Htt
 pRequestMessage request,
+ protected override Task<HttpResponseMessage> SendAsyncCore(HttpReque
 stMessage request,
 CancellationToken cancellationToken)
 {
 if (ThrowException)
 {
 throw new InvalidOperationMockException("INVALID");
 }
- return new HttpResponseMessage();
+
+ TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompleti
 onSource<HttpResponseMessage>();
+ tcs.SetResult(new HttpResponseMessage());
+ return tcs.Task;
 }
 }
 
 /// <summary> A message handler which is used to cancel an Http request
in the middle.</summary>
 class CancelRedirectMessageHandler : CountableMessageHandler
 {
 /// <summary> The cancellation token we are going to use to cancel a
request.</summary>
 public CancellationTokenSource CancellationTokenSource { get; set; }
 
 /// <summary> The request index we are going to cancel.</summary>
 public int CancelRequestNum { get; set; }
 
- protected override async Task<HttpResponseMessage> SendAsyncCore(Htt
 pRequestMessage request,
+ protected override Task<HttpResponseMessage> SendAsyncCore(HttpReque
 stMessage request,
 CancellationToken cancellationToken)
 {
 if (Calls == CancelRequestNum)
 {
 CancellationTokenSource.Cancel();
 }
 var response = new HttpResponseMessage()
 {
 StatusCode = HttpStatusCode.Redirect,
 RequestMessage = request
 };
 response.Headers.Location = new Uri("http://www.test.com");
- return response;
+
+ TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompleti
 onSource<HttpResponseMessage>();
+ tcs.SetResult(response);
+ return tcs.Task;
 }
 }
 
 /// <summary>·
 /// A message handler which checks concurrent calls (each odd request wi
ll succeeded, and even request will·
 /// fail on the first try and will succeeded in the second try.
 /// </summary>
 class ConcurrentCallsHandler : CountableMessageHandler
 {
 /// <summary> Gets or sets the Serializer which is used to serialize
and deserialize messages. </summary>
 public ISerializer Serializer { get; set; }
 
- protected override async Task<HttpResponseMessage> SendAsyncCore(Htt
 pRequestMessage request,
+ protected override Task<HttpResponseMessage> SendAsyncCore(HttpReque
 stMessage request,
 CancellationToken cancellationToken)
 {
 var response = new HttpResponseMessage();
 var uri = request.RequestUri.AbsoluteUri;
 int lastDigit = 0;
 if (int.TryParse(uri[uri.Length - 1].ToString(), out lastDigit)
&& lastDigit % 2 == 0)
 {
 response.StatusCode = System.Net.HttpStatusCode.ServiceUnava
ilable;
 request.RequestUri = new Uri(uri (lastDigit 1));
 }
 else
 {
 var mockObject = new MockResponse { Name = "Name-" lastDig
it };
 var serializedObject = Serializer.Serialize(mockObject);
 response.Content = new StringContent(serializedObject, Encod
ing.UTF8, "application/json");
 }
- return response;
+
+ TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompleti
 onSource<HttpResponseMessage>();
+ tcs.SetResult(response);
+ return tcs.Task;
 }
 
 /// <summary> Unsuccessful response handler which "handles" service
unavailable responses. </summary>
 internal class ServiceUnavailableUnsuccessfulResponseHandler : IHttp
UnsuccessfulResponseHandler
 {
 public bool HandleResponse(HandleUnsuccessfulResponseArgs args)
 {
 return args.Response.StatusCode == System.Net.HttpStatusCode
.ServiceUnavailable;
 }
 }
@@ skipping 185 matching lines @@
 Assert.That(handler.Calls, Is.EqualTo(1));
 // the returned response should contain ETag, check that the ser
vice add the right ETag property on·
 // the response
 handler.ResponseObject.ETag = handler.ResponseETag;
 Assert.That(response, Is.EqualTo(handler.ResponseObject));
 }
 }
 
 /// <summary>·
 /// A subtest for testing execute when an exception is thrown during sen
ding the request, with or without·
- /// back-off. If back-off handler is attached to the service's message h
 andler, there are going to be several·
- /// retries (up to 5 seconds for a single request or 3 tries in total).
+ /// back-off. If back-off handler is attached to the service's message h
 andler, there are going to be 3 tries·
+ /// (3 is the default value of <seealso cref="ConfigurableMessageHandler
 .NumTries" />) before the operation·
+ /// fails.
 /// </summary>
 /// <param name="backOff">Indicates if back-off handler is attached to t
he service.</param>
 private void SubtestExecute_ThrowException(bool backOff)
 {
 var handler = new MockMessageHandler(true);
 var initializer = new BaseClientService.Initializer()
 {
 HttpClientFactory = new MockHttpClientFactory(handler)
 };
 
 // sets the default exponential back-off policy by the input
 initializer.DefaultExponentialBackOffPolicy = backOff ?
 BaseClientService.ExponentialBackOffPolicy.Exception :
 BaseClientService.ExponentialBackOffPolicy.None;
 
 using (var service = new MockClientService(initializer))
 {
 var request = new TestClientServiceRequest(service, "GET", null)
;
 Assert.Throws<InvalidOperationMockException>(() => request.Execu
te());
 
- // if back-off is enabled, we use 5 seconds maximum wait time fo
 r a request.·
- // So we should make minimum of (lg(5) 1 calls and service.Htt
 pClient.MessageHandler.NumTries tries)·

[ngmiceli, 2013/08/13 19:31:26]

This is a test with consistent, predictable behavior, so I don't see the point
of the formula here. You know which will come first, the 3 calls or the 5
seconds, so please be explicit in the comments. Rather than "it should do X or
Y", say "it will do X".

[peleyal, 2013/08/13 21:46:20]

Done.

- // calls
- int calls = backOff ? (int)Math.Ceiling(Math.Log(5, 2) 1) : 1;
- calls = Math.Min(calls, service.HttpClient.MessageHandler.NumTri
 es);
+ int calls = backOff ? service.HttpClient.MessageHandler.NumTries
  : 1;
 Assert.That(handler.Calls, Is.EqualTo(calls));
 }
 }
 
 /// <summary>·
 /// Tests execute when an exception is thrown during a request and expon
ential back-off is enabled.
 /// </summary>
 [Test]
 public void Execute_ThrowException_WithBackOff()
 {
 SubtestExecute_ThrowException(true);
 }
 
 /// <summary>·
 /// Tests execute when an exception is thrown during a request and expon
ential back-off is disabled.
 /// </summary>
 [Test]
 public void Execute_ThrowException_WithoutBackOff()
 {
 SubtestExecute_ThrowException(false);
 }
 
 /// <summary>·
 /// A subtest for testing async execute when an exception is thrown duri
ng sending the request, with or without·
- /// back-off handler. If back-off handler is attached to the service's m
 essage handler, there are going to be·
- /// several retries (up to 5 seconds for a single request or 3 tries in 
 total).

[ngmiceli, 2013/08/13 19:31:26]

Same as above. This comment is far less confusing, but there still is no reason
why the reader should have to guess. Which will come first, the 3 tries limit or
the 5 seconds?

[peleyal, 2013/08/13 21:46:20]

Done.

+ /// back-off handler. If back-off handler is attached to the service's m
 essage handler, there are going to be 3
+ /// tries (3 is the default value of <seealso cref="ConfigurableMessageH
 andler.NumTries" />) before the·
+ /// operation fails.
 /// </summary>
 /// <param name="backOff">Indicates if back-off handler is attached to t
he service.</param>
 private void SubtestExecuteAsync_ThrowException(bool backOff)
 {
 var handler = new MockMessageHandler(true);
 var initializer = new BaseClientService.Initializer()
 {
 HttpClientFactory = new MockHttpClientFactory(handler)
 };
 
 // configure the back-off behavior by the input
 initializer.DefaultExponentialBackOffPolicy = backOff ?
 BaseClientService.ExponentialBackOffPolicy.Exception :
 BaseClientService.ExponentialBackOffPolicy.None;
 
 using (var service = new MockClientService(initializer))
 {
 var request = new TestClientServiceRequest(service, "GET", null)
;
 var task = request.ExecuteAsync();
 try
 {
 var result = task.Result;
 Assert.Fail("Exception should be thrown");
 }
 catch (AggregateException ex)
 {
 Assert.That(ex.InnerException, Is.AssignableFrom(typeof(Inva
lidOperationMockException)));
 }
 
- // if back-off is enabled, we use 5 seconds maximum wait time fo
 r a request.·
- // So we should make minimum of (lg(5) 1 calls and service.Htt
 pClient.MessageHandler.NumTries tries)·

[ngmiceli, 2013/08/13 19:31:26]

Ditto, confusing comment.

[peleyal, 2013/08/13 21:46:20]

Done.

- // calls
- int calls = backOff ? (int)Math.Ceiling(Math.Log(5, 2) 1) : 1;
- calls = Math.Min(calls, service.HttpClient.MessageHandler.NumTri
 es);
+ int calls = backOff ? service.HttpClient.MessageHandler.NumTries
  : 1;
 Assert.That(handler.Calls, Is.EqualTo(calls));
 }
 }
 
 /// <summary>·
 /// Tests async execute when an exception is thrown during a request and
exponential back-off is enabled.
 /// </summary>
 [Test]
 public void ExecuteAsync_ThrowException_WithBackOff()
 {
@@ skipping 59 matching lines @@
 // catch the error
 error = t.Exception.InnerException.ToString();
 resetEvent.Set();
 }, TaskContinuationOptions.NotOnRanToCompletion);
 resetEvent.WaitOne();
 Assert.True(error.Contains(handler.ExpectedError), "Error messag
e is invalid");
 Assert.That(handler.Calls, Is.EqualTo(1));
 }
 }
 
- /// <summary> tests async execution of multiple request simultaneously. 
 </summary>
+ /// <summary> Tests async execution of multiple request simultaneously. 
 </summary>
 [Test]
 public void ExecuteAsync_Simultaneously()
 {
 var tasks = new List<Task<MockResponse>>();
 var handler = new ConcurrentCallsHandler();
 var initializer = new BaseClientService.Initializer()
 {
 HttpClientFactory = new MockHttpClientFactory(handler),
 HttpClientInitializer = new ConcurrentCallsHandler.Initializ
er()
 };
@@ skipping 116 matching lines @@
 
 [RequestParameterAttribute("optionalEmpty", Google.Apis.Util.Request
ParameterType.Query)]
 public string OptionalEmpty { get; set; }
 
 [RequestParameterAttribute("optionalNotPressent", Google.Apis.Util.R
equestParameterType.Query)]
 public string OptionalNotPressent { get; set; }
 
 public ClientServiceRequestWithQueryParameters(IClientService servic
e, string method, object body)
 : base(service, method, body)
 {
- _requestParameters.Add("required", new MockParameter
+ RequestParameters.Add("required", new Parameter
 {
 Name = "required",
 IsRequired = true,
 ParameterType = "query"
 });
- _requestParameters.Add("optionalWithValue", new MockParameter
+ RequestParameters.Add("optionalWithValue", new Parameter
 {
 Name = "optionalWithValue",
 IsRequired = false,
 ParameterType = "query",
 DefaultValue = "DoesNotDisplay"
 });
- _requestParameters.Add("optionalWithValue2", new MockParameter
+ RequestParameters.Add("optionalWithValue2", new Parameter
 {
 Name = "optionalWithValue",
 IsRequired = false,
 ParameterType = "query",
 DefaultValue = "DoesNotDisplay"
 });
- _requestParameters.Add("optionalWithNull", new MockParameter
+ RequestParameters.Add("optionalWithNull", new Parameter
 {
 Name = "optionalWithNull",
 IsRequired = false,
 ParameterType = "query",
 DefaultValue = "c"
 });
- _requestParameters.Add("optionalEmpty", new MockParameter
+ RequestParameters.Add("optionalEmpty", new Parameter
 {
 Name = "optionalEmpty",
 IsRequired = false,
 ParameterType = "query",
 DefaultValue = "d"
 });
- _requestParameters.Add("optionalNotPressent", new MockParameter
+ RequestParameters.Add("optionalNotPressent", new Parameter
 {
 Name = "optionalNotPressent",
 IsRequired = false,
 ParameterType = "query",
 DefaultValue = "DoesNotDisplay"
 });
 }
 }
 
 /// <summary> Tests build request with query parameters. </summary>
@@ skipping 46 matching lines @@
 public int TestParameterA { get; set; }
 
 [RequestParameter("path2", RequestParameterType.Path)]
 public int TestParameterB { get; set; }
 
 public int TestParameterC { get; set; }
 
 public ClientServiceRequestWithPathParameters(IClientService service
, string method, object body)
 : base(service, method, body)
 {
- _requestParameters = new Dictionary<string, IParameter>();
- _requestParameters.Add("path1", new MockParameter
+ RequestParameters.Add("path1", new Parameter
 {
 Name = "path1",
 ParameterType = "path"
 });
- _requestParameters.Add("path2", new MockParameter
+ RequestParameters.Add("path2", new Parameter
 {
 Name = "path2",
 ParameterType = "path",
 });
 }
 
 public override string RestPath
 {
 get { return "restPath/{path1}/something/{path2}"; }
 }
@@ skipping 158 matching lines @@
 Assert.AreEqual(ETagAction.IfMatch, ClientServiceRequest<object>.Get
DefaultETagAction(HttpConsts.Post));
 Assert.AreEqual(ETagAction.IfMatch, ClientServiceRequest<object>.Get
DefaultETagAction(HttpConsts.Patch));
 Assert.AreEqual(ETagAction.IfMatch, ClientServiceRequest<object>.Get
DefaultETagAction(HttpConsts.Put));
 Assert.AreEqual(ETagAction.IfMatch, ClientServiceRequest<object>.Get
DefaultETagAction(HttpConsts.Delete));
 Assert.AreEqual(ETagAction.Ignore, ClientServiceRequest<object>.GetD
efaultETagAction("INVALID"));
 }
 
 #endregion
 }
 }