Skip to content
This repository was archived by the owner on Mar 20, 2019. It is now read-only.

Commit 303b3b2

Browse files
AArnottAArnott
committed
Attribute extension interop helper testing complete, along with several bug fixes.
1 parent 8eed943 commit 303b3b2

9 files changed

Lines changed: 327 additions & 74 deletions

‎Settings.StyleCop‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,11 +55,12 @@
5555
<Analyzer AnalyzerId="Microsoft.StyleCop.CSharp.NamingRules">
5656
<AnalyzerSettings>
5757
<CollectionProperty Name="Hungarian">
58+
<Value>ax</Value>
5859
<Value>op</Value>
5960
<Value>rp</Value>
6061
<Value>sp</Value>
6162
</CollectionProperty>
6263
</AnalyzerSettings>
6364
</Analyzer>
6465
</Analyzers>
65-
</StyleCopSettings>
66+
</StyleCopSettings>

‎src/DotNetOpenAuth.Test/DotNetOpenAuth.Test.csproj‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -192,6 +192,8 @@
192192
<Compile Include="OpenId\Extensions\AttributeExchange\AttributeValuesTests.cs" />
193193
<Compile Include="OpenId\Extensions\AttributeExchange\StoreRequestTests.cs" />
194194
<Compile Include="OpenId\Extensions\AttributeExchange\StoreResponseTests.cs" />
195+
<Compile Include="OpenId\Extensions\ExtensionsInteropHelperOPTests.cs" />
196+
<Compile Include="OpenId\Extensions\ExtensionsInteropHelperRPResponseTests.cs" />
195197
<Compile Include="OpenId\Extensions\ProviderAuthenticationPolicy\PapeRoundTripTests.cs" />
196198
<Compile Include="OpenId\Extensions\ProviderAuthenticationPolicy\PolicyRequestTests.cs" />
197199
<Compile Include="OpenId\Extensions\ProviderAuthenticationPolicy\PolicyResponseTests.cs" />
@@ -200,7 +202,7 @@
200202
<Compile Include="OpenId\Extensions\SimpleRegistration\ClaimsRequestTests.cs" />
201203
<Compile Include="OpenId\Extensions\UI\UIRequestTests.cs" />
202204
<Compile Include="OpenId\IdentifierTests.cs" />
203-
<Compile Include="OpenId\Extensions\ExtensionsInteropHelperTests.cs" />
205+
<Compile Include="OpenId\Extensions\ExtensionsInteropHelperRPRequestTests.cs" />
204206
<Compile Include="OpenId\Messages\AssociateDiffieHellmanRequestTests.cs" />
205207
<Compile Include="OpenId\Messages\AssociateRequestTests.cs" />
206208
<Compile Include="OpenId\Messages\AssociateUnsuccessfulResponseTests.cs" />

‎src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperOPTests.cs‎

