diff --git a/src/Core/AdminConsole/AbilitiesCache/ExtendedProviderAbilityCacheService.cs b/src/Core/AdminConsole/AbilitiesCache/ExtendedProviderAbilityCacheService.cs index 036320961b56..39e259300474 100644 --- a/src/Core/AdminConsole/AbilitiesCache/ExtendedProviderAbilityCacheService.cs +++ b/src/Core/AdminConsole/AbilitiesCache/ExtendedProviderAbilityCacheService.cs @@ -13,14 +13,28 @@ public class ExtendedProviderAbilityCacheService( { public const string CacheName = "ProviderAbilities"; - public async Task GetProviderAbilityAsync(Guid providerId) + public async Task GetProviderAbilityAsync(Guid providerId, CancellationToken cancellationToken = default) { return await cache.GetOrSetAsync( $"{providerId}", - async _ => await providerRepository.GetAbilityAsync(providerId) + async (_, _) => await providerRepository.GetAbilityAsync(providerId), + token: cancellationToken ); } + public async Task> GetProviderAbilitiesAsync(IEnumerable 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)); diff --git a/src/Core/AdminConsole/AbilitiesCache/IProviderAbilityCacheService.cs b/src/Core/AdminConsole/AbilitiesCache/IProviderAbilityCacheService.cs index 71e5bb572c2e..a838406bf518 100644 --- a/src/Core/AdminConsole/AbilitiesCache/IProviderAbilityCacheService.cs +++ b/src/Core/AdminConsole/AbilitiesCache/IProviderAbilityCacheService.cs @@ -5,7 +5,8 @@ namespace Bit.Core.AdminConsole.AbilitiesCache; public interface IProviderAbilityCacheService { - Task GetProviderAbilityAsync(Guid providerId); + Task GetProviderAbilityAsync(Guid providerId, CancellationToken cancellationToken = default); + Task> GetProviderAbilitiesAsync(IEnumerable providerIds, CancellationToken cancellationToken = default); Task UpsertProviderAbilityAsync(Provider provider); Task DeleteProviderAbilityAsync(Guid providerId); } diff --git a/src/Core/Services/Implementations/FeatureRoutedCacheService.cs b/src/Core/Services/Implementations/FeatureRoutedCacheService.cs index 609d3b4b1660..2e0385f5835d 100644 --- a/src/Core/Services/Implementations/FeatureRoutedCacheService.cs +++ b/src/Core/Services/Implementations/FeatureRoutedCacheService.cs @@ -37,6 +37,11 @@ public Task> GetProviderAbilitiesAsync() => public async Task> GetProviderAbilitiesAsync(IEnumerable providerIds) { + if (featureService.IsEnabled(FeatureFlagKeys.ProviderAbilityExtendedCache)) + { + return await providerAbilityCacheService.GetProviderAbilitiesAsync(providerIds); + } + var allProviderAbilities = await inMemoryApplicationCacheService.GetProviderAbilitiesAsync(); return providerIds .Distinct() diff --git a/test/Core.Test/AdminConsole/AbilitiesCache/ExtendedProviderAbilityCacheServiceTests.cs b/test/Core.Test/AdminConsole/AbilitiesCache/ExtendedProviderAbilityCacheServiceTests.cs new file mode 100644 index 000000000000..164872f4b484 --- /dev/null +++ b/test/Core.Test/AdminConsole/AbilitiesCache/ExtendedProviderAbilityCacheServiceTests.cs @@ -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 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 sutProvider, + ProviderAbility ability, + Guid missingProviderId) + { + // Arrange + SetupCacheReturns(sutProvider, ability); + sutProvider.GetDependency() + .GetOrSetAsync( + $"{missingProviderId}", + Arg.Any, CancellationToken, Task>>(), + token: Arg.Any()) + .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 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() + .Received(1) + .GetOrSetAsync( + $"{ability.Id}", + Arg.Any, CancellationToken, Task>>(), + token: Arg.Any()); + } + + [Theory, BitAutoData] + public async Task GetProviderAbilitiesAsync_WhenEmptyList_ReturnsEmptyDictionary( + SutProvider sutProvider) + { + // Act + var result = await sutProvider.Sut.GetProviderAbilitiesAsync([]); + + // Assert + Assert.Empty(result); + await sutProvider.GetDependency() + .DidNotReceiveWithAnyArgs() + .GetAbilityAsync(default); + } + + [Theory, BitAutoData] + public async Task GetProviderAbilitiesAsync_WhenAllProvidersNotFound_ReturnsEmptyDictionary( + SutProvider sutProvider, + Guid missingId1, + Guid missingId2) + { + // Arrange + sutProvider.GetDependency() + .GetOrSetAsync( + Arg.Any(), + Arg.Any, CancellationToken, Task>>(), + token: Arg.Any()) + .Returns((ProviderAbility?)null); + + // Act + var result = await sutProvider.Sut.GetProviderAbilitiesAsync([missingId1, missingId2]); + + // Assert + Assert.Empty(result); + } + + private static void SetupCacheReturns( + SutProvider sutProvider, + params ProviderAbility[] abilities) + { + foreach (var ability in abilities) + { + sutProvider.GetDependency() + .GetOrSetAsync( + $"{ability.Id}", + Arg.Any, CancellationToken, Task>>(), + token: Arg.Any()) + .Returns(ability); + } + } +} diff --git a/test/Core.Test/Services/Implementations/FeatureRoutedCacheServiceTests.cs b/test/Core.Test/Services/Implementations/FeatureRoutedCacheServiceTests.cs index 5e01ed5b18e4..ad1e527fbf49 100644 --- a/test/Core.Test/Services/Implementations/FeatureRoutedCacheServiceTests.cs +++ b/test/Core.Test/Services/Implementations/FeatureRoutedCacheServiceTests.cs @@ -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 sutProvider, + ProviderAbility ability) + { + // Arrange + var providerIds = new[] { ability.Id }; + var expectedResult = new Dictionary { [ability.Id] = ability }; + sutProvider.GetDependency() + .IsEnabled(FeatureFlagKeys.ProviderAbilityExtendedCache) + .Returns(true); + sutProvider.GetDependency() + .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() + .Received(1) + .GetProviderAbilitiesAsync(providerIds); + await sutProvider.GetDependency() + .DidNotReceiveWithAnyArgs() + .GetProviderAbilitiesAsync(); + } + [Theory, BitAutoData] public async Task GetOrganizationAbilitiesAsync_WhenFlagOff_ReturnsFromInMemoryService( SutProvider sutProvider,