Re-enabled directed identity tests after merge from master to fastertesting branch.

2 files changed, 67 insertions, 20 deletions

diff --git a/src/DotNetOpenId.Test/EndToEndTesting.cs b/src/DotNetOpenId.Test/EndToEndTesting.cs
index 16a77a3..726dc9a 100644
--- a/src/DotNetOpenId.Test/EndToEndTesting.cs
+++ b/src/DotNetOpenId.Test/EndToEndTesting.cs
@@ -25,6 +25,15 @@ namespace DotNetOpenId.Test {
 			parameterizedProgrammaticTest(scenario, version, claimedId, requestMode, expectedResult, false);

 			parameterizedWebClientTest(userSuppliedIdentifier, requestMode, expectedResult);

 		}

+		void parameterizedOPIdentifierTest(TestSupport.Scenarios scenario,

+			AuthenticationRequestMode requestMode, AuthenticationStatus expectedResult) {

+			ProtocolVersion version = ProtocolVersion.V20; // only this version supports directed identity

+			Identifier opIdentifier = TestSupport.GetMockOPIdentifier(TestSupport.Scenarios.ApproveOnSetup);

+			Identifier claimedIdentifier = TestSupport.GetDirectedIdentityUrl(TestSupport.Scenarios.ApproveOnSetup, version);

+			parameterizedProgrammaticOPIdentifierTest(opIdentifier, version, claimedIdentifier, requestMode, expectedResult, true);

+			parameterizedProgrammaticOPIdentifierTest(opIdentifier, version, claimedIdentifier, requestMode, expectedResult, false);

+			parameterizedWebClientTest(opIdentifier, requestMode, expectedResult);

+		}

 		void parameterizedProgrammaticTest(TestSupport.Scenarios scenario, ProtocolVersion version, 

 			Identifier claimedUrl, AuthenticationRequestMode requestMode, 

 			AuthenticationStatus expectedResult, bool provideStore) {

@@ -37,6 +46,27 @@ namespace DotNetOpenId.Test {
 			Assert.AreEqual(expectedResult, rpResponse.Status);

 			Assert.AreEqual(claimedUrl, rpResponse.ClaimedIdentifier);

 		}

+		void parameterizedProgrammaticOPIdentifierTest(Identifier opIdentifier, ProtocolVersion version,

+			Identifier claimedUrl, AuthenticationRequestMode requestMode,

+			AuthenticationStatus expectedResult, bool provideStore) {

+

+			var rp = TestSupport.CreateRelyingParty(provideStore ? TestSupport.RelyingPartyStore : null, null, null);

+

+			var returnTo = TestSupport.GetFullUrl(TestSupport.ConsumerPage);

+			var realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);

+			var request = rp.CreateRequest(opIdentifier, realm, returnTo);

+			request.Mode = requestMode;

+

+			var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(request,

+				opReq => {

+					opReq.ClaimedIdentifier = claimedUrl;

+					opReq.IsAuthenticated = expectedResult == AuthenticationStatus.Authenticated;

+				});

+			Assert.AreEqual(expectedResult, rpResponse.Status);

+			if (rpResponse.Status == AuthenticationStatus.Authenticated) {

+				Assert.AreEqual(claimedUrl, rpResponse.ClaimedIdentifier);

+			}

+		}

 		void parameterizedWebClientTest(Identifier identityUrl,

 			AuthenticationRequestMode requestMode, AuthenticationStatus expectedResult) {

 

@@ -176,28 +206,30 @@ namespace DotNetOpenId.Test {
 				AuthenticationStatus.Authenticated

 			);

 		}

