public void GetTokenParsingString(WsFederationMessageTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.GetTokenParsingString", theoryData);
try
{
var token = WsFederationMessage.GetToken(theoryData.Wresult);
if (token == null && theoryData.Token != null)
{
context.AddDiff("(token == null && theoryData.Token != null)");
}
else if (token != null && theoryData.Token == null)
{
context.AddDiff("(token != null && theoryData.Token == null)");
}
else if (string.Compare(token, theoryData.Token) != 0)
{
context.AddDiff("string.Compare(token, token2) != 0");
}
theoryData.ExpectedException.ProcessNoException(context);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
public void GetTokenTest(WsFederationMessageTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.GetTokenTest", theoryData);
try
{
// GetToken (for other than NETSTANDARD 1.4) uses XmlReaders to obtain token from Wresult.
// GetToken(string) {internal} uses string manipulation to obtain token.
// The result should be the same token.
var tokenUsingReader = theoryData.WsFederationMessageTestSet.WsFederationMessage.GetToken();
var tokenFromString = WsFederationMessage.GetToken(theoryData.WsFederationMessageTestSet.WsFederationMessage.Wresult);
if (string.Compare(tokenUsingReader, tokenFromString) != 0)
{
context.AddDiff("string.Compare(tokenUsingReader, tokenFromString) != 0");
}
if (theoryData.TokenValidationParameters != null)
{
var tokenHandler = new Saml2SecurityTokenHandler();
tokenHandler.ValidateToken(tokenUsingReader, theoryData.TokenValidationParameters, out SecurityToken validatedToken);
}
theoryData.ExpectedException.ProcessNoException(context);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
public void ConstructorTest(WsFederationMessageTheoryData theoryData)
{
TestUtilities.WriteHeader($"{this}.ConstructorTest", theoryData);
try
{
// check default constructor
var wsFederationMessage1 = new WsFederationMessage
{
IssuerAddress = theoryData.IssuerAddress,
Wreply = theoryData.Wreply,
Wct = theoryData.Wct
};
Assert.Equal(theoryData.IssuerAddress, wsFederationMessage1.IssuerAddress);
Assert.Equal(theoryData.Wreply, wsFederationMessage1.Wreply);
Assert.Equal(theoryData.Wct, wsFederationMessage1.Wct);
// check copy constructor
WsFederationMessage wsFederationMessage2 = new WsFederationMessage(wsFederationMessage1);
Assert.Equal(theoryData.IssuerAddress, wsFederationMessage2.IssuerAddress);
Assert.Equal(theoryData.Wreply, wsFederationMessage2.Wreply);
Assert.Equal(theoryData.Wct, wsFederationMessage2.Wct);
theoryData.ExpectedException.ProcessNoException();
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex);
}
}
public void WaSignIn(WsFederationMessageTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.WaSignIn", theoryData);
try
{
var fedMessage = WsFederationMessage.FromQueryString(theoryData.QueryString);
var token = fedMessage.GetToken();
if (theoryData.TokenValidationParameters != null)
{
theoryData.SecurityTokenHandler.ValidateToken(token, theoryData.TokenValidationParameters, out SecurityToken validatedToken);
if (theoryData.SecurityToken != null)
{
IdentityComparer.AreEqual(theoryData.SecurityToken, validatedToken, context);
}
}
theoryData.ExpectedException.ProcessNoException(context);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
public void ParametersTest(WsFederationMessageTheoryData theoryData)
{
TestUtilities.WriteHeader($"{this}.ParametersTest", theoryData);
try
{
var wsFederationMessage = new WsFederationMessage
{
IssuerAddress = theoryData.IssuerAddress,
Wreply = theoryData.Wreply,
Wct = theoryData.Wct
};
Assert.Equal(theoryData.IssuerAddress, wsFederationMessage.IssuerAddress);
Assert.Equal(theoryData.Wreply, wsFederationMessage.Wreply);
Assert.Equal(theoryData.Wct, wsFederationMessage.Wct);
// add parameter
wsFederationMessage.SetParameter(theoryData.Parameter1.Key, theoryData.Parameter1.Value);
// add parameters
var nameValueCollection = new NameValueCollection
{
{ theoryData.Parameter2.Key, theoryData.Parameter2.Value },
{ theoryData.Parameter3.Key, theoryData.Parameter3.Value }
};
wsFederationMessage.SetParameters(nameValueCollection);
// validate the parameters are added
Assert.Equal(theoryData.Parameter1.Value, wsFederationMessage.Parameters[theoryData.Parameter1.Key]);
Assert.Equal(theoryData.Parameter2.Value, wsFederationMessage.Parameters[theoryData.Parameter2.Key]);
Assert.Equal(theoryData.Parameter3.Value, wsFederationMessage.Parameters[theoryData.Parameter3.Key]);
// remove parameter
wsFederationMessage.SetParameter(theoryData.Parameter1.Key, null);
// validate the parameter is removed
Assert.False(wsFederationMessage.Parameters.ContainsKey(theoryData.Parameter1.Key));
// create redirectUri
var uriString = wsFederationMessage.BuildRedirectUrl();
Uri uri = new Uri(uriString);
// convert query back to WsFederationMessage
var wsFederationMessageReturned = WsFederationMessage.FromQueryString(uri.Query);
// validate the parameters in the returned wsFederationMessage
Assert.Equal(theoryData.Parameter2.Value, wsFederationMessageReturned.Parameters[theoryData.Parameter2.Key]);
Assert.Equal(theoryData.Parameter3.Value, wsFederationMessageReturned.Parameters[theoryData.Parameter3.Key]);
theoryData.ExpectedException.ProcessNoException();
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex);
}
}
public void GetTokenNegativeTest(WsFederationMessageTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.GetTokenNegativeTest", theoryData);
try
{
var token = theoryData.WsFederationMessageTestSet.WsFederationMessage.GetToken();
theoryData.ExpectedException.ProcessNoException(context);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
public void QueryStringTest(WsFederationMessageTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.QueryStringTest", theoryData);
try
{
var wsFederationMessage = WsFederationMessage.FromQueryString(theoryData.WsFederationMessageTestSet.Xml);
theoryData.ExpectedException.ProcessNoException();
IdentityComparer.AreWsFederationMessagesEqual(wsFederationMessage, theoryData.WsFederationMessageTestSet.WsFederationMessage, context);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex);
}
TestUtilities.AssertFailIfErrors(context);
}
public void GetTokenTest(WsFederationMessageTheoryData theoryData)
{
var context = TestUtilities.WriteHeader($"{this}.GetTokenTest", theoryData);
try
{
var token = theoryData.WsFederationMessageTestSet.WsFederationMessage.GetToken();
//Assert.Equal(theoryData.Token, token);
if (theoryData.TokenValidationParameters != null)
{
var tokenHandler = new Saml2SecurityTokenHandler();
tokenHandler.ValidateToken(token, theoryData.TokenValidationParameters, out SecurityToken validatedToken);
}
theoryData.ExpectedException.ProcessNoException(context);
}
catch (Exception ex)
{
theoryData.ExpectedException.ProcessException(ex, context);
}
TestUtilities.AssertFailIfErrors(context);
}
