public async void PutAccessContext_Should_Update_If_UserId_CredentialsId_ProviderName_Have_Match()
{
string userId = Guid.NewGuid().ToString();
string credentialsId = Guid.NewGuid().ToString();
string providerName = Guid.NewGuid().ToString();
string newValue = "MyNewValue";
_mockCacheItems.Add(userId, new List <AccountAccessContext> {
new AccountAccessContext {
UserId = userId, CredentialsId = credentialsId, ProviderName = providerName
}
});
SetupCacheGetMethod(userId);
var newContext = new AccountAccessContext {
UserId = userId, CredentialsId = credentialsId, ProviderName = providerName, AccessToken = newValue
};
SetupCacheSetMethod(userId);
var result = await _accessContextCachingService.PutAccessContext(newContext);
Assert.True(result.Success);
Assert.Single(_mockCacheItems[userId]);
_mockCache.Verify(x => x.GetAsync(userId, default), Times.Once);
_mockCache.Verify(x => x.SetAsync(userId, It.IsAny <byte[]>(), It.IsAny <DistributedCacheEntryOptions>(), default), Times.Once);
Assert.Equal(newValue, _mockCacheItems[userId].Single().AccessToken);
}
public async void PutAccessContext_Should_Add_Additional_Item_If_Different_ProviderName()
{
string userId = Guid.NewGuid().ToString();
string credentialsId = Guid.NewGuid().ToString();
string providerName = Guid.NewGuid().ToString();
_mockCacheItems.Add(userId, new List <AccountAccessContext> {
new AccountAccessContext {
UserId = userId, CredentialsId = credentialsId, ProviderName = providerName
}
});
SetupCacheGetMethod(userId);
var newContext = new AccountAccessContext {
UserId = userId, CredentialsId = credentialsId, ProviderName = "newProvider"
};
SetupCacheSetMethod(userId);
var result = await _accessContextCachingService.PutAccessContext(newContext);
Assert.True(result.Success);
Assert.Equal(2, _mockCacheItems[userId].Count);
_mockCache.Verify(x => x.GetAsync(userId, default), Times.Once);
_mockCache.Verify(x => x.SetAsync(userId, It.IsAny <byte[]>(), It.IsAny <DistributedCacheEntryOptions>(), default), Times.Once);
}
public async void RemoveMethod_Should_Remove_Item_If_Matches_UserId_CredentialsId_ProviderName()
{
string userId = Guid.NewGuid().ToString();
string credentialsId = Guid.NewGuid().ToString();
string providerName = Guid.NewGuid().ToString();
var accessContext = new AccountAccessContext
{
UserId = userId, CredentialsId = credentialsId, ProviderName = providerName
};
_mockCacheItems.Add(userId, new List <AccountAccessContext> {
accessContext
});
SetupCacheGetMethod(userId);
SetupCacheSetMethod(userId);
var result = await _accessContextCachingService.RemoveAccessContext(accessContext);
Assert.True(result.Success);
Assert.Empty(_mockCacheItems[userId]);
_mockCache.Verify(x => x.GetAsync(userId, default), Times.Once);
_mockCache.Verify(x => x.SetAsync(userId, It.IsAny <byte[]>(), It.IsAny <DistributedCacheEntryOptions>(), default), Times.Once);
}
public async Task <ServiceResult> Process(string userId, CallbackRequest callbackData)
{
if (!string.IsNullOrEmpty(callbackData.Error))
{
return(ServiceResult.Failed(new[] { ErrorMessages.CallbackStatedAccessDenied }));
}
var accountContext = new AccountAccessContext
{
UserId = userId,
Code = callbackData.Code,
Scopes = callbackData.GetScopes()
};
var exchangeCodeResult = await _authorizationService.ExchangeCode(accountContext);
if (!exchangeCodeResult.Success)
{
return(ServiceResult.Failed(exchangeCodeResult.Errors));
}
await _userDataCachingService.ClearUserData(userId);
return(ServiceResult.Succeeded());
}
private async Task <ServiceResult> ObtainMetadataAndUpdateCache(AccountAccessContext accessContext)
{
var accessMetadataResult =
await _trueLayerDataRequestExecutor.GetAccessTokenMetadata(accessContext.AccessToken);
if (!accessMetadataResult.Success)
{
return(ServiceResult.Failed(accessMetadataResult.Errors));
}
if (accessMetadataResult.Result == null)
{
return(ServiceResult.Failed(new List <string> {
ErrorMessages.FailedToObtainAccessTokenMetadata
}));
}
var accessMetadata = accessMetadataResult.Result.Results.Single();
accessContext.ProviderName = accessMetadata.Provider.DisplayName;
accessContext.CredentialsId = accessMetadata.CredentialsId;
await _accessContextCachingService.PutAccessContext(accessContext);
return(ServiceResult.Succeeded());
}
public async Task <ServiceObjectResult <ICollection <Account> > > GetAccountsInContext(
AccountAccessContext accessContext)
{
var accountsInContextResult = await _requestExecutor.GetAccounts(accessContext.AccessToken);
if (!accountsInContextResult.Success || accountsInContextResult.Result.Status != "Succeeded")
{
return(ServiceObjectResult <ICollection <Account> > .Failed(null,
accountsInContextResult.Errors ?? new List <string>
{
"An error occurred fetching account information"
}));
}
return(ServiceObjectResult <ICollection <Account> > .Succeeded(accountsInContextResult.Result.Results));
}
public async void GetAccountsInContext_Should_Return_Failed_If_Executor_Call_Fails()
{
var accessContext = new AccountAccessContext
{
AccessToken = "AccessToken"
};
_mockTrueLayerRequestExecutor.Setup(x => x.GetAccounts(accessContext.AccessToken))
.ReturnsAsync(ServiceObjectResult <TrueLayerListResponse <Account> > .Failed(null, new List <string> {
"Value"
}));
var result = await _accountService.GetAccountsInContext(accessContext);
Assert.False(result.Success);
_mockTrueLayerRequestExecutor.Verify(x => x.GetAccounts(accessContext.AccessToken), Times.Once);
}
public async void PutAccessMethod_Should_Create_New_List_If_New_UserId()
{
string userId = Guid.NewGuid().ToString();
SetupCacheGetMethod(userId);
SetupCacheSetMethod(userId);
var newContext = new AccountAccessContext {
UserId = userId, ProviderName = "newProvider"
};
var result = await _accessContextCachingService.PutAccessContext(newContext);
Assert.True(result.Success);
Assert.NotEmpty(_mockCacheItems[userId]);
_mockCache.Verify(x => x.GetAsync(userId, default), Times.Once);
_mockCache.Verify(x => x.SetAsync(userId, It.IsAny <byte[]>(), It.IsAny <DistributedCacheEntryOptions>(), default), Times.Once);
}
public async void RemoveMethod_Should_Not_Remove_Item_If_Any_UserId_CredentialsId_ProviderName_Differ()
{
string userId = Guid.NewGuid().ToString();
string credentialsId = Guid.NewGuid().ToString();
string providerName = Guid.NewGuid().ToString();
var accessContext = new AccountAccessContext
{
UserId = userId, CredentialsId = credentialsId, ProviderName = providerName
};
_mockCacheItems.Add(userId, new List <AccountAccessContext> {
accessContext
});
SetupCacheGetMethod(userId);
SetupCacheSetMethod(userId);
var newUserId = new AccountAccessContext
{
CredentialsId = accessContext.CredentialsId,
UserId = Guid.NewGuid().ToString(),
ProviderName = accessContext.ProviderName
};
var result1 = await _accessContextCachingService.RemoveAccessContext(newUserId);
var newProvider = new AccountAccessContext
{
ProviderName = Guid.NewGuid().ToString(),
UserId = accessContext.UserId,
CredentialsId = accessContext.CredentialsId
};
var result2 = await _accessContextCachingService.RemoveAccessContext(newProvider);
Assert.True(result1.Success);
Assert.True(result2.Success);
Assert.Single(_mockCacheItems[userId]);
Assert.Equal(userId, _mockCacheItems[userId].Single().UserId);
Assert.Equal(providerName, _mockCacheItems[userId].Single().ProviderName);
_mockCache.Verify(x => x.GetAsync(userId, default), Times.Exactly(1));
_mockCache.Verify(x => x.SetAsync(userId, It.IsAny <byte[]>(), It.IsAny <DistributedCacheEntryOptions>(), default), Times.Never);
}
public async Task <ServiceObjectResult <AuthResponse> > RefreshAccountAccess(AccountAccessContext accountContext)
{
var client = _clientFactory.CreateClient(HttpClients.TrueLayerAuthClientName);
var formContent = new FormUrlEncodedContent(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "refresh_token"),
new KeyValuePair <string, string>("client_id", _requestConfiguration.ClientId),
new KeyValuePair <string, string>("client_secret", _requestConfiguration.ClientSecret),
new KeyValuePair <string, string>("refresh_token", accountContext.RefreshToken)
});
var requestEndpoint = _requestTypeEndpointService.GetEndpoint(RequestType.RefreshAccess);
using (var response =
await client.PostAsync(requestEndpoint, formContent))
{
return(await ProcessResponse <AuthResponse>(response, RequestType.RefreshAccess,
$"{client.BaseAddress}{requestEndpoint}"));
}
}
private void SetupAccountContexts(bool expired, bool hasRefreshToken)
{
var accountContext = new AccountAccessContext {
AccessTokenExpiry = DateTime.UtcNow.AddMonths(1)
};
if (expired)
{
accountContext.AccessTokenExpiry = DateTime.UtcNow;
}
if (hasRefreshToken)
{
accountContext.RefreshToken = "string";
}
_mockAccessContextCachingService.Setup(x => x.RetrieveAccessContexts(It.IsAny <string>(), null))
.ReturnsAsync(
ServiceObjectResult <ICollection <AccountAccessContext> > .Succeeded(new List <AccountAccessContext> {
accountContext
}));
}
public async Task <ServiceObjectResult <AuthResponse> > ExchangeCode(AccountAccessContext accountContext)
{
var client = _clientFactory.CreateClient(HttpClients.TrueLayerAuthClientName);
var formContent = new FormUrlEncodedContent(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "authorization_code"),
new KeyValuePair <string, string>("client_id", _requestConfiguration.ClientId),
new KeyValuePair <string, string>("client_secret", _requestConfiguration.ClientSecret),
new KeyValuePair <string, string>("redirect_uri", $"{_requestConfiguration.CallbackUrlBase}{accountContext.UserId}"),
new KeyValuePair <string, string>("code", accountContext.Code)
});
var requestEndpoint = _requestTypeEndpointService.GetEndpoint(RequestType.ExchangeCode);
using (var response =
await client.PostAsync(requestEndpoint, formContent))
{
return(await ProcessResponse <AuthResponse>(response, RequestType.ExchangeCode,
$"{client.BaseAddress}{requestEndpoint}"));
}
}
public async Task <ServiceObjectResult <AccountAccessContext> > ExchangeCode(AccountAccessContext accessContext)
{
var exchangeCodeResult = await _trueLayerDataRequestExecutor.ExchangeCode(accessContext);
if (!exchangeCodeResult.Success)
{
return(ServiceObjectResult <AccountAccessContext> .Failed(accessContext, exchangeCodeResult.Errors));
}
accessContext.AccessToken = exchangeCodeResult.Result.AccessToken;
accessContext.RefreshToken = exchangeCodeResult.Result.RefreshToken;
accessContext.AccessTokenExpiry = DateTime.UtcNow.AddSeconds(exchangeCodeResult.Result.ExpiresIn);
var saveContextResult = await ObtainMetadataAndUpdateCache(accessContext);
if (!saveContextResult.Success)
{
return(ServiceObjectResult <AccountAccessContext> .Failed(null, saveContextResult.Errors));
}
return(ServiceObjectResult <AccountAccessContext> .Succeeded(accessContext));
}
public async void GetAccountsInContext_Should_Call_Executor_Method_With_Context_Token()
{
var accessContext = new AccountAccessContext
{
AccessToken = "AccessToken"
};
_mockTrueLayerRequestExecutor.Setup(x => x.GetAccounts(accessContext.AccessToken))
.ReturnsAsync(ServiceObjectResult <TrueLayerListResponse <Account> > .Succeeded(
new TrueLayerListResponse <Account>
{
Status = "Succeeded",
Results = new List <Account>
{
new Account()
}
}));
var result = await _accountService.GetAccountsInContext(accessContext);
Assert.True(result.Success);
_mockTrueLayerRequestExecutor.Verify(x => x.GetAccounts(accessContext.AccessToken), Times.Once);
}
public async Task <ServiceResult> RemoveAccessContext(AccountAccessContext accessContext)
{
var userAccessContexts = await _cache.Get <List <AccountAccessContext> >(accessContext.UserId);
if (userAccessContexts == null)
{
return(ServiceResult.Succeeded());
}
var existingAccessContext = userAccessContexts.FirstOrDefault(x =>
x.UserId == accessContext.UserId &&
x.ProviderName == accessContext.ProviderName);
if (existingAccessContext == null)
{
return(ServiceResult.Succeeded());
}
userAccessContexts.Remove(existingAccessContext);
await _cache.SetValueObject(accessContext.UserId, userAccessContexts);
return(ServiceResult.Succeeded());
}