-/*

+

+		[Test]

+		public void Pass_Immediate_AutoApproval_DirectedIdentity_20() {

+			parameterizedOPIdentifierTest(

+				TestSupport.Scenarios.AutoApproval,

+				AuthenticationRequestMode.Immediate,

+				AuthenticationStatus.Authenticated);

+		}

+

 		[Test]

 		public void Pass_Setup_ApproveOnSetup_DirectedIdentity_20() {

-			parameterizedTest(

-				TestSupport.GetOPIdentityUrl(TestSupport.Scenarios.ApproveOnSetup),

-				TestSupport.GetDirectedIdentityUrl(TestSupport.Scenarios.ApproveOnSetup, ProtocolVersion.V20),

+			parameterizedOPIdentifierTest(

+				TestSupport.Scenarios.ApproveOnSetup,

 				AuthenticationRequestMode.Setup,

-				AuthenticationStatus.Authenticated,

-				true,

-				true);

+				AuthenticationStatus.Authenticated);

 		}

+

 		[Test]

-		public void Pass_NoStore_ApproveOnSetup_DirectedIdentity_20() {

-			parameterizedTest(

-				TestSupport.GetOPIdentityUrl(TestSupport.Scenarios.ApproveOnSetup),

-				TestSupport.GetDirectedIdentityUrl(TestSupport.Scenarios.ApproveOnSetup, ProtocolVersion.V20),

-				AuthenticationRequestMode.Setup,

-				AuthenticationStatus.Authenticated,

-				true,

-				false);

+		public void Fail_Immediate_ApproveOnSetup_DirectedIdentity_20() {

+			parameterizedOPIdentifierTest(

+				TestSupport.Scenarios.ApproveOnSetup,

+				AuthenticationRequestMode.Immediate,

+				AuthenticationStatus.SetupRequired);

 		}

-*/

 

 		[Test]

 		public void ProviderAddedFragmentRemainsInClaimedIdentifier() {

diff --git a/src/DotNetOpenId.Test/TestSupport.cs b/src/DotNetOpenId.Test/TestSupport.cs
index 987d2df..1eaa268 100644
--- a/src/DotNetOpenId.Test/TestSupport.cs
+++ b/src/DotNetOpenId.Test/TestSupport.cs
@@ -21,6 +21,7 @@ public class TestSupport {
 	const string identityPage = "IdentityEndpoint.aspx";

 	const string directedIdentityPage = "DirectedIdentityEndpoint.aspx";

 	public const string ProviderPage = "ProviderEndpoint.aspx";

+	public const string DirectedProviderEndpoint = "DirectedProviderEndpoint.aspx";

 	public const string MobileConsumerPage = "RelyingPartyMobile.aspx";

 	public const string ConsumerPage = "RelyingParty.aspx";

 	public enum Scenarios {

@@ -65,13 +66,24 @@ public class TestSupport {
 		ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(

 			GetIdentityUrl(scenario, providerVersion),

 			GetDelegateUrl(scenario),

-			new Uri(Host.BaseUri, "/ProviderEndpoint.aspx"),

+			new Uri(Host.BaseUri, "/" + ProviderPage),

 			new string[] { Protocol.Lookup(providerVersion).ClaimedIdentifierServiceTypeURI },

 			10,

 			10

 			);

 		return new MockIdentifier(GetIdentityUrl(scenario, providerVersion), new ServiceEndpoint[] { se });

 	}

+	internal static MockIdentifier GetMockOPIdentifier(Scenarios scenario) {

+		Uri opEndpoint = new Uri(Host.BaseUri, DirectedProviderEndpoint + "?user=" + scenario);

+		ServiceEndpoint se = ServiceEndpoint.CreateForProviderIdentifier(

+			GetOPIdentityUrl(scenario),

+			opEndpoint,

+			new string[] { Protocol.v20.OPIdentifierServiceTypeURI },

+			10,

+			10

+			);

+		return new MockIdentifier(GetOPIdentityUrl(scenario), new ServiceEndpoint[] { se });

+	}

 	public static Uri GetFullUrl(string url) {

 		return GetFullUrl(url, null);

 	}

@@ -179,15 +191,18 @@ public class TestSupport {
 	/// store in <see cref="ProviderStore"/>.

 	/// </summary>

 	internal static OpenIdProvider CreateProvider(NameValueCollection fields) {

-		var provider = new OpenIdProvider(ProviderStore,

-			GetFullUrl(ProviderPage), GetFullUrl(ProviderPage), fields);

+		Protocol protocol = Protocol.Detect(fields.ToDictionary());

+		Uri opEndpoint = GetFullUrl(ProviderPage);

+		var provider = new OpenIdProvider(ProviderStore, opEndpoint, opEndpoint, fields);

 		return provider;

 	}

 	internal static OpenIdProvider CreateProviderForRequest(DotNetOpenId.RelyingParty.IAuthenticationRequest request) {

 		IResponse relyingPartyAuthenticationRequest = request.RedirectingResponse;

 		var rpWebMessageToOP = (Response)relyingPartyAuthenticationRequest;

 		var rpMessageToOP = (IndirectMessageRequest)rpWebMessageToOP.EncodableMessage;

-		var provider = CreateProvider(rpMessageToOP.EncodedFields.ToNameValueCollection());

+		var opEndpoint = (ServiceEndpoint)request.Provider;

+		var provider = new OpenIdProvider(ProviderStore, opEndpoint.ProviderEndpoint,

+			opEndpoint.ProviderEndpoint, rpMessageToOP.EncodedFields.ToNameValueCollection());

 		return provider;

 	}

 	internal static IResponse CreateProviderResponseToRequest(