1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
//-----------------------------------------------------------------------
// <copyright file="ExtensionsBindingElementTests.cs" company="Andrew Arnott">
// Copyright (c) Andrew Arnott. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
namespace DotNetOpenAuth.Test.OpenId.ChannelElements {
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using DotNetOpenAuth.Messaging;
using DotNetOpenAuth.OpenId;
using DotNetOpenAuth.OpenId.ChannelElements;
using DotNetOpenAuth.OpenId.Extensions;
using DotNetOpenAuth.OpenId.Messages;
using DotNetOpenAuth.OpenId.RelyingParty;
using DotNetOpenAuth.Test.Mocks;
using DotNetOpenAuth.Test.OpenId.Extensions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
[TestClass]
public class ExtensionsBindingElementTests : OpenIdTestBase {
private OpenIdExtensionFactory factory;
private ExtensionsBindingElement element;
private IProtocolMessageWithExtensions request;
[TestInitialize]
public override void SetUp() {
base.SetUp();
this.factory = new OpenIdExtensionFactory();
this.factory.RegisterExtension(MockOpenIdExtension.Factory);
this.element = new ExtensionsBindingElement(this.factory);
this.request = new SignedResponseRequest(Protocol.Default.Version, OpenIdTestBase.ProviderUri, AuthenticationRequestMode.Immediate);
}
[TestMethod]
public void RoundTripFullStackTest() {
IOpenIdMessageExtension request = new MockOpenIdExtension("requestPart", "requestData");
IOpenIdMessageExtension response = new MockOpenIdExtension("responsePart", "responseData");
ExtensionTestUtilities.Roundtrip(
Protocol.Default,
new IOpenIdMessageExtension[] { request },
new IOpenIdMessageExtension[] { response });
}
[TestMethod]
public void ExtensionFactory() {
Assert.AreSame(this.factory, this.element.ExtensionFactory);
}
[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void PrepareMessageForSendingNull() {
this.element.PrepareMessageForSending(null);
}
/// <summary>
/// Verifies that false is returned when a non-extendable message is sent.
/// </summary>
[TestMethod]
public void PrepareMessageForSendingNonExtendableMessage() {
IProtocolMessage request = new AssociateDiffieHellmanRequest(Protocol.Default.Version, OpenIdTestBase.ProviderUri);
Assert.IsFalse(this.element.PrepareMessageForSending(request));
}
[TestMethod]
public void PrepareMessageForSending() {
this.request.Extensions.Add(new MockOpenIdExtension("part", "extra"));
Assert.IsTrue(this.element.PrepareMessageForSending(this.request));
string alias = GetAliases(this.request.ExtraData).Single();
Assert.AreEqual(MockOpenIdExtension.MockTypeUri, this.request.ExtraData["openid.ns." + alias]);
Assert.AreEqual("part", this.request.ExtraData["openid." + alias + ".Part"]);
Assert.AreEqual("extra", this.request.ExtraData["openid." + alias + ".data"]);
}
[TestMethod]
public void PrepareMessageForReceiving() {
this.request.ExtraData["openid.ns.mock"] = MockOpenIdExtension.MockTypeUri;
this.request.ExtraData["openid.mock.Part"] = "part";
this.request.ExtraData["openid.mock.data"] = "extra";
Assert.IsTrue(this.element.PrepareMessageForReceiving(this.request));
MockOpenIdExtension ext = this.request.Extensions.OfType<MockOpenIdExtension>().Single();
Assert.AreEqual("part", ext.Part);
Assert.AreEqual("extra", ext.Data);
}
/// <summary>
/// Verifies that unsigned extension responses (where any or all fields are unsigned) are ignored.
/// </summary>
[TestMethod, Ignore]
public void UnsignedExtensionsAreIgnored() {
Assert.Inconclusive("Not yet implemented.");
}
private static IEnumerable<string> GetAliases(IDictionary<string, string> extraData) {
Regex regex = new Regex(@"^openid\.ns\.(\w+)");
return from key in extraData.Keys
let m = regex.Match(key)
where m.Success
select m.Groups[1].Value;
}
}
}
|
