More test build break fixes.

4 files changed, 136 insertions, 105 deletions

diff --git a/src/DotNetOpenAuth.Test/OAuth2/ResourceServerTests.cs b/src/DotNetOpenAuth.Test/OAuth2/ResourceServerTests.cs
index 80a8392..ed5558f 100644
--- a/src/DotNetOpenAuth.Test/OAuth2/ResourceServerTests.cs
+++ b/src/DotNetOpenAuth.Test/OAuth2/ResourceServerTests.cs
@@ -11,6 +11,8 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 	using System.Linq;
 	using System.Security.Cryptography;
 	using System.Text;
+	using System.Threading.Tasks;
+
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OAuth2;
 	using DotNetOpenAuth.OAuth2.ChannelElements;
@@ -28,7 +30,7 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 				{ "Authorization", "Bearer " },
 			};
 			var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
-			Assert.That(() => resourceServer.GetAccessToken(request), Throws.InstanceOf<ProtocolException>());
+			Assert.That(() => resourceServer.GetAccessTokenAsync(request).GetAwaiter().GetResult(), Throws.InstanceOf<ProtocolException>());
 		}
 
 		[Test]
@@ -39,7 +41,7 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 				{ "Authorization", "Bearer " },
 			};
 			var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
-			Assert.That(() => resourceServer.GetPrincipal(request), Throws.InstanceOf<ProtocolException>());
+			Assert.That(() => resourceServer.GetPrincipalAsync(request).GetAwaiter().GetResult(), Throws.InstanceOf<ProtocolException>());
 		}
 
 		[Test]
@@ -50,12 +52,12 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 				{ "Authorization", "Bearer foobar" },
 			};
 			var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
-			Assert.That(() => resourceServer.GetAccessToken(request), Throws.InstanceOf<ProtocolException>());
+			Assert.That(() => resourceServer.GetAccessTokenAsync(request).GetAwaiter().GetResult(), Throws.InstanceOf<ProtocolException>());
 		}
 
 		[Test]
-		public void GetAccessTokenWithCorruptedToken() {
-			var accessToken = this.ObtainValidAccessToken();
+		public async Task GetAccessTokenWithCorruptedToken() {
+			var accessToken = await this.ObtainValidAccessTokenAsync();
 
 			var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AsymmetricKey, null));
 
@@ -63,12 +65,12 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 				{ "Authorization", "Bearer " + accessToken.Substring(0, accessToken.Length - 1) + "zzz" },
 			};
 			var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
-			Assert.That(() => resourceServer.GetAccessToken(request), Throws.InstanceOf<ProtocolException>());
+			Assert.That(() => resourceServer.GetAccessTokenAsync(request).GetAwaiter().GetResult(), Throws.InstanceOf<ProtocolException>());
 		}
 
 		[Test]
-		public void GetAccessTokenWithValidToken() {
-			var accessToken = this.ObtainValidAccessToken();
+		public async Task GetAccessTokenWithValidToken() {
+			var accessToken = await this.ObtainValidAccessTokenAsync();
 
 			var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AsymmetricKey, null));
 
@@ -76,11 +78,11 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 				{ "Authorization", "Bearer " + accessToken },
 			};
 			var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
-			var resourceServerDecodedToken = resourceServer.GetAccessToken(request);
+			var resourceServerDecodedToken = await resourceServer.GetAccessTokenAsync(request);
 			Assert.That(resourceServerDecodedToken, Is.Not.Null);
 		}
 
