private void RunConstructionTest(JwtSecurityTokenTestVariation variation)
{
JwtSecurityToken jwt = null;
try
{
jwt = CreateToken(variation);
variation.ExpectedException.ProcessNoException();
}
catch (Exception ex)
{
variation.ExpectedException.ProcessException(ex);
}
try
{
// ensure we can get to every property
if (jwt != null && (variation.ExpectedException == null || variation.ExpectedException.TypeExpected == null))
{
TestUtilities.CallAllPublicInstanceAndStaticPropertyGets(jwt, variation.Name);
}
if (null != variation.ExpectedJwtSecurityToken)
{
Assert.True(IdentityComparer.AreEqual(variation.ExpectedJwtSecurityToken, jwt));
}
}
catch (Exception ex)
{
Assert.True(false, string.Format("Testcase: {0}. UnExpected when getting a properties: '{1}'", variation.Name, ex.ToString()));
}
}
private void RunEncodedTest(JwtSecurityTokenTestVariation variation)
{
JwtSecurityToken jwt = null;
Console.WriteLine(string.Format("Variation: {0}", variation.Name));
try
{
jwt = new JwtSecurityToken(variation.EncodedString);
IEnumerable <Claim> claims = jwt.Payload.Claims;
variation.ExpectedException.ProcessNoException();
}
catch (Exception ex)
{
variation.ExpectedException.ProcessException(ex);
}
// ensure we can get to every property
if (jwt != null && (variation.ExpectedException == null || variation.ExpectedException.TypeExpected == null))
{
TestUtilities.CallAllPublicInstanceAndStaticPropertyGets(jwt, variation.Name);
}
if (null != variation.ExpectedJwtSecurityToken)
{
Assert.True(
IdentityComparer.AreEqual(variation.ExpectedJwtSecurityToken, jwt),
string.Format("Testcase: {0}. JWTSecurityTokens are not equal.", variation.Name));
}
}
private static void CheckOuterTokenProperties(JwtSecurityToken token, JwtSecurityTokenTestVariation variation)
{
Assert.Equal(token.RawHeader, variation.RawHeader);
Assert.Equal(token.RawEncryptedKey, variation.RawEncryptedKey);
Assert.Equal(token.RawInitializationVector, variation.RawInitializationVector);
Assert.Equal(token.RawCiphertext, variation.RawCiphertext);
Assert.Equal(token.RawAuthenticationTag, variation.RawAuthenticationTag);
}
private JwtSecurityToken CreateToken(JwtSecurityTokenTestVariation variation)
{
return(new JwtSecurityToken(
issuer: variation.Issuer,
audience: variation.Audience,
claims: variation.Claims,
signingCredentials: variation.SigningCredentials,
notBefore: variation.NotBefore,
expires: variation.Expires));
}
public static TheoryData <string, JwtSecurityTokenTestVariation, JwtSecurityTokenTestVariation, string, ExpectedException> EmbeddedTokenConstructorData()
{
var dataSet = new TheoryData <string, JwtSecurityTokenTestVariation, JwtSecurityTokenTestVariation, string, ExpectedException>();
dataSet.Add("Embedded token all properties null",
// outer token
new JwtSecurityTokenTestVariation
{
RawHeader = null,
RawEncryptedKey = null,
RawInitializationVector = null,
RawCiphertext = null,
RawAuthenticationTag = null,
},
// inner token
new JwtSecurityTokenTestVariation
{
Issuer = null,
Audience = null,
Claims = null,
SigningCredentials = null,
},
String.Empty,
ExpectedException.ArgumentNullException()
);
JwtSecurityTokenTestVariation innerToken = new JwtSecurityTokenTestVariation
{
NotBefore = DateTime.MinValue,
Expires = DateTime.UtcNow,
};
JwtSecurityTokenTestVariation outerValidJweDirect = CreateVariationOnToken(EncodedJwts.ValidJweDirect);
dataSet.Add("ValidJweDirect- Construct by parts", outerValidJweDirect, innerToken, String.Empty, ExpectedException.NoExceptionExpected);
dataSet.Add("ValidJweDirect- Construct by string", outerValidJweDirect, null, EncodedJwts.ValidJweDirect, ExpectedException.NoExceptionExpected);
JwtSecurityTokenTestVariation outerValidJweDirect2 = CreateVariationOnToken(EncodedJwts.ValidJweDirect2);
dataSet.Add("ValidJweDirect2- Construct by parts", outerValidJweDirect2, innerToken, String.Empty, ExpectedException.NoExceptionExpected);
dataSet.Add("ValidJweDirect2- Construct by string", outerValidJweDirect2, null, EncodedJwts.ValidJweDirect2, ExpectedException.NoExceptionExpected);
JwtSecurityTokenTestVariation outerValidJwe = CreateVariationOnToken(EncodedJwts.ValidJwe);
dataSet.Add("ValidJwe- Construct by parts", outerValidJwe, innerToken, String.Empty, ExpectedException.NoExceptionExpected);
dataSet.Add("ValidJwe- Construct by string", outerValidJwe, null, EncodedJwts.ValidJwe, ExpectedException.NoExceptionExpected);
JwtSecurityTokenTestVariation outerValidJwe2 = CreateVariationOnToken(EncodedJwts.ValidJwe2);
dataSet.Add("ValidJwe2- Construct by parts", outerValidJwe2, innerToken, String.Empty, ExpectedException.NoExceptionExpected);
dataSet.Add("ValidJwe2- Construct by string", outerValidJwe2, null, EncodedJwts.ValidJwe2, ExpectedException.NoExceptionExpected);
// Hand in a valid variation. We should fail before the variation is used.
dataSet.Add("Invalid outer token 1- Construct by string", outerValidJweDirect, null, EncodedJwts.InvalidJwe, ExpectedException.ArgumentException(substringExpected: "IDX12709"));
dataSet.Add("Invalid outer token 2- Construct by string", outerValidJweDirect, null, EncodedJwts.InvalidJwe2, ExpectedException.ArgumentException(substringExpected: "IDX12709"));
dataSet.Add("Invalid outer token 3- Construct by string", outerValidJweDirect, null, EncodedJwts.InvalidJwe3, ExpectedException.ArgumentException(substringExpected: "IDX12709"));
dataSet.Add("Invalid outer token 4- Construct by string", outerValidJweDirect, null, EncodedJwts.InvalidJwe4, ExpectedException.ArgumentException(substringExpected: "IDX12709"));
dataSet.Add("Invalid outer token 5- Construct by string", outerValidJweDirect, null, EncodedJwts.InvalidJwe5, ExpectedException.ArgumentException(substringExpected: "IDX12709"));
dataSet.Add("Invalid outer token 6- Construct by string", outerValidJweDirect, null, EncodedJwts.InvalidJwe6, ExpectedException.ArgumentException(substringExpected: "IDX12709"));
return(dataSet);
}
public void EmbeddedTokenConstructor1(string testId, JwtSecurityTokenTestVariation outerTokenVariation, JwtSecurityTokenTestVariation innerTokenVariation, string jwt, ExpectedException ee)
{
JwtSecurityToken outerJwt = null;
JwtSecurityToken innerJwt = null;
// create inner token
try
{
if (innerTokenVariation != null)
{
innerJwt = CreateToken(innerTokenVariation);
}
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
// create outer token
try
{
if (string.IsNullOrEmpty(jwt))
{
outerJwt = new JwtSecurityToken(
header: outerTokenVariation.Header,
innerToken: innerJwt,
rawHeader: outerTokenVariation.RawHeader,
rawEncryptedKey: outerTokenVariation.RawEncryptedKey,
rawInitializationVector: outerTokenVariation.RawInitializationVector,
rawCiphertext: outerTokenVariation.RawCiphertext,
rawAuthenticationTag: outerTokenVariation.RawAuthenticationTag);
}
else
{
outerJwt = new JwtSecurityToken(jwt);
}
ee.ProcessNoException();
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
try
{
// ensure we can get to every outer token property
if (outerJwt != null && (ee == null || ee.TypeExpected == null))
{
TestUtilities.CallAllPublicInstanceAndStaticPropertyGets(outerJwt, testId);
}
if (null != outerTokenVariation.ExpectedJwtSecurityToken)
{
Assert.True(IdentityComparer.AreEqual(outerTokenVariation.ExpectedJwtSecurityToken, outerJwt));
}
}
catch (Exception ex)
{
Assert.True(false, string.Format("Testcase: {0}. UnExpected when getting a properties: '{1}'", outerTokenVariation.Name, ex.ToString()));
}
try
{
// ensure we can get to every inner token property
if (innerJwt != null && (ee == null || ee.TypeExpected == null))
{
TestUtilities.CallAllPublicInstanceAndStaticPropertyGets(innerJwt, testId);
}
if (null != innerTokenVariation && null != innerTokenVariation.ExpectedJwtSecurityToken)
{
Assert.True(IdentityComparer.AreEqual(innerTokenVariation.ExpectedJwtSecurityToken, innerJwt));
}
}
catch (Exception ex)
{
Assert.True(false, string.Format("Testcase: {0}. UnExpected when getting a properties: '{1}'", testId, ex.ToString()));
}
try
{
if (outerJwt != null && innerJwt != null && (ee == null || ee.TypeExpected == null))
{
// confirm properties of outer token match our expectation
Assert.Equal(outerJwt.InnerToken, innerJwt);
CheckPayloadProperties(outerJwt, innerJwt);
CheckOuterTokenProperties(outerJwt, outerTokenVariation);
}
}
catch (Exception ex)
{
Assert.True(false, string.Format("Testcase: {0}. Unexpected inequality between outer and inner token properties: '{1}'", testId, ex.ToString()));
}
}