Skip to content
Original file line number Diff line number Diff line change
Expand Up @@ -13,14 +13,28 @@ public class ExtendedProviderAbilityCacheService(
{
public const string CacheName = "ProviderAbilities";

public async Task<ProviderAbility?> GetProviderAbilityAsync(Guid providerId)
public async Task<ProviderAbility?> GetProviderAbilityAsync(Guid providerId, CancellationToken cancellationToken = default)
Comment thread
eliykat marked this conversation as resolved.
Resolved
{
return await cache.GetOrSetAsync<ProviderAbility?>(
$"{providerId}",
async _ => await providerRepository.GetAbilityAsync(providerId)
async (_, _) => await providerRepository.GetAbilityAsync(providerId),
token: cancellationToken
);
}

public async Task<Dictionary<Guid, ProviderAbility>> GetProviderAbilitiesAsync(IEnumerable<Guid> providerIds, CancellationToken cancellationToken = default)
{
var tasks = providerIds
.Distinct()
.Select(providerId => GetProviderAbilityAsync(providerId, cancellationToken));

var results = await Task.WhenAll(tasks);

return results
.Where(ability => ability != null)
.ToDictionary(ability => ability!.Id, ability => ability!);
}

public async Task UpsertProviderAbilityAsync(Provider provider)
{
await cache.SetAsync($"{provider.Id}", new ProviderAbility(provider));
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,8 @@ namespace Bit.Core.AdminConsole.AbilitiesCache;

public interface IProviderAbilityCacheService
{
Task<ProviderAbility?> GetProviderAbilityAsync(Guid providerId);
Task<ProviderAbility?> GetProviderAbilityAsync(Guid providerId, CancellationToken cancellationToken = default);
Task<Dictionary<Guid, ProviderAbility>> GetProviderAbilitiesAsync(IEnumerable<Guid> providerIds, CancellationToken cancellationToken = default);
Task UpsertProviderAbilityAsync(Provider provider);
Task DeleteProviderAbilityAsync(Guid providerId);
}
Original file line number Diff line number Diff line change
Expand Up @@ -37,6 +37,11 @@ public Task<IDictionary<Guid, ProviderAbility>> GetProviderAbilitiesAsync() =>

public async Task<IDictionary<Guid, ProviderAbility>> GetProviderAbilitiesAsync(IEnumerable<Guid> providerIds)
{
if (featureService.IsEnabled(FeatureFlagKeys.ProviderAbilityExtendedCache))
{
return await providerAbilityCacheService.GetProviderAbilitiesAsync(providerIds);
}

var allProviderAbilities = await inMemoryApplicationCacheService.GetProviderAbilitiesAsync();
return providerIds
.Distinct()
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,131 @@
ο»Ώusing Bit.Core.AdminConsole.AbilitiesCache;
using Bit.Core.AdminConsole.Models.Data.Provider;
using Bit.Core.AdminConsole.Repositories;
using Bit.Test.Common.AutoFixture;
using Bit.Test.Common.AutoFixture.Attributes;
using NSubstitute;
using Xunit;
using ZiggyCreatures.Caching.Fusion;

namespace Bit.Core.Test.AdminConsole.AbilitiesCache;

[SutProviderCustomize]
public class ExtendedProviderAbilityCacheServiceTests
{
[Theory, BitAutoData]
public async Task GetProviderAbilitiesAsync_ReturnsAvailableAbilitiesForRequestedIds(
SutProvider<ExtendedProviderAbilityCacheService> sutProvider,
ProviderAbility requestedAbility1,
ProviderAbility requestedAbility2,
ProviderAbility nonRequestedAbility,
ProviderAbility nonExistAbility)
{
// Arrange
SetupCacheReturns(sutProvider, requestedAbility1, requestedAbility2, nonRequestedAbility);

// Act
var result = await sutProvider.Sut.GetProviderAbilitiesAsync([requestedAbility1.Id, requestedAbility2.Id, nonExistAbility.Id]);

// Assert
Assert.Equal(2, result.Count);
Assert.Equal(requestedAbility1, result[requestedAbility1.Id]);
Assert.Equal(requestedAbility2, result[requestedAbility2.Id]);
Assert.DoesNotContain(nonRequestedAbility.Id, result.Keys);
Assert.DoesNotContain(nonExistAbility.Id, result.Keys);
}

[Theory, BitAutoData]
public async Task GetProviderAbilitiesAsync_WhenProviderNotFound_ExcludesNullAbilities(
SutProvider<ExtendedProviderAbilityCacheService> sutProvider,
ProviderAbility ability,
Guid missingProviderId)
{
// Arrange
SetupCacheReturns(sutProvider, ability);
sutProvider.GetDependency<IFusionCache>()
.GetOrSetAsync<ProviderAbility?>(
$"{missingProviderId}",
Arg.Any<Func<FusionCacheFactoryExecutionContext<ProviderAbility?>, CancellationToken, Task<ProviderAbility?>>>(),
token: Arg.Any<CancellationToken>())
.Returns((ProviderAbility?)null);

// Act
var result = await sutProvider.Sut.GetProviderAbilitiesAsync([ability.Id, missingProviderId]);

// Assert
Assert.Single(result);
Assert.Equal(ability, result[ability.Id]);
}

[Theory, BitAutoData]
public async Task GetProviderAbilitiesAsync_WhenDuplicateIdsProvided_DoesNotThrowAndReturnsSingleEntry(
SutProvider<ExtendedProviderAbilityCacheService> sutProvider,
ProviderAbility ability)
{
// Arrange
SetupCacheReturns(sutProvider, ability);

// Act
var result = await sutProvider.Sut.GetProviderAbilitiesAsync([ability.Id, ability.Id, ability.Id]);

// Assert
Assert.Single(result);
Assert.Equal(ability, result[ability.Id]);
await sutProvider.GetDependency<IFusionCache>()
.Received(1)
.GetOrSetAsync<ProviderAbility?>(
$"{ability.Id}",
Arg.Any<Func<FusionCacheFactoryExecutionContext<ProviderAbility?>, CancellationToken, Task<ProviderAbility?>>>(),
token: Arg.Any<CancellationToken>());
}

[Theory, BitAutoData]
public async Task GetProviderAbilitiesAsync_WhenEmptyList_ReturnsEmptyDictionary(
SutProvider<ExtendedProviderAbilityCacheService> sutProvider)
{
// Act
var result = await sutProvider.Sut.GetProviderAbilitiesAsync([]);

// Assert
Assert.Empty(result);
await sutProvider.GetDependency<IProviderRepository>()
.DidNotReceiveWithAnyArgs()
.GetAbilityAsync(default);
}

[Theory, BitAutoData]
public async Task GetProviderAbilitiesAsync_WhenAllProvidersNotFound_ReturnsEmptyDictionary(
SutProvider<ExtendedProviderAbilityCacheService> sutProvider,
Guid missingId1,
Guid missingId2)
{
// Arrange
sutProvider.GetDependency<IFusionCache>()
.GetOrSetAsync<ProviderAbility?>(
Arg.Any<string>(),
Arg.Any<Func<FusionCacheFactoryExecutionContext<ProviderAbility?>, CancellationToken, Task<ProviderAbility?>>>(),
token: Arg.Any<CancellationToken>())
.Returns((ProviderAbility?)null);

// Act
var result = await sutProvider.Sut.GetProviderAbilitiesAsync([missingId1, missingId2]);

// Assert
Assert.Empty(result);
}

private static void SetupCacheReturns(
SutProvider<ExtendedProviderAbilityCacheService> sutProvider,
params ProviderAbility[] abilities)
{
foreach (var ability in abilities)
{
sutProvider.GetDependency<IFusionCache>()
.GetOrSetAsync<ProviderAbility?>(
$"{ability.Id}",
Arg.Any<Func<FusionCacheFactoryExecutionContext<ProviderAbility?>, CancellationToken, Task<ProviderAbility?>>>(),
token: Arg.Any<CancellationToken>())
.Returns(ability);
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -314,6 +314,35 @@ public async Task GetProviderAbilitiesAsync_WhenDuplicateIdsProvided_DoesNotThro
Assert.Equal(ability, result[ability.Id]);
}

[Theory, BitAutoData]
public async Task GetProviderAbilitiesAsync_WhenFlagOn_ReturnsFromExtendedCacheService(
SutProvider<FeatureRoutedCacheService> sutProvider,
ProviderAbility ability)
{
// Arrange
var providerIds = new[] { ability.Id };
var expectedResult = new Dictionary<Guid, ProviderAbility> { [ability.Id] = ability };
sutProvider.GetDependency<IFeatureService>()
.IsEnabled(FeatureFlagKeys.ProviderAbilityExtendedCache)
.Returns(true);
sutProvider.GetDependency<IProviderAbilityCacheService>()
.GetProviderAbilitiesAsync(providerIds)
.Returns(expectedResult);

// Act
var result = await sutProvider.Sut.GetProviderAbilitiesAsync(providerIds);

// Assert
Assert.Single(result);
Assert.Equal(ability, result[ability.Id]);
await sutProvider.GetDependency<IProviderAbilityCacheService>()
.Received(1)
.GetProviderAbilitiesAsync(providerIds);
await sutProvider.GetDependency<IVCurrentInMemoryApplicationCacheService>()
.DidNotReceiveWithAnyArgs()
.GetProviderAbilitiesAsync();
}

[Theory, BitAutoData]
public async Task GetOrganizationAbilitiesAsync_WhenFlagOff_ReturnsFromInMemoryService(
SutProvider<FeatureRoutedCacheService> sutProvider,
Expand Down
Loading