src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs

   1 //-----------------------------------------------------------------------
   2 // <copyright file="AuthenticationRequestTests.cs" company="Andrew Arnott">
   3 //     Copyright (c) Andrew Arnott. All rights reserved.
   4 // </copyright>
   5 //-----------------------------------------------------------------------
   6
   7 namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
   8         using System;
   9         using System.Collections.Generic;
  10         using System.Collections.Specialized;
  11         using System.Linq;
  12         using System.Text;
  13         using System.Web;
  14         using DotNetOpenAuth.OpenId;
  15         using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
  16         using DotNetOpenAuth.OpenId.Messages;
  17         using DotNetOpenAuth.OpenId.RelyingParty;
  18         using Microsoft.VisualStudio.TestTools.UnitTesting;
  19
  20         [TestClass]
  21         public class AuthenticationRequestTests : OpenIdTestBase {
  22                 private readonly Realm realm = new Realm("http://localhost/rp.aspx");
  23                 private readonly Uri returnTo = new Uri("http://localhost/rp.aspx");
  24                 private readonly Identifier claimedId = "http://claimedId";
  25                 private readonly Identifier delegatedLocalId = "http://localId";
  26                 private readonly Protocol protocol = Protocol.Default;
  27
  28                 [TestInitialize]
  29                 public override void SetUp() {
  30                         base.SetUp();
  31                 }
  32
  33                 /// <summary>
  34                 /// Verifies IsDirectedIdentity returns true when appropriate.
  35                 /// </summary>
  36                 [TestMethod]
  37                 public void IsDirectedIdentity() {
  38                         IAuthenticationRequest_Accessor iauthRequest = this.CreateAuthenticationRequest(this.claimedId, this.claimedId);
  39                         Assert.IsFalse(iauthRequest.IsDirectedIdentity);
  40
  41                         iauthRequest = this.CreateAuthenticationRequest(IdentifierSelect, IdentifierSelect);
  42                         Assert.IsTrue(iauthRequest.IsDirectedIdentity);
  43                 }
  44
  45                 /// <summary>
  46                 /// Verifies ClaimedIdentifier behavior.
  47                 /// </summary>
  48                 [TestMethod]
  49                 public void ClaimedIdentifier() {
  50                         IAuthenticationRequest_Accessor iauthRequest = this.CreateAuthenticationRequest(this.claimedId, this.delegatedLocalId);
  51                         Assert.AreEqual(this.claimedId, iauthRequest.ClaimedIdentifier);
  52
  53                         iauthRequest = this.CreateAuthenticationRequest(IdentifierSelect, IdentifierSelect);
  54                         Assert.IsNull(iauthRequest.ClaimedIdentifier, "In directed identity mode, the ClaimedIdentifier should be null.");
  55                 }
  56
  57                 /// <summary>
  58                 /// Verifies ProviderVersion behavior.
  59                 /// </summary>
  60                 [TestMethod]
  61                 public void ProviderVersion() {
  62                         var authRequest = this.CreateAuthenticationRequest(this.claimedId, this.claimedId);
  63                         Assert.AreEqual(this.protocol.Version, authRequest.ProviderVersion);
  64                 }
  65
  66                 /// <summary>
  67                 /// Verifies RedirectingResponse.
  68                 /// </summary>
  69                 [TestMethod]
  70                 public void CreateRequestMessage() {
  71                         OpenIdCoordinator coordinator = new OpenIdCoordinator(
  72                                 rp => {
  73                                         Identifier id = this.GetMockIdentifier(ProtocolVersion.V20);
  74                                         IAuthenticationRequest authRequest = rp.CreateRequest(id, this.realm, this.returnTo);
  75
  76                                         // Add some callback arguments
  77                                         authRequest.AddCallbackArguments("a", "b");
  78                                         authRequest.AddCallbackArguments(new Dictionary<string, string> { { "c", "d" }, { "e", "f" } });
  79
  80                                         // Assembly an extension request.
  81                                         ClaimsRequest sregRequest = new ClaimsRequest();
  82                                         sregRequest.Nickname = DemandLevel.Request;
  83                                         authRequest.AddExtension(sregRequest);
  84
  85                                         // Construct the actual authentication request message.
  86                                         var authRequestAccessor = AuthenticationRequest_Accessor.AttachShadow(authRequest);
  87                                         var req = authRequestAccessor.CreateRequestMessage();
  88                                         Assert.IsNotNull(req);
  89
  90                                         // Verify that callback arguments were included.
  91                                         NameValueCollection callbackArguments = HttpUtility.ParseQueryString(req.ReturnTo.Query);
  92                                         Assert.AreEqual("b", callbackArguments["a"]);
  93                                         Assert.AreEqual("d", callbackArguments["c"]);
  94                                         Assert.AreEqual("f", callbackArguments["e"]);
  95
  96                                         // Verify that extensions were included.
  97                                         Assert.AreEqual(1, req.Extensions.Count);
  98                                         Assert.IsTrue(req.Extensions.Contains(sregRequest));
  99                                 },
 100                                 AutoProvider);
 101                         coordinator.Run();
 102                 }
 103
 104                 /// <summary>
 105                 /// Verifies the Provider property returns non-null.
 106                 /// </summary>
 107                 [TestMethod]
 108                 public void Provider() {
 109                         IAuthenticationRequest_Accessor authRequest = this.CreateAuthenticationRequest(this.claimedId, this.claimedId);
 110                         Assert.IsNotNull(authRequest.Provider);
 111                         Assert.AreEqual(OPUri, authRequest.Provider.Uri);
 112                         Assert.AreEqual(this.protocol.Version, authRequest.Provider.Version);
 113                 }
 114
 115                 /// <summary>
 116                 /// Verifies that authentication requests are generated first for OPs that respond
 117                 /// to authentication requests.
 118                 /// </summary>
 119                 [TestMethod, Ignore]
 120                 public void UnresponsiveProvidersComeLast() {
 121                         Assert.Inconclusive("Not yet implemented.");
 122                 }
 123
 124                 private AuthenticationRequest_Accessor CreateAuthenticationRequest(Identifier claimedIdentifier, Identifier providerLocalIdentifier) {
 125                         ProviderEndpointDescription providerEndpoint = new ProviderEndpointDescription(OPUri, this.protocol.Version);
 126                         ServiceEndpoint endpoint = ServiceEndpoint.CreateForClaimedIdentifier(claimedIdentifier, providerLocalIdentifier, providerEndpoint, 10, 5);
 127                         ServiceEndpoint_Accessor endpointAccessor = ServiceEndpoint_Accessor.AttachShadow(endpoint);
 128                         OpenIdRelyingParty rp = this.CreateRelyingParty();
 129                         AuthenticationRequest_Accessor authRequest = new AuthenticationRequest_Accessor(endpointAccessor, this.realm, this.returnTo, rp);
 130                         return authRequest;
 131                 }
 132         }
 133 }