Issue 351: Reimplement OAuth2 (Step 3 - Tests, Flows and Credential)

Src/GoogleApis.Auth.Tests/OAuth2/AuthorizationCodeFlowTests.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
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Moq;
+using NUnit.Framework;
+
+using Google.Apis.Auth.OAuth2.Requests;
+using Google.Apis.Auth.OAuth2.Responses;
+using Google.Apis.Http;
+using Google.Apis.Json;
+using Google.Apis.Testing;
+using Google.Apis.Tests;
+using Google.Apis.Util;
+using Google.Apis.Util.Store;
+
+namespace Google.Apis.Auth.OAuth2
+{
+/// <summary>Tests for <see cref="Google.Apis.Auth.OAuth2.AuthorizationCodeF
low"/>.</summary>
+[TestFixture]
+public class AuthorizationCodeFlowTests
+{
+private const string TokenUrl = "https://token.com";
+private const string AuthorizationCodeUrl = "https://authorization.com";
+
+#region Constructor
+
+[Test]
+public void TestConstructor_ArgumentException()
+{
+// ClientSecrets are missing.
+try
+{
+new AuthorizationCodeFlow(new AuthorizationCodeFlow.Initializer(
+"https://authorization_code.com", "https://token.com"));
+Assert.Fail();
+}
+catch (ArgumentException ex)
+{
+Assert.True(ex.Message.Contains("You MUST set ClientSecret or Cl
ientSecretStream"));
+}
+}
+
+[Test]
+public void TestConstructor_DefaultValues()
+{
+var flow = CreateFlow();
+Assert.NotNull(flow.AccessMethod);
+Assert.That(flow.AccessMethod, Is.InstanceOf<BearerToken.Authorizati
onHeaderAccessMethod>());
+Assert.That(flow.AuthorizationServerUrl, Is.EqualTo("https://authori
zation.com"));
+Assert.NotNull(flow.ClientSecrets);
+Assert.That(flow.ClientSecrets.ClientId, Is.EqualTo("id"));
+Assert.That(flow.ClientSecrets.ClientSecret, Is.EqualTo("secret"));
+Assert.That(flow.Clock, Is.InstanceOf<SystemClock>());
+Assert.Null(flow.DataStore);
+Assert.NotNull(flow.HttpClient);
+Assert.NotNull(flow.Scopes);
+Assert.That(flow.TokenServerUrl, Is.EqualTo("https://token.com"));
+
+Assert.That(flow.HttpClient.MessageHandler.UnsuccessfulResponseHandl
ers.Count(), Is.EqualTo(1));
+Assert.That(flow.HttpClient.MessageHandler.UnsuccessfulResponseHandl
ers.First(),
+Is.InstanceOf<BackOffHandler>());
+}
+
+#endregion
+
+#region LoadToken
+
+[Test]
+public void LoadTokenAsync_NoDataStore()
+{
+var flow = CreateFlow();
+Assert.Null(flow.LoadTokenAsync("user", CancellationToken.None).Resu
lt);
+}
+
+[Test]
+public void LoadTokenAsync_NullResponse()
+{
+TaskCompletionSource<TokenResponse> tcs = new TaskCompletionSource<T
okenResponse>();
+tcs.SetResult(null);
+Assert.Null(SubtestLoadTokenAsync(tcs));
+}
+
+[Test]
+public void LoadTokenAsync_TokenResponse()
+{
+TokenResponse response = new TokenResponse
+{
+AccessToken = "access"
+};
+
+TaskCompletionSource<TokenResponse> tcs = new TaskCompletionSource<T
okenResponse>();
+tcs.SetResult(response);
+var result = SubtestLoadTokenAsync(tcs);
+Assert.That(result, Is.EqualTo(response));
+}
+
+private TokenResponse SubtestLoadTokenAsync(TaskCompletionSource<TokenRe
sponse> tcs)
+{
+var mock = new Mock<IDataStore>();
+mock.Setup(ds => ds.GetAsync<TokenResponse>("user")).Returns(tcs.Tas
k);
+var flow = CreateFlow(dataStore: mock.Object);
+var result = flow.LoadTokenAsync("user", CancellationToken.None).Res
ult;
+mock.Verify(ds => ds.GetAsync<TokenResponse>("user"));
+return result;
+}
+
+#endregion
+
+#region CreateAuthorizationCodeRequest
+
+[Test]
+public void TestCreateAuthorizationCodeRequest()
+{
+var request = CreateFlow(scopes: new[] { "a", "b" }).CreateAuthoriza
tionCodeRequest("redirect");
+Assert.That(request.AuthorizationServerUrl, Is.EqualTo(new Uri(Autho
rizationCodeUrl)));
+Assert.That(request.ClientId, Is.EqualTo("id"));
+Assert.That(request.RedirectUri, Is.EqualTo("redirect"));
+Assert.That(request.ResponseType, Is.EqualTo("code"));
+Assert.That(request.Scope, Is.EqualTo("a b"));
+Assert.Null(request.State);
+}
+
+#endregion
+
+[Test]
+public void TestExchangeCodeForTokenAsync()
+{
+var mock = new Mock<IDataStore>();
+var handler = new FetchTokenMessageHandler();
+handler.AuthorizationCodeTokenRequest = new AuthorizationCodeTokenRe
quest()
+{
+Code = "c0de",
+RedirectUri = "redIrect",
+Scope = "a"
+};
+MockHttpClientFactory mockFactory = new MockHttpClientFactory(handle
r);
+
+TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(
);
+tcs.SetResult(null);
+mock.Setup(ds => ds.StoreAsync("uSer", It.IsAny<TokenResponse>())).R
eturns(tcs.Task);
+
+var flow = CreateFlow(httpClientFactory: mockFactory, scopes: new[]
{ "a" }, dataStore: mock.Object);
+var response = flow.ExchangeCodeForTokenAsync("uSer", "c0de", "redIr
ect", CancellationToken.None).Result;
+SubtestTokenResponse(response);
+
+mock.Verify(ds => ds.StoreAsync("uSer", It.IsAny<TokenResponse>()));
+}
+
+[Test]
+public void TestRefreshTokenAsync()
+{
+var mock = new Mock<IDataStore>();
+var handler = new FetchTokenMessageHandler();
+handler.RefreshTokenRequest = new RefreshTokenRequest()
+{
+RefreshToken = "REFRESH",
+Scope = "a"
+};
+MockHttpClientFactory mockFactory = new MockHttpClientFactory(handle
r);
+
+TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(
);
+tcs.SetResult(null);
+mock.Setup(ds => ds.StoreAsync("uSer", It.IsAny<TokenResponse>())).R
eturns(tcs.Task);
+
+var flow = CreateFlow(httpClientFactory: mockFactory, scopes: new[]
{ "a" }, dataStore: mock.Object);
+var response = flow.RefreshTokenAsync("uSer", "REFRESH", Cancellatio
nToken.None).Result;
+SubtestTokenResponse(response);
+
+
+mock.Verify(ds => ds.StoreAsync("uSer", It.IsAny<TokenResponse>()));
+}
+
+#region FetchToken
+
+/// <summary>
+/// Fetch token message handler, which expects an authorization code tok
en request or a refresh token request.
+/// It verifies all the query parameters are valid and return an error r
esponse in case <see cref="Error"/>·
+/// is <c>true</c>.
+/// </summary>
+public class FetchTokenMessageHandler : CountableMessageHandler
+{
+internal AuthorizationCodeTokenRequest AuthorizationCodeTokenRequest
{ get; set; }
+internal RefreshTokenRequest RefreshTokenRequest { get; set; }
+internal bool Error { get; set; }
+
+protected override async Task<HttpResponseMessage> SendAsyncCore(Htt
pRequestMessage request,
+CancellationToken taskCancellationToken)
+{
+Assert.That(request.RequestUri, Is.EqualTo(new Uri(TokenUrl)));
+
+if (AuthorizationCodeTokenRequest != null)
+{
+// Verify right parameters.
+var content = await request.Content.ReadAsStringAsync();
+foreach (var parameter in content.Split('&'))
+{
+var keyValue = parameter.Split('=');
+switch (keyValue[0])
+{
+case "code":
+Assert.That(keyValue[1], Is.EqualTo("c0de"));
+break;
+case "redirect_uri":
+Assert.That(keyValue[1], Is.EqualTo("redIrect"))
;
+break;
+case "scope":
+Assert.That(keyValue[1], Is.EqualTo("a"));
+break;
+case "grant_type":
+Assert.That(keyValue[1], Is.EqualTo("authorizati
on_code"));
+break;
+case "client_id":
+Assert.That(keyValue[1], Is.EqualTo("id"));
+break;
+case "client_secret":
+Assert.That(keyValue[1], Is.EqualTo("secret"));
+break;
+default:
+throw new ArgumentOutOfRangeException("Invalid p
arameter!");
+}
+}
+}
+else
+{
+// Verify right parameters.
+var content = await request.Content.ReadAsStringAsync();
+foreach (var parameter in content.Split('&'))
+{
+var keyValue = parameter.Split('=');
+switch (keyValue[0])
+{
+case "refresh_token":
+Assert.That(keyValue[1], Is.EqualTo("REFRESH"));
+break;
+case "scope":
+Assert.That(keyValue[1], Is.EqualTo("a"));
+break;
+case "grant_type":
+Assert.That(keyValue[1], Is.EqualTo("refresh_tok
en"));
+break;
+case "client_id":
+Assert.That(keyValue[1], Is.EqualTo("id"));
+break;
+case "client_secret":
+Assert.That(keyValue[1], Is.EqualTo("secret"));
+break;
+default:
+throw new ArgumentOutOfRangeException("Invalid p
arameter!");
+}
+}
+}
+
+var response = new HttpResponseMessage();
+if (Error)
+{
+response.StatusCode = System.Net.HttpStatusCode.BadRequest;
+var serializedObject = NewtonsoftJsonSerializer.Instance.Ser
ialize(new TokenErrorResponse
+{
+Error = "error",
+ErrorDescription = "desc",
+ErrorUri = "uri"
+});
+response.Content = new StringContent(serializedObject, Encod
ing.UTF8);
+}
+else
+{
+var serializedObject = NewtonsoftJsonSerializer.Instance.Ser
ialize(new TokenResponse
+{
+AccessToken = "a",
+RefreshToken = "r",
+ExpiresInSeconds = 100,
+Scope = "b",
+});
+response.Content = new StringContent(serializedObject, Encod
ing.UTF8);
+}
+
+return response;
+}
+}
+
+[Test]
+public void TestFetchTokenAsync_AuthorizationCodeRequest()
+{
+var handler = new FetchTokenMessageHandler();
+handler.AuthorizationCodeTokenRequest = new AuthorizationCodeTokenRe
quest()
+{
+Code = "c0de",
+RedirectUri = "redIrect",
+Scope = "a"
+};
+MockHttpClientFactory mockFactory = new MockHttpClientFactory(handle
r);
+
+var flow = CreateFlow(httpClientFactory: mockFactory);
+var response = flow.FetchTokenAsync("user", handler.AuthorizationCod
eTokenRequest,
+CancellationToken.None).Result;
+SubtestTokenResponse(response);
+}
+
+[Test]
+public void TestFetchTokenAsync_RefreshTokenRequest()
+{
+var handler = new FetchTokenMessageHandler();
+handler.RefreshTokenRequest = new RefreshTokenRequest()
+{
+RefreshToken = "REFRESH",
+Scope = "a"
+};
+
+MockHttpClientFactory mockFactory = new MockHttpClientFactory(handle
r);
+
+var flow = CreateFlow(httpClientFactory: mockFactory);
+var response = flow.FetchTokenAsync("user", handler.RefreshTokenRequ
est, CancellationToken.None).Result;
+SubtestTokenResponse(response);
+}
+
+[Test]
+public void TestFetchTokenAsync_AuthorizationCodeRequest_Error()
+{
+var handler = new FetchTokenMessageHandler();
+handler.AuthorizationCodeTokenRequest = new AuthorizationCodeTokenRe
quest()
+{
+Code = "c0de",
+RedirectUri = "redIrect",
+Scope = "a"
+};
+handler.Error = true;
+SubtestFetchTokenAsync_Error(handler);
+}
+
+[Test]
+public void TestFetchTokenAsync_RefreshTokenRequest_Error()
+{
+var handler = new FetchTokenMessageHandler();
+handler.RefreshTokenRequest = new RefreshTokenRequest()
+{
+RefreshToken = "REFRESH",
+Scope = "a"
+};
+handler.Error = true;
+SubtestFetchTokenAsync_Error(handler);
+}
+
+/// <summary>Subtest for receiving an error token response.</summary>
+/// <param name="handler">The message handler.</param>
+private void SubtestFetchTokenAsync_Error(FetchTokenMessageHandler handl
er)
+{
+MockHttpClientFactory mockFactory = new MockHttpClientFactory(handle
r);
+var flow = CreateFlow(httpClientFactory: mockFactory);
+try
+{
+var request =
+(TokenRequest)handler.AuthorizationCodeTokenRequest ?? (Toke
nRequest)handler.RefreshTokenRequest;
+var result = flow.FetchTokenAsync("user", request, CancellationT
oken.None).Result;
+Assert.Fail();
+}
+catch (AggregateException aex)
+{
+var ex = aex.InnerException as TokenResponseException;
+Assert.IsNotNull(ex);
+var result = ex.Error;
+Assert.That(result.Error, Is.EqualTo("error"));
+Assert.That(result.ErrorDescription, Is.EqualTo("desc"));
+Assert.That(result.ErrorUri, Is.EqualTo("uri"));
+}
+}
+
+#endregion
+
+/// <summary>Creates an authorization code flow with the given parameter
s.</summary>
+/// <param name="dataStore">The data store.</param>
+/// <param name="scopes">The Scopes.</param>
+/// <param name="httpClientFactory">The HTTP client factory. If not set
the default will be used.</param>
+/// <returns>Authorization code flow</returns>
+private AuthorizationCodeFlow CreateFlow(IDataStore dataStore = null, IE
numerable<string> scopes = null,
+IHttpClientFactory httpClientFactory = null)
+{
+var secrets = new ClientSecrets() { ClientId = "id", ClientSecret =
"secret" };
+var initializer = new AuthorizationCodeFlow.Initializer(Authorizatio
nCodeUrl, TokenUrl)
+{
+ClientSecrets = secrets,
+HttpClientFactory = httpClientFactory
+};
+
+if (dataStore != null)
+{
+initializer.DataStore = dataStore;
+}
+if (scopes != null)
+{
+initializer.Scopes = scopes;
+}
+return new AuthorizationCodeFlow(initializer);
+}
+
+/// <summary>Verifies that the token response contains the expected data
.</summary>
+/// <param name="response">The token response</param>
+private void SubtestTokenResponse(TokenResponse response)
+{
+Assert.That(response.RefreshToken, Is.EqualTo("r"));
+Assert.That(response.ExpiresInSeconds, Is.EqualTo(100));
+Assert.That(response.Scope, Is.EqualTo("b"));
+}
+}
+}