summaryrefslogtreecommitdiffstats
path: root/src/DotNetOpenAuth.Test/OpenId
diff options
context:
space:
mode:
Diffstat (limited to 'src/DotNetOpenAuth.Test/OpenId')
-rw-r--r--src/DotNetOpenAuth.Test/OpenId/IdentifierTests.cs34
-rw-r--r--src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs4
-rw-r--r--src/DotNetOpenAuth.Test/OpenId/TestSupport.cs154
-rw-r--r--src/DotNetOpenAuth.Test/OpenId/UI/UITestSupport.cs8
-rw-r--r--src/DotNetOpenAuth.Test/OpenId/UriIdentifierTests.cs221
-rw-r--r--src/DotNetOpenAuth.Test/OpenId/XriIdentifierTests.cs92
6 files changed, 272 insertions, 241 deletions
diff --git a/src/DotNetOpenAuth.Test/OpenId/IdentifierTests.cs b/src/DotNetOpenAuth.Test/OpenId/IdentifierTests.cs
index 941aa70..7bc60c7 100644
--- a/src/DotNetOpenAuth.Test/OpenId/IdentifierTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/IdentifierTests.cs
@@ -1,21 +1,27 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using DotNetOpenAuth.OpenId;
+//-----------------------------------------------------------------------
+// <copyright file="IdentifierTests.cs" company="Andrew Arnott">
+// Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
namespace DotNetOpenAuth.Test.OpenId {
+ using System;
+ using System.Collections.Generic;
+ using System.Linq;
+ using DotNetOpenAuth.OpenId;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
+
[TestClass]
public class IdentifierTests {
- string uri = "http://www.yahoo.com/";
- string uriNoScheme = "www.yahoo.com";
- string uriHttps = "https://www.yahoo.com/";
- string xri = "=arnott*andrew";
+ private string uri = "http://www.yahoo.com/";
+ private string uriNoScheme = "www.yahoo.com";
+ private string uriHttps = "https://www.yahoo.com/";
+ private string xri = "=arnott*andrew";
[TestMethod]
public void Parse() {
- Assert.IsInstanceOfType(Identifier.Parse(uri), typeof(UriIdentifier));
- Assert.IsInstanceOfType(Identifier.Parse(xri), typeof(XriIdentifier));
+ Assert.IsInstanceOfType(Identifier.Parse(this.uri), typeof(UriIdentifier));
+ Assert.IsInstanceOfType(Identifier.Parse(this.xri), typeof(XriIdentifier));
}
/// <summary>
@@ -40,9 +46,9 @@ namespace DotNetOpenAuth.Test.OpenId {
[TestMethod]
public void ParseEndUserSuppliedUriIdentifier() {
// verify a fully-qualified Uri
- var id = Identifier.Parse(uri);
+ var id = Identifier.Parse(this.uri);
Assert.IsInstanceOfType(id, typeof(UriIdentifier));
- Assert.AreEqual(uri, ((UriIdentifier)id).Uri.AbsoluteUri);
+ Assert.AreEqual(this.uri, ((UriIdentifier)id).Uri.AbsoluteUri);
// verify an HTTPS Uri
id = Identifier.Parse(uriHttps);
Assert.IsInstanceOfType(id, typeof(UriIdentifier));
@@ -50,7 +56,7 @@ namespace DotNetOpenAuth.Test.OpenId {
// verify that if the scheme is missing it is added automatically
id = Identifier.Parse(uriNoScheme);
Assert.IsInstanceOfType(id, typeof(UriIdentifier));
- Assert.AreEqual(uri, ((UriIdentifier)id).Uri.AbsoluteUri);
+ Assert.AreEqual(this.uri, ((UriIdentifier)id).Uri.AbsoluteUri);
}
[TestMethod, ExpectedException(typeof(ArgumentNullException))]
diff --git a/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs b/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
index 82cf976..7deafef 100644
--- a/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
@@ -6,11 +6,11 @@
namespace DotNetOpenAuth.Test.OpenId {
using DotNetOpenAuth.Configuration;
+ using DotNetOpenAuth.Messaging;
using DotNetOpenAuth.OpenId.Provider;
using DotNetOpenAuth.OpenId.RelyingParty;
- using Microsoft.VisualStudio.TestTools.UnitTesting;
using DotNetOpenAuth.Test.Mocks;
- using DotNetOpenAuth.Messaging;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
public class OpenIdTestBase : TestBase {
protected RelyingPartySecuritySettings RelyingPartySecuritySettings { get; private set; }
diff --git a/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs b/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs
index 4e742dc..4470b99 100644
--- a/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs
@@ -7,29 +7,19 @@
namespace DotNetOpenAuth.Test.OpenId {
using System;
using System.Collections.Generic;
- using System.Collections.Specialized;
- using System.Diagnostics;
using System.IO;
using System.Reflection;
- using System.Web;
- using DotNetOpenAuth;
+ using DotNetOAuth.Test.OpenId.UI;
+ using DotNetOpenAuth.Messaging;
using DotNetOpenAuth.OpenId;
- using DotNetOpenAuth.OpenId.Provider;
using DotNetOpenAuth.OpenId.RelyingParty;
using DotNetOpenAuth.Test.Mocks;
//using DotNetOpenAuth.Test.UI;
using log4net;
- using IProviderAssociationStore = DotNetOpenAuth.OpenId.IAssociationStore<DotNetOpenAuth.OpenId.AssociationRelyingPartyType>;
- using ProviderMemoryStore = DotNetOpenAuth.OpenId.AssociationMemoryStore<DotNetOpenAuth.OpenId.AssociationRelyingPartyType>;
- using Microsoft.VisualStudio.TestTools.UnitTesting;
- using DotNetOAuth.Test.OpenId.UI;
- using DotNetOpenAuth.Messaging;
public class TestSupport {
public static readonly string TestWebDirectory = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), @"..\..\src\DotNetOpenId.TestWeb"));
public const string HostTestPage = "HostTest.aspx";
- 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";
@@ -42,6 +32,8 @@ namespace DotNetOpenAuth.Test.OpenId {
get { return new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri); }
}
public readonly static ILog Logger = LogManager.GetLogger("DotNetOpenId.Test");
+ private const string IdentityPage = "IdentityEndpoint.aspx";
+ private const string DirectedIdentityPage = "DirectedIdentityEndpoint.aspx";
public enum Scenarios {
// Authentication test scenarios
@@ -61,82 +53,24 @@ namespace DotNetOpenAuth.Test.OpenId {
ExtensionPartialCooperation,
}
- ////internal static UriIdentifier GetOPIdentityUrl(Scenarios scenario, bool useSsl) {
- //// var args = new Dictionary<string, string> {
- //// { "user", scenario.ToString() },
- ////};
- //// return new UriIdentifier(GetFullUrl("/" + OPDefaultPage, args, useSsl));
- ////}
- internal static UriIdentifier GetIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion) {
- return GetIdentityUrl(scenario, providerVersion, false);
- }
- internal static UriIdentifier GetIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion, bool useSsl) {
- return new UriIdentifier(GetFullUrl("/" + identityPage, new Dictionary<string, string> {
- { "user", scenario.ToString() },
- { "version", providerVersion.ToString() },
- }, useSsl));
- }
- ////internal static UriIdentifier GetDirectedIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion) {
- //// return GetDirectedIdentityUrl(scenario, providerVersion, false);
- ////}
- ////internal static UriIdentifier GetDirectedIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion, bool useSsl) {
- //// return new UriIdentifier(GetFullUrl("/" + directedIdentityPage, new Dictionary<string, string> {
- //// { "user", scenario.ToString() },
- //// { "version", providerVersion.ToString() },
- ////}, useSsl));
- ////}
public static Identifier GetDelegateUrl(Scenarios scenario) {
return GetDelegateUrl(scenario, false);
}
+
public static Identifier GetDelegateUrl(Scenarios scenario, bool useSsl) {
return new UriIdentifier(GetFullUrl("/" + scenario, null, useSsl));
}
- internal static MockIdentifier GetMockIdentifier(Scenarios scenario, MockHttpRequest mockRequest, ProtocolVersion providerVersion) {
- return GetMockIdentifier(scenario, mockRequest, providerVersion, false);
- }
- internal static MockIdentifier GetMockIdentifier(Scenarios scenario, MockHttpRequest mockRequest, ProtocolVersion providerVersion, bool useSsl) {
- ServiceEndpoint se = GetServiceEndpoint(scenario, providerVersion, 10, useSsl);
- return new MockIdentifier(GetIdentityUrl(scenario, providerVersion, useSsl), mockRequest, new ServiceEndpoint[] { se });
- }
- internal static ServiceEndpoint GetServiceEndpoint(Scenarios scenario, ProtocolVersion providerVersion, int servicePriority, bool useSsl) {
- return ServiceEndpoint.CreateForClaimedIdentifier(
- GetIdentityUrl(scenario, providerVersion, useSsl),
- GetDelegateUrl(scenario, useSsl),
- GetFullUrl("/" + ProviderPage, null, useSsl),
- new string[] { Protocol.Lookup(providerVersion).ClaimedIdentifierServiceTypeURI },
- servicePriority,
- 10);
- }
- ////internal static MockIdentifier GetMockOPIdentifier(Scenarios scenario, UriIdentifier expectedClaimedId) {
- //// return GetMockOPIdentifier(scenario, expectedClaimedId, false, false);
- ////}
- ////internal static MockIdentifier GetMockOPIdentifier(Scenarios scenario, UriIdentifier expectedClaimedId, bool useSslOpIdentifier, bool useSslProviderEndpoint) {
- //// var fields = new Dictionary<string, string> {
- //// { "user", scenario.ToString() },
- ////};
- //// Uri opEndpoint = GetFullUrl(DirectedProviderEndpoint, fields, useSslProviderEndpoint);
- //// Uri opIdentifier = GetOPIdentityUrl(scenario, useSslOpIdentifier);
- //// ServiceEndpoint se = ServiceEndpoint.CreateForProviderIdentifier(
- //// opIdentifier,
- //// opEndpoint,
- //// new string[] { Protocol.V20.OPIdentifierServiceTypeURI },
- //// 10,
- //// 10);
-
- //// // Register the Claimed Identifier that directed identity will choose so that RP
- //// // discovery on that identifier can be mocked up.
- //// MockHttpRequest.RegisterMockXrdsResponse(expectedClaimedId, se);
-
- //// return new MockIdentifier(opIdentifier, new ServiceEndpoint[] { se });
- ////}
+
public static Uri GetFullUrl(string url) {
return GetFullUrl(url, null, false);
}
+
public static Uri GetFullUrl(string url, string key, object value) {
return GetFullUrl(url, new Dictionary<string, string> {
{ key, value.ToString() },
}, false);
}
+
public static Uri GetFullUrl(string url, IDictionary<string, string> args, bool useSsl) {
Uri defaultUriBase = new Uri(useSsl ? "https://localhost/" : "http://localhost/");
Uri baseUri = UITestSupport.Host != null ? UITestSupport.Host.BaseUri : defaultUriBase;
@@ -154,12 +88,60 @@ namespace DotNetOpenAuth.Test.OpenId {
if (!path.StartsWith("/")) path = "/" + path;
path = "DotNetOpenAuth.Test.OpenId" + path.Replace('/', '.');
Stream resource = Assembly.GetExecutingAssembly().GetManifestResourceStream(path);
- if (resource == null) throw new ArgumentException();
+ if (resource == null) {
+ throw new ArgumentException();
+ }
using (StreamReader sr = new StreamReader(resource)) {
return sr.ReadToEnd();
}
}
+ ////internal static UriIdentifier GetOPIdentityUrl(Scenarios scenario, bool useSsl) {
+ //// var args = new Dictionary<string, string> {
+ //// { "user", scenario.ToString() },
+ ////};
+ //// return new UriIdentifier(GetFullUrl("/" + OPDefaultPage, args, useSsl));
+ ////}
+ internal static UriIdentifier GetIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion) {
+ return GetIdentityUrl(scenario, providerVersion, false);
+ }
+
+ internal static UriIdentifier GetIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion, bool useSsl) {
+ return new UriIdentifier(GetFullUrl("/" + IdentityPage, new Dictionary<string, string> {
+ { "user", scenario.ToString() },
+ { "version", providerVersion.ToString() },
+ }, useSsl));
+ }
+
+ internal static MockIdentifier GetMockIdentifier(Scenarios scenario, MockHttpRequest mockRequest, ProtocolVersion providerVersion) {
+ return GetMockIdentifier(scenario, mockRequest, providerVersion, false);
+ }
+
+ internal static MockIdentifier GetMockIdentifier(Scenarios scenario, MockHttpRequest mockRequest, ProtocolVersion providerVersion, bool useSsl) {
+ ServiceEndpoint se = GetServiceEndpoint(scenario, providerVersion, 10, useSsl);
+ return new MockIdentifier(GetIdentityUrl(scenario, providerVersion, useSsl), mockRequest, new ServiceEndpoint[] { se });
+ }
+
+ internal static ServiceEndpoint GetServiceEndpoint(Scenarios scenario, ProtocolVersion providerVersion, int servicePriority, bool useSsl) {
+ return ServiceEndpoint.CreateForClaimedIdentifier(
+ GetIdentityUrl(scenario, providerVersion, useSsl),
+ GetDelegateUrl(scenario, useSsl),
+ GetFullUrl("/" + ProviderPage, null, useSsl),
+ new string[] { Protocol.Lookup(providerVersion).ClaimedIdentifierServiceTypeURI },
+ servicePriority,
+ 10);
+ }
+
+ ////internal static UriIdentifier GetDirectedIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion) {
+ //// return GetDirectedIdentityUrl(scenario, providerVersion, false);
+ ////}
+ ////internal static UriIdentifier GetDirectedIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion, bool useSsl) {
+ //// return new UriIdentifier(GetFullUrl("/" + directedIdentityPage, new Dictionary<string, string> {
+ //// { "user", scenario.ToString() },
+ //// { "version", providerVersion.ToString() },
+ ////}, useSsl));
+ ////}
+
////internal static IRelyingPartyApplicationStore RelyingPartyStore;
////internal static IProviderAssociationStore ProviderStore;
/////// <summary>
@@ -360,5 +342,27 @@ namespace DotNetOpenAuth.Test.OpenId {
//// return DotNetOpenId.Provider.OpenIdProvider.HttpApplicationStore;
//// }
////}
+ ////internal static MockIdentifier GetMockOPIdentifier(Scenarios scenario, UriIdentifier expectedClaimedId) {
+ //// return GetMockOPIdentifier(scenario, expectedClaimedId, false, false);
+ ////}
+ ////internal static MockIdentifier GetMockOPIdentifier(Scenarios scenario, UriIdentifier expectedClaimedId, bool useSslOpIdentifier, bool useSslProviderEndpoint) {
+ //// var fields = new Dictionary<string, string> {
+ //// { "user", scenario.ToString() },
+ ////};
+ //// Uri opEndpoint = GetFullUrl(DirectedProviderEndpoint, fields, useSslProviderEndpoint);
+ //// Uri opIdentifier = GetOPIdentityUrl(scenario, useSslOpIdentifier);
+ //// ServiceEndpoint se = ServiceEndpoint.CreateForProviderIdentifier(
+ //// opIdentifier,
+ //// opEndpoint,
+ //// new string[] { Protocol.V20.OPIdentifierServiceTypeURI },
+ //// 10,
+ //// 10);
+
+ //// // Register the Claimed Identifier that directed identity will choose so that RP
+ //// // discovery on that identifier can be mocked up.
+ //// MockHttpRequest.RegisterMockXrdsResponse(expectedClaimedId, se);
+
+ //// return new MockIdentifier(opIdentifier, new ServiceEndpoint[] { se });
+ ////}
}
} \ No newline at end of file
diff --git a/src/DotNetOpenAuth.Test/OpenId/UI/UITestSupport.cs b/src/DotNetOpenAuth.Test/OpenId/UI/UITestSupport.cs
index da18fa9..92008ad 100644
--- a/src/DotNetOpenAuth.Test/OpenId/UI/UITestSupport.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/UI/UITestSupport.cs
@@ -1,4 +1,10 @@
-namespace DotNetOAuth.Test.OpenId.UI {
+//-----------------------------------------------------------------------
+// <copyright file="UITestSupport.cs" company="Andrew Arnott">
+// Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOAuth.Test.OpenId.UI {
using DotNetOpenAuth.Test.Hosting;
////[SetUpFixture]
diff --git a/src/DotNetOpenAuth.Test/OpenId/UriIdentifierTests.cs b/src/DotNetOpenAuth.Test/OpenId/UriIdentifierTests.cs
index f9b54b4..1dfb173 100644
--- a/src/DotNetOpenAuth.Test/OpenId/UriIdentifierTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/UriIdentifierTests.cs
@@ -9,17 +9,16 @@ namespace DotNetOpenAuth.Test.OpenId {
using System.Linq;
using System.Net;
using System.Web;
+ using DotNetOpenAuth.Messaging;
+ using DotNetOpenAuth.OpenId;
using DotNetOpenAuth.OpenId.RelyingParty;
- using DotNetOpenAuth.Test.Mocks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
- using DotNetOpenAuth.OpenId;
- using DotNetOpenAuth.Messaging;
[TestClass]
public class UriIdentifierTests : OpenIdTestBase {
- string goodUri = "http://blog.nerdbank.net/";
- string relativeUri = "host/path";
- string badUri = "som%-)830w8vf/?.<>,ewackedURI";
+ private string goodUri = "http://blog.nerdbank.net/";
+ private string relativeUri = "host/path";
+ private string badUri = "som%-)830w8vf/?.<>,ewackedURI";
[TestInitialize]
public override void SetUp() {
@@ -43,13 +42,13 @@ namespace DotNetOpenAuth.Test.OpenId {
[TestMethod, ExpectedException(typeof(UriFormatException))]
public void CtorBadUri() {
- new UriIdentifier(badUri);
+ new UriIdentifier(this.badUri);
}
[TestMethod]
public void CtorGoodUri() {
- var uri = new UriIdentifier(goodUri);
- Assert.AreEqual(new Uri(goodUri), uri.Uri);
+ var uri = new UriIdentifier(this.goodUri);
+ Assert.AreEqual(new Uri(this.goodUri), uri.Uri);
Assert.IsFalse(uri.SchemeImplicitlyPrepended);
Assert.IsFalse(uri.IsDiscoverySecureEndToEnd);
}
@@ -102,8 +101,8 @@ namespace DotNetOpenAuth.Test.OpenId {
[TestMethod]
public void IsValid() {
- Assert.IsTrue(UriIdentifier.IsValidUri(goodUri));
- Assert.IsFalse(UriIdentifier.IsValidUri(badUri));
+ Assert.IsTrue(UriIdentifier.IsValidUri(this.goodUri));
+ Assert.IsFalse(UriIdentifier.IsValidUri(this.badUri));
Assert.IsTrue(UriIdentifier.IsValidUri(relativeUri), "URL lacking http:// prefix should have worked anyway.");
}
@@ -117,17 +116,17 @@ namespace DotNetOpenAuth.Test.OpenId {
[TestMethod]
public void ToStringTest() {
- Assert.AreEqual(goodUri, new UriIdentifier(goodUri).ToString());
+ Assert.AreEqual(this.goodUri, new UriIdentifier(this.goodUri).ToString());
}
[TestMethod]
public void EqualsTest() {
- Assert.AreEqual(new UriIdentifier(goodUri), new UriIdentifier(goodUri));
+ Assert.AreEqual(new UriIdentifier(this.goodUri), new UriIdentifier(this.goodUri));
// This next test is an interesting side-effect of passing off to Uri.Equals. But it's probably ok.
- Assert.AreEqual(new UriIdentifier(goodUri), new UriIdentifier(goodUri + "#frag"));
- Assert.AreNotEqual(new UriIdentifier(goodUri), new UriIdentifier(goodUri + "a"));
- Assert.AreNotEqual(null, new UriIdentifier(goodUri));
- Assert.AreEqual(goodUri, new UriIdentifier(goodUri));
+ Assert.AreEqual(new UriIdentifier(this.goodUri), new UriIdentifier(this.goodUri + "#frag"));
+ Assert.AreNotEqual(new UriIdentifier(this.goodUri), new UriIdentifier(this.goodUri + "a"));
+ Assert.AreNotEqual(null, new UriIdentifier(this.goodUri));
+ Assert.AreEqual(this.goodUri, new UriIdentifier(this.goodUri));
}
[TestMethod]
@@ -140,113 +139,54 @@ namespace DotNetOpenAuth.Test.OpenId {
Assert.AreEqual(Uri.EscapeUriString(unicodeUrl), id.ToString());
}
- void discover(string url, ProtocolVersion version, Identifier expectedLocalId, bool expectSreg, bool useRedirect) {
- discover(url, version, expectedLocalId, expectSreg, useRedirect, null);
- }
- void discover(string url, ProtocolVersion version, Identifier expectedLocalId, bool expectSreg, bool useRedirect, WebHeaderCollection headers) {
- Protocol protocol = Protocol.Lookup(version);
- UriIdentifier claimedId = TestSupport.GetFullUrl(url);
- UriIdentifier userSuppliedIdentifier = TestSupport.GetFullUrl(
- "Discovery/htmldiscovery/redirect.aspx?target=" + url);
- if (expectedLocalId == null) expectedLocalId = claimedId;
- Identifier idToDiscover = useRedirect ? userSuppliedIdentifier : claimedId;
-
- string contentType;
- if (url.EndsWith("html")) {
- contentType = "text/html";
- } else if (url.EndsWith("xml")) {
- contentType = "application/xrds+xml";
- } else {
- throw new InvalidOperationException();
- }
- this.mockResponder.RegisterMockResponse(new Uri(idToDiscover), claimedId, contentType,
- headers ?? new WebHeaderCollection(), TestSupport.LoadEmbeddedFile(url));
-
- ServiceEndpoint se = idToDiscover.Discover(this.requestHandler).FirstOrDefault();
- Assert.IsNotNull(se, url + " failed to be discovered.");
- Assert.AreSame(protocol, se.Protocol);
- Assert.AreEqual(claimedId, se.ClaimedIdentifier);
- Assert.AreEqual(expectedLocalId, se.ProviderLocalIdentifier);
- Assert.AreEqual(expectSreg ? 2 : 1, se.ProviderSupportedServiceTypeUris.Length);
- Assert.IsTrue(Array.IndexOf(se.ProviderSupportedServiceTypeUris, protocol.ClaimedIdentifierServiceTypeURI) >= 0);
-
- // TODO: re-enable this line once extensions support is added back in.
- ////Assert.AreEqual(expectSreg, se.IsExtensionSupported(new ClaimsRequest()));
- }
- void discoverXrds(string page, ProtocolVersion version, Identifier expectedLocalId) {
- discoverXrds(page, version, expectedLocalId, null);
- }
- void discoverXrds(string page, ProtocolVersion version, Identifier expectedLocalId, WebHeaderCollection headers) {
- if (!page.Contains(".")) page += ".xml";
- discover("/Discovery/xrdsdiscovery/" + page, version, expectedLocalId, true, false, headers);
- discover("/Discovery/xrdsdiscovery/" + page, version, expectedLocalId, true, true, headers);
- }
- void discoverHtml(string page, ProtocolVersion version, Identifier expectedLocalId, bool useRedirect) {
- discover("/Discovery/htmldiscovery/" + page, version, expectedLocalId, false, useRedirect);
- }
- void discoverHtml(string scenario, ProtocolVersion version, Identifier expectedLocalId) {
- string page = scenario + ".html";
- discoverHtml(page, version, expectedLocalId, false);
- discoverHtml(page, version, expectedLocalId, true);
- }
- void failDiscover(string url) {
- UriIdentifier userSuppliedId = TestSupport.GetFullUrl(url);
-
- this.mockResponder.RegisterMockResponse(new Uri(userSuppliedId), userSuppliedId, "text/html",
- TestSupport.LoadEmbeddedFile(url));
-
- Assert.AreEqual(0, userSuppliedId.Discover(this.requestHandler).Count()); // ... but that no endpoint info is discoverable
- }
- void failDiscoverHtml(string scenario) {
- failDiscover("/Discovery/htmldiscovery/" + scenario + ".html");
- }
- void failDiscoverXrds(string scenario) {
- failDiscover("/Discovery/xrdsdiscovery/" + scenario + ".xml");
- }
[TestMethod]
public void HtmlDiscover_11() {
- discoverHtml("html10prov", ProtocolVersion.V11, null);
- discoverHtml("html10both", ProtocolVersion.V11, "http://c/d");
- failDiscoverHtml("html10del");
+ this.DiscoverHtml("html10prov", ProtocolVersion.V11, null);
+ this.DiscoverHtml("html10both", ProtocolVersion.V11, "http://c/d");
+ this.FailDiscoverHtml("html10del");
}
+
[TestMethod]
public void HtmlDiscover_20() {
- discoverHtml("html20prov", ProtocolVersion.V20, null);
- discoverHtml("html20both", ProtocolVersion.V20, "http://c/d");
- failDiscoverHtml("html20del");
- discoverHtml("html2010", ProtocolVersion.V20, "http://c/d");
- discoverHtml("html1020", ProtocolVersion.V20, "http://c/d");
- discoverHtml("html2010combinedA", ProtocolVersion.V20, "http://c/d");
- discoverHtml("html2010combinedB", ProtocolVersion.V20, "http://c/d");
- discoverHtml("html2010combinedC", ProtocolVersion.V20, "http://c/d");
- failDiscoverHtml("html20relative");
+ this.DiscoverHtml("html20prov", ProtocolVersion.V20, null);
+ this.DiscoverHtml("html20both", ProtocolVersion.V20, "http://c/d");
+ this.FailDiscoverHtml("html20del");
+ this.DiscoverHtml("html2010", ProtocolVersion.V20, "http://c/d");
+ this.DiscoverHtml("html1020", ProtocolVersion.V20, "http://c/d");
+ this.DiscoverHtml("html2010combinedA", ProtocolVersion.V20, "http://c/d");
+ this.DiscoverHtml("html2010combinedB", ProtocolVersion.V20, "http://c/d");
+ this.DiscoverHtml("html2010combinedC", ProtocolVersion.V20, "http://c/d");
+ this.FailDiscoverHtml("html20relative");
}
+
[TestMethod]
public void XrdsDiscoveryFromHead() {
this.mockResponder.RegisterMockResponse(new Uri("http://localhost/xrds1020.xml"),
"application/xrds+xml", TestSupport.LoadEmbeddedFile("/Discovery/xrdsdiscovery/xrds1020.xml"));
- discoverXrds("XrdsReferencedInHead.html", ProtocolVersion.V10, null);
+ this.DiscoverXrds("XrdsReferencedInHead.html", ProtocolVersion.V10, null);
}
+
[TestMethod]
public void XrdsDiscoveryFromHttpHeader() {
WebHeaderCollection headers = new WebHeaderCollection();
headers.Add("X-XRDS-Location", TestSupport.GetFullUrl("http://localhost/xrds1020.xml").AbsoluteUri);
- this.mockResponder.RegisterMockResponse(new Uri("http://localhost/xrds1020.xml"),
- "application/xrds+xml", TestSupport.LoadEmbeddedFile("/Discovery/xrdsdiscovery/xrds1020.xml"));
- discoverXrds("XrdsReferencedInHttpHeader.html", ProtocolVersion.V10, null, headers);
+ this.mockResponder.RegisterMockResponse(new Uri("http://localhost/xrds1020.xml"), "application/xrds+xml", TestSupport.LoadEmbeddedFile("/Discovery/xrdsdiscovery/xrds1020.xml"));
+ this.DiscoverXrds("XrdsReferencedInHttpHeader.html", ProtocolVersion.V10, null, headers);
}
+
[TestMethod]
public void XrdsDirectDiscovery_10() {
- failDiscoverXrds("xrds-irrelevant");
- discoverXrds("xrds10", ProtocolVersion.V10, null);
- discoverXrds("xrds11", ProtocolVersion.V11, null);
- discoverXrds("xrds1020", ProtocolVersion.V10, null);
+ this.FailDiscoverXrds("xrds-irrelevant");
+ this.DiscoverXrds("xrds10", ProtocolVersion.V10, null);
+ this.DiscoverXrds("xrds11", ProtocolVersion.V11, null);
+ this.DiscoverXrds("xrds1020", ProtocolVersion.V10, null);
}
+
[TestMethod]
public void XrdsDirectDiscovery_20() {
- discoverXrds("xrds20", ProtocolVersion.V20, null);
- discoverXrds("xrds2010a", ProtocolVersion.V20, null);
- discoverXrds("xrds2010b", ProtocolVersion.V20, null);
+ this.DiscoverXrds("xrds20", ProtocolVersion.V20, null);
+ this.DiscoverXrds("xrds2010a", ProtocolVersion.V20, null);
+ this.DiscoverXrds("xrds2010b", ProtocolVersion.V20, null);
}
[TestMethod]
@@ -354,8 +294,7 @@ namespace DotNetOpenAuth.Test.OpenId {
var insecureXrdsSource = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, this.mockResponder, ProtocolVersion.V20, false);
Uri secureClaimedUri = TestSupport.GetFullUrl("/secureId", null, true);
- string html = string.Format("<html><head><meta http-equiv='X-XRDS-Location' content='{0}'/></head><body></body></html>",
- insecureXrdsSource);
+ string html = string.Format("<html><head><meta http-equiv='X-XRDS-Location' content='{0}'/></head><body></body></html>", insecureXrdsSource);
this.mockResponder.RegisterMockResponse(secureClaimedUri, "text/html", html);
Identifier userSuppliedIdentifier = new UriIdentifier(secureClaimedUri, true);
@@ -406,5 +345,77 @@ namespace DotNetOpenAuth.Test.OpenId {
this.mockResponder.RegisterMockXrdsResponse(secureClaimedId, new ServiceEndpoint[] { insecureEndpoint, secureEndpoint });
Assert.AreEqual(secureEndpoint.ProviderLocalIdentifier, secureClaimedId.Discover(this.requestHandler).Single().ProviderLocalIdentifier);
}
+
+ private void Discover(string url, ProtocolVersion version, Identifier expectedLocalId, bool expectSreg, bool useRedirect) {
+ this.Discover(url, version, expectedLocalId, expectSreg, useRedirect, null);
+ }
+
+ private void Discover(string url, ProtocolVersion version, Identifier expectedLocalId, bool expectSreg, bool useRedirect, WebHeaderCollection headers) {
+ Protocol protocol = Protocol.Lookup(version);
+ UriIdentifier claimedId = TestSupport.GetFullUrl(url);
+ UriIdentifier userSuppliedIdentifier = TestSupport.GetFullUrl(
+ "Discovery/htmldiscovery/redirect.aspx?target=" + url);
+ if (expectedLocalId == null) {
+ expectedLocalId = claimedId;
+ }
+ Identifier idToDiscover = useRedirect ? userSuppliedIdentifier : claimedId;
+
+ string contentType;
+ if (url.EndsWith("html")) {
+ contentType = "text/html";
+ } else if (url.EndsWith("xml")) {
+ contentType = "application/xrds+xml";
+ } else {
+ throw new InvalidOperationException();
+ }
+ this.mockResponder.RegisterMockResponse(new Uri(idToDiscover), claimedId, contentType, headers ?? new WebHeaderCollection(), TestSupport.LoadEmbeddedFile(url));
+
+ ServiceEndpoint se = idToDiscover.Discover(this.requestHandler).FirstOrDefault();
+ Assert.IsNotNull(se, url + " failed to be discovered.");
+ Assert.AreSame(protocol, se.Protocol);
+ Assert.AreEqual(claimedId, se.ClaimedIdentifier);
+ Assert.AreEqual(expectedLocalId, se.ProviderLocalIdentifier);
+ Assert.AreEqual(expectSreg ? 2 : 1, se.ProviderSupportedServiceTypeUris.Length);
+ Assert.IsTrue(Array.IndexOf(se.ProviderSupportedServiceTypeUris, protocol.ClaimedIdentifierServiceTypeURI) >= 0);
+
+ // TODO: re-enable this line once extensions support is added back in.
+ ////Assert.AreEqual(expectSreg, se.IsExtensionSupported(new ClaimsRequest()));
+ }
+
+ private void DiscoverXrds(string page, ProtocolVersion version, Identifier expectedLocalId) {
+ this.DiscoverXrds(page, version, expectedLocalId, null);
+ }
+
+ private void DiscoverXrds(string page, ProtocolVersion version, Identifier expectedLocalId, WebHeaderCollection headers) {
+ if (!page.Contains(".")) page += ".xml";
+ this.Discover("/Discovery/xrdsdiscovery/" + page, version, expectedLocalId, true, false, headers);
+ this.Discover("/Discovery/xrdsdiscovery/" + page, version, expectedLocalId, true, true, headers);
+ }
+
+ private void DiscoverHtml(string page, ProtocolVersion version, Identifier expectedLocalId, bool useRedirect) {
+ this.Discover("/Discovery/htmldiscovery/" + page, version, expectedLocalId, false, useRedirect);
+ }
+
+ private void DiscoverHtml(string scenario, ProtocolVersion version, Identifier expectedLocalId) {
+ string page = scenario + ".html";
+ this.DiscoverHtml(page, version, expectedLocalId, false);
+ this.DiscoverHtml(page, version, expectedLocalId, true);
+ }
+
+ private void FailDiscover(string url) {
+ UriIdentifier userSuppliedId = TestSupport.GetFullUrl(url);
+
+ this.mockResponder.RegisterMockResponse(new Uri(userSuppliedId), userSuppliedId, "text/html", TestSupport.LoadEmbeddedFile(url));
+
+ Assert.AreEqual(0, userSuppliedId.Discover(this.requestHandler).Count()); // ... but that no endpoint info is discoverable
+ }
+
+ private void FailDiscoverHtml(string scenario) {
+ this.FailDiscover("/Discovery/htmldiscovery/" + scenario + ".html");
+ }
+
+ private void FailDiscoverXrds(string scenario) {
+ this.FailDiscover("/Discovery/xrdsdiscovery/" + scenario + ".xml");
+ }
}
}
diff --git a/src/DotNetOpenAuth.Test/OpenId/XriIdentifierTests.cs b/src/DotNetOpenAuth.Test/OpenId/XriIdentifierTests.cs
index 5f85f28..4d349ff 100644
--- a/src/DotNetOpenAuth.Test/OpenId/XriIdentifierTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/XriIdentifierTests.cs
@@ -1,17 +1,21 @@
-namespace DotNetOpenAuth.Test.OpenId {
+//-----------------------------------------------------------------------
+// <copyright file="XriIdentifierTests.cs" company="Andrew Arnott">
+// Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.Test.OpenId {
using System;
using System.Collections.Generic;
using System.Linq;
+ using DotNetOpenAuth.OpenId;
using DotNetOpenAuth.OpenId.RelyingParty;
- using DotNetOpenAuth.Test.Mocks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
- using DotNetOpenAuth.OpenId;
- using DotNetOpenAuth.Messaging;
[TestClass]
public class XriIdentifierTests : OpenIdTestBase {
- string goodXri = "=Andrew*Arnott";
- string badXri = "some\\wacky%^&*()non-XRI";
+ private string goodXri = "=Andrew*Arnott";
+ private string badXri = "some\\wacky%^&*()non-XRI";
[TestInitialize]
public override void SetUp() {
@@ -30,29 +34,29 @@
[TestMethod, ExpectedException(typeof(FormatException))]
public void CtorBadXri() {
- new XriIdentifier(badXri);
+ new XriIdentifier(this.badXri);
}
[TestMethod]
public void CtorGoodXri() {
- var xri = new XriIdentifier(goodXri);
- Assert.AreEqual(goodXri, xri.OriginalXri);
- Assert.AreEqual(goodXri, xri.CanonicalXri); // assumes 'goodXri' is canonical already
+ var xri = new XriIdentifier(this.goodXri);
+ Assert.AreEqual(this.goodXri, xri.OriginalXri);
+ Assert.AreEqual(this.goodXri, xri.CanonicalXri); // assumes 'goodXri' is canonical already
Assert.IsFalse(xri.IsDiscoverySecureEndToEnd);
}
[TestMethod]
public void CtorGoodXriSecure() {
- var xri = new XriIdentifier(goodXri, true);
- Assert.AreEqual(goodXri, xri.OriginalXri);
- Assert.AreEqual(goodXri, xri.CanonicalXri); // assumes 'goodXri' is canonical already
+ var xri = new XriIdentifier(this.goodXri, true);
+ Assert.AreEqual(this.goodXri, xri.OriginalXri);
+ Assert.AreEqual(this.goodXri, xri.CanonicalXri); // assumes 'goodXri' is canonical already
Assert.IsTrue(xri.IsDiscoverySecureEndToEnd);
}
[TestMethod]
public void IsValid() {
- Assert.IsTrue(XriIdentifier.IsValidXri(goodXri));
- Assert.IsFalse(XriIdentifier.IsValidXri(badXri));
+ Assert.IsTrue(XriIdentifier.IsValidXri(this.goodXri));
+ Assert.IsFalse(XriIdentifier.IsValidXri(this.badXri));
}
/// <summary>
@@ -60,40 +64,28 @@
/// </summary>
[TestMethod]
public void StripXriScheme() {
- var xri = new XriIdentifier("xri://" + goodXri);
- Assert.AreEqual("xri://" + goodXri, xri.OriginalXri);
- Assert.AreEqual(goodXri, xri.CanonicalXri);
+ var xri = new XriIdentifier("xri://" + this.goodXri);
+ Assert.AreEqual("xri://" + this.goodXri, xri.OriginalXri);
+ Assert.AreEqual(this.goodXri, xri.CanonicalXri);
}
[TestMethod]
public void TrimFragment() {
- Identifier xri = new XriIdentifier(goodXri);
+ Identifier xri = new XriIdentifier(this.goodXri);
Assert.AreSame(xri, xri.TrimFragment());
}
[TestMethod]
public void ToStringTest() {
- Assert.AreEqual(goodXri, new XriIdentifier(goodXri).ToString());
+ Assert.AreEqual(this.goodXri, new XriIdentifier(this.goodXri).ToString());
}
[TestMethod]
public void EqualsTest() {
- Assert.AreEqual(new XriIdentifier(goodXri), new XriIdentifier(goodXri));
- Assert.AreNotEqual(new XriIdentifier(goodXri), new XriIdentifier(goodXri + "a"));
- Assert.AreNotEqual(null, new XriIdentifier(goodXri));
- Assert.AreEqual(goodXri, new XriIdentifier(goodXri));
- }
-
- private ServiceEndpoint verifyCanonicalId(Identifier iname, string expectedClaimedIdentifier) {
- ServiceEndpoint se = iname.Discover(this.requestHandler).FirstOrDefault();
- if (expectedClaimedIdentifier != null) {
- Assert.IsNotNull(se);
- Assert.AreEqual(expectedClaimedIdentifier, se.ClaimedIdentifier.ToString(), "i-name {0} discovery resulted in unexpected CanonicalId", iname);
- Assert.IsTrue(se.ProviderSupportedServiceTypeUris.Length > 0);
- } else {
- Assert.IsNull(se);
- }
- return se;
+ Assert.AreEqual(new XriIdentifier(this.goodXri), new XriIdentifier(this.goodXri));
+ Assert.AreNotEqual(new XriIdentifier(this.goodXri), new XriIdentifier(this.goodXri + "a"));
+ Assert.AreNotEqual(null, new XriIdentifier(this.goodXri));
+ Assert.AreEqual(this.goodXri, new XriIdentifier(this.goodXri));
}
[TestMethod]
@@ -136,7 +128,7 @@
this.mockResponder.RegisterMockXrdsResponses(mocks);
string expectedCanonicalId = "=!9B72.7DD1.50A9.5CCD";
- ServiceEndpoint se = verifyCanonicalId("=Arnott", expectedCanonicalId);
+ ServiceEndpoint se = this.VerifyCanonicalId("=Arnott", expectedCanonicalId);
Assert.AreEqual(Protocol.V10, se.Protocol);
Assert.AreEqual("http://1id.com/sso", se.ProviderEndpoint.ToString());
Assert.AreEqual(se.ClaimedIdentifier, se.ProviderLocalIdentifier);
@@ -366,11 +358,11 @@ uEyb50RJ7DWmXctSC0b3eymZ2lSXxAWNOsNy
{ "https://xri.net/@llli*area*canada.unattached*ada?_xrd_r=application/xrd%2Bxml;sep=false", llliAreaCanadaUnattachedAdaResponse },
{ "https://xri.net/=Web?_xrd_r=application/xrd%2Bxml;sep=false", webResponse },
});
- verifyCanonicalId("@llli", "@!72CD.A072.157E.A9C6");
- verifyCanonicalId("@llli*area", "@!72CD.A072.157E.A9C6!0000.0000.3B9A.CA0C");
- verifyCanonicalId("@llli*area*canada.unattached", "@!72CD.A072.157E.A9C6!0000.0000.3B9A.CA0C!0000.0000.3B9A.CA41");
- verifyCanonicalId("@llli*area*canada.unattached*ada", "@!72CD.A072.157E.A9C6!0000.0000.3B9A.CA0C!0000.0000.3B9A.CA41!0000.0000.3B9A.CA01");
- verifyCanonicalId("=Web", "=!91F2.8153.F600.AE24");
+ this.VerifyCanonicalId("@llli", "@!72CD.A072.157E.A9C6");
+ this.VerifyCanonicalId("@llli*area", "@!72CD.A072.157E.A9C6!0000.0000.3B9A.CA0C");
+ this.VerifyCanonicalId("@llli*area*canada.unattached", "@!72CD.A072.157E.A9C6!0000.0000.3B9A.CA0C!0000.0000.3B9A.CA41");
+ this.VerifyCanonicalId("@llli*area*canada.unattached*ada", "@!72CD.A072.157E.A9C6!0000.0000.3B9A.CA0C!0000.0000.3B9A.CA41!0000.0000.3B9A.CA01");
+ this.VerifyCanonicalId("=Web", "=!91F2.8153.F600.AE24");
}
[TestMethod]
@@ -456,8 +448,8 @@ uEyb50RJ7DWmXctSC0b3eymZ2lSXxAWNOsNy
});
// Consistent with spec section 7.3.2.3, we do not permit
// delegation on XRI discovery when there is no CanonicalID present.
- verifyCanonicalId("=Web*andrew.arnott", null);
- verifyCanonicalId("@id*andrewarnott", null);
+ this.VerifyCanonicalId("=Web*andrew.arnott", null);
+ this.VerifyCanonicalId("@id*andrewarnott", null);
}
////[TestMethod, Ignore("XRI parsing and normalization is not implemented (yet).")]
@@ -465,5 +457,17 @@ uEyb50RJ7DWmXctSC0b3eymZ2lSXxAWNOsNy
Identifier id = "=!9B72.7dd1.50a9.5ccd";
Assert.AreEqual("=!9B72.7DD1.50A9.5CCD", id.ToString());
}
+
+ private ServiceEndpoint VerifyCanonicalId(Identifier iname, string expectedClaimedIdentifier) {
+ ServiceEndpoint se = iname.Discover(this.requestHandler).FirstOrDefault();
+ if (expectedClaimedIdentifier != null) {
+ Assert.IsNotNull(se);
+ Assert.AreEqual(expectedClaimedIdentifier, se.ClaimedIdentifier.ToString(), "i-name {0} discovery resulted in unexpected CanonicalId", iname);
+ Assert.IsTrue(se.ProviderSupportedServiceTypeUris.Length > 0);
+ } else {
+ Assert.IsNull(se);
+ }
+ return se;
+ }
}
}
generated by cgit v1.1 at 2025-06-05 05:04:23 +0000