Issues 373 (Execute Bug), 374 (Remove Tests.Utility) and 375 (Clean warnings)

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 56 matching lines @@
 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;
 
@@ skipping 25 matching lines @@
 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 486 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.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
 }
 }