-		private string ObtainValidAccessToken() {
+		private async Task<string> ObtainValidAccessTokenAsync() {
 			string accessToken = null;
 			var authServer = CreateAuthorizationServerMock();
 			authServer.Setup(
@@ -89,20 +91,19 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 			authServer.Setup(
 				a => a.CheckAuthorizeClientCredentialsGrant(It.Is<IAccessTokenRequest>(d => d.ClientIdentifier == ClientId && MessagingUtilities.AreEquivalent(d.Scope, TestScopes))))
 				.Returns<IAccessTokenRequest>(req => new AutomatedAuthorizationCheckResponse(req, true));
-			var coordinator = new OAuth2Coordinator<WebServerClient>(
-				AuthorizationServerDescription,
-				authServer.Object,
-				new WebServerClient(AuthorizationServerDescription),
-				client => {
-					var authState = client.GetClientAccessToken(TestScopes);
+			var coordinator = new CoordinatorBase(
+				async (hostFactories, ct) => {
+					var client = new WebServerClient(AuthorizationServerDescription);
+					var authState = await client.GetClientAccessTokenAsync(TestScopes, ct);
 					Assert.That(authState.AccessToken, Is.Not.Null.And.Not.Empty);
 					Assert.That(authState.RefreshToken, Is.Null);
 					accessToken = authState.AccessToken;
 				},
-				server => {
-					server.HandleTokenRequest().Respond();
-				});
-			coordinator.Run();
+				CoordinatorBase.Handle(AuthorizationServerDescription.TokenEndpoint).By(async (req, ct) => {
+					var server = new AuthorizationServer(authServer.Object);
+					return await server.HandleTokenRequestAsync(req, ct);
+				}));
+			await coordinator.RunAsync();
 
 			return accessToken;
 		}
diff --git a/src/DotNetOpenAuth.Test/OAuth2/Task.cs b/src/DotNetOpenAuth.Test/OAuth2/Task.cs
new file mode 100644
index 0000000..5f28270
--- /dev/null
+++ b/src/DotNetOpenAuth.Test/OAuth2/Task.cs
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/DotNetOpenAuth.Test/OAuth2/UserAgentClientAuthorizeTests.cs b/src/DotNetOpenAuth.Test/OAuth2/UserAgentClientAuthorizeTests.cs
index ae03b0c..fe439a2 100644
--- a/src/DotNetOpenAuth.Test/OAuth2/UserAgentClientAuthorizeTests.cs
+++ b/src/DotNetOpenAuth.Test/OAuth2/UserAgentClientAuthorizeTests.cs
@@ -8,7 +8,9 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 	using System;
 	using System.Collections.Generic;
 	using System.Linq;
+	using System.Net.Http;
 	using System.Text;
+	using System.Threading.Tasks;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.Messaging.Bindings;
 	using DotNetOpenAuth.OAuth2;
@@ -20,61 +22,80 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 	[TestFixture]
 	public class UserAgentClientAuthorizeTests : OAuth2TestBase {
 		[Test]
-		public void AuthorizationCodeGrant() {
-			var coordinator = new OAuth2Coordinator<UserAgentClient>(
-				AuthorizationServerDescription,
-				AuthorizationServerMock,
-				new UserAgentClient(AuthorizationServerDescription),
-				client => {
+		public async Task AuthorizationCodeGrant() {
+			var coordinator = new CoordinatorBase(
+				async (hostFactories, ct) => {
+					var client = new UserAgentClient(AuthorizationServerDescription);
 					var authState = new AuthorizationState(TestScopes) {
 						Callback = ClientCallback,
 					};
 					var request = client.PrepareRequestUserAuthorization(authState);
 					Assert.AreEqual(EndUserAuthorizationResponseType.AuthorizationCode, request.ResponseType);
-					client.Channel.Respond(request);
-					var incoming = client.Channel.ReadFromRequest();
-					var result = client.ProcessUserAuthorization(authState, incoming);
+					var authRequestRedirect = await client.Channel.PrepareResponseAsync(request, ct);
+					Uri authRequestResponse;
+					using (var httpClient = hostFactories.CreateHttpClient()) {
+						using (var httpResponse = await httpClient.GetAsync(authRequestRedirect.Headers.Location, ct)) {
+							authRequestResponse = httpResponse.Headers.Location;
+						}
+					}
+					var incoming = await client.Channel.ReadFromRequestAsync(new HttpRequestMessage(HttpMethod.Get, authRequestResponse), ct);
+					var result = await client.ProcessUserAuthorizationAsync(authState, incoming, ct);
 					Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
 					Assert.That(result.RefreshToken, Is.Not.Null.And.Not.Empty);
 				},
-				server => {
-					var request = server.ReadAuthorizationRequest();
-					Assert.That(request, Is.Not.Null);
-					server.ApproveAuthorizationRequest(request, ResourceOwnerUsername);
-					server.HandleTokenRequest().Respond();
-				});
-			coordinator.Run();
+				CoordinatorBase.Handle(AuthorizationServerDescription.AuthorizationEndpoint).By(
+					async (req, ct) => {
+						var server = new AuthorizationServer(AuthorizationServerMock);
+						var request = await server.ReadAuthorizationRequestAsync(req, ct);
+						Assert.That(request, Is.Not.Null);
+						var response = server.PrepareApproveAuthorizationRequest(request, ResourceOwnerUsername);
+						return await server.Channel.PrepareResponseAsync(response, ct);
+					}),
+					CoordinatorBase.Handle(AuthorizationServerDescription.TokenEndpoint).By(
+						async (req, ct) => {
+							var server = new AuthorizationServer(AuthorizationServerMock);
+							return await server.HandleTokenRequestAsync(req, ct);
+						}));
+			await coordinator.RunAsync();
 		}
 
 		[Test]
-		public void ImplicitGrant() {
+		public async Task ImplicitGrant() {
 			var coordinatorClient = new UserAgentClient(AuthorizationServerDescription);
-			var coordinator = new OAuth2Coordinator<UserAgentClient>(
-				AuthorizationServerDescription,
-				AuthorizationServerMock,
-				coordinatorClient,
-				client => {
+			var coordinator = new CoordinatorBase(
+				async (hostFactories, ct) => {
+					var client = new UserAgentClient(AuthorizationServerDescription);
 					var authState = new AuthorizationState(TestScopes) {
 						Callback = ClientCallback,
 					};
 					var request = client.PrepareRequestUserAuthorization(authState, implicitResponseType: true);
 					Assert.That(request.ResponseType, Is.EqualTo(EndUserAuthorizationResponseType.AccessToken));
-					client.Channel.Respond(request);
-					var incoming = client.Channel.ReadFromRequest();
-					var result = client.ProcessUserAuthorization(authState, incoming);
+					var authRequestRedirect = await client.Channel.PrepareResponseAsync(request, ct);
+					Uri authRequestResponse;
+					using (var httpClient = hostFactories.CreateHttpClient()) {
+						using (var httpResponse = await httpClient.GetAsync(authRequestRedirect.Headers.Location, ct)) {
+							authRequestResponse = httpResponse.Headers.Location;
+						}
+					}
+
+					var incoming = await client.Channel.ReadFromRequestAsync(new HttpRequestMessage(HttpMethod.Get, authRequestResponse), ct);
+					var result = await client.ProcessUserAuthorizationAsync(authState, incoming, ct);
 					Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
 					Assert.That(result.RefreshToken, Is.Null);
 				},
-				server => {
-					var request = server.ReadAuthorizationRequest();
-					Assert.That(request, Is.Not.Null);
-					IAccessTokenRequest accessTokenRequest = (EndUserAuthorizationImplicitRequest)request;
-					Assert.That(accessTokenRequest.ClientAuthenticated, Is.False);
-					server.ApproveAuthorizationRequest(request, ResourceOwnerUsername);
-				});
+				CoordinatorBase.Handle(AuthorizationServerDescription.AuthorizationEndpoint).By(
+					async (req, ct) => {
+						var server = new AuthorizationServer(AuthorizationServerMock);
+						var request = await server.ReadAuthorizationRequestAsync(req, ct);
+						Assert.That(request, Is.Not.Null);
+						IAccessTokenRequest accessTokenRequest = (EndUserAuthorizationImplicitRequest)request;
+						Assert.That(accessTokenRequest.ClientAuthenticated, Is.False);
+						var response = server.PrepareApproveAuthorizationRequest(request, ResourceOwnerUsername);
+						return await server.Channel.PrepareResponseAsync(response, ct);
+					}));
 
 			coordinatorClient.ClientCredentialApplicator = null; // implicit grant clients don't need a secret.
-			coordinator.Run();
+			await coordinator.RunAsync();
 		}
 	}
 }
diff --git a/src/DotNetOpenAuth.Test/OAuth2/WebServerClientAuthorizeTests.cs b/src/DotNetOpenAuth.Test/OAuth2/WebServerClientAuthorizeTests.cs
index 2a4241e..bd94533 100644
--- a/src/DotNetOpenAuth.Test/OAuth2/WebServerClientAuthorizeTests.cs
+++ b/src/DotNetOpenAuth.Test/OAuth2/WebServerClientAuthorizeTests.cs
@@ -22,31 +22,42 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 	[TestFixture]
 	public class WebServerClientAuthorizeTests : OAuth2TestBase {
 		[Test]
-		public void AuthorizationCodeGrant() {
-			var coordinator = new OAuth2Coordinator<WebServerClient>(
-				AuthorizationServerDescription,
-				AuthorizationServerMock,
-				new WebServerClient(AuthorizationServerDescription),
-				client => {
+		public async Task AuthorizationCodeGrant() {
+			var coordinator = new CoordinatorBase(
+				async (hostFactories, ct) => {
+					var client = new WebServerClient(AuthorizationServerDescription);
 					var authState = new AuthorizationState(TestScopes) {
 						Callback = ClientCallback,
 					};
-					client.PrepareRequestUserAuthorization(authState).Respond();
-					var result = client.ProcessUserAuthorization();
+					var authRequestRedirect = await client.PrepareRequestUserAuthorizationAsync(authState, ct);
+					Uri authRequestResponse;
+					using (var httpClient = hostFactories.CreateHttpClient()) {
+						using (var httpResponse = await httpClient.GetAsync(authRequestRedirect.Headers.Location, ct)) {
+							authRequestResponse = httpResponse.Headers.Location;
+						}
+					}
+
+					var result = await client.ProcessUserAuthorizationAsync(new HttpRequestMessage(HttpMethod.Get, authRequestResponse), ct);
 					Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
 					Assert.That(result.RefreshToken, Is.Not.Null.And.Not.Empty);
 				},
-				server => {
-					var request = server.ReadAuthorizationRequest();
-					Assert.That(request, Is.Not.Null);
-					server.ApproveAuthorizationRequest(request, ResourceOwnerUsername);
-					server.HandleTokenRequest().Respond();
-				});
-			coordinator.Run();
+				CoordinatorBase.Handle(AuthorizationServerDescription.AuthorizationEndpoint).By(
+					async (req, ct) => {
+						var server = new AuthorizationServer(AuthorizationServerMock);
+						var request = await server.ReadAuthorizationRequestAsync(req, ct);
+						Assert.That(request, Is.Not.Null);
+						var response = server.PrepareApproveAuthorizationRequest(request, ResourceOwnerUsername);
+						return await server.Channel.PrepareResponseAsync(response, ct);
+					}),
+					CoordinatorBase.Handle(AuthorizationServerDescription.TokenEndpoint).By(async (req, ct) => {
+						var server = new AuthorizationServer(AuthorizationServerMock);
+						return await server.HandleTokenRequestAsync(req, ct);
+					}));
+			await coordinator.RunAsync();
 		}
 
 		[Theory]
-		public void ResourceOwnerPasswordCredentialGrant(bool anonymousClient) {
+		public async Task ResourceOwnerPasswordCredentialGrant(bool anonymousClient) {
 			var authHostMock = CreateAuthorizationServerMock();
 			if (anonymousClient) {
 				authHostMock.Setup(
@@ -58,27 +69,26 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 							MessagingUtilities.AreEquivalent(d.Scope, TestScopes)))).Returns(true);
 			}
 
-			var coordinator = new OAuth2Coordinator<WebServerClient>(
-				AuthorizationServerDescription,
-				authHostMock.Object,
-				new WebServerClient(AuthorizationServerDescription),
-				client => {
+			var coordinator = new CoordinatorBase(
+				async (hostFactories, ct) => {
+					var client = new WebServerClient(AuthorizationServerDescription);
 					if (anonymousClient) {
 						client.ClientIdentifier = null;
 					}
 
-					var authState = client.ExchangeUserCredentialForToken(ResourceOwnerUsername, ResourceOwnerPassword, TestScopes);
+					var authState = await client.ExchangeUserCredentialForTokenAsync(ResourceOwnerUsername, ResourceOwnerPassword, TestScopes, ct);
 					Assert.That(authState.AccessToken, Is.Not.Null.And.Not.Empty);
 					Assert.That(authState.RefreshToken, Is.Not.Null.And.Not.Empty);
 				},
-				server => {
-					server.HandleTokenRequest().Respond();
-				});
-			coordinator.Run();
+				CoordinatorBase.Handle(AuthorizationServerDescription.TokenEndpoint).By(async (req, ct) => {
+					var server = new AuthorizationServer(authHostMock.Object);
+					return await server.HandleTokenRequestAsync(req, ct);
+				}));
+			await coordinator.RunAsync();
 		}
 
 		[Test]
-		public void ClientCredentialGrant() {
+		public async Task ClientCredentialGrant() {
 			var authServer = CreateAuthorizationServerMock();
 			authServer.Setup(
 				a => a.IsAuthorizationValid(It.Is<IAuthorizationDescription>(d => d.User == null && d.ClientIdentifier == ClientId && MessagingUtilities.AreEquivalent(d.Scope, TestScopes))))
@@ -86,23 +96,22 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 			authServer.Setup(
 				a => a.CheckAuthorizeClientCredentialsGrant(It.Is<IAccessTokenRequest>(d => d.ClientIdentifier == ClientId && MessagingUtilities.AreEquivalent(d.Scope, TestScopes))))
 				.Returns<IAccessTokenRequest>(req => new AutomatedAuthorizationCheckResponse(req, true));
-			var coordinator = new OAuth2Coordinator<WebServerClient>(
-				AuthorizationServerDescription,
-				authServer.Object,
-				new WebServerClient(AuthorizationServerDescription),
-				client => {
-					var authState = client.GetClientAccessToken(TestScopes);
+			var coordinator = new CoordinatorBase(
+				async (hostFactories, ct) => {
+					var client = new WebServerClient(AuthorizationServerDescription);
+					var authState = await client.GetClientAccessTokenAsync(TestScopes, ct);
 					Assert.That(authState.AccessToken, Is.Not.Null.And.Not.Empty);
 					Assert.That(authState.RefreshToken, Is.Null);
 				},
-				server => {
-					server.HandleTokenRequest().Respond();
-				});
-			coordinator.Run();
+				CoordinatorBase.Handle(AuthorizationServerDescription.TokenEndpoint).By(async (req, ct) => {
+					var server = new AuthorizationServer(authServer.Object);
+					return await server.HandleTokenRequestAsync(req, ct);
+				}));
+			await coordinator.RunAsync();
 		}
 
 		[Test]
-		public void GetClientAccessTokenReturnsApprovedScope() {
+		public async Task GetClientAccessTokenReturnsApprovedScope() {
 			string[] approvedScopes = new[] { "Scope2", "Scope3" };
 			var authServer = CreateAuthorizationServerMock();
 			authServer.Setup(
@@ -111,22 +120,21 @@ namespace DotNetOpenAuth.Test.OAuth2 {
 			authServer.Setup(
 				a => a.CheckAuthorizeClientCredentialsGrant(It.Is<IAccessTokenRequest>(d => d.ClientIdentifier == ClientId && MessagingUtilities.AreEquivalent(d.Scope, TestScopes))))
 					  .Returns<IAccessTokenRequest>(req => {
-						var response = new AutomatedAuthorizationCheckResponse(req, true);
-						response.ApprovedScope.ResetContents(approvedScopes);
-						return response;
-					});
-			var coordinator = new OAuth2Coordinator<WebServerClient>(
-				AuthorizationServerDescription,
-				authServer.Object,
-				new WebServerClient(AuthorizationServerDescription),
-				client => {
-					var authState = client.GetClientAccessToken(TestScopes);
+						  var response = new AutomatedAuthorizationCheckResponse(req, true);
+						  response.ApprovedScope.ResetContents(approvedScopes);
+						  return response;
+					  });
+			var coordinator = new CoordinatorBase(
+				async (hostFactories, ct) => {
+					var client = new WebServerClient(AuthorizationServerDescription);
+					var authState = await client.GetClientAccessTokenAsync(TestScopes, ct);
 					Assert.That(authState.Scope, Is.EquivalentTo(approvedScopes));
 				},
-				server => {
-					server.HandleTokenRequest().Respond();
-				});
-			coordinator.Run();
+				CoordinatorBase.Handle(AuthorizationServerDescription.TokenEndpoint).By(async (req, ct) => {
+					var server = new AuthorizationServer(authServer.Object);
+					return await server.HandleTokenRequestAsync(req, ct);
+				}));
+			await coordinator.RunAsync();
 		}
 
 		[Test]