Lines changed: 147 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,147 @@
1+
//-----------------------------------------------------------------------
2+
// <copyright file="ExtensionsInteropHelperOPTests.cs" company="Andrew Arnott">
3+
// Copyright (c) Andrew Arnott. All rights reserved.
4+
// </copyright>
5+
//-----------------------------------------------------------------------
6+
7+
namespace DotNetOpenAuth.Test.OpenId.Extensions {
8+
using System.Collections.Generic;
9+
using System.Linq;
10+
using DotNetOpenAuth.Messaging;
11+
using DotNetOpenAuth.OpenId;
12+
using DotNetOpenAuth.OpenId.Extensions;
13+
using DotNetOpenAuth.OpenId.Extensions.AttributeExchange;
14+
using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
15+
using DotNetOpenAuth.OpenId.Messages;
16+
using DotNetOpenAuth.OpenId.Provider;
17+
using Microsoft.VisualStudio.TestTools.UnitTesting;
18+
19+
[TestClass]
20+
public class ExtensionsInteropHelperOPTests : OpenIdTestBase {
21+
private AuthenticationRequest request;
22+
private IList<IExtensionMessage> extensions;
23+
24+
[TestInitialize]
25+
public override void SetUp() {
26+
base.SetUp();
27+
28+
var op = this.CreateProvider();
29+
var rpRequest = new CheckIdRequest(Protocol.Default.Version, OPUri, DotNetOpenAuth.OpenId.RelyingParty.AuthenticationRequestMode.Setup);
30+
rpRequest.ReturnTo = RPUri;
31+
this.extensions = rpRequest.Extensions;
32+
this.request = new AuthenticationRequest(op, rpRequest);
33+
this.request.IsAuthenticated = true;
34+
}
35+
36+
/// <summary>
37+
/// Verifies no extensions appear as no extensions
38+
/// </summary>
39+
[TestMethod]
40+
public void NoRequestedExtensions() {
41+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
42+
Assert.IsNull(sreg);
43+
44+
// Make sure we're still able to send an sreg response.
45+
var sregResponse = new ClaimsResponse();
46+
this.request.AddResponseExtension(sregResponse);
47+
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
48+
var extensions = this.GetResponseExtensions();
49+
Assert.AreSame(sregResponse, extensions.Single());
50+
}
51+
52+
/// <summary>
53+
/// Verifies sreg coming in is seen as sreg.
54+
/// </summary>
55+
[TestMethod]
56+
public void UnifyExtensionsAsSregWithSreg() {
57+
var sregInjected = new ClaimsRequest {
58+
Nickname = DemandLevel.Request,
59+
};
60+
this.extensions.Add(sregInjected);
61+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
62+
Assert.AreSame(sregInjected, sreg);
63+
Assert.AreEqual(DemandLevel.Request, sreg.Nickname);
64+
Assert.AreEqual(DemandLevel.NoRequest, sreg.FullName);
65+
66+
var sregResponse = new ClaimsResponse();
67+
this.request.AddResponseExtension(sregResponse);
68+
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
69+
var extensions = this.GetResponseExtensions();
70+
Assert.AreSame(sregResponse, extensions.Single());
71+
}
72+
73+
/// <summary>
74+
/// Verifies AX coming in looks like sreg.
75+
/// </summary>
76+
[TestMethod]
77+
public void UnifyExtensionsAsSregWithAX() {
78+
this.ParameterizedAXTest(AXAttributeFormats.AXSchemaOrg);
79+
}
80+
81+
/// <summary>
82+
/// Verifies AX coming in looks like sreg.
83+
/// </summary>
84+
[TestMethod]
85+
public void UnifyExtensionsAsSregWithAXSchemaOpenIdNet() {
86+
this.ParameterizedAXTest(AXAttributeFormats.SchemaOpenIdNet);
87+
}
88+
89+
/// <summary>
90+
/// Verifies sreg and AX in one request has a preserved sreg request.
91+
/// </summary>
92+
[TestMethod]
93+
public void UnifyExtensionsAsSregWithBothSregAndAX() {
94+
var sregInjected = new ClaimsRequest {
95+
Nickname = DemandLevel.Request,
96+
};
97+
this.extensions.Add(sregInjected);
98+
var axInjected = new FetchRequest();
99+
axInjected.Attributes.AddOptional(WellKnownAttributes.Contact.Email);
100+
this.extensions.Add(axInjected);
101+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
102+
Assert.AreSame(sregInjected, sreg);
103+
Assert.AreEqual(DemandLevel.Request, sreg.Nickname);
104+
Assert.AreEqual(DemandLevel.NoRequest, sreg.Email);
105+
106+
var sregResponseInjected = new ClaimsResponse {
107+
Nickname = "andy",
108+
};
109+
this.request.AddResponseExtension(sregResponseInjected);
110+
var axResponseInjected = new FetchResponse();
111+
axResponseInjected.Attributes.Add(WellKnownAttributes.Contact.Email, "a@b.com");
112+
this.request.AddResponseExtension(axResponseInjected);
113+
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
114+
var extensions = this.GetResponseExtensions();
115+
var sregResponse = extensions.OfType<ClaimsResponse>().Single();
116+
Assert.AreEqual("andy", sregResponse.Nickname);
117+
var axResponse = extensions.OfType<FetchResponse>().Single();
118+
Assert.AreEqual("a@b.com", axResponse.GetAttributeValue(WellKnownAttributes.Contact.Email));
119+
}
120+
121+
private IList<IExtensionMessage> GetResponseExtensions() {
122+
IProtocolMessageWithExtensions response = (IProtocolMessageWithExtensions)this.request.Response;
123+
return response.Extensions;
124+
}
125+
126+
private void ParameterizedAXTest(AXAttributeFormats format) {
127+
var axInjected = new FetchRequest();
128+
axInjected.Attributes.AddOptional(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.Alias, format));
129+
axInjected.Attributes.AddRequired(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.FullName, format));
130+
this.extensions.Add(axInjected);
131+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
132+
Assert.AreSame(sreg, this.request.GetExtension<ClaimsRequest>());
133+
Assert.AreEqual(DemandLevel.Request, sreg.Nickname);
134+
Assert.AreEqual(DemandLevel.Require, sreg.FullName);
135+
Assert.AreEqual(DemandLevel.NoRequest, sreg.Language);
136+
137+
var sregResponse = new ClaimsResponse {
138+
Nickname = "andy",
139+
};
140+
this.request.AddResponseExtension(sregResponse);
141+
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
142+
var extensions = this.GetResponseExtensions();
143+
var axResponse = extensions.OfType<FetchResponse>().Single();
144+
Assert.AreEqual("andy", axResponse.GetAttributeValue(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.Alias, format)));
145+
}
146+
}
147+
}

src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperTests.cs renamed to src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperRPRequestTests.cs

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,20 @@
11
//-----------------------------------------------------------------------
2-
// <copyright file="InteropHelperTests.cs" company="Andrew Arnott">
2+
// <copyright file="ExtensionsInteropHelperRPRequestTests.cs" company="Andrew Arnott">
33
// Copyright (c) Andrew Arnott. All rights reserved.
44
// </copyright>
55
//-----------------------------------------------------------------------
66

