Reimplement OAuth2 library - Step 1

Src/GoogleApis.Tests/Apis/Services/BaseClientServiceTest.cs

 /*
 Copyright 2013 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 19 matching lines @@
 using Google.Apis.Discovery;
 using Google.Apis.Http;
 using Google.Apis.Json;
 using Google.Apis.Requests;
 using Google.Apis.Services;
 using Google.Apis.Testing;
 using Google.Apis.Util;
 
 namespace Google.Apis.Tests.Apis.Services
 {
- /// <summary> Test for the BaseClientService class. </summary>
+ /// <summary>Test for the BaseClientService class.</summary>
 [TestFixture]
 public class BaseClientServiceTest
 {
- /// <summary> A Json schema for testing serialization/deserialization. <
 /summary>
+ /// <summary>A Json schema for testing serialization/deserialization.</s
 ummary>
 internal class MockJsonSchema : IDirectResponseSchema
 {
 [JsonProperty("kind")]
 public string Kind { get; set; }
 
 [JsonProperty("longUrl")]
 public string LongURL { get; set; }
 
 [JsonProperty("status")]
 public string Status { get; set; }
 
 public RequestError Error { get; set; }
 
 public string ETag { get; set; }
 }
 
- private void CheckDeserializationResults(MockJsonSchema result)
+ /// <summary>Validates the deserialization result.</summary>
+ private void CheckDeserializationResult(MockJsonSchema result)
 {
 Assert.NotNull(result);
 Assert.That(result.Kind, Is.EqualTo("urlshortener#url"));
 Assert.That(result.LongURL, Is.EqualTo("http://google.com/"));
 Assert.That(result.Status, Is.Null);
 }
 
- private IClientService CreateClientServiceV_03()
- {
- return CreateClientService(DiscoveryVersion.Version_0_3);
- }
-
- private IClientService CreateClientServiceV_1()
- {
- return CreateClientService(DiscoveryVersion.Version_1_0);
- }
-
- private IClientService CreateClientService(DiscoveryVersion version)
+ /// <summary>Creates a client service for the given features.</summary>
+ private IClientService CreateClientService(Features? features = null)
 {
 var client = new MockClientService();
- if (version == DiscoveryVersion.Version_0_3)
- client.SetFeatures(new[] { Features.LegacyDataResponse.GetString
 Value() });
+ if (features.HasValue)
+ {
+ client.SetFeatures(new[] { features.Value.GetStringValue() });
+ }
+
 return client;
 }
 
- /// <summary> This tests the v0.3 deserialization of the BaseService. </
 summary>
- [Test]
- public void TestDeserializationV0_3()
- {
- const string ResponseV0_3 =
+ /// <summary>This tests deserialization with data wrapping.</summary>
+ [Test]
+ public void TestDeserialization_WithDataWrapping()
+ {
+ const string Response =
 @"{ ""data"" :·
 {
 ""kind"": ""urlshortener#url"",
 ""longUrl"": ""http://google.com/"",
 }·
 }";
 
- var client = CreateClientServiceV_03();
+ var client = CreateClientService(Features.LegacyDataResponse);
 
 // Check that the default serializer is set.
 Assert.IsInstanceOf<NewtonsoftJsonSerializer>(client.Serializer);
 
 // Check that the response is decoded correctly.
- var stream = new MemoryStream(Encoding.Default.GetBytes(ResponseV0_3
 ));
+ var stream = new MemoryStream(Encoding.Default.GetBytes(Response));
 var response = new HttpResponseMessage { Content = new StreamContent
(stream) };
- CheckDeserializationResults(client.DeserializeResponse<MockJsonSchem
 a>(response).Result);
- }
-
-
- /// <summary> This tests the v1 Deserialization of the BaseService. </su
 mmary>
- [Test]
- public void TestDeserializationV1()
- {
- const string ResponseV1 = @"{""kind"":""urlshortener#url"",""longUrl
 "":""http://google.com/""}";
+ CheckDeserializationResult(client.DeserializeResponse<MockJsonSchema
 >(response).Result);
+ }
+
+
+ /// <summary>This tests Deserialization without data wrapping.</summary>
+ [Test]
+ public void TestDeserialization_WithoutDataWrapping()
+ {
+ const string Response = @"{""kind"":""urlshortener#url"",""longUrl""
 :""http://google.com/""}";
 
 // by default the request provider doesn't contain the LegacyDataRes
ponse
- var client = CreateClientServiceV_1();
+ var client = CreateClientService();
 
 // Check that the default serializer is set
 Assert.IsInstanceOf<NewtonsoftJsonSerializer>(client.Serializer);
 
 // Check that the response is decoded correctly
- var stream = new MemoryStream(Encoding.Default.GetBytes(ResponseV1))
 ;
+ var stream = new MemoryStream(Encoding.Default.GetBytes(Response));
 var response = new HttpResponseMessage { Content = new StreamContent
(stream) };
- CheckDeserializationResults(
+ CheckDeserializationResult(
 client.DeserializeResponse<MockJsonSchema>(response).Result);
 }
 
- /// <summary> Tests if serialization works. </summary>
- [Test]
- public void TestSerializationV0_3()
- {
- const string ResponseV0_3 =
+ /// <summary>Tests serialization with data wrapping.</summary>
+ [Test]
+ public void TestSerialization_WithDataWrapping()
+ {
+ const string Response =
 "{\"data\":{\"kind\":\"urlshortener#url\",\"longUrl\":\"http://g
oogle.com/\"}}";
 
 MockJsonSchema schema = new MockJsonSchema();
 schema.Kind = "urlshortener#url";
 schema.LongURL = "http://google.com/";
 
- var client = CreateClientServiceV_03();
+ var client = CreateClientService(Features.LegacyDataResponse);
 
 // Check if a response is serialized correctly
 string result = client.SerializeObject(schema);
- Assert.AreEqual(ResponseV0_3, result);
- }
-
- /// <summary> Tests if serialization works. </summary>
- [Test]
- public void TestSerializationV1()
- {
- const string ResponseV1 = @"{""kind"":""urlshortener#url"",""longUrl
 "":""http://google.com/""}";
+ Assert.AreEqual(Response, result);
+ }
+
+ /// <summary>Tests serialization without data wrapping.</summary>
+ [Test]
+ public void TestSerialization_WithoutDataWrapping()
+ {
+ const string Response = @"{""kind"":""urlshortener#url"",""longUrl""
 :""http://google.com/""}";
 
 MockJsonSchema schema = new MockJsonSchema();
 schema.Kind = "urlshortener#url";
 schema.LongURL = "http://google.com/";
 
- var client = CreateClientServiceV_1();
-
- // Check if a response is serialized correctly
+ var client = CreateClientService();
+
+ // Check if a response is serialized correctly.
 string result = client.SerializeObject(schema);
- Assert.AreEqual(ResponseV1, result);
+ Assert.AreEqual(Response, result);
 }
 
 /// <summary>
 /// Confirms that the serializer won't do anything if a string is the re
quested response type.
 /// </summary>
 [Test]
 public void TestDeserializationString()
 {
- const string ResponseV1 = @"{""kind"":""urlshortener#url"",""longUrl
 "":""http://google.com/""}";
+ const string Response = @"{""kind"":""urlshortener#url"",""longUrl""
 :""http://google.com/""}";
 
 MockClientService client = new MockClientService();
 
 // Check that the response is decoded correctly
- var stream = new MemoryStream(Encoding.Default.GetBytes(ResponseV1))
 ;
+ var stream = new MemoryStream(Encoding.Default.GetBytes(Response));
 var response = new HttpResponseMessage { Content = new StreamContent
(stream) };
 string result = client.DeserializeResponse<string>(response).Result;
- Assert.AreEqual(ResponseV1, result);
- }
-
- /// <summary> Tests the deserialization for server error responses. </su
 mmary>
+ Assert.AreEqual(Response, result);
+ }
+
+ /// <summary>Tests deserialization for server error response.</summary>
 [Test]
 public void TestErrorDeserialization(
- [Values(DiscoveryVersion.Version_0_3, DiscoveryVersion.Version_1_0)] D
 iscoveryVersion version)
+ [Values(Features.LegacyDataResponse, null)] Features? features)
 {
 const string ErrorResponse =
 @"{
 ""error"": {
 ""errors"": [
 {
 ""domain"": ""global"",
 ""reason"": ""required"",
 ""message"": ""Required"",
 ""locationType"": ""parameter"",
 ""location"": ""resource.longUrl""
 }
 ],
 ""code"": 400,
 ""message"": ""Required""
 }
 }";
 
- var client = CreateClientService(version);
+ var client = CreateClientService(features);
 
 using (var stream = new MemoryStream(Encoding.Default.GetBytes(Error
Response)))
 {
 var response = new HttpResponseMessage { Content = new StreamCon
tent(stream) };
 RequestError error = client.DeserializeError(response).Result;
 Assert.AreEqual(400, error.Code);
 Assert.AreEqual("Required", error.Message);
 Assert.AreEqual(1, error.Errors.Count);
 }
 }
 
 #region Authentication
 
- /// <summary> 
- /// Mock authentication message handler which returns unauthorized respo
 nse in the first call, and in the·
- /// second call it returns a successful response.
+ /// <summary>
+ /// A mock authentication message handler which returns an unauthorized 
 response in the first call, and a·
+ /// successful response in the second.
 /// </summary>
 class MockAuthenticationMessageHandler : CountableMessageHandler
 {
 internal static string FirstToken = "invalid";
 internal static string SecondToken = "valid";
 
 protected override Task<HttpResponseMessage> SendAsyncCore(HttpReque
stMessage request,
 CancellationToken cancellationToken)
 {
 TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompleti
onSource<HttpResponseMessage>();
@@ skipping 13 matching lines @@
 tcs.SetResult(new HttpResponseMessage());
 break;
 default:
 throw new Exception("There should be only two calls");
 }
 
 return tcs.Task;
 }
 }
 
- /// <summary> Mock Authenticator which adds Authorization header to a re
 quest on the second call. </summary>
+ /// <summary>A mock Authenticator which adds Authorization header to a r
 equest on the second call.</summary>
 class Authenticator : IAuthenticator
 {
+/// <summary>Gets ot set the number of calls to <see cref="ApplyAuth
enticationToRequest"/>.</summary>
 public int ApplyCalls { get; set; }
 
- public void ApplyAuthenticationToRequest(System.Net.HttpWebRequest r
 equest)
+ public void ApplyAuthenticationToRequest(HttpWebRequest request)
 {
 ApplyCalls ;
 switch (ApplyCalls)
 {
 case 1:
 request.Headers["Authorization"] = MockAuthenticationMes
sageHandler.FirstToken;
 break;
 case 2:
 request.Headers["Authorization"] = MockAuthenticationMes
sageHandler.SecondToken;
 break;
 default:
 throw new Exception("There should be only two calls");
 }
 }
 }
 
- /// <summary> Mock Authenticator which handles unsuccessful response by 
 "refreshing" the token. </summary>
+ /// <summary>Mock Authenticator which handles unsuccessful response by "
 refreshing" the token.</summary>
 class AuthenticatorUnsuccessfulHandler : Authenticator, IHttpUnsuccessfu
lResponseHandler
 {
+/// <summary>Gets or sets the number of calls to <see cref="HandleRe
sponseAsync"/>.</summary>
 public int HandleCalls { get; set; }
 
 public Task<bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs
args)
 {
 HandleCalls ;
- // Mock a refresh token process here... (second apply will attac
 h SecondToken authorization)
+ // Mock a refresh token process here... (second apply will attac
 h SecondToken authorization).
 TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(
);
 tcs.SetResult(true);
 return tcs.Task;
 }
 }
 
- /// <summary> 
- /// Tests that authenticator helpers invokes both apply authentication a
 nd handle response methods on the 
- /// authentication instance.
+ /// <summary>
+ /// Tests that the authenticator helpers, when invoked, both apply authe
 ntication and handle response methods·
+ /// on the authentication instance.
 /// </summary>
 [Test]
 public void Test_Authentication_UnsuccessfulHandler()
 {
 var handler = new MockAuthenticationMessageHandler();
 var authenticator = new AuthenticatorUnsuccessfulHandler();
- using (var service = new MockClientService(new BaseClientService.Ini
 tializer()
-  {
-  HttpClientFactory = new MockHttpClientFactory(handler),
-  Authenticator = authenticator
- }))
+ var initializer = new BaseClientService.Initializer()
+ {
+ HttpClientFactory = new MockHttpClientFactory(handler),
+ Authenticator = authenticator
+ };
+
+  using (var service = new MockClientService(initializer))
 {
 var response = service.HttpClient.SendAsync(
 new HttpRequestMessage(HttpMethod.Get, "https://test")).Resu
lt;
- // the authenticator handles unsuccessful response handler by "r
 efreshing" the token, so the request
- // will success
+ // The authenticator handles unsuccessful response handler by "r
 efreshing" the token, so the request
+ // will success.
 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
 Assert.That(handler.Calls, Is.EqualTo(2));
 Assert.That(authenticator.ApplyCalls, Is.EqualTo(2));
 Assert.That(authenticator.HandleCalls, Is.EqualTo(1));
 }
 }
 
- /// <summary> 
- /// Tests an authenticator which doesn't implement unsuccessful response
  handler, and as a result the request
- /// fails (when the token is invalid).
+ /// <summary>
+ /// Tests an authenticator which doesn't implement an unsuccessful respo
 nse handler. The request should fail 
+ /// when the token is invalid.
 /// </summary>
 [Test]
 public void Test_Authentication()
 {
 var handler = new MockAuthenticationMessageHandler();
 var authenticator = new Authenticator();
- using (var service = new MockClientService(new BaseClientService.Ini
 tializer()
-  {
-  HttpClientFactory = new MockHttpClientFactory(handler),
-  Authenticator = authenticator
- }))
+ var initializer = new BaseClientService.Initializer()
+ {
+ HttpClientFactory = new MockHttpClientFactory(handler),
+ Authenticator = authenticator
+ };
+
+  using (var service = new MockClientService(initializer))
 {
 var response = service.HttpClient.SendAsync(
 new HttpRequestMessage(HttpMethod.Get, "https://test")).Resu
lt;
- // the authenticator doesn't implement unsuccessful response han
 dler, so the request fails
+ // The authenticator doesn't implement unsuccessful response han
 dler, so the request fails.
 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Unaut
horized));
 Assert.That(handler.Calls, Is.EqualTo(1));
 Assert.That(authenticator.ApplyCalls, Is.EqualTo(1));
 }
 }
 
 #endregion
 
 #region Constructor
 
+/// <summary>
+/// Tests the default values of <seealso cref="Google.Apis.Services.Base
ClientService"/>
+/// </summary>
 [Test]
 public void Constructor_DefaultValues()
 {
 var service = new MockClientService(new BaseClientService.Initialize
r());
 Assert.NotNull(service.HttpClient);
 Assert.Null(service.HttpClientInitializer);
 Assert.That(service.Authenticator, Is.EqualTo(NullAuthenticator.Inst
ance));
 Assert.True(service.GZipEnabled);
 
- // back-off handler for unsuccessful response (503) is added by defa
 ult
+ // Back-off handler for unsuccessful response (503) is added by defa
 ult.
 Assert.That(service.HttpClient.MessageHandler.UnsuccessfulResponseHa
ndlers.Count, Is.EqualTo(1));
 Assert.That(service.HttpClient.MessageHandler.UnsuccessfulResponseHa
ndlers[0],
 Is.InstanceOf<BackOffHandler>());
 
- // one execute interceptor (for adding the "Authenticate" header
+ // One execute interceptor (for adding the "Authenticate" header,
 Assert.That(service.HttpClient.MessageHandler.ExecuteInterceptors.Co
unt, Is.EqualTo(1));
 Assert.That(service.HttpClient.MessageHandler.ExecuteInterceptors[0]
,
 Is.InstanceOf<AuthenticatorInterceptor>());
 }
 
 #endregion
 }
 }