Moves OpenID coordinator handlers to base class.

10 files changed, 55 insertions, 53 deletions

diff --git a/src/DotNetOpenAuth.Test/CoordinatorBase.cs b/src/DotNetOpenAuth.Test/CoordinatorBase.cs
index c041ac1..48c6371 100644
--- a/src/DotNetOpenAuth.Test/CoordinatorBase.cs
+++ b/src/DotNetOpenAuth.Test/CoordinatorBase.cs
@@ -49,27 +49,6 @@ namespace DotNetOpenAuth.Test {
 			return new Handler(uri);
 		}
 
-		internal static Func<IHostFactories, CancellationToken, Task> RelyingPartyDriver(Func<OpenIdRelyingParty, CancellationToken, Task> relyingPartyDriver) {
-			return async (hostFactories, ct) => {
-				var rp = new OpenIdRelyingParty(new StandardRelyingPartyApplicationStore(), hostFactories);
-				await relyingPartyDriver(rp, ct);
-			};
-		}
-
-		internal static Func<IHostFactories, CancellationToken, Task> ProviderDriver(Func<OpenIdProvider, CancellationToken, Task> providerDriver) {
-			return async (hostFactories, ct) => {
-				var op = new OpenIdProvider(new StandardProviderApplicationStore(), hostFactories);
-				await providerDriver(op, ct);
-			};
-		}
-
-		internal static Handler HandleProvider(Func<OpenIdProvider, HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> provider) {
-			return Handle(OpenIdTestBase.OPUri).By(async (req, ct) => {
-				var op = new OpenIdProvider(new StandardProviderApplicationStore());
-				return await provider(op, req, ct);
-			});
-		}
-
 		internal struct Handler {
 			internal Handler(Uri uri)
 				: this() {
diff --git a/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs b/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs
index 14a0a6d..4f0bed8 100644
--- a/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs
@@ -44,7 +44,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 		public async Task AssociateDiffieHellmanOverHttps() {
 			Protocol protocol = Protocol.V20;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					// We have to formulate the associate request manually,
 					// since the DNOI RP won't voluntarily use DH on HTTPS.
 					var request = new AssociateDiffieHellmanRequest(protocol.Version, OPUri) {
@@ -74,13 +74,13 @@ namespace DotNetOpenAuth.Test.OpenId {
 			// the OP and RP are behaving as expected.
 			int providerAttemptCount = 0;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var opDescription = new ProviderEndpointDescription(OPUri, protocol.Version);
 					Association association = await rp.AssociationManager.GetOrCreateAssociationAsync(opDescription, ct);
 					Assert.IsNotNull(association, "Association failed to be created.");
 					Assert.AreEqual(protocol.Args.SignatureAlgorithm.HMAC_SHA1, association.GetAssociationType(protocol));
 				}),
-				CoordinatorBase.HandleProvider(async (op, request, ct) => {
+				HandleProvider(async (op, request, ct) => {
 					op.SecuritySettings.MaximumHashBitLength = 160; // Force OP to reject HMAC-SHA256
 
 					switch (++providerAttemptCount) {
@@ -124,7 +124,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 		public async Task OPRejectsHttpNoEncryptionAssociateRequests() {
 			Protocol protocol = Protocol.V20;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					// We have to formulate the associate request manually,
 					// since the DNOA RP won't voluntarily suggest no encryption at all.
 					var request = new AssociateUnencryptedRequestNoSslCheck(protocol.Version, OPUri);
@@ -145,7 +145,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 		public async Task OPRejectsMismatchingAssociationAndSessionTypes() {
 			Protocol protocol = Protocol.V20;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					// We have to formulate the associate request manually,
 					// since the DNOI RP won't voluntarily mismatch the association and session types.
 					AssociateDiffieHellmanRequest request = new AssociateDiffieHellmanRequest(protocol.Version, new Uri("https://Provider"));
@@ -168,11 +168,11 @@ namespace DotNetOpenAuth.Test.OpenId {
 		public async Task RPRejectsUnrecognizedAssociationType() {
 			Protocol protocol = Protocol.V20;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var association = await rp.AssociationManager.GetOrCreateAssociationAsync(new ProviderEndpointDescription(OPUri, protocol.Version), ct);
 					Assert.IsNull(association, "The RP should quietly give up when the OP misbehaves.");
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					// Receive initial request.
 					var request = await op.Channel.ReadFromRequestAsync<AssociateRequest>(req, ct);
 
@@ -195,11 +195,11 @@ namespace DotNetOpenAuth.Test.OpenId {
 		public async Task RPRejectsUnencryptedSuggestion() {
 			Protocol protocol = Protocol.V20;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var association = await rp.AssociationManager.GetOrCreateAssociationAsync(new ProviderEndpointDescription(OPUri, protocol.Version), ct);
 					Assert.IsNull(association, "The RP should quietly give up when the OP misbehaves.");
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					// Receive initial request.
 					var request = await op.Channel.ReadFromRequestAsync<AssociateRequest>(req, ct);
 
@@ -220,11 +220,11 @@ namespace DotNetOpenAuth.Test.OpenId {
 		public async Task RPRejectsMismatchingAssociationAndSessionBitLengths() {
 			Protocol protocol = Protocol.V20;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var association = await rp.AssociationManager.GetOrCreateAssociationAsync(new ProviderEndpointDescription(OPUri, protocol.Version), ct);
 					Assert.IsNull(association, "The RP should quietly give up when the OP misbehaves.");
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					// Receive initial request.
 					var request = await op.Channel.ReadFromRequestAsync<AssociateRequest>(req, ct);
 
@@ -246,11 +246,11 @@ namespace DotNetOpenAuth.Test.OpenId {
 			Protocol protocol = Protocol.V20;
 			int opStep = 0;
 			await CoordinatorBase.RunAsync(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var association = await rp.AssociationManager.GetOrCreateAssociationAsync(new ProviderEndpointDescription(OPUri, protocol.Version), ct);
 					Assert.IsNull(association, "The RP should quietly give up when the OP misbehaves.");
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					switch (++opStep) {
 						case 1:
 							// Receive initial request.
@@ -285,12 +285,12 @@ namespace DotNetOpenAuth.Test.OpenId {
 		public async Task AssociateRenegotiateLimitedByRPSecuritySettings() {
 			Protocol protocol = Protocol.V20;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					rp.SecuritySettings.MinimumHashBitLength = 256;
 					var association = await rp.AssociationManager.GetOrCreateAssociationAsync(new ProviderEndpointDescription(OPUri, protocol.Version), ct);
 					Assert.IsNull(association, "No association should have been created when RP and OP could not agree on association strength.");
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					op.SecuritySettings.MaximumHashBitLength = 160;
 					return await AutoProviderActionAsync(op, req, ct);
 				}));
diff --git a/src/DotNetOpenAuth.Test/OpenId/AuthenticationTests.cs b/src/DotNetOpenAuth.Test/OpenId/AuthenticationTests.cs
index 6fb0d7a..cb12e77 100644
--- a/src/DotNetOpenAuth.Test/OpenId/AuthenticationTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/AuthenticationTests.cs
@@ -179,7 +179,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 			Association association = sharedAssociation ? HmacShaAssociationProvider.Create(protocol, protocol.Args.SignatureAlgorithm.Best, AssociationRelyingPartyType.Smart, associationStore, securitySettings) : null;
 			int opStep = 0;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					if (statelessRP) {
 						rp = new OpenIdRelyingParty(null, rp.Channel.HostFactories);
 					}
@@ -246,7 +246,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 						}
 					}
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					if (association != null) {
 						var key = cryptoKeyStore.GetCurrentKey(ProviderAssociationHandleEncoder.AssociationHandleEncodingSecretBucket, TimeSpan.FromSeconds(1));
 						op.CryptoKeyStore.StoreKey(ProviderAssociationHandleEncoder.AssociationHandleEncodingSecretBucket, key.Key, key.Value);
diff --git a/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionTestUtilities.cs b/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionTestUtilities.cs
index f2928f3..057abb3 100644
--- a/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionTestUtilities.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionTestUtilities.cs
@@ -42,7 +42,7 @@ namespace DotNetOpenAuth.Test.OpenId.Extensions {
 			var associationStore = new ProviderAssociationHandleEncoder(cryptoKeyStore);
 			Association association = HmacShaAssociationProvider.Create(protocol, protocol.Args.SignatureAlgorithm.Best, AssociationRelyingPartyType.Smart, associationStore, securitySettings);
 			await CoordinatorBase.RunAsync(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				OpenIdTestBase.RelyingPartyDriver(async (rp, ct) => {
 					RegisterExtension(rp.Channel, Mocks.MockOpenIdExtension.Factory);
 					var requestBase = new CheckIdRequest(protocol.Version, OpenIdTestBase.OPUri, AuthenticationRequestMode.Immediate);
 					OpenIdTestBase.StoreAssociation(rp, OpenIdTestBase.OPUri, association);
@@ -68,7 +68,7 @@ namespace DotNetOpenAuth.Test.OpenId.Extensions {
 					var receivedResponses = response.Extensions.Cast<IOpenIdMessageExtension>();
 					CollectionAssert<IOpenIdMessageExtension>.AreEquivalentByEquality(responses.ToArray(), receivedResponses.ToArray());
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				OpenIdTestBase.HandleProvider(async (op, req, ct) => {
 					RegisterExtension(op.Channel, Mocks.MockOpenIdExtension.Factory);
 					var key = cryptoKeyStore.GetCurrentKey(ProviderAssociationHandleEncoder.AssociationHandleEncodingSecretBucket, TimeSpan.FromSeconds(1));
 					op.CryptoKeyStore.StoreKey(ProviderAssociationHandleEncoder.AssociationHandleEncodingSecretBucket, key.Key, key.Value);
diff --git a/src/DotNetOpenAuth.Test/OpenId/NonIdentityTests.cs b/src/DotNetOpenAuth.Test/OpenId/NonIdentityTests.cs
index 21b1d0b..8764e69 100644
--- a/src/DotNetOpenAuth.Test/OpenId/NonIdentityTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/NonIdentityTests.cs
@@ -24,7 +24,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 			var mode = AuthenticationRequestMode.Setup;
 
 			await CoordinatorBase.RunAsync(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var request = new SignedResponseRequest(protocol.Version, OPUri, mode);
 					var authRequest = await rp.Channel.PrepareResponseAsync(request);
 					using (var httpClient = rp.Channel.HostFactories.CreateHttpClient()) {
@@ -33,7 +33,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 						}
 					}
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					var request = await op.Channel.ReadFromRequestAsync<SignedResponseRequest>(req, ct);
 					Assert.IsNotInstanceOf<CheckIdRequest>(request);
 					return new HttpResponseMessage();
@@ -45,7 +45,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 			Protocol protocol = Protocol.V20;
 			int opStep = 0;
 			await CoordinatorBase.RunAsync(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var request = await rp.CreateRequestAsync(GetMockIdentifier(protocol.ProtocolVersion), RPRealmUri, RPUri, ct);
 
 					request.IsExtensionOnly = true;
@@ -61,7 +61,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 					IAuthenticationResponse response = await rp.GetResponseAsync(new HttpRequestMessage(HttpMethod.Get, redirectResponseUrl));
 					Assert.AreEqual(AuthenticationStatus.ExtensionsOnly, response.Status);
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					switch (++opStep) {
 						case 1:
 							var assocRequest = await op.GetRequestAsync(req, ct);
diff --git a/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs b/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
index 5b4a5aa..d3b8aa0 100644
--- a/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
@@ -22,6 +22,8 @@ namespace DotNetOpenAuth.Test.OpenId {
 	using DotNetOpenAuth.Test.Mocks;
 	using NUnit.Framework;
 
+	using IAuthenticationRequest = DotNetOpenAuth.OpenId.Provider.IAuthenticationRequest;
+
 	public class OpenIdTestBase : TestBase {
 		protected internal const string IdentifierSelect = "http://specs.openid.net/auth/2.0/identifier_select";
 
@@ -119,7 +121,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 
 		internal static IdentifierDiscoveryResult GetServiceEndpoint(int user, ProtocolVersion providerVersion, int servicePriority, bool useSsl, bool delegating) {
 			var providerEndpoint = new ProviderEndpointDescription(
-				useSsl ? OpenIdTestBase.OPUriSsl : OpenIdTestBase.OPUri,
+				useSsl ? OPUriSsl : OPUri,
 				new string[] { Protocol.Lookup(providerVersion).ClaimedIdentifierServiceTypeURI });
 			var local_id = useSsl ? OPLocalIdentifiersSsl[user] : OPLocalIdentifiers[user];
 			var claimed_id = delegating ? (useSsl ? VanityUriSsl : VanityUri) : local_id;
@@ -161,7 +163,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 			Assert.That(request, Is.Not.Null);
 
 			if (!request.IsResponseReady) {
-				var authRequest = (DotNetOpenAuth.OpenId.Provider.IAuthenticationRequest)request;
+				var authRequest = (IAuthenticationRequest)request;
 				switch (this.AutoProviderScenario) {
 					case Scenarios.AutoApproval:
 						authRequest.IsAuthenticated = true;
@@ -247,5 +249,26 @@ namespace DotNetOpenAuth.Test.OpenId {
 			var op = new OpenIdProvider(new StandardProviderApplicationStore(), this.HostFactories);
 			return op;
 		}
+
+		protected internal static Func<IHostFactories, CancellationToken, Task> RelyingPartyDriver(Func<OpenIdRelyingParty, CancellationToken, Task> relyingPartyDriver) {
+			return async (hostFactories, ct) => {
+				var rp = new OpenIdRelyingParty(new StandardRelyingPartyApplicationStore(), hostFactories);
+				await relyingPartyDriver(rp, ct);
+			};
+		}
+
+		protected internal static Func<IHostFactories, CancellationToken, Task> ProviderDriver(Func<OpenIdProvider, CancellationToken, Task> providerDriver) {
+			return async (hostFactories, ct) => {
+				var op = new OpenIdProvider(new StandardProviderApplicationStore(), hostFactories);
+				await providerDriver(op, ct);
+			};
+		}
+
+		internal static CoordinatorBase.Handler HandleProvider(Func<OpenIdProvider, HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> provider) {
+			return CoordinatorBase.Handle(OPUri).By(async (req, ct) => {
+				var op = new OpenIdProvider(new StandardProviderApplicationStore());
+				return await provider(op, req, ct);
+			});
+		}
 	}
 }
diff --git a/src/DotNetOpenAuth.Test/OpenId/Provider/OpenIdProviderTests.cs b/src/DotNetOpenAuth.Test/OpenId/Provider/OpenIdProviderTests.cs
index 984337c..1033198 100644
--- a/src/DotNetOpenAuth.Test/OpenId/Provider/OpenIdProviderTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/Provider/OpenIdProviderTests.cs
@@ -101,10 +101,10 @@ namespace DotNetOpenAuth.Test.OpenId.Provider {
 
 			// Test some non-empty request scenario.
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					await rp.Channel.RequestAsync(AssociateRequestRelyingParty.Create(rp.SecuritySettings, providerDescription), ct);
 				}),
-				CoordinatorBase.HandleProvider(async (op, req, ct) => {
+				HandleProvider(async (op, req, ct) => {
 					IRequest request = await op.GetRequestAsync(req);
 					Assert.IsInstanceOf<AutoResponsiveRequest>(request);
 					return await op.PrepareResponseAsync(request, ct);
@@ -115,7 +115,7 @@ namespace DotNetOpenAuth.Test.OpenId.Provider {
 		[Test]
 		public async Task BadRequestsGenerateValidErrorResponses() {
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var nonOpenIdMessage = new Mocks.TestDirectedMessage {
 						Recipient = OPUri,
 						HttpMethods = HttpDeliveryMethods.PostRequest
diff --git a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs
index f8eef61..af66bed 100644
--- a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs
@@ -74,7 +74,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 		[Test]
 		public async Task CreateRequestMessage() {
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					Identifier id = this.GetMockIdentifier(ProtocolVersion.V20);
 					IAuthenticationRequest authRequest = await rp.CreateRequestAsync(id, this.realm, this.returnTo);
 
diff --git a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/OpenIdRelyingPartyTests.cs b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/OpenIdRelyingPartyTests.cs
index 986a64e..1dc5678 100644
--- a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/OpenIdRelyingPartyTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/OpenIdRelyingPartyTests.cs
@@ -90,7 +90,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 		public async Task CreateRequestOnNonOpenID() {
 			var nonOpenId = new Uri("http://www.microsoft.com/");
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(
+				RelyingPartyDriver(
 					async (rp, ct) => {
 						await rp.CreateRequestAsync(nonOpenId, RPRealmUri, RPUri);
 					}),
@@ -102,7 +102,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 		public async Task CreateRequestsOnNonOpenID() {
 			var nonOpenId = new Uri("http://www.microsoft.com/");
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(
+				RelyingPartyDriver(
 					async (rp, ct) => {
 						var requests = await rp.CreateRequestsAsync(nonOpenId, RPRealmUri, RPUri);
 						Assert.AreEqual(0, requests.Count());
diff --git a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs
index 5642bc5..a998ef2 100644
--- a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs
@@ -132,7 +132,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 			var se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(claimed_id, claimed_id, providerEndpoint, null, null);
 			var identityUri = (UriIdentifier)se.ClaimedIdentifier;
 			var coordinator = new CoordinatorBase(
-				CoordinatorBase.RelyingPartyDriver(async (rp, ct) => {
+				RelyingPartyDriver(async (rp, ct) => {
 					var positiveAssertion = this.GetPositiveAssertion();
 					positiveAssertion.ClaimedIdentifier = claimed_id;
 					positiveAssertion.LocalIdentifier = claimed_id;