77
namespace DotNetOpenAuth.Test.OpenId {
8-
using System;
9-
using System.Collections.Generic;
108
using System.Linq;
11-
using System.Text;
129
using DotNetOpenAuth.OpenId;
10+
using DotNetOpenAuth.OpenId.Extensions;
1311
using DotNetOpenAuth.OpenId.Extensions.AttributeExchange;
1412
using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
1513
using DotNetOpenAuth.OpenId.RelyingParty;
1614
using Microsoft.VisualStudio.TestTools.UnitTesting;
17-
using Moq;
18-
using DotNetOpenAuth.OpenId.Extensions;
1915

2016
[TestClass]
21-
public class ExtensionsInteropHelperTests : OpenIdTestBase {
17+
public class ExtensionsInteropHelperRPRequestTests : OpenIdTestBase {
2218
private AuthenticationRequest authReq;
2319
private ClaimsRequest sreg;
2420

‎src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperRPResponseTests.cs‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
//-----------------------------------------------------------------------
2+
// <copyright file="ExtensionsInteropHelperRPResponseTests.cs" company="Andrew Arnott">
3+
// Copyright (c) Andrew Arnott. All rights reserved.
4+
// </copyright>
5+
//-----------------------------------------------------------------------
6+
7+
namespace DotNetOpenAuth.Test.OpenId {
8+
using System.Collections.Generic;
9+
using DotNetOpenAuth.Messaging;
10+
using DotNetOpenAuth.OpenId;
11+
using DotNetOpenAuth.OpenId.Extensions;
12+
using DotNetOpenAuth.OpenId.Extensions.AttributeExchange;
13+
using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
14+
using DotNetOpenAuth.OpenId.Messages;
15+
using DotNetOpenAuth.OpenId.RelyingParty;
16+
using Microsoft.VisualStudio.TestTools.UnitTesting;
17+
18+
[TestClass]
19+
public class ExtensionsInteropHelperRPResponseTests : OpenIdTestBase {
20+
private IAuthenticationResponse response;
21+
private IList<IExtensionMessage> extensions;
22+
23+
[TestInitialize]
24+
public override void SetUp() {
25+
base.SetUp();
26+
27+
IndirectSignedResponse responseMessage = new IndirectSignedResponse(Protocol.Default.Version, RPUri);
28+
this.extensions = responseMessage.Extensions;
29+
this.response = new DotNetOpenAuth.OpenId.RelyingParty.PositiveAnonymousResponse(responseMessage);
30+
}
31+
32+
/// <summary>
33+
/// Verifies that with no extensions present, UnifyExtensionsAsSreg returns an empty ClaimsResponse.
34+
/// </summary>
35+
[TestMethod]
36+
public void UnifyExtensionsAsSregNoExtensions() {
37+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
38+
Assert.IsNotNull(sreg);
39+
Assert.IsNull(sreg.Nickname);
40+
}
41+
42+
/// <summary>
43+
/// Verifies that with sreg and AX extensions present, the sreg extension is returned.
44+
/// </summary>
45+
[TestMethod]
46+
public void UnifyExtensionsAsSregWithSreg() {
47+
var sregInjected = new ClaimsResponse {
48+
Nickname = "andy",
49+
};
50+
var axInjected = new FetchResponse();
51+
axInjected.Attributes.Add(WellKnownAttributes.Name.Alias, "nate");
52+
this.extensions.Add(sregInjected);
53+
this.extensions.Add(axInjected);
54+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
55+
Assert.AreSame(sregInjected, sreg);
56+
Assert.AreEqual("andy", sreg.Nickname);
57+
}
58+
59+
/// <summary>
60+
/// Verifies UnifyExtensionsAsSreg correctly converts AX to sreg.
61+
/// </summary>
62+
[TestMethod]
63+
public void UnifyExtensionsAsSregFromAXSchemaOrg() {
64+
var axInjected = new FetchResponse();
65+
axInjected.Attributes.Add(WellKnownAttributes.Name.Alias, "nate");
66+
this.extensions.Add(axInjected);
67+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
68+
Assert.AreEqual("nate", sreg.Nickname);
69+
}
70+
71+
/// <summary>
72+
/// Verifies UnifyExtensionsAsSreg correctly converts AX in a non-standard format to sreg.
73+
/// </summary>
74+
[TestMethod]
75+
public void UnifyExtensionsasSregFromSchemaOpenIdNet() {
76+
var axInjected = new FetchResponse();
77+
axInjected.Attributes.Add(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.Alias, AXAttributeFormats.SchemaOpenIdNet), "nate");
78+
this.extensions.Add(axInjected);
79+
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
80+
Assert.AreEqual("nate", sreg.Nickname);
81+
}
82+
}
83+
}

0 commit comments

Comments
 (0)