public async Task When_A_Consent_Has_Been_Given_And_The_AuthorizationFlow_Is_Not_Supported_Then_Exception_Is_Thrown()
{
// ARRANGE
InitializeFakeObjects();
const string clientId = "clientId";
const string state = "state";
var claimsIdentity = new ClaimsIdentity();
var claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
var responseTypes = new List <ResponseType>();
var authorizationParameter = new AuthorizationParameter
{
ClientId = clientId,
State = state,
ResponseMode = ResponseMode.None // No response mode is defined
};
var consent = new Core.Models.Consent();
_clientRepositoryFake.Setup(c => c.GetClientByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new Client()));
_consentHelperFake.Setup(c => c.GetConfirmedConsentsAsync(It.IsAny <string>(),
It.IsAny <AuthorizationParameter>()))
.Returns(Task.FromResult(consent));
_parameterParserHelperFake.Setup(p => p.ParseResponseTypes(It.IsAny <string>()))
.Returns(responseTypes);
// ACT & ASSERTS
var exception = await Assert.ThrowsAsync <IdentityServerExceptionWithState>(() => _displayConsentAction.Execute(authorizationParameter,
claimsPrincipal));
Assert.True(exception.Code == ErrorCodes.InvalidRequestCode);
Assert.True(exception.Message == ErrorDescriptions.TheAuthorizationFlowIsNotSupported);
Assert.True(exception.State == state);
}
public async Task When_A_Consent_Has_Been_Given_Then_Redirect_To_Callback()
{
// ARRANGE
InitializeFakeObjects();
var claimsIdentity = new ClaimsIdentity();
var claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
var actionResult = new ActionResult
{
RedirectInstruction = new RedirectInstruction()
};
var authorizationParameter = new AuthorizationParameter
{
ResponseMode = ResponseMode.fragment
};
var consent = new Core.Models.Consent();
_clientRepositoryFake.Setup(c => c.GetClientByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new Client()));
_consentHelperFake.Setup(c => c.GetConfirmedConsentsAsync(It.IsAny <string>(),
It.IsAny <AuthorizationParameter>()))
.Returns(Task.FromResult(consent));
_actionResultFactoryFake.Setup(a => a.CreateAnEmptyActionResultWithRedirectionToCallBackUrl())
.Returns(actionResult);
// ACT
var result = await _displayConsentAction.Execute(authorizationParameter, claimsPrincipal);
// ASSERT
_actionResultFactoryFake.Verify(a => a.CreateAnEmptyActionResultWithRedirectionToCallBackUrl());
Assert.True(result.ActionResult.RedirectInstruction.ResponseMode == ResponseMode.fragment);
}
public async Task <bool> DeleteAsync(Core.Models.Consent record)
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
var consent = await _context.Consents.FirstOrDefaultAsync(c => c.Id == record.Id).ConfigureAwait(false);
if (consent == null)
{
return(false);
}
_context.Consents.Remove(consent);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
_managerEventSource.Failure(ex);
transaction.Rollback();
return(false);
}
}
return(true);
}
public async Task When_Consent_Has_Already_Been_Given_Then_Redirect_To_Callback()
{
// ARRANGE
InitializeFakeObjects();
const string subject = "subject";
const string code = "code";
var prompts = new List <PromptParameter>
{
PromptParameter.none
};
var actionResult = new ActionResult
{
RedirectInstruction = new RedirectInstruction()
};
var consent = new Core.Models.Consent();
var authorizationParameter = new AuthorizationParameter
{
ResponseMode = ResponseMode.form_post
};
var claims = new List <Claim>();
_clientRepositoryStub.Setup(c => c.GetClientByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new Client()));
_parameterParserHelperFake.Setup(p => p.ParsePrompts(It.IsAny <string>()))
.Returns(prompts);
_consentHelperFake.Setup(c => c.GetConfirmedConsentsAsync(It.IsAny <string>(),
It.IsAny <AuthorizationParameter>()))
.Returns(Task.FromResult(consent));
_actionResultFactoryFake.Setup(a => a.CreateAnEmptyActionResultWithRedirectionToCallBackUrl())
.Returns(actionResult);
// ACT
actionResult = await _authenticateHelper.ProcessRedirection(authorizationParameter,
code,
subject,
claims);
// ASSERTS
Assert.True(actionResult.RedirectInstruction.ResponseMode == ResponseMode.form_post);
}
public async Task <Core.Models.Consent> InsertAsync(Core.Models.Consent record)
{
Core.Models.Consent result = null;
using (var transaction = _context.Database.BeginTransaction())
{
try
{
var clientId = record.Client.ClientId;
var resourceOwnerId = record.ResourceOwner.Id;
var client = await _context.Clients.FirstOrDefaultAsync(c => c.ClientId == clientId).ConfigureAwait(false);
var resourceOwner = await _context.ResourceOwners.FirstOrDefaultAsync(r => r.Id == resourceOwnerId).ConfigureAwait(false);
var assignedClaims = new List <ConsentClaim>();
var assignedScopes = new List <ConsentScope>();
if (record.Claims != null)
{
var claimCodes = record.Claims;
var codes = await _context.Claims.Where(c => claimCodes.Contains(c.Code)).Select(c => c.Code).ToListAsync().ConfigureAwait(false);
foreach (var code in codes)
{
assignedClaims.Add(new ConsentClaim
{
ClaimCode = code
});
}
}
if (record.GrantedScopes != null)
{
var scopeNames = record.GrantedScopes.Select(g => g.Name);
var names = await _context.Scopes.Where(s => scopeNames.Contains(s.Name)).Select(s => s.Name).ToListAsync().ConfigureAwait(false);
foreach (var name in names)
{
assignedScopes.Add(new ConsentScope
{
ScopeName = name
});
}
}
var newConsent = new Consent
{
Id = Guid.NewGuid().ToString(),
Client = client,
ResourceOwner = resourceOwner,
ConsentClaims = assignedClaims,
ConsentScopes = assignedScopes
};
var insertedConsent = _context.Consents.Add(newConsent);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
result = insertedConsent.Entity.ToDomain();
}
catch (Exception ex)
{
_managerEventSource.Failure(ex);
transaction.Rollback();
}
}
return(result);
}
