summaryrefslogtreecommitdiffstats
path: root/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs
diff options
context:
space:
mode:
Diffstat (limited to 'src/DotNetOpenAuth.Test/OpenId/TestSupport.cs')
-rw-r--r--src/DotNetOpenAuth.Test/OpenId/TestSupport.cs440
1 files changed, 0 insertions, 440 deletions
diff --git a/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs b/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs
deleted file mode 100644
index 5223c12..0000000
--- a/src/DotNetOpenAuth.Test/OpenId/TestSupport.cs
+++ /dev/null
@@ -1,440 +0,0 @@
-//-----------------------------------------------------------------------
-// <copyright file="TestSupport.cs" company="Andrew Arnott">
-// Copyright (c) Andrew Arnott. All rights reserved.
-// </copyright>
-//-----------------------------------------------------------------------
-
-namespace DotNetOpenAuth.Test.OpenId {
- using System;
- using System.Collections.Generic;
- using System.IO;
- using System.Reflection;
- using DotNetOpenAuth.Messaging;
- using DotNetOpenAuth.OpenId;
- using DotNetOpenAuth.OpenId.Provider;
- using DotNetOpenAuth.OpenId.RelyingParty;
- using DotNetOpenAuth.Test.Mocks;
- ////using DotNetOpenAuth.Test.UI;
- using log4net;
-
- public class TestSupport {
- public const string HostTestPage = "HostTest.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 const string OPDefaultPage = "OPDefault.aspx";
-
- public static readonly ILog Logger = LogManager.GetLogger("DotNetOpenId.Test");
-
- public static readonly string TestWebDirectory = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), @"..\..\..\..\src\DotNetOpenAuth.TestWeb"));
-
- private const string IdentityPage = "IdentityEndpoint.aspx";
-
- private const string DirectedIdentityPage = "DirectedIdentityEndpoint.aspx";
-
- public enum Scenarios {
- // Authentication test scenarios
- AutoApproval,
-
- AutoApprovalAddFragment,
-
- ApproveOnSetup,
-
- AlwaysDeny,
-
- /* Extension test scenarios */
-
- /// <summary>
- /// Provides all required and requested fields.
- /// </summary>
- ExtensionFullCooperation,
-
- /// <summary>
- /// Provides only those fields marked as required.
- /// </summary>
- ExtensionPartialCooperation,
- }
-
- public static Uri ReturnTo {
- get { return TestSupport.GetFullUrl(TestSupport.ConsumerPage); }
- }
-
- public static Realm Realm {
- get { return new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri); }
- }
-
- 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));
- }
-
- public static Uri GetFullUrl(string url) {
- return GetFullUrl(url, null, false);
- }
-
- public static Uri GetFullUrl(string url, string key, object value) {
- var dictionary = new Dictionary<string, string> {
- { key, value.ToString() },
- };
- return GetFullUrl(url, dictionary, 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;
- UriBuilder builder = new UriBuilder(new Uri(baseUri, url));
- MessagingUtilities.AppendQueryArgs(builder, args);
- return builder.Uri;
- }
-
- /// <summary>
- /// Returns the content of a given embedded resource.
- /// </summary>
- /// <param name="path">The path of the file as it appears within the project,
- /// where the leading / marks the root directory of the project.</param>
- /// <returns>The content of the requested resource.</returns>
- internal static string LoadEmbeddedFile(string path) {
- if (!path.StartsWith("/")) {
- path = "/" + path;
- }
- path = "DotNetOpenAuth.Test.OpenId" + path.Replace('/', '.');
- Stream resource = Assembly.GetExecutingAssembly().GetManifestResourceStream(path);
- 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) {
- var dictionary = new Dictionary<string, string> {
- { "user", scenario.ToString() },
- { "version", providerVersion.ToString() },
- };
- return new UriIdentifier(GetFullUrl("/" + IdentityPage, dictionary, 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) {
- var providerEndpoint = new ProviderEndpointDescription(GetFullUrl("/" + ProviderPage, null, useSsl), new string[] { Protocol.Lookup(providerVersion).ClaimedIdentifierServiceTypeURI });
- return ServiceEndpoint.CreateForClaimedIdentifier(
- GetIdentityUrl(scenario, providerVersion, useSsl),
- GetIdentityUrl(scenario, providerVersion, useSsl),
- GetDelegateUrl(scenario, useSsl),
- providerEndpoint,
- servicePriority,
- 10);
- }
-
- /// <summary>
- /// A default implementation of a simple provider that responds to authentication requests
- /// per the scenario that is being simulated.
- /// </summary>
- /// <param name="provider">The OpenIdProvider on which the process messages.</param>
- /// <remarks>
- /// This is a very useful method to pass to the OpenIdCoordinator constructor for the Provider argument.
- /// </remarks>
- internal static void AutoProvider(OpenIdProvider provider) {
- IRequest request;
- while ((request = provider.GetRequest()) != null) {
- if (!request.IsResponseReady) {
- var authRequest = (DotNetOpenAuth.OpenId.Provider.IAuthenticationRequest)request;
- var scenario = (Scenarios)Enum.Parse(typeof(Scenarios), new Uri(authRequest.LocalIdentifier).AbsolutePath.TrimStart('/'));
- switch (scenario) {
- case TestSupport.Scenarios.AutoApproval:
- authRequest.IsAuthenticated = true;
- break;
- case Scenarios.AutoApprovalAddFragment:
- authRequest.SetClaimedIdentifierFragment("frag");
- authRequest.IsAuthenticated = true;
- break;
- case TestSupport.Scenarios.ApproveOnSetup:
- authRequest.IsAuthenticated = !authRequest.Immediate;
- break;
- case Scenarios.AlwaysDeny:
- authRequest.IsAuthenticated = false;
- break;
- default:
- // All other scenarios are done programmatically only.
- throw new InvalidOperationException("Unrecognized scenario");
- }
- }
-
- request.Response.Send();
- }
- }
-
- /// <summary>
- /// Forces storage of an association in an RP's association store.
- /// </summary>
- /// <param name="relyingParty">The relying party.</param>
- /// <param name="providerEndpoint">The provider endpoint.</param>
- /// <param name="association">The association.</param>
- internal static void StoreAssociation(OpenIdRelyingParty relyingParty, Uri providerEndpoint, Association association) {
- var associationManagerAccessor = AssociationManager_Accessor.AttachShadow(relyingParty.AssociationManager);
- associationManagerAccessor.associationStore.StoreAssociation(providerEndpoint, association);
- }
-
- ////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>
- /////// Generates a new, stateful <see cref="OpenIdRelyingParty"/> whose direct messages
- /////// will be automatically handled by an internal <see cref="OpenIdProvider"/>
- /////// that uses the shared <see cref="ProviderStore"/>.
- /////// </summary>
- ////internal static OpenIdRelyingParty CreateRelyingParty(NameValueCollection fields) {
- //// return CreateRelyingParty(RelyingPartyStore, null, fields);
- ////}
- ////internal static OpenIdRelyingParty CreateRelyingParty(IRelyingPartyApplicationStore store, NameValueCollection fields) {
- //// return CreateRelyingParty(store, null, fields);
- ////}
- /////// <summary>
- /////// Generates a new <see cref="OpenIdRelyingParty"/> whose direct messages
- /////// will be automatically handled by an internal <see cref="OpenIdProvider"/>
- /////// that uses the shared <see cref="ProviderStore"/>.
- /////// </summary>
- ////internal static OpenIdRelyingParty CreateRelyingParty(IRelyingPartyApplicationStore store, Uri requestUrl, NameValueCollection fields) {
- //// var rp = new OpenIdRelyingParty(store, requestUrl ?? GetFullUrl(ConsumerPage), fields ?? new NameValueCollection());
- //// if (fields == null || fields.Count == 0) {
- //// Assert.IsNull(rp.Response);
- //// }
- //// rp.DirectMessageChannel = new DirectMessageTestRedirector(ProviderStore);
- //// return rp;
- ////}
- ////internal static DotNetOpenId.RelyingParty.IAuthenticationRequest CreateRelyingPartyRequest(bool stateless, Scenarios scenario, ProtocolVersion version, bool useSsl) {
- //// // Publish RP discovery information
- //// MockHttpRequest.RegisterMockRPDiscovery();
-
- //// var rp = TestSupport.CreateRelyingParty(stateless ? null : RelyingPartyStore, null);
- //// var rpReq = rp.CreateRequest(TestSupport.GetMockIdentifier(scenario, version, useSsl), Realm, ReturnTo);
-
- //// // Sidetrack: verify URLs and other default properties
- //// {
- //// Assert.AreEqual(AuthenticationRequestMode.Setup, rpReq.Mode);
- //// Assert.AreEqual(Realm, rpReq.Realm);
- //// Assert.AreEqual(ReturnTo, rpReq.ReturnToUrl);
- //// }
-
- //// return rpReq;
- ////}
- /////// <summary>
- /////// Generates a new <see cref="OpenIdRelyingParty"/> ready to process a
- /////// response from an <see cref="OpenIdProvider"/>.
- /////// </summary>
- ////internal static IAuthenticationResponse CreateRelyingPartyResponse(IRelyingPartyApplicationStore store, IResponse providerResponse) {
- //// return CreateRelyingPartyResponse(store, providerResponse, false);
- ////}
- ////internal static IAuthenticationResponse CreateRelyingPartyResponse(IRelyingPartyApplicationStore store, IResponse providerResponse, bool requireSsl) {
- //// if (providerResponse == null) throw new ArgumentNullException("providerResponse");
-
- //// var opAuthWebResponse = (Response)providerResponse;
- //// var opAuthResponse = (EncodableResponse)opAuthWebResponse.EncodableMessage;
- //// var rp = CreateRelyingParty(store, opAuthResponse.RedirectUrl,
- //// opAuthResponse.EncodedFields.ToNameValueCollection());
- //// rp.Settings.RequireSsl = requireSsl;
- //// // Get the response now, before trying the replay attack. The Response
- //// // property is lazily-evaluated, so the replay attack can be evaluated first
- //// // and pass, while this one that SUPPOSED to pass fails, if we don't force it now.
- //// var response = rp.Response;
-
- //// // Side-track to test for replay attack while we're at it.
- //// // This simulates a network sniffing user who caught the
- //// // authenticating query en route to either the user agent or
- //// // the consumer, and tries the same query to the consumer in an
- //// // attempt to spoof the identity of the authenticating user.
- //// try {
- //// Logger.Info("Attempting replay attack...");
- //// var replayRP = CreateRelyingParty(store, opAuthResponse.RedirectUrl,
- //// opAuthResponse.EncodedFields.ToNameValueCollection());
- //// replayRP.Settings.RequireSsl = requireSsl;
- //// Assert.AreNotEqual(AuthenticationStatus.Authenticated, replayRP.Response.Status, "Replay attack succeeded!");
- //// } catch (OpenIdException) { // nonce already used
- //// // another way to pass
- //// }
-
- //// // Return the result of the initial response (not the replay attack one).
- //// return response;
- ////}
- /////// <summary>
- /////// Generates a new <see cref="OpenIdProvider"/> that uses the shared
- /////// store in <see cref="ProviderStore"/>.
- /////// </summary>
- ////internal static OpenIdProvider CreateProvider(NameValueCollection fields) {
- //// return CreateProvider(fields, false);
- ////}
- ////internal static OpenIdProvider CreateProvider(NameValueCollection fields, bool useSsl) {
- //// Protocol protocol = fields != null ? Protocol.Detect(fields.ToDictionary()) : Protocol.V20;
- //// Uri opEndpoint = GetFullUrl(ProviderPage, null, useSsl);
- //// var provider = new OpenIdProvider(ProviderStore, opEndpoint, opEndpoint, fields ?? new NameValueCollection());
- //// return provider;
- ////}
- ////internal static OpenIdProvider CreateProviderForRequest(DotNetOpenId.RelyingParty.IAuthenticationRequest request) {
- //// IResponse relyingPartyAuthenticationRequest = request.RedirectingResponse;
- //// var rpWebMessageToOP = (Response)relyingPartyAuthenticationRequest;
- //// var rpMessageToOP = (IndirectMessageRequest)rpWebMessageToOP.EncodableMessage;
- //// var opEndpoint = (ServiceEndpoint)request.Provider;
- //// var provider = new OpenIdProvider(ProviderStore, opEndpoint.ProviderEndpoint,
- //// opEndpoint.ProviderEndpoint, rpMessageToOP.EncodedFields.ToNameValueCollection());
- //// return provider;
- ////}
- ////internal static IResponse CreateProviderResponseToRequest(
- //// DotNetOpenId.RelyingParty.IAuthenticationRequest request,
- //// Action<DotNetOpenId.Provider.IAuthenticationRequest> prepareProviderResponse) {
- //// {
- //// // Sidetrack: Verify the return_to and realm URLs
- //// var consumerToProviderQuery = HttpUtility.ParseQueryString(request.RedirectingResponse.ExtractUrl().Query);
- //// Protocol protocol = Protocol.Detect(consumerToProviderQuery.ToDictionary());
- //// Assert.IsTrue(consumerToProviderQuery[protocol.openid.return_to].StartsWith(request.ReturnToUrl.AbsoluteUri, StringComparison.Ordinal));
- //// Assert.AreEqual(request.Realm.ToString(), consumerToProviderQuery[protocol.openid.Realm]);
- //// }
-
- //// var op = TestSupport.CreateProviderForRequest(request);
- //// var opReq = (DotNetOpenId.Provider.IAuthenticationRequest)op.Request;
- //// prepareProviderResponse(opReq);
- //// Assert.IsTrue(opReq.IsResponseReady);
- //// return opReq.Response;
- ////}
- ////internal static IAuthenticationResponse CreateRelyingPartyResponseThroughProvider(
- //// DotNetOpenId.RelyingParty.IAuthenticationRequest request,
- //// Action<DotNetOpenId.Provider.IAuthenticationRequest> providerAction) {
- //// var rpReq = (AuthenticationRequest)request;
- //// var opResponse = CreateProviderResponseToRequest(rpReq, providerAction);
- //// // Be careful to use whatever store the original RP was using.
- //// var rp = CreateRelyingPartyResponse(rpReq.RelyingParty.Store, opResponse,
- //// ((AuthenticationRequest)request).RelyingParty.Settings.RequireSsl);
- //// Assert.IsNotNull(rp);
- //// return rp;
- ////}
-
- ////[SetUp]
- ////public void SetUp() {
- //// log4net.Config.XmlConfigurator.Configure(Assembly.GetExecutingAssembly().GetManifestResourceStream("DotNetOpenId.Test.Logging.config"));
-
- //// ResetStores();
- ////}
-
- ////[TearDown]
- ////public void TearDown() {
- //// log4net.LogManager.Shutdown();
- ////}
-
- ////internal static void ResetStores() {
- //// RelyingPartyStore = new ApplicationMemoryStore();
- //// ProviderStore = new ProviderMemoryStore();
- ////}
-
- ////internal static void SetAuthenticationFromScenario(Scenarios scenario, DotNetOpenId.Provider.IAuthenticationRequest request) {
- //// Assert.IsTrue(request.IsReturnUrlDiscoverable);
- //// switch (scenario) {
- //// case TestSupport.Scenarios.ExtensionFullCooperation:
- //// case TestSupport.Scenarios.ExtensionPartialCooperation:
- //// case TestSupport.Scenarios.AutoApproval:
- //// // immediately approve
- //// request.IsAuthenticated = true;
- //// break;
- //// case TestSupport.Scenarios.AutoApprovalAddFragment:
- //// request.SetClaimedIdentifierFragment("frag");
- //// request.IsAuthenticated = true;
- //// break;
- //// case TestSupport.Scenarios.ApproveOnSetup:
- //// request.IsAuthenticated = !request.Immediate;
- //// break;
- //// case TestSupport.Scenarios.AlwaysDeny:
- //// request.IsAuthenticated = false;
- //// break;
- //// default:
- //// throw new InvalidOperationException("Unrecognized scenario");
- //// }
- ////}
-
- /////// <summary>
- /////// Uses an RPs stored association to resign an altered message from a Provider,
- /////// to simulate a Provider that deliberately sent a bad message in an attempt
- /////// to thwart RP security.
- /////// </summary>
- ////internal static void Resign(NameValueCollection nvc, IRelyingPartyApplicationStore store) {
- //// Debug.Assert(nvc != null);
- //// Debug.Assert(store != null);
- //// var dict = Util.NameValueCollectionToDictionary(nvc);
- //// Protocol protocol = Protocol.Detect(dict);
- //// Uri providerEndpoint = new Uri(nvc[protocol.openid.op_endpoint]);
- //// string assoc_handle = nvc[protocol.openid.assoc_handle];
- //// Association assoc = store.GetAssociation(providerEndpoint, assoc_handle);
- //// Debug.Assert(assoc != null, "Association not found in RP's store. Maybe you're communicating with a hosted OP instead of the TestSupport one?");
- //// IList<string> signed = nvc[protocol.openid.signed].Split(',');
- //// var subsetDictionary = new Dictionary<string, string>();
- //// foreach (string signedKey in signed) {
- //// string keyName = protocol.openid.Prefix + signedKey;
- //// subsetDictionary.Add(signedKey, dict[keyName]);
- //// }
- //// nvc[protocol.openid.sig] = Convert.ToBase64String(assoc.Sign(subsetDictionary, signed));
- ////}
-
- ////public static IAssociationStore<AssociationRelyingPartyType> ProviderStoreContext {
- //// get {
- //// 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
generated by cgit v1.1 at 2025-05-12 13:02:38 +0000