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
@@ skipping 30 matching lines @@
 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
+ // 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("client secret or client secret 
 stream MUST be set"),
- "User MUST specify client secrets!");
+ 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.TokenServerEncodedUrl, Is.EqualTo("https://token.co
 m"));
+ 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 LoadToken_NoDataStore()
+ public void LoadTokenAsync_NoDataStore()
 {
 var flow = CreateFlow();
- Assert.Null(flow.LoadToken("user", CancellationToken.None).Result);
- }
-
- [Test]
- public void LoadToken_NullResponse()
+ 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(SubtestLoadToken(tcs));
- }
-
- [Test]
- public void LoadToken_TokenResponse()
+ 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 = SubtestLoadToken(tcs);
+ var result = SubtestLoadTokenAsync(tcs);
 Assert.That(result, Is.EqualTo(response));
 }
 
- private TokenResponse SubtestLoadToken(TaskCompletionSource<TokenRespons
 e> tcs)
+ private TokenResponse SubtestLoadTokenAsync(TaskCompletionSource<TokenRe
 sponse> tcs)
 {
 var mock = new Mock<IDataStore>();
- mock.Setup(ds => ds.Get<TokenResponse>("user")).Returns(tcs.Task);
+ mock.Setup(ds => ds.GetAsync<TokenResponse>("user")).Returns(tcs.Tas
 k);
 var flow = CreateFlow(dataStore: mock.Object);
- var result = flow.LoadToken("user", CancellationToken.None).Result;
- // Verify that Get("user") was called.
- mock.Verify(ds => ds.Get<TokenResponse>("user"));
+ 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 TestExchangeCodeForToken()
+ 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.Store("uSer", It.IsAny<TokenResponse>())).Return
 s(tcs.Task);
+ 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.ExchangeCodeForToken("uSer", "c0de", "redIrect",
  CancellationToken.None).Result;
+ var response = flow.ExchangeCodeForTokenAsync("uSer", "c0de", "redIr
 ect", CancellationToken.None).Result;
 SubtestTokenResponse(response);
 
- mock.Verify(ds => ds.Store("uSer", It.IsAny<TokenResponse>()));
- }
-
- [Test]
- public void TestRefreshToken()
+ 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.Store("uSer", It.IsAny<TokenResponse>())).Return
 s(tcs.Task);
+ 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.RefreshToken("uSer", "REFRESH", CancellationToke
 n.None).Result;
+ var response = flow.RefreshTokenAsync("uSer", "REFRESH", Cancellatio
 nToken.None).Result;
 SubtestTokenResponse(response);
 
 
- mock.Verify(ds => ds.Store("uSer", It.IsAny<TokenResponse>()));
+ 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)));
@@ skipping 82 matching lines @@
 Scope = "b",
 });
 response.Content = new StringContent(serializedObject, Encod
ing.UTF8);
 }
 
 return response;
 }
 }
 
 [Test]
- public void TestFetchToken_AuthorizationCodeRequest()
+ 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.FetchToken("user", handler.AuthorizationCodeToke
 nRequest,
+ var response = flow.FetchTokenAsync("user", handler.AuthorizationCod
 eTokenRequest,
 CancellationToken.None).Result;
 SubtestTokenResponse(response);
 }
 
 [Test]
- public void TestFetchToken_RefreshTokenRequest()
+ 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.FetchToken("user", handler.RefreshTokenRequest, 
 CancellationToken.None).Result;
+ var response = flow.FetchTokenAsync("user", handler.RefreshTokenRequ
 est, CancellationToken.None).Result;
 SubtestTokenResponse(response);
 }
 
 [Test]
- public void TestFetchToken_AuthorizationCodeRequest_Error()
+ public void TestFetchTokenAsync_AuthorizationCodeRequest_Error()
 {
 var handler = new FetchTokenMessageHandler();
 handler.AuthorizationCodeTokenRequest = new AuthorizationCodeTokenRe
quest()
 {
 Code = "c0de",
 RedirectUri = "redIrect",
 Scope = "a"
 };
 handler.Error = true;
- SubtestFetchToken_Error(handler);
- }
-
- [Test]
- public void TestFetchToken_RefreshTokenRequest_Error()
+ SubtestFetchTokenAsync_Error(handler);
+ }
+
+ [Test]
+ public void TestFetchTokenAsync_RefreshTokenRequest_Error()
 {
 var handler = new FetchTokenMessageHandler();
 handler.RefreshTokenRequest = new RefreshTokenRequest()
 {
 RefreshToken = "REFRESH",
 Scope = "a"
 };
 handler.Error = true;
- SubtestFetchToken_Error(handler);
- }
-
- private void SubtestFetchToken_Error(FetchTokenMessageHandler handler)
+ 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.FetchToken("user", request, CancellationToken.
 None).Result;
+ 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>
+ /// <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
 };
@@ skipping 12 matching lines @@
 /// <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"));
 }
 }
 }