public void Aggregate_argument_null_exception()
{
//ARRANGE
//ACT
//ASSERT
Assert.Throws <ArgumentNullException>(() => EnumerableExtensions.Aggregate(null));
}
public void Aggregate_strings_to_a_single_string()
{
//ARRANGE
var expected = "1\r\n2";
var source = new[] { "1", "2" };
//ACT
var result = EnumerableExtensions.Aggregate(source);
//ASSERT
Assert.AreEqual(expected, result);
}
/// <summary>
/// Gets the aggragated message.
/// </summary>
/// <returns></returns>
public string GetAggragatedMessage()
{
if (ResponseMessages == null)
{
return(string.Empty);
}
var messages = ResponseMessages.Select(m => m.Message);
return(EnumerableExtensions.Aggregate(messages));
}
public async Task Handle(HttpPostResponseInboundContext context)
{
try
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var responseStatus = await this._responseParser.Parse(context);
var samlResponse = responseStatus.StatusResponse as TokenResponse;
var hasToken = (samlResponse != null && samlResponse.Assertions != null && samlResponse.Assertions.Length == 1);
context.HasSecurityToken = hasToken;
this._logProvider.LogMessage(String.Format("Response is{0} a security token carrier.", hasToken ? String.Empty : " not"));
if (hasToken)
{
var token = samlResponse.Assertions[0];
var handlerContext = new HandleTokenContext(token, responseStatus.FederationPartyId, context.AuthenticationMethod, responseStatus.SamlInboundMessage.RelayState);
var response = await this._tokenHandler.HandleToken(handlerContext);
if (!response.IsValid)
{
throw new Exception(EnumerableExtensions.Aggregate(response.ValidationResults.Select(x => x.ErrorMessage)));
}
context.Identity = response.Identity;
if (response.Token != null)
{
context.Properties.Add("ValidFrom", response.Token.ValidFrom);
context.Properties.Add("ValidTo", response.Token.ValidTo);
}
}
}
catch (Exception ex)
{
Exception innerEx;
this._logProvider.TryLogException(ex, out innerEx);
if (innerEx != null)
{
throw innerEx;
}
}
}
public async Task ValidateIRequest(SamlInboundRequestContext request)
{
this._logProvider.LogMessage("Validating saml response.");
var validationContext = new SamlRequestValidationContext(request);
var rules = this._ruleFactory.GetValidationRules();
var seed = new Func <ValidationContext, Task>(c =>
{
if (!c.IsValid)
{
throw new Exception(EnumerableExtensions.Aggregate(validationContext.ValidationResult.Select(x => x.ErrorMessage)));
}
return(Task.CompletedTask);
});
var del = rules
.Reverse()
.Aggregate(seed, (next, r) => new Func <ValidationContext, Task>(ctx => r.Validate(ctx, next)));
await del(validationContext);
}
public async Task <ClaimsIdentity> Handle(HttpPostResponseContext context)
{
try
{
//ToDo handle this properly, response handling, token validation, claims generation etc
var elements = context.Form;
var responseBase64 = elements[HttpRedirectBindingConstants.SamlResponse];
var responseBytes = Convert.FromBase64String(responseBase64);
var responseText = Encoding.UTF8.GetString(responseBytes);
var relayState = await this._relayStateHandler.GetRelayStateFromFormData(elements);
this._logProvider.LogMessage(String.Format("Response recieved:\r\n {0}", responseText));
var responseStatus = ResponseHelper.ParseResponseStatus(responseText, this._logProvider);
ResponseHelper.EnsureSuccessAndThrow(responseStatus);
using (var reader = new StringReader(responseText))
{
using (var xmlReader = XmlReader.Create(reader))
{
var handlerContext = new HandleTokenContext(xmlReader, relayState, context.AuthenticationMethod);
var response = await this._tokenHandler.HandleToken(handlerContext);
if (!response.IsValid)
{
throw new Exception(EnumerableExtensions.Aggregate(response.ValidationResults.Select(x => x.ErrorMessage)));
}
return(response.Identity);
}
}
}
catch (Exception ex)
{
Exception innerEx;
this._logProvider.TryLogException(ex, out innerEx);
if (innerEx != null)
{
throw innerEx;
}
}
return(null);
}
public async Task ValidateResponse(SamlInboundResponseContext response)
{
this._logProvider.LogMessage("Validating saml response.");
var context = new SamlResponseValidationContext(response);
var rules = this._ruleFactory.GetValidationRules(r => r.Scope == (response.IsIdpInitiated ? RuleScope.IdpInitiated : RuleScope.SPInitiated));
var seed = new Func <ValidationContext, Task>(c =>
{
if (!c.IsValid)
{
throw new Exception(EnumerableExtensions.Aggregate(context.ValidationResult.Select(x => x.ErrorMessage)));
}
context.ResponseContext.Validated();
return(Task.CompletedTask);
});
var del = rules
.Reverse()
.Aggregate(seed, (next, r) => new Func <ValidationContext, Task>(ctx => r.Validate(ctx, next)));
await del(context);
}
