mirror of
https://github.com/bitwarden/server.git
synced 2025-07-02 08:32:50 -05:00
[AC-1512] Feature: Secrets Manager Billing - round 2 (#3119)
* [AC-1423] Add AddonProduct and BitwardenProduct properties to BillingSubscriptionItem (#3037)
* [AC-1423] Add AddonProduct and BitwardenProduct properties to BillingSubscriptionItem
- Add a helper method to determine the appropriate addon type based on the subscription items StripeId
* [AC-1423] Add helper to StaticStore.cs to find a Plan by StripePlanId
* [AC-1423] Use the helper method to set SubscriptionInfo.BitwardenProduct
* Add SecretsManagerBilling feature flag to Constants
* [AC 1409] Secrets Manager Subscription Stripe Integration (#3019)
* Adding the Secret manager to the Plan List
* Adding the unit test for the StaticStoreTests class
* Fix whitespace formatting
* Fix whitespace formatting
* Price update
* Resolving the PR comments
* Resolving PR comments
* Fixing the whitespace
* only password manager plans are return for now
* format whitespace
* Resolve the test issue
* Fixing the failing test
* Refactoring the Plan separation
* add a unit test for SingleOrDefault
* Fix the whitespace format
* Separate the PM and SM plans
* Fixing the whitespace
* Remove unnecessary directive
* Fix imports ordering
* Fix imports ordering
* Resolve imports ordering
* Fixing imports ordering
* Fix response model, add MaxProjects
* Fix filename
* Fix format
* Fix: seat price should match annual/monthly
* Fix service account annual pricing
* Changes for secret manager signup and upgradeplan
* Changes for secrets manager signup and upgrade
* refactoring the code
* Format whitespace
* remove unnecessary using directive
* Resolve the PR comment on Subscription creation
* Resolve PR comment
* Add password manager to the error message
* Add UseSecretsManager to the event log
* Resolve PR comment on plan validation
* Resolving pr comments for service account count
* Resolving pr comments for service account count
* Resolve the pr comments
* Remove the store procedure that is no-longer needed
* Rename a property properly
* Resolving the PR comment
* Resolve PR comments
* Resolving PR comments
* Resolving the Pr comments
* Resolving some PR comments
* Resolving the PR comments
* Resolving the build identity build
* Add additional Validation
* Resolve the Lint issues
* remove unnecessary using directive
* Remove the white spaces
* Adding unit test for the stripe payment
* Remove the incomplete test
* Fixing the failing test
* Fix the failing test
* Fix the fail test on organization service
* Fix the failing unit test
* Fix the whitespace format
* Fix the failing test
* Fix the whitespace format
* resolve pr comments
* Fix the lint message
* Resolve the PR comments
* resolve pr comments
* Resolve pr comments
* Resolve the pr comments
* remove unused code
* Added for sm validation test
* Fix the whitespace format issues
---------
Co-authored-by: Thomas Rittson <trittson@bitwarden.com>
Co-authored-by: Thomas Rittson <31796059+eliykat@users.noreply.github.com>
* SM-802: Add SecretsManagerBetaColumn SQL migration and Org table update
* SM-802: Run EF Migrations for SecretsManagerBeta
* SM-802: Update the two Org procs and View, and move data migration to a separate file
* SM-802: Add missing comma to Organization_Create
* [AC-1418] Add missing SecretsManagerPlan property to OrganizationResponseModel (#3055)
* SM-802: Remove extra GO statement from data migration script
* [AC 1460] Update Stripe Configuration (#3070)
* change the stripeseat id
* change service accountId to align with new product
* make all the Id name for consistent
* SM-802: Add SecretsManagerBeta to OrganizationResponseModel
* SM-802: Move SecretsManagerBeta from OrganizationResponseModel to OrganizationSubscriptionResponseModel. Use sp_refreshview instead of sp_refreshsqlmodule in the migration script.
* SM-802: Remove OrganizationUserOrganizationDetailsView.sql changes
* [AC 1410] Secrets Manager subscription adjustment back-end changes (#3036)
* Create UpgradeSecretsManagerSubscription command
---------
Co-authored-by: Thomas Rittson <trittson@bitwarden.com>
* SM-802: Remove SecretsManagerBetaColumn migration
* SM-802: Add SecretsManagerBetaColumn migration
* SM-802: Remove OrganizationUserOrganizationDetailsView update
* [AC-1495] Extract UpgradePlanAsync into a command (#3081)
* This is a pure lift & shift with no refactors
* Only register subscription commands in Api
---------
Co-authored-by: cyprain-okeke <cokeke@bitwarden.com>
* [AC-1503] Fix Stripe integration on organization upgrade (#3084)
* Fix SM parameters not being passed to Stripe
* Fix flaky test
* Fix error message
* [AC-1504] Allow SM max autoscale limits to be disabled (#3085)
* [AC-1488] Changed SM Signup and Upgrade paths to set SmServiceAccounts to include the plan BaseServiceAccount (#3086)
* [AC-1510] Enable access to Secrets Manager to Organization owner for new Subscription (#3089)
* Revert changes to ReferenceEvent code (#3091)
* Revert changes to ReferenceEvent code
This will be done in AC-1481
* Revert ReferenceEventType change
* Move NoopServiceAccountRepository to SM and update namespace
* [AC-1462] Add secrets manager service accounts autoscaling commands (#3059)
* Adding the Secret manager to the Plan List
* Adding the unit test for the StaticStoreTests class
* Fix whitespace formatting
* Fix whitespace formatting
* Price update
* Resolving the PR comments
* Resolving PR comments
* Fixing the whitespace
* only password manager plans are return for now
* format whitespace
* Resolve the test issue
* Fixing the failing test
* Refactoring the Plan separation
* add a unit test for SingleOrDefault
* Fix the whitespace format
* Separate the PM and SM plans
* Fixing the whitespace
* Remove unnecessary directive
* Fix imports ordering
* Fix imports ordering
* Resolve imports ordering
* Fixing imports ordering
* Fix response model, add MaxProjects
* Fix filename
* Fix format
* Fix: seat price should match annual/monthly
* Fix service account annual pricing
* Changes for secret manager signup and upgradeplan
* Changes for secrets manager signup and upgrade
* refactoring the code
* Format whitespace
* remove unnecessary using directive
* Changes for subscription Update
* Update the seatAdjustment and update
* Resolve the PR comment on Subscription creation
* Resolve PR comment
* Add password manager to the error message
* Add UseSecretsManager to the event log
* Resolve PR comment on plan validation
* Resolving pr comments for service account count
* Resolving pr comments for service account count
* Resolve the pr comments
* Remove the store procedure that is no-longer needed
* Add a new class for update subscription
* Modify the Update subscription for sm
* Add the missing property
* Rename a property properly
* Resolving the PR comment
* Resolve PR comments
* Resolving PR comments
* Resolving the Pr comments
* Resolving some PR comments
* Resolving the PR comments
* Resolving the build identity build
* Add additional Validation
* Resolve the Lint issues
* remove unnecessary using directive
* Remove the white spaces
* Adding unit test for the stripe payment
* Remove the incomplete test
* Fixing the failing test
* Fix the failing test
* Fix the fail test on organization service
* Fix the failing unit test
* Fix the whitespace format
* Fix the failing test
* Fix the whitespace format
* resolve pr comments
* Fix the lint message
* refactor the code
* Fix the failing Test
* adding a new endpoint
* Remove the unwanted code
* Changes for Command and Queries
* changes for command and queries
* Fix the Lint issues
* Fix imports ordering
* Resolve the PR comments
* resolve pr comments
* Resolve pr comments
* Fix the failing test on adjustSeatscommandtests
* Fix the failing test
* Fix the whitespaces
* resolve failing test
* rename a property
* Resolve the pr comments
* refactoring the existing implementation
* Resolve the whitespaces format issue
* Resolve the pr comments
* [AC-1462] Created IAvailableServiceAccountsQuery along its implementation and with unit tests
* [AC-1462] Renamed ICountNewServiceAccountSlotsRequiredQuery
* [AC-1462] Added IAutoscaleServiceAccountsCommand and implementation
* Add more unit testing
* fix the whitespaces issues
* [AC-1462] Added unit tests for AutoscaleServiceAccountsCommand
* Add more unit test
* Remove unnecessary directive
* Resolve some pr comments
* Adding more unit test
* adding more test
* add more test
* Resolving some pr comments
* Resolving some pr comments
* Resolving some pr comments
* resolve some pr comments
* Resolving pr comments
* remove whitespaces
* remove white spaces
* Resolving pr comments
* resolving pr comments and fixing white spaces
* resolving the lint error
* Run dotnet format
* resolving the pr comments
* Add a missing properties to plan response model
* Add the email sender for sm seat and service acct
* Add the email sender for sm seat and service acct
* Fix the failing test after email sender changes
* Add staticstorewrapper to properly test the plans
* Add more test and validate the existing test
* Fix the white spaces issues
* Remove staticstorewrapper and fix the test
* fix a null issue on autoscaling
* Suggestion: do all seat calculations in update model
* Resolve some pr comments
* resolving some pr comments
* Return value is unnecessary
* Resolve the failing test
* resolve pr comments
* Resolve the pr comments
* Resolving admin api failure and adding more test
* Resolve the issue failing admin project
* Fixing the failed test
* Clarify naming and add comments
* Clarify naming conventions
* Dotnet format
* Fix the failing dependency
* remove similar test
* [AC-1462] Rewrote AutoscaleServiceAccountsCommand to use UpdateSecretsManagerSubscriptionCommand which has the same logic
* [AC-1462] Deleted IAutoscaleServiceAccountsCommand as the logic will be moved to UpdateSecretsManagerSubscriptionCommand
* [AC-1462] Created method AdjustSecretsManagerServiceAccountsAsync
* [AC-1462] Changed SecretsManagerSubscriptionUpdate to only be set by its constructor
* [AC-1462] Added check to CountNewServiceAccountSlotsRequiredQuery and revised unit tests
* [AC-1462] Revised logic for CountNewServiceAccountSlotsRequiredQuery and fixed unit tests
* [AC-1462] Changed SecretsManagerSubscriptionUpdate to receive Organization as a parameter and fixed the unit tests
* [AC-1462] Renamed IUpdateSecretsManagerSubscriptionCommand methods UpdateSubscriptionAsync and AdjustServiceAccountsAsync
* [AC-1462] Rewrote unit test UpdateSubscriptionAsync_ValidInput_Passes
* [AC-1462] Registered CountNewServiceAccountSlotsRequiredQuery for dependency injection
* [AC-1462] Added parameter names to SecretsManagerSubscriptionUpdateRequestModel
* [AC-1462] Updated SecretsManagerSubscriptionUpdate logic to handle null parameters. Revised the unit tests to test null values
---------
Co-authored-by: cyprain-okeke <cokeke@bitwarden.com>
Co-authored-by: Thomas Rittson <trittson@bitwarden.com>
Co-authored-by: Thomas Rittson <31796059+eliykat@users.noreply.github.com>
* Add UsePasswordManager to sync data (#3114)
* [AC-1522] Fix service account check on upgrading (#3111)
* Resolved the checkmarx issues
* [AC-1521] Address checkmarx security feedback (#3124)
* Reinstate target attribute but add noopener noreferrer
* Update date on migration script
* Remove unused constant
* Revert "Remove unused constant"
This reverts commit 4fcb9da4d6.
This is required to make feature flags work on the client
* [AC-1458] Add Endpoint And Service Logic for secrets manager to existing subscription (#3087)
---------
Co-authored-by: Thomas Rittson <31796059+eliykat@users.noreply.github.com>
Co-authored-by: Thomas Rittson <trittson@bitwarden.com>
* Remove duplicate migrations from incorrectly resolved merge
* [AC-1468] Modified CountNewServiceAccountSlotsRequiredQuery to return zero if organization has SecretsManagerBeta == true (#3112)
Co-authored-by: Thomas Rittson <trittson@bitwarden.com>
* [Ac 1563] Unable to load billing and subscription related pages for non-enterprise organizations (#3138)
* Resolve the failing family plan
* resolve issues
* Resolve code related pr comments
* Resolve test related comments
* Resolving or comments
* [SM-809] Add service account slot limit check (#3093)
* Add service account slot limit check
* Add query to DI
* [AC-1462] Registered CountNewServiceAccountSlotsRequiredQuery for dependency injection
* remove duplicate DI entry
* Update unit tests
* Remove comment
* Code review updates
---------
Co-authored-by: cyprain-okeke <cokeke@bitwarden.com>
Co-authored-by: Thomas Rittson <trittson@bitwarden.com>
Co-authored-by: Thomas Rittson <31796059+eliykat@users.noreply.github.com>
Co-authored-by: Rui Tome <rtome@bitwarden.com>
* [AC-1461] Secrets manager seat autoscaling (#3121)
* Add autoscaling code to invite user, save user, and bulk enable SM
flows
* Add tests
* Delete command for BulkEnableSecretsManager
* circular dependency between OrganizationService and
UpdateSecretsManagerSubscriptionCommand - fixed by temporarily
duplicating ReplaceAndUpdateCache
* Unresolvable dependencies in other services - fixed by temporarily
registering noop services and moving around some DI code
All should be resolved in PM-1880
* Refactor: improve the update object and use it to adjust values,
remove excess interfaces on the command
* Handle autoscaling-specific errors
---------
Co-authored-by: Rui Tomé <108268980+r-tome@users.noreply.github.com>
* Move bitwarden_license include reference into conditional block
* [AC 1526]Show current SM seat and service account usage in Bitwarden Portal (#3142)
* changes base on the tickets request
* Code refactoring
* Removed the unwanted method
* Add implementation to the new method
* Resolve some pr comments
* resolve lint issue
* resolve pr comments
* add the new noop files
* Add new noop file and resolve some pr comments
* resolve pr comments
* removed unused method
---------
Co-authored-by: Shane Melton <smelton@bitwarden.com>
Co-authored-by: cyprain-okeke <108260115+cyprain-okeke@users.noreply.github.com>
Co-authored-by: Colton Hurst <colton@coltonhurst.com>
Co-authored-by: cyprain-okeke <cokeke@bitwarden.com>
Co-authored-by: Rui Tomé <108268980+r-tome@users.noreply.github.com>
Co-authored-by: Conner Turnbull <cturnbull@bitwarden.com>
Co-authored-by: Rui Tome <rtome@bitwarden.com>
Co-authored-by: Thomas Avery <43214426+Thomas-Avery@users.noreply.github.com>
This commit is contained in:
Thomas Rittson
@ -43,6 +43,7 @@ public class OrganizationsControllerTests : IDisposable
|
||||
private readonly ILicensingService _licensingService;
|
||||
private readonly IUpdateSecretsManagerSubscriptionCommand _updateSecretsManagerSubscriptionCommand;
|
||||
private readonly IUpgradeOrganizationPlanCommand _upgradeOrganizationPlanCommand;
|
||||
private readonly IAddSecretsManagerSubscriptionCommand _addSecretsManagerSubscriptionCommand;
|
||||
|
||||
private readonly OrganizationsController _sut;
|
||||
|
||||
@ -69,13 +70,14 @@ public class OrganizationsControllerTests : IDisposable
|
||||
_licensingService = Substitute.For<ILicensingService>();
|
||||
_updateSecretsManagerSubscriptionCommand = Substitute.For<IUpdateSecretsManagerSubscriptionCommand>();
|
||||
_upgradeOrganizationPlanCommand = Substitute.For<IUpgradeOrganizationPlanCommand>();
|
||||
_addSecretsManagerSubscriptionCommand = Substitute.For<IAddSecretsManagerSubscriptionCommand>();
|
||||
|
||||
_sut = new OrganizationsController(_organizationRepository, _organizationUserRepository,
|
||||
_policyRepository, _providerRepository, _organizationService, _userService, _paymentService, _currentContext,
|
||||
_ssoConfigRepository, _ssoConfigService, _getOrganizationApiKeyQuery, _rotateOrganizationApiKeyCommand,
|
||||
_createOrganizationApiKeyCommand, _organizationApiKeyRepository, _updateOrganizationLicenseCommand,
|
||||
_cloudGetOrganizationLicenseQuery, _featureService, _globalSettings, _licensingService,
|
||||
_updateSecretsManagerSubscriptionCommand, _upgradeOrganizationPlanCommand);
|
||||
_updateSecretsManagerSubscriptionCommand, _upgradeOrganizationPlanCommand, _addSecretsManagerSubscriptionCommand);
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
|
||||
@ -2,8 +2,11 @@
|
||||
using Bit.Api.SecretsManager.Controllers;
|
||||
using Bit.Api.SecretsManager.Models.Request;
|
||||
using Bit.Core.Context;
|
||||
using Bit.Core.Entities;
|
||||
using Bit.Core.Enums;
|
||||
using Bit.Core.Exceptions;
|
||||
using Bit.Core.OrganizationFeatures.OrganizationSubscriptions.Interface;
|
||||
using Bit.Core.Repositories;
|
||||
using Bit.Core.SecretsManager.Commands.AccessTokens.Interfaces;
|
||||
using Bit.Core.SecretsManager.Commands.ServiceAccounts.Interfaces;
|
||||
using Bit.Core.SecretsManager.Entities;
|
||||
@ -89,14 +92,51 @@ public class ServiceAccountsControllerTests
|
||||
.CreateAsync(Arg.Any<ServiceAccount>(), Arg.Any<Guid>());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(0)]
|
||||
public async void CreateServiceAccount_WhenAutoscalingNotRequired_DoesNotCallUpdateSubscription(
|
||||
int newSlotsRequired, SutProvider<ServiceAccountsController> sutProvider,
|
||||
ServiceAccountCreateRequestModel data, Organization organization)
|
||||
{
|
||||
ArrangeCreateServiceAccountAutoScalingTest(newSlotsRequired, sutProvider, data, organization);
|
||||
|
||||
await sutProvider.Sut.CreateAsync(organization.Id, data);
|
||||
|
||||
await sutProvider.GetDependency<ICreateServiceAccountCommand>().Received(1)
|
||||
.CreateAsync(Arg.Is<ServiceAccount>(sa => sa.Name == data.Name), Arg.Any<Guid>());
|
||||
|
||||
await sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>().DidNotReceiveWithAnyArgs()
|
||||
.AdjustServiceAccountsAsync(Arg.Any<Organization>(), Arg.Any<int>());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(1)]
|
||||
[BitAutoData(2)]
|
||||
public async void CreateServiceAccount_WhenAutoscalingRequired_CallsUpdateSubscription(int newSlotsRequired,
|
||||
SutProvider<ServiceAccountsController> sutProvider,
|
||||
ServiceAccountCreateRequestModel data, Organization organization)
|
||||
{
|
||||
ArrangeCreateServiceAccountAutoScalingTest(newSlotsRequired, sutProvider, data, organization);
|
||||
|
||||
await sutProvider.Sut.CreateAsync(organization.Id, data);
|
||||
|
||||
await sutProvider.GetDependency<ICreateServiceAccountCommand>().Received(1)
|
||||
.CreateAsync(Arg.Is<ServiceAccount>(sa => sa.Name == data.Name), Arg.Any<Guid>());
|
||||
|
||||
await sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>().Received(1)
|
||||
.AdjustServiceAccountsAsync(Arg.Is(organization), Arg.Is(newSlotsRequired));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async void CreateServiceAccount_Success(SutProvider<ServiceAccountsController> sutProvider,
|
||||
ServiceAccountCreateRequestModel data, Guid organizationId)
|
||||
ServiceAccountCreateRequestModel data, Guid organizationId, Organization mockOrg)
|
||||
{
|
||||
mockOrg.Id = organizationId;
|
||||
sutProvider.GetDependency<IAuthorizationService>()
|
||||
.AuthorizeAsync(Arg.Any<ClaimsPrincipal>(), data.ToServiceAccount(organizationId),
|
||||
Arg.Any<IEnumerable<IAuthorizationRequirement>>()).ReturnsForAnyArgs(AuthorizationResult.Success());
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(Arg.Is(organizationId)).Returns(mockOrg);
|
||||
sutProvider.GetDependency<IUserService>().GetProperUserId(default).ReturnsForAnyArgs(Guid.NewGuid());
|
||||
var resultServiceAccount = data.ToServiceAccount(organizationId);
|
||||
sutProvider.GetDependency<ICreateServiceAccountCommand>().CreateAsync(default, default)
|
||||
@ -365,4 +405,20 @@ public class ServiceAccountsControllerTests
|
||||
Assert.Null(result.Error);
|
||||
}
|
||||
}
|
||||
|
||||
private static void ArrangeCreateServiceAccountAutoScalingTest(int newSlotsRequired, SutProvider<ServiceAccountsController> sutProvider,
|
||||
ServiceAccountCreateRequestModel data, Organization organization)
|
||||
{
|
||||
sutProvider.GetDependency<IAuthorizationService>()
|
||||
.AuthorizeAsync(Arg.Any<ClaimsPrincipal>(), data.ToServiceAccount(organization.Id),
|
||||
Arg.Any<IEnumerable<IAuthorizationRequirement>>()).ReturnsForAnyArgs(AuthorizationResult.Success());
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(Arg.Is(organization.Id)).Returns(organization);
|
||||
sutProvider.GetDependency<ICountNewServiceAccountSlotsRequiredQuery>()
|
||||
.CountNewServiceAccountSlotsRequiredAsync(organization.Id, 1)
|
||||
.ReturnsForAnyArgs(newSlotsRequired);
|
||||
sutProvider.GetDependency<IUserService>().GetProperUserId(default).ReturnsForAnyArgs(Guid.NewGuid());
|
||||
var resultServiceAccount = data.ToServiceAccount(organization.Id);
|
||||
sutProvider.GetDependency<ICreateServiceAccountCommand>().CreateAsync(default, default)
|
||||
.ReturnsForAnyArgs(resultServiceAccount);
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,107 @@
|
||||
using Bit.Core.Entities;
|
||||
using Bit.Core.Enums;
|
||||
using Bit.Core.Exceptions;
|
||||
using Bit.Core.Models.Business;
|
||||
using Bit.Core.Models.StaticStore;
|
||||
using Bit.Core.OrganizationFeatures.OrganizationSubscriptions;
|
||||
using Bit.Core.Services;
|
||||
using Bit.Core.Utilities;
|
||||
using Bit.Test.Common.AutoFixture;
|
||||
using Bit.Test.Common.AutoFixture.Attributes;
|
||||
using NSubstitute;
|
||||
using Xunit;
|
||||
|
||||
namespace Bit.Core.Test.OrganizationFeatures.OrganizationSubscriptionUpdate;
|
||||
[SutProviderCustomize]
|
||||
public class AddSecretsManagerSubscriptionCommandTests
|
||||
{
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
public async Task SignUpAsync_ReturnsSuccessAndClientSecret_WhenOrganizationAndPlanExist(PlanType planType,
|
||||
SutProvider<AddSecretsManagerSubscriptionCommand> sutProvider,
|
||||
int additionalServiceAccounts,
|
||||
int additionalSmSeats,
|
||||
Organization organization,
|
||||
bool useSecretsManager)
|
||||
{
|
||||
organization.PlanType = planType;
|
||||
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(p => p.Type == organization.PlanType);
|
||||
|
||||
await sutProvider.Sut.SignUpAsync(organization, additionalSmSeats, additionalServiceAccounts);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationService>().Received(1)
|
||||
.ValidateSecretsManagerPlan(plan, Arg.Is<OrganizationUpgrade>(c =>
|
||||
c.UseSecretsManager == useSecretsManager &&
|
||||
c.AdditionalSmSeats == additionalSmSeats &&
|
||||
c.AdditionalServiceAccounts == additionalServiceAccounts &&
|
||||
c.AdditionalSeats == organization.Seats.GetValueOrDefault()));
|
||||
|
||||
await sutProvider.GetDependency<IPaymentService>().Received()
|
||||
.AddSecretsManagerToSubscription(organization, plan, additionalSmSeats, additionalServiceAccounts);
|
||||
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
|
||||
sutProvider.GetDependency<IOrganizationService>().Received(1).ReplaceAndUpdateCacheAsync(Arg.Is<Organization>(c =>
|
||||
c.SmSeats == plan.BaseSeats + additionalSmSeats &&
|
||||
c.SmServiceAccounts == plan.BaseServiceAccount.GetValueOrDefault() + additionalServiceAccounts &&
|
||||
c.UseSecretsManager == true));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task SignUpAsync_ThrowsNotFoundException_WhenOrganizationIsNull(
|
||||
SutProvider<AddSecretsManagerSubscriptionCommand> sutProvider,
|
||||
int additionalServiceAccounts,
|
||||
int additionalSmSeats)
|
||||
{
|
||||
await Assert.ThrowsAsync<NotFoundException>(() =>
|
||||
sutProvider.Sut.SignUpAsync(null, additionalSmSeats, additionalServiceAccounts));
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task SignUpAsync_ThrowsGatewayException_WhenGatewayCustomerIdIsNullOrWhitespace(
|
||||
SutProvider<AddSecretsManagerSubscriptionCommand> sutProvider,
|
||||
Organization organization,
|
||||
int additionalServiceAccounts,
|
||||
int additionalSmSeats)
|
||||
{
|
||||
organization.GatewayCustomerId = null;
|
||||
organization.PlanType = PlanType.EnterpriseAnnually;
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() =>
|
||||
sutProvider.Sut.SignUpAsync(organization, additionalSmSeats, additionalServiceAccounts));
|
||||
Assert.Contains("No payment method found.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task SignUpAsync_ThrowsGatewayException_WhenGatewaySubscriptionIdIsNullOrWhitespace(
|
||||
SutProvider<AddSecretsManagerSubscriptionCommand> sutProvider,
|
||||
Organization organization,
|
||||
int additionalServiceAccounts,
|
||||
int additionalSmSeats)
|
||||
{
|
||||
organization.GatewaySubscriptionId = null;
|
||||
organization.PlanType = PlanType.EnterpriseAnnually;
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() =>
|
||||
sutProvider.Sut.SignUpAsync(organization, additionalSmSeats, additionalServiceAccounts));
|
||||
Assert.Contains("No subscription found.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
private static async Task VerifyDependencyNotCalledAsync(SutProvider<AddSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
await sutProvider.GetDependency<IPaymentService>().DidNotReceive()
|
||||
.AddSecretsManagerToSubscription(Arg.Any<Organization>(), Arg.Any<Plan>(), Arg.Any<int>(), Arg.Any<int>());
|
||||
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationService>().DidNotReceive().ReplaceAndUpdateCacheAsync(Arg.Any<Organization>());
|
||||
}
|
||||
}
|
||||
@ -7,6 +7,7 @@ using Bit.Core.OrganizationFeatures.OrganizationSubscriptions;
|
||||
using Bit.Core.Repositories;
|
||||
using Bit.Core.SecretsManager.Repositories;
|
||||
using Bit.Core.Services;
|
||||
using Bit.Core.Settings;
|
||||
using Bit.Core.Utilities;
|
||||
using Bit.Test.Common.AutoFixture;
|
||||
using Bit.Test.Common.AutoFixture.Attributes;
|
||||
@ -20,36 +21,26 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
{
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_NoOrganization_Throws(
|
||||
Guid organizationId,
|
||||
public async Task UpdateSubscriptionAsync_NoOrganization_Throws(
|
||||
SecretsManagerSubscriptionUpdate secretsManagerSubscriptionUpdate,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
sutProvider.GetDependency<IOrganizationRepository>()
|
||||
.GetByIdAsync(organizationId)
|
||||
.Returns((Organization)null);
|
||||
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = null,
|
||||
SmSeatsAdjustment = 0
|
||||
};
|
||||
secretsManagerSubscriptionUpdate.Organization = null;
|
||||
|
||||
var exception = await Assert.ThrowsAsync<NotFoundException>(
|
||||
() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
() => sutProvider.Sut.UpdateSubscriptionAsync(secretsManagerSubscriptionUpdate));
|
||||
|
||||
Assert.Contains("Organization is not found", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_NoSecretsManagerAccess_ThrowsException(
|
||||
Guid organizationId,
|
||||
public async Task UpdateSubscriptionAsync_NoSecretsManagerAccess_ThrowsException(
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
var organization = new Organization
|
||||
{
|
||||
Id = organizationId,
|
||||
SmSeats = 10,
|
||||
SmServiceAccounts = 5,
|
||||
UseSecretsManager = false,
|
||||
@ -57,26 +48,18 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
MaxAutoscaleSmServiceAccounts = 10
|
||||
};
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>()
|
||||
.GetByIdAsync(organizationId)
|
||||
.Returns(organization);
|
||||
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmSeats = 1
|
||||
};
|
||||
var secretsManagerSubscriptionUpdate = new SecretsManagerSubscriptionUpdate(organization, seatAdjustment: 0, maxAutoscaleSeats: null, serviceAccountAdjustment: 0, maxAutoscaleServiceAccounts: null);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(
|
||||
() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
() => sutProvider.Sut.UpdateSubscriptionAsync(secretsManagerSubscriptionUpdate));
|
||||
|
||||
Assert.Contains("Organization has no access to Secrets Manager.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_SeatsAdustmentGreaterThanMaxAutoscaleSeats_ThrowsException(
|
||||
public async Task UpdateSubscriptionAsync_SeatsAdjustmentGreaterThanMaxAutoscaleSeats_ThrowsException(
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
@ -89,29 +72,20 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
MaxAutoscaleSmSeats = 20,
|
||||
MaxAutoscaleSmServiceAccounts = 10,
|
||||
PlanType = PlanType.EnterpriseAnnually,
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 10,
|
||||
SmSeatsAdjustment = 15,
|
||||
SmSeats = organization.SmSeats.GetValueOrDefault() + 10,
|
||||
SmSeatsExcludingBase = (organization.SmSeats.GetValueOrDefault() + 10) - plan.BaseSeats,
|
||||
SmServiceAccounts = organization.SmServiceAccounts.GetValueOrDefault() + 5,
|
||||
SmServiceAccountsExcludingBase = (organization.SmServiceAccounts.GetValueOrDefault() + 5) - (int)plan.BaseServiceAccount
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 15, maxAutoscaleSeats: 10, serviceAccountAdjustment: 0, maxAutoscaleServiceAccounts: null);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("Cannot set max seat autoscaling below seat count.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_ServiceAccountsGreaterThanMaxAutoscaleSeats_ThrowsException(
|
||||
public async Task UpdateSubscriptionAsync_ServiceAccountsGreaterThanMaxAutoscaleSeats_ThrowsException(
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
@ -127,30 +101,17 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "9"
|
||||
};
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmServiceAccounts = 10,
|
||||
SmServiceAccountsAdjustment = 11,
|
||||
SmSeats = organization.SmSeats.GetValueOrDefault() + 1,
|
||||
SmSeatsExcludingBase = (organization.SmSeats.GetValueOrDefault() + 1) - plan.BaseSeats,
|
||||
SmServiceAccounts = organization.SmServiceAccounts.GetValueOrDefault() + 11,
|
||||
SmServiceAccountsExcludingBase = (organization.SmServiceAccounts.GetValueOrDefault() + 11) - (int)plan.BaseServiceAccount
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 1, maxAutoscaleSeats: 15, serviceAccountAdjustment: 11, maxAutoscaleServiceAccounts: 10);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
Assert.Contains("Cannot set max Service Accounts autoscaling below Service Accounts count", exception.Message);
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("Cannot set max service accounts autoscaling below service account amount", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_NullGatewayCustomerId_ThrowsException(
|
||||
public async Task UpdateSubscriptionAsync_NullGatewayCustomerId_ThrowsException(
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
@ -164,25 +125,17 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
MaxAutoscaleSmServiceAccounts = 15,
|
||||
PlanType = PlanType.EnterpriseAnnually
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmServiceAccounts = 15,
|
||||
SmServiceAccountsAdjustment = 1
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 1, maxAutoscaleSeats: 15, serviceAccountAdjustment: 1, maxAutoscaleServiceAccounts: 15);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("No payment method found.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_NullGatewaySubscriptionId_ThrowsException(
|
||||
public async Task UpdateSubscriptionAsync_NullGatewaySubscriptionId_ThrowsException(
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
@ -197,25 +150,17 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
PlanType = PlanType.EnterpriseAnnually,
|
||||
GatewayCustomerId = "1"
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmServiceAccounts = 15,
|
||||
SmServiceAccountsAdjustment = 1
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 1, maxAutoscaleSeats: 15, serviceAccountAdjustment: 1, maxAutoscaleServiceAccounts: 15);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("No subscription found.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_OrgWithNullSmSeatOnSeatsAdjustment_ThrowsException(
|
||||
public async Task UpdateSubscriptionAsync_OrgWithNullSmSeatOnSeatsAdjustment_ThrowsException(
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
@ -228,21 +173,14 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
MaxAutoscaleSmSeats = 20,
|
||||
MaxAutoscaleSmServiceAccounts = 15,
|
||||
PlanType = PlanType.EnterpriseAnnually,
|
||||
GatewayCustomerId = "1"
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmServiceAccounts = 15,
|
||||
SmServiceAccountsAdjustment = 1
|
||||
};
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 1, maxAutoscaleSeats: 15, serviceAccountAdjustment: 1, maxAutoscaleServiceAccounts: 15);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(
|
||||
() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
|
||||
Assert.Contains("Organization has no Secrets Manager seat limit, no need to adjust seats", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
@ -256,12 +194,11 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
[BitAutoData(PlanType.EnterpriseAnnually2019)]
|
||||
[BitAutoData(PlanType.TeamsMonthly2019)]
|
||||
[BitAutoData(PlanType.TeamsAnnually2019)]
|
||||
public async Task UpdateSecretsManagerSubscription_WithNonSecretsManagerPlanType_ThrowsBadRequestException(
|
||||
public async Task UpdateSubscriptionAsync_WithNonSecretsManagerPlanType_ThrowsBadRequestException(
|
||||
PlanType planType,
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
|
||||
var organization = new Organization
|
||||
{
|
||||
Id = organizationId,
|
||||
@ -270,95 +207,68 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
SmServiceAccounts = 200,
|
||||
MaxAutoscaleSmSeats = 20,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
PlanType = planType,
|
||||
PlanType = PlanType.EnterpriseAnnually,
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organization.Id,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 1
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 1, maxAutoscaleSeats: 15, serviceAccountAdjustment: 1, maxAutoscaleServiceAccounts: 300);
|
||||
organization.PlanType = planType;
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("Existing plan not found", exception.Message, StringComparison.InvariantCultureIgnoreCase);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.Free)]
|
||||
public async Task UpdateSecretsManagerSubscription_WithHasAdditionalSeatsOptionfalse_ThrowsBadRequestException(
|
||||
public async Task UpdateSubscriptionAsync_WithHasAdditionalSeatsOptionFalse_ThrowsBadRequestException(
|
||||
PlanType planType,
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
|
||||
var organization = new Organization
|
||||
{
|
||||
Id = organizationId,
|
||||
UseSecretsManager = true,
|
||||
SmSeats = 10,
|
||||
SmServiceAccounts = 200,
|
||||
MaxAutoscaleSmSeats = 20,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmSeats = 2,
|
||||
SmServiceAccounts = 3,
|
||||
PlanType = planType,
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organization.Id,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 1
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 1, maxAutoscaleSeats: null, serviceAccountAdjustment: 0, maxAutoscaleServiceAccounts: null);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
Assert.Contains("Plan does not allow additional Secrets Manager seats.", exception.Message, StringComparison.InvariantCultureIgnoreCase);
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("You have reached the maximum number of Secrets Manager seats (2) for this plan",
|
||||
exception.Message, StringComparison.InvariantCultureIgnoreCase);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.Free)]
|
||||
public async Task UpdateSecretsManagerSubscription_WithHasAdditionalServiceAccountOptionFalse_ThrowsBadRequestException(
|
||||
public async Task UpdateSubscriptionAsync_WithHasAdditionalServiceAccountOptionFalse_ThrowsBadRequestException(
|
||||
PlanType planType,
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
|
||||
var organization = new Organization
|
||||
{
|
||||
Id = organizationId,
|
||||
UseSecretsManager = true,
|
||||
SmSeats = 10,
|
||||
SmServiceAccounts = 200,
|
||||
MaxAutoscaleSmSeats = 20,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmSeats = 2,
|
||||
SmServiceAccounts = 3,
|
||||
PlanType = planType,
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organization.Id,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 0,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 1
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 0, maxAutoscaleSeats: null, serviceAccountAdjustment: 1, maxAutoscaleServiceAccounts: null);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
Assert.Contains("Plan does not allow additional Service Accounts", exception.Message, StringComparison.InvariantCultureIgnoreCase);
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("You have reached the maximum number of service accounts (3) for this plan",
|
||||
exception.Message, StringComparison.InvariantCultureIgnoreCase);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
@ -367,7 +277,7 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
public async Task UpdateSecretsManagerSubscription_ValidInput_Passes(
|
||||
public async Task UpdateSubscriptionAsync_ValidInput_Passes(
|
||||
PlanType planType,
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
@ -392,71 +302,89 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
};
|
||||
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
SmSeatsAdjustment = seatAdjustment,
|
||||
SmSeats = organization.SmSeats.GetValueOrDefault() + seatAdjustment,
|
||||
SmSeatsExcludingBase = (organization.SmSeats.GetValueOrDefault() + seatAdjustment) - plan.BaseSeats,
|
||||
MaxAutoscaleSmSeats = maxAutoscaleSeats,
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization,
|
||||
seatAdjustment: seatAdjustment, maxAutoscaleSeats: maxAutoscaleSeats,
|
||||
serviceAccountAdjustment: serviceAccountAdjustment, maxAutoscaleServiceAccounts: maxAutoScaleServiceAccounts);
|
||||
|
||||
SmServiceAccountsAdjustment = serviceAccountAdjustment,
|
||||
SmServiceAccounts = organization.SmServiceAccounts.GetValueOrDefault() + serviceAccountAdjustment,
|
||||
SmServiceAccountsExcludingBase = (organization.SmServiceAccounts.GetValueOrDefault() + serviceAccountAdjustment) - (int)plan.BaseServiceAccount,
|
||||
MaxAutoscaleSmServiceAccounts = maxAutoScaleServiceAccounts,
|
||||
await sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate);
|
||||
|
||||
MaxAutoscaleSmSeatsChanged = maxAutoscaleSeats != organization.MaxAutoscaleSeats.GetValueOrDefault(),
|
||||
MaxAutoscaleSmServiceAccountsChanged = 200 != organization.MaxAutoscaleSmServiceAccounts.GetValueOrDefault()
|
||||
};
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1)
|
||||
.AdjustSeatsAsync(organization, plan, organizationUpdate.SmSeatsExcludingBase);
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1)
|
||||
.AdjustServiceAccountsAsync(organization, plan, organizationUpdate.SmServiceAccountsExcludingBase);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
|
||||
await sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate);
|
||||
|
||||
if (organizationUpdate.SmSeatsAdjustment != 0)
|
||||
{
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1)
|
||||
.AdjustServiceAccountsAsync(organization, plan, organizationUpdate.SmServiceAccountsExcludingBase);
|
||||
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationService>().Received(1).ReplaceAndUpdateCacheAsync(
|
||||
Arg.Is<Organization>(org => org.SmSeats == organizationUpdate.SmSeats));
|
||||
}
|
||||
|
||||
if (organizationUpdate.SmServiceAccountsAdjustment != 0)
|
||||
{
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1)
|
||||
.AdjustSeatsAsync(organization, plan, organizationUpdate.SmSeatsExcludingBase);
|
||||
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationService>().Received(1).ReplaceAndUpdateCacheAsync(
|
||||
Arg.Is<Organization>(org =>
|
||||
org.SmServiceAccounts == (organizationServiceAccounts + organizationUpdate.SmServiceAccountsAdjustment)));
|
||||
}
|
||||
|
||||
if (organizationUpdate.MaxAutoscaleSmSeats != organization.MaxAutoscaleSmSeats)
|
||||
{
|
||||
await sutProvider.GetDependency<IOrganizationService>().Received(1).ReplaceAndUpdateCacheAsync(
|
||||
Arg.Is<Organization>(org =>
|
||||
org.MaxAutoscaleSmSeats == organizationUpdate.MaxAutoscaleSmServiceAccounts));
|
||||
}
|
||||
|
||||
if (organizationUpdate.MaxAutoscaleSmServiceAccounts != organization.MaxAutoscaleSmServiceAccounts)
|
||||
{
|
||||
await sutProvider.GetDependency<IOrganizationService>().Received(1).ReplaceAndUpdateCacheAsync(
|
||||
Arg.Is<Organization>(org =>
|
||||
org.MaxAutoscaleSmServiceAccounts == organizationUpdate.MaxAutoscaleSmServiceAccounts));
|
||||
}
|
||||
AssertUpdatedOrganization(() => Arg.Is<Organization>(org =>
|
||||
org.Id == organizationId
|
||||
&& org.SmSeats == organizationUpdate.SmSeats
|
||||
&& org.MaxAutoscaleSmSeats == organizationUpdate.MaxAutoscaleSmSeats
|
||||
&& org.SmServiceAccounts == (organizationServiceAccounts + serviceAccountAdjustment)
|
||||
&& org.MaxAutoscaleSmServiceAccounts == organizationUpdate.MaxAutoscaleSmServiceAccounts), sutProvider);
|
||||
|
||||
await sutProvider.GetDependency<IMailService>().Received(1).SendSecretsManagerMaxSeatLimitReachedEmailAsync(organization, organization.MaxAutoscaleSmSeats.Value, Arg.Any<IEnumerable<string>>());
|
||||
await sutProvider.GetDependency<IMailService>().Received(1).SendSecretsManagerMaxServiceAccountLimitReachedEmailAsync(organization, organization.MaxAutoscaleSmServiceAccounts.Value, Arg.Any<IEnumerable<string>>());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
public async Task UpdateSubscriptionAsync_ValidInput_WithNullMaxAutoscale_Passes(
|
||||
PlanType planType,
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
int organizationServiceAccounts = 200;
|
||||
int seatAdjustment = 5;
|
||||
int? maxAutoscaleSeats = null;
|
||||
int serviceAccountAdjustment = 100;
|
||||
int? maxAutoScaleServiceAccounts = null;
|
||||
|
||||
var organization = new Organization
|
||||
{
|
||||
Id = organizationId,
|
||||
UseSecretsManager = true,
|
||||
SmSeats = 10,
|
||||
MaxAutoscaleSmSeats = 20,
|
||||
SmServiceAccounts = organizationServiceAccounts,
|
||||
MaxAutoscaleSmServiceAccounts = 350,
|
||||
PlanType = planType,
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization,
|
||||
seatAdjustment: seatAdjustment, maxAutoscaleSeats: maxAutoscaleSeats,
|
||||
serviceAccountAdjustment: serviceAccountAdjustment, maxAutoscaleServiceAccounts: maxAutoScaleServiceAccounts);
|
||||
|
||||
await sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate);
|
||||
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1)
|
||||
.AdjustSeatsAsync(organization, plan, organizationUpdate.SmSeatsExcludingBase);
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1)
|
||||
.AdjustServiceAccountsAsync(organization, plan, organizationUpdate.SmServiceAccountsExcludingBase);
|
||||
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
|
||||
AssertUpdatedOrganization(() => Arg.Is<Organization>(org =>
|
||||
org.Id == organizationId
|
||||
&& org.SmSeats == organizationUpdate.SmSeats
|
||||
&& org.MaxAutoscaleSmSeats == organizationUpdate.MaxAutoscaleSmSeats
|
||||
&& org.SmServiceAccounts == (organizationServiceAccounts + serviceAccountAdjustment)
|
||||
&& org.MaxAutoscaleSmServiceAccounts == organizationUpdate.MaxAutoscaleSmServiceAccounts), sutProvider);
|
||||
|
||||
await sutProvider.GetDependency<IMailService>().DidNotReceiveWithAnyArgs().SendSecretsManagerMaxSeatLimitReachedEmailAsync(default, default, default);
|
||||
await sutProvider.GetDependency<IMailService>().DidNotReceiveWithAnyArgs().SendSecretsManagerMaxServiceAccountLimitReachedEmailAsync(default, default, default);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_ThrowsBadRequestException_WhenMaxAutoscaleSeatsBelowSeatCount(
|
||||
public async Task UpdateSubscriptionAsync_ThrowsBadRequestException_WhenMaxAutoscaleSeatsBelowSeatCount(
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
@ -472,30 +400,17 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var update = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 4,
|
||||
SmSeatsAdjustment = 1,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 5,
|
||||
SmSeats = organization.SmSeats.GetValueOrDefault() + 1,
|
||||
SmSeatsExcludingBase = (organization.SmSeats.GetValueOrDefault() + 1) - plan.BaseSeats,
|
||||
SmServiceAccounts = organization.SmServiceAccounts.GetValueOrDefault() + 5,
|
||||
SmServiceAccountsExcludingBase = (organization.SmServiceAccounts.GetValueOrDefault() + 5) - (int)plan.BaseServiceAccount
|
||||
};
|
||||
var update = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 1, maxAutoscaleSeats: 4, serviceAccountAdjustment: 5, maxAutoscaleServiceAccounts: 300);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(update));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains("Cannot set max seat autoscaling below seat count.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task UpdateSecretsManagerSubscription_ThrowsBadRequestException_WhenOccupiedSeatsExceedNewSeatTotal(
|
||||
public async Task UpdateSubscriptionAsync_ThrowsBadRequestException_WhenOccupiedSeatsExceedNewSeatTotal(
|
||||
Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
@ -508,25 +423,12 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
GatewaySubscriptionId = "2",
|
||||
PlanType = PlanType.EnterpriseAnnually
|
||||
};
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var update = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 7,
|
||||
SmSeatsAdjustment = -3,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 5,
|
||||
SmSeats = organization.SmSeats.GetValueOrDefault() - 3,
|
||||
SmSeatsExcludingBase = (organization.SmSeats.GetValueOrDefault() - 3) - plan.BaseSeats,
|
||||
SmServiceAccounts = organization.SmServiceAccounts.GetValueOrDefault() + 5,
|
||||
SmServiceAccountsExcludingBase = (organization.SmServiceAccounts.GetValueOrDefault() + 5) - (int)plan.BaseServiceAccount
|
||||
};
|
||||
var update = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: -3, maxAutoscaleSeats: 7, serviceAccountAdjustment: 5, maxAutoscaleServiceAccounts: 300);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
sutProvider.GetDependency<IOrganizationUserRepository>().GetOccupiedSmSeatCountByOrganizationIdAsync(organizationId).Returns(8);
|
||||
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(update));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains("Your organization currently has 8 Secrets Manager seats. Your plan only allows 7 Secrets Manager seats. Remove some Secrets Manager users", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
@ -547,23 +449,10 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
SmServiceAccounts = null,
|
||||
PlanType = PlanType.EnterpriseAnnually
|
||||
};
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var update = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 21,
|
||||
SmSeatsAdjustment = 10,
|
||||
MaxAutoscaleSmServiceAccounts = 250,
|
||||
SmServiceAccountsAdjustment = 1,
|
||||
SmSeats = organization.SmSeats.GetValueOrDefault() + 10,
|
||||
SmSeatsExcludingBase = (organization.SmSeats.GetValueOrDefault() + 10) - plan.BaseSeats,
|
||||
SmServiceAccounts = organization.SmServiceAccounts.GetValueOrDefault() + 1,
|
||||
SmServiceAccountsExcludingBase = (organization.SmServiceAccounts.GetValueOrDefault() + 1) - (int)plan.BaseServiceAccount
|
||||
};
|
||||
var update = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 10, maxAutoscaleSeats: 21, serviceAccountAdjustment: 1, maxAutoscaleServiceAccounts: 250);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(update));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains("Organization has no Service Accounts limit, no need to adjust Service Accounts", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
@ -585,20 +474,10 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
GatewaySubscriptionId = "2",
|
||||
};
|
||||
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 0,
|
||||
MaxAutoscaleSmServiceAccounts = 200,
|
||||
SmServiceAccountsAdjustment = 0,
|
||||
MaxAutoscaleSmSeatsChanged = 15 != organization.MaxAutoscaleSeats.GetValueOrDefault(),
|
||||
MaxAutoscaleSmServiceAccountsChanged = 200 != organization.MaxAutoscaleSmServiceAccounts.GetValueOrDefault()
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 0, maxAutoscaleSeats: 15, serviceAccountAdjustment: 0, maxAutoscaleServiceAccounts: 200);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("Your plan has a Secrets Manager seat limit of 2, but you have specified a max autoscale count of 15.Reduce your max autoscale count.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
@ -623,20 +502,10 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 1,
|
||||
SmSeatsAdjustment = 0,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 0,
|
||||
MaxAutoscaleSmSeatsChanged = 1 != organization.MaxAutoscaleSeats.GetValueOrDefault(),
|
||||
MaxAutoscaleSmServiceAccountsChanged = 200 != organization.MaxAutoscaleSmServiceAccounts.GetValueOrDefault()
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 0, maxAutoscaleSeats: 1, serviceAccountAdjustment: 0, maxAutoscaleServiceAccounts: 300);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("Your plan does not allow Secrets Manager seat autoscaling", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
|
||||
@ -662,20 +531,10 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = null,
|
||||
SmSeatsAdjustment = 0,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 0,
|
||||
MaxAutoscaleSmSeatsChanged = false,
|
||||
MaxAutoscaleSmServiceAccountsChanged = 300 != organization.MaxAutoscaleSmServiceAccounts.GetValueOrDefault()
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 0, maxAutoscaleSeats: null, serviceAccountAdjustment: 0, maxAutoscaleServiceAccounts: 300);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("Your plan does not allow Service Accounts autoscaling.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
|
||||
@ -696,42 +555,173 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
Id = organizationId,
|
||||
UseSecretsManager = true,
|
||||
SmSeats = 10,
|
||||
SmServiceAccounts = 301,
|
||||
MaxAutoscaleSmSeats = 20,
|
||||
SmServiceAccounts = 301,
|
||||
MaxAutoscaleSmServiceAccounts = 350,
|
||||
PlanType = planType,
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2"
|
||||
};
|
||||
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == organization.PlanType);
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate
|
||||
{
|
||||
OrganizationId = organizationId,
|
||||
MaxAutoscaleSmSeats = 15,
|
||||
SmSeatsAdjustment = 5,
|
||||
MaxAutoscaleSmServiceAccounts = 300,
|
||||
SmServiceAccountsAdjustment = 100,
|
||||
SmSeats = organization.SmSeats.GetValueOrDefault() + 5,
|
||||
SmSeatsExcludingBase = (organization.SmSeats.GetValueOrDefault() + 5) - plan.BaseSeats,
|
||||
SmServiceAccounts = 300,
|
||||
SmServiceAccountsExcludingBase = (organization.SmServiceAccounts.GetValueOrDefault() + 100) - (int)plan.BaseServiceAccount,
|
||||
MaxAutoscaleSmSeatsChanged = 15 != organization.MaxAutoscaleSeats.GetValueOrDefault(),
|
||||
MaxAutoscaleSmServiceAccountsChanged = 200 != organization.MaxAutoscaleSmServiceAccounts.GetValueOrDefault()
|
||||
};
|
||||
var organizationUpdate = new SecretsManagerSubscriptionUpdate(
|
||||
organization, seatAdjustment: 5, maxAutoscaleSeats: 15, serviceAccountAdjustment: -100, maxAutoscaleServiceAccounts: 300);
|
||||
var currentServiceAccounts = 301;
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns(organization);
|
||||
|
||||
sutProvider.GetDependency<IServiceAccountRepository>()
|
||||
.GetServiceAccountCountByOrganizationIdAsync(organization.Id)
|
||||
.Returns(currentServiceAccounts);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSecretsManagerSubscription(organizationUpdate));
|
||||
Assert.Contains("Your organization currently has 301 Service Accounts. Your plan only allows 300 Service Accounts. Remove some Service Accounts", exception.Message);
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(organizationUpdate));
|
||||
Assert.Contains("Your organization currently has 301 Service Accounts. Your plan only allows 201 Service Accounts. Remove some Service Accounts", exception.Message);
|
||||
await sutProvider.GetDependency<IServiceAccountRepository>().Received(1).GetServiceAccountCountByOrganizationIdAsync(organization.Id);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
public async Task AdjustServiceAccountsAsync_WithEnterpriseOrTeamsPlans_Success(PlanType planType, Guid organizationId,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(p => p.Type == planType);
|
||||
|
||||
var organizationSeats = plan.BaseSeats + 10;
|
||||
var organizationMaxAutoscaleSeats = 20;
|
||||
var organizationServiceAccounts = plan.BaseServiceAccount.GetValueOrDefault() + 10;
|
||||
var organizationMaxAutoscaleServiceAccounts = 300;
|
||||
|
||||
var organization = new Organization
|
||||
{
|
||||
Id = organizationId,
|
||||
PlanType = planType,
|
||||
GatewayCustomerId = "1",
|
||||
GatewaySubscriptionId = "2",
|
||||
UseSecretsManager = true,
|
||||
SmSeats = organizationSeats,
|
||||
MaxAutoscaleSmSeats = organizationMaxAutoscaleSeats,
|
||||
SmServiceAccounts = organizationServiceAccounts,
|
||||
MaxAutoscaleSmServiceAccounts = organizationMaxAutoscaleServiceAccounts
|
||||
};
|
||||
|
||||
var smServiceAccountsAdjustment = 10;
|
||||
var expectedSmServiceAccounts = organizationServiceAccounts + smServiceAccountsAdjustment;
|
||||
var expectedSmServiceAccountsExcludingBase = expectedSmServiceAccounts - plan.BaseServiceAccount.GetValueOrDefault();
|
||||
|
||||
await sutProvider.Sut.AdjustServiceAccountsAsync(organization, smServiceAccountsAdjustment);
|
||||
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1).AdjustServiceAccountsAsync(
|
||||
Arg.Is<Organization>(o => o.Id == organizationId),
|
||||
plan,
|
||||
expectedSmServiceAccountsExcludingBase);
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
AssertUpdatedOrganization(() => Arg.Is<Organization>(o =>
|
||||
o.Id == organizationId
|
||||
&& o.SmSeats == organizationSeats
|
||||
&& o.MaxAutoscaleSmSeats == organizationMaxAutoscaleSeats
|
||||
&& o.SmServiceAccounts == expectedSmServiceAccounts
|
||||
&& o.MaxAutoscaleSmServiceAccounts == organizationMaxAutoscaleServiceAccounts), sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
public async Task ServiceAccountAutoscaling_MaxLimitReached_ThrowsBadRequestException(
|
||||
PlanType planType,
|
||||
Organization organization,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
organization.PlanType = planType;
|
||||
organization.UseSecretsManager = true;
|
||||
organization.SmServiceAccounts = 9;
|
||||
organization.MaxAutoscaleSmServiceAccounts = 10;
|
||||
|
||||
var update = new SecretsManagerSubscriptionUpdate(organization, true);
|
||||
update.AdjustServiceAccounts(2);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains("Secrets Manager service account limit has been reached.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
public async Task ServiceAccountAutoscaling_Subtracting_ThrowsBadRequestException(
|
||||
PlanType planType,
|
||||
Organization organization,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
organization.PlanType = planType;
|
||||
organization.UseSecretsManager = true;
|
||||
|
||||
var update = new SecretsManagerSubscriptionUpdate(organization, true);
|
||||
update.AdjustServiceAccounts(-2);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains("Cannot use autoscaling to subtract service accounts.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
public async Task SmSeatAutoscaling_MaxLimitReached_ThrowsBadRequestException(
|
||||
PlanType planType,
|
||||
Organization organization,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
organization.PlanType = planType;
|
||||
organization.UseSecretsManager = true;
|
||||
organization.SmSeats = 9;
|
||||
organization.MaxAutoscaleSmSeats = 10;
|
||||
|
||||
var update = new SecretsManagerSubscriptionUpdate(organization, true);
|
||||
update.AdjustSeats(2);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains("Secrets Manager seat limit has been reached.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
public async Task SmSeatAutoscaling_Subtracting_ThrowsBadRequestException(
|
||||
PlanType planType,
|
||||
Organization organization,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
organization.PlanType = planType;
|
||||
organization.UseSecretsManager = true;
|
||||
|
||||
var update = new SecretsManagerSubscriptionUpdate(organization, true);
|
||||
update.AdjustSeats(-2);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains("Cannot use autoscaling to subtract seats.", exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(false, "Cannot update subscription on a self-hosted instance.")]
|
||||
[BitAutoData(true, "Cannot autoscale on a self-hosted instance.")]
|
||||
public async Task UpdatingSubscription_WhenSelfHosted_ThrowsBadRequestException(
|
||||
bool autoscaling,
|
||||
string expectedError,
|
||||
Organization organization,
|
||||
SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
organization.PlanType = PlanType.EnterpriseAnnually;
|
||||
organization.UseSecretsManager = true;
|
||||
|
||||
var update = new SecretsManagerSubscriptionUpdate(organization, autoscaling);
|
||||
update.AdjustSeats(2);
|
||||
|
||||
sutProvider.GetDependency<IGlobalSettings>().SelfHosted.Returns(true);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscriptionAsync(update));
|
||||
Assert.Contains(expectedError, exception.Message);
|
||||
await VerifyDependencyNotCalledAsync(sutProvider);
|
||||
}
|
||||
|
||||
private static async Task VerifyDependencyNotCalledAsync(SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
await sutProvider.GetDependency<IPaymentService>().DidNotReceive()
|
||||
@ -739,10 +729,17 @@ public class UpdateSecretsManagerSubscriptionCommandTests
|
||||
await sutProvider.GetDependency<IPaymentService>().DidNotReceive()
|
||||
.AdjustServiceAccountsAsync(Arg.Any<Organization>(), Arg.Any<Plan>(), Arg.Any<int>());
|
||||
// TODO: call ReferenceEventService - see AC-1481
|
||||
await sutProvider.GetDependency<IOrganizationService>().DidNotReceive()
|
||||
.ReplaceAndUpdateCacheAsync(Arg.Any<Organization>());
|
||||
await sutProvider.GetDependency<IMailService>().DidNotReceive()
|
||||
.SendOrganizationMaxSeatLimitReachedEmailAsync(Arg.Any<Organization>(), Arg.Any<int>(),
|
||||
Arg.Any<IEnumerable<string>>());
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>().DidNotReceiveWithAnyArgs().ReplaceAsync(default);
|
||||
sutProvider.GetDependency<IApplicationCacheService>().DidNotReceiveWithAnyArgs().UpsertOrganizationAbilityAsync(default);
|
||||
}
|
||||
|
||||
private void AssertUpdatedOrganization(Func<Organization> organizationMatcher, SutProvider<UpdateSecretsManagerSubscriptionCommand> sutProvider)
|
||||
{
|
||||
sutProvider.GetDependency<IOrganizationRepository>().Received(1).ReplaceAsync(organizationMatcher());
|
||||
sutProvider.GetDependency<IApplicationCacheService>().Received(1).UpsertOrganizationAbilityAsync(organizationMatcher());
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,110 @@
|
||||
using Bit.Core.Entities;
|
||||
using Bit.Core.Exceptions;
|
||||
using Bit.Core.OrganizationFeatures.OrganizationUsers;
|
||||
using Bit.Core.Repositories;
|
||||
using Bit.Test.Common.AutoFixture;
|
||||
using Bit.Test.Common.AutoFixture.Attributes;
|
||||
using NSubstitute;
|
||||
using Xunit;
|
||||
|
||||
namespace Bit.Core.Test.OrganizationFeatures.OrganizationUsers;
|
||||
|
||||
[SutProviderCustomize]
|
||||
public class CountNewSmSeatsRequiredQueryTests
|
||||
{
|
||||
[Theory]
|
||||
[BitAutoData(2, 5, 2, 0)]
|
||||
[BitAutoData(0, 5, 2, 0)]
|
||||
[BitAutoData(6, 5, 2, 3)]
|
||||
[BitAutoData(2, 5, 10, 7)]
|
||||
public async Task CountNewSmSeatsRequiredAsync_ReturnsCorrectCount(
|
||||
int usersToAdd,
|
||||
int organizationSmSeats,
|
||||
int currentOccupiedSmSeats,
|
||||
int expectedNewSmSeatsRequired,
|
||||
Organization organization,
|
||||
SutProvider<CountNewSmSeatsRequiredQuery> sutProvider)
|
||||
{
|
||||
organization.UseSecretsManager = true;
|
||||
organization.SmSeats = organizationSmSeats;
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>()
|
||||
.GetByIdAsync(organization.Id)
|
||||
.Returns(organization);
|
||||
|
||||
sutProvider.GetDependency<IOrganizationUserRepository>()
|
||||
.GetOccupiedSmSeatCountByOrganizationIdAsync(organization.Id)
|
||||
.Returns(currentOccupiedSmSeats);
|
||||
|
||||
var result = await sutProvider.Sut.CountNewSmSeatsRequiredAsync(organization.Id, usersToAdd);
|
||||
|
||||
Assert.Equal(expectedNewSmSeatsRequired, result);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(0)]
|
||||
[BitAutoData(5)]
|
||||
public async Task CountNewSmSeatsRequiredAsync_WithNullSmSeats_ReturnsZero(
|
||||
int usersToAdd,
|
||||
Organization organization,
|
||||
SutProvider<CountNewSmSeatsRequiredQuery> sutProvider)
|
||||
{
|
||||
const int expected = 0;
|
||||
|
||||
organization.UseSecretsManager = true;
|
||||
organization.SmSeats = null;
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>()
|
||||
.GetByIdAsync(organization.Id)
|
||||
.Returns(organization);
|
||||
|
||||
var result = await sutProvider.Sut.CountNewSmSeatsRequiredAsync(organization.Id, usersToAdd);
|
||||
|
||||
Assert.Equal(expected, result);
|
||||
}
|
||||
|
||||
[Theory, BitAutoData]
|
||||
public async Task CountNewSmSeatsRequiredAsync_WithNonExistentOrganizationId_ThrowsNotFound(
|
||||
Guid organizationId, int usersToAdd,
|
||||
SutProvider<CountNewSmSeatsRequiredQuery> sutProvider)
|
||||
{
|
||||
await Assert.ThrowsAsync<NotFoundException>(async () => await sutProvider.Sut.CountNewSmSeatsRequiredAsync(organizationId, usersToAdd));
|
||||
}
|
||||
|
||||
[Theory, BitAutoData]
|
||||
public async Task CountNewSmSeatsRequiredAsync_WithOrganizationUseSecretsManagerFalse_ThrowsNotFound(
|
||||
Organization organization, int usersToAdd,
|
||||
SutProvider<CountNewSmSeatsRequiredQuery> sutProvider)
|
||||
{
|
||||
organization.UseSecretsManager = false;
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>()
|
||||
.GetByIdAsync(organization.Id)
|
||||
.Returns(organization);
|
||||
|
||||
var exception = await Assert.ThrowsAsync<BadRequestException>(async () =>
|
||||
await sutProvider.Sut.CountNewSmSeatsRequiredAsync(organization.Id, usersToAdd));
|
||||
Assert.Contains("Organization does not use Secrets Manager", exception.Message);
|
||||
}
|
||||
|
||||
[Theory, BitAutoData]
|
||||
public async Task CountNewSmSeatsRequiredAsync_WithSecretsManagerBeta_ReturnsZero(
|
||||
int usersToAdd,
|
||||
Organization organization,
|
||||
SutProvider<CountNewSmSeatsRequiredQuery> sutProvider)
|
||||
{
|
||||
organization.UseSecretsManager = true;
|
||||
organization.SecretsManagerBeta = true;
|
||||
|
||||
sutProvider.GetDependency<IOrganizationRepository>()
|
||||
.GetByIdAsync(organization.Id)
|
||||
.Returns(organization);
|
||||
|
||||
var result = await sutProvider.Sut.CountNewSmSeatsRequiredAsync(organization.Id, usersToAdd);
|
||||
|
||||
Assert.Equal(0, result);
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationUserRepository>().DidNotReceiveWithAnyArgs()
|
||||
.GetOccupiedSmSeatCountByOrganizationIdAsync(default);
|
||||
}
|
||||
}
|
||||
@ -1,81 +0,0 @@
|
||||
using Bit.Core.Entities;
|
||||
using Bit.Core.Repositories;
|
||||
using Bit.Core.SecretsManager.Commands.EnableAccessSecretsManager;
|
||||
using Bit.Test.Common.AutoFixture;
|
||||
using Bit.Test.Common.AutoFixture.Attributes;
|
||||
using Bit.Test.Common.Helpers;
|
||||
using NSubstitute;
|
||||
using Xunit;
|
||||
|
||||
namespace Bit.Core.Test.SecretsManager.Commands.EnableAccessSecretsManager;
|
||||
|
||||
[SutProviderCustomize]
|
||||
public class EnableAccessSecretsManagerCommandTests
|
||||
{
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task EnableUsers_UsersAlreadyEnabled_DoesNotCallRepository(
|
||||
SutProvider<EnableAccessSecretsManagerCommand> sutProvider, ICollection<OrganizationUser> data)
|
||||
{
|
||||
foreach (var item in data)
|
||||
{
|
||||
item.AccessSecretsManager = true;
|
||||
}
|
||||
|
||||
var result = await sutProvider.Sut.EnableUsersAsync(data);
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationUserRepository>().DidNotReceiveWithAnyArgs()
|
||||
.ReplaceManyAsync(default);
|
||||
|
||||
Assert.Equal(data.Count, result.Count);
|
||||
Assert.Equal(data.Count,
|
||||
result.Where(x => x.error == "User already has access to Secrets Manager").ToList().Count);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task EnableUsers_OneUserNotEnabled_CallsRepositoryForOne(
|
||||
SutProvider<EnableAccessSecretsManagerCommand> sutProvider, ICollection<OrganizationUser> data)
|
||||
{
|
||||
var firstUser = new List<OrganizationUser>();
|
||||
foreach (var item in data)
|
||||
{
|
||||
if (item == data.First())
|
||||
{
|
||||
item.AccessSecretsManager = false;
|
||||
firstUser.Add(item);
|
||||
}
|
||||
else
|
||||
{
|
||||
item.AccessSecretsManager = true;
|
||||
}
|
||||
}
|
||||
|
||||
var result = await sutProvider.Sut.EnableUsersAsync(data);
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationUserRepository>().Received(1)
|
||||
.ReplaceManyAsync(Arg.Is(AssertHelper.AssertPropertyEqual(firstUser)));
|
||||
|
||||
Assert.Equal(data.Count, result.Count);
|
||||
Assert.Equal(data.Count - 1,
|
||||
result.Where(x => x.error == "User already has access to Secrets Manager").ToList().Count);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData]
|
||||
public async Task EnableUsers_Success(
|
||||
SutProvider<EnableAccessSecretsManagerCommand> sutProvider, ICollection<OrganizationUser> data)
|
||||
{
|
||||
foreach (var item in data)
|
||||
{
|
||||
item.AccessSecretsManager = false;
|
||||
}
|
||||
|
||||
var result = await sutProvider.Sut.EnableUsersAsync(data);
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationUserRepository>().Received(1)
|
||||
.ReplaceManyAsync(Arg.Is(AssertHelper.AssertPropertyEqual(data)));
|
||||
|
||||
Assert.Equal(data.Count, result.Count);
|
||||
}
|
||||
}
|
||||
@ -14,6 +14,8 @@ using Bit.Core.Models.Business;
|
||||
using Bit.Core.Models.Data;
|
||||
using Bit.Core.Models.Data.Organizations.OrganizationUsers;
|
||||
using Bit.Core.Models.StaticStore;
|
||||
using Bit.Core.OrganizationFeatures.OrganizationSubscriptions.Interface;
|
||||
using Bit.Core.OrganizationFeatures.OrganizationUsers.Interfaces;
|
||||
using Bit.Core.Repositories;
|
||||
using Bit.Core.Services;
|
||||
using Bit.Core.Settings;
|
||||
@ -27,6 +29,7 @@ using Bit.Core.Utilities;
|
||||
using Bit.Test.Common.AutoFixture;
|
||||
using Bit.Test.Common.AutoFixture.Attributes;
|
||||
using NSubstitute;
|
||||
using NSubstitute.ExceptionExtensions;
|
||||
using Xunit;
|
||||
using Organization = Bit.Core.Entities.Organization;
|
||||
using OrganizationUser = Bit.Core.Entities.OrganizationUser;
|
||||
@ -145,6 +148,59 @@ public class OrganizationServiceTests
|
||||
referenceEvent.Users == expectedNewUsersCount));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.FamiliesAnnually)]
|
||||
public async Task SignUp_PM_Family_Passes(PlanType planType, OrganizationSignup signup, SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
signup.Plan = planType;
|
||||
|
||||
var passwordManagerPlan = StaticStore.GetPasswordManagerPlan(signup.Plan);
|
||||
|
||||
signup.AdditionalSeats = 0;
|
||||
signup.PaymentMethodType = PaymentMethodType.Card;
|
||||
signup.PremiumAccessAddon = false;
|
||||
signup.UseSecretsManager = false;
|
||||
|
||||
var purchaseOrganizationPlan = StaticStore.Plans.Where(x => x.Type == signup.Plan).ToList();
|
||||
|
||||
var result = await sutProvider.Sut.SignUpAsync(signup);
|
||||
|
||||
await sutProvider.GetDependency<IOrganizationRepository>().Received(1).CreateAsync(
|
||||
Arg.Is<Organization>(o =>
|
||||
o.Seats == passwordManagerPlan.BaseSeats + signup.AdditionalSeats
|
||||
&& o.SmSeats == null
|
||||
&& o.SmServiceAccounts == null));
|
||||
await sutProvider.GetDependency<IOrganizationUserRepository>().Received(1).CreateAsync(
|
||||
Arg.Is<OrganizationUser>(o => o.AccessSecretsManager == signup.UseSecretsManager));
|
||||
|
||||
await sutProvider.GetDependency<IReferenceEventService>().Received(1)
|
||||
.RaiseEventAsync(Arg.Is<ReferenceEvent>(referenceEvent =>
|
||||
referenceEvent.Type == ReferenceEventType.Signup &&
|
||||
referenceEvent.PlanName == passwordManagerPlan.Name &&
|
||||
referenceEvent.PlanType == passwordManagerPlan.Type &&
|
||||
referenceEvent.Seats == result.Item1.Seats &&
|
||||
referenceEvent.Storage == result.Item1.MaxStorageGb));
|
||||
// TODO: add reference events for SmSeats and Service Accounts - see AC-1481
|
||||
|
||||
Assert.NotNull(result);
|
||||
Assert.NotNull(result.Item1);
|
||||
Assert.NotNull(result.Item2);
|
||||
Assert.IsType<Tuple<Organization, OrganizationUser>>(result);
|
||||
|
||||
await sutProvider.GetDependency<IPaymentService>().Received(1).PurchaseOrganizationAsync(
|
||||
Arg.Any<Organization>(),
|
||||
signup.PaymentMethodType.Value,
|
||||
signup.PaymentToken,
|
||||
Arg.Is<List<Plan>>(plan => plan.Single() == passwordManagerPlan),
|
||||
signup.AdditionalStorageGb,
|
||||
signup.AdditionalSeats,
|
||||
signup.PremiumAccessAddon,
|
||||
signup.TaxInfo,
|
||||
false,
|
||||
signup.AdditionalSmSeats.GetValueOrDefault(),
|
||||
signup.AdditionalServiceAccounts.GetValueOrDefault()
|
||||
);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
@ -586,6 +642,97 @@ public class OrganizationServiceTests
|
||||
await sutProvider.GetDependency<IEventService>().Received(1).LogOrganizationUserEventsAsync(Arg.Any<IEnumerable<(OrganizationUser, EventType, EventSystemUser, DateTime?)>>());
|
||||
}
|
||||
|
||||
[Theory, BitAutoData]
|
||||
public async Task InviteUser_WithSecretsManager_Passes(Organization organization,
|
||||
IEnumerable<(OrganizationUserInvite invite, string externalId)> invites,
|
||||
[OrganizationUser(type: OrganizationUserType.Owner, status: OrganizationUserStatusType.Confirmed)] OrganizationUser savingUser,
|
||||
SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
InviteUserHelper_ArrangeValidPermissions(organization, savingUser, sutProvider);
|
||||
|
||||
// Set up some invites to grant access to SM
|
||||
invites.First().invite.AccessSecretsManager = true;
|
||||
var invitedSmUsers = invites.First().invite.Emails.Count();
|
||||
|
||||
// Assume we need to add seats for all invited SM users
|
||||
sutProvider.GetDependency<ICountNewSmSeatsRequiredQuery>()
|
||||
.CountNewSmSeatsRequiredAsync(organization.Id, invitedSmUsers).Returns(invitedSmUsers);
|
||||
|
||||
await sutProvider.Sut.InviteUsersAsync(organization.Id, savingUser.Id, invites);
|
||||
|
||||
sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>().Received(1)
|
||||
.UpdateSubscriptionAsync(Arg.Is<SecretsManagerSubscriptionUpdate>(update =>
|
||||
update.SmSeats == organization.SmSeats + invitedSmUsers &&
|
||||
!update.SmServiceAccountsChanged &&
|
||||
!update.MaxAutoscaleSmSeatsChanged &&
|
||||
!update.MaxAutoscaleSmSeatsChanged));
|
||||
}
|
||||
|
||||
[Theory, BitAutoData]
|
||||
public async Task InviteUser_WithSecretsManager_WhenErrorIsThrown_RevertsAutoscaling(Organization organization,
|
||||
IEnumerable<(OrganizationUserInvite invite, string externalId)> invites,
|
||||
[OrganizationUser(type: OrganizationUserType.Owner, status: OrganizationUserStatusType.Confirmed)] OrganizationUser savingUser,
|
||||
SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var initialSmSeats = organization.SmSeats;
|
||||
InviteUserHelper_ArrangeValidPermissions(organization, savingUser, sutProvider);
|
||||
|
||||
// Set up some invites to grant access to SM
|
||||
invites.First().invite.AccessSecretsManager = true;
|
||||
var invitedSmUsers = invites.First().invite.Emails.Count();
|
||||
|
||||
// Assume we need to add seats for all invited SM users
|
||||
sutProvider.GetDependency<ICountNewSmSeatsRequiredQuery>()
|
||||
.CountNewSmSeatsRequiredAsync(organization.Id, invitedSmUsers).Returns(invitedSmUsers);
|
||||
|
||||
// Mock SecretsManagerSubscriptionUpdateCommand to actually change the organization's subscription in memory
|
||||
sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>()
|
||||
.UpdateSubscriptionAsync(Arg.Any<SecretsManagerSubscriptionUpdate>())
|
||||
.ReturnsForAnyArgs(Task.FromResult(0)).AndDoes(x => organization.SmSeats += invitedSmUsers);
|
||||
|
||||
// Throw error at the end of the try block
|
||||
sutProvider.GetDependency<IReferenceEventService>().RaiseEventAsync(default).ThrowsForAnyArgs<BadRequestException>();
|
||||
|
||||
await Assert.ThrowsAsync<AggregateException>(async () => await sutProvider.Sut.InviteUsersAsync(organization.Id, savingUser.Id, invites));
|
||||
|
||||
// OrgUser is reverted
|
||||
// Note: we don't know what their guids are so comparing length is the best we can do
|
||||
var invitedEmails = invites.SelectMany(i => i.invite.Emails);
|
||||
sutProvider.GetDependency<IOrganizationUserRepository>().Received(1).DeleteManyAsync(
|
||||
Arg.Is<IEnumerable<Guid>>(ids => ids.Count() == invitedEmails.Count()));
|
||||
|
||||
Received.InOrder(() =>
|
||||
{
|
||||
// Initial autoscaling
|
||||
sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>()
|
||||
.UpdateSubscriptionAsync(Arg.Is<SecretsManagerSubscriptionUpdate>(update =>
|
||||
update.SmSeats == initialSmSeats + invitedSmUsers &&
|
||||
!update.SmServiceAccountsChanged &&
|
||||
!update.MaxAutoscaleSmSeatsChanged &&
|
||||
!update.MaxAutoscaleSmSeatsChanged));
|
||||
|
||||
// Revert autoscaling
|
||||
sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>()
|
||||
.UpdateSubscriptionAsync(Arg.Is<SecretsManagerSubscriptionUpdate>(update =>
|
||||
update.SmSeats == initialSmSeats &&
|
||||
!update.SmServiceAccountsChanged &&
|
||||
!update.MaxAutoscaleSmSeatsChanged &&
|
||||
!update.MaxAutoscaleSmSeatsChanged));
|
||||
});
|
||||
}
|
||||
|
||||
private void InviteUserHelper_ArrangeValidPermissions(Organization organization, OrganizationUser savingUser,
|
||||
SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
savingUser.OrganizationId = organization.Id;
|
||||
organization.UseCustomPermissions = true;
|
||||
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
|
||||
sutProvider.GetDependency<ICurrentContext>().OrganizationOwner(organization.Id).Returns(true);
|
||||
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organization.Id).Returns(true);
|
||||
sutProvider.GetDependency<IOrganizationUserRepository>().GetManyByOrganizationAsync(savingUser.OrganizationId, OrganizationUserType.Owner)
|
||||
.Returns(new List<OrganizationUser> { savingUser });
|
||||
}
|
||||
|
||||
[Theory, BitAutoData]
|
||||
public async Task SaveUser_NoUserId_Throws(OrganizationUser user, Guid? savingUserId,
|
||||
IEnumerable<CollectionAccessSelection> collections, IEnumerable<Guid> groups, SutProvider<OrganizationService> sutProvider)
|
||||
@ -1534,4 +1681,154 @@ public class OrganizationServiceTests
|
||||
Assert.Equal(includeProvider, result);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually2019)]
|
||||
public void ValidateSecretsManagerPlan_ThrowsException_WhenInvalidPlanSelected(
|
||||
PlanType planType, SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.Plans.FirstOrDefault(x => x.Type == planType);
|
||||
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = 1,
|
||||
AdditionalServiceAccounts = 10,
|
||||
AdditionalSeats = 1
|
||||
};
|
||||
|
||||
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
|
||||
Assert.Contains("Invalid Secrets Manager plan selected.", exception.Message);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
public void ValidateSecretsManagerPlan_ThrowsException_WhenNoSecretsManagerSeats(PlanType planType, SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == planType);
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = 0,
|
||||
AdditionalServiceAccounts = 5,
|
||||
AdditionalSeats = 2
|
||||
};
|
||||
|
||||
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
|
||||
Assert.Contains("You do not have any Secrets Manager seats!", exception.Message);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.Free)]
|
||||
public void ValidateSecretsManagerPlan_ThrowsException_WhenSubtractingSeats(PlanType planType, SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == planType);
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = -1,
|
||||
AdditionalServiceAccounts = 5
|
||||
};
|
||||
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
|
||||
Assert.Contains("You can't subtract Secrets Manager seats!", exception.Message);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.Free)]
|
||||
public void ValidateSecretsManagerPlan_ThrowsException_WhenPlanDoesNotAllowAdditionalServiceAccounts(
|
||||
PlanType planType,
|
||||
SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == planType);
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = 2,
|
||||
AdditionalServiceAccounts = 5,
|
||||
AdditionalSeats = 3
|
||||
};
|
||||
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
|
||||
Assert.Contains("Plan does not allow additional Service Accounts.", exception.Message);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
public void ValidateSecretsManagerPlan_ThrowsException_WhenMoreSeatsThanPasswordManagerSeats(PlanType planType, SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == planType);
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = 4,
|
||||
AdditionalServiceAccounts = 5,
|
||||
AdditionalSeats = 3
|
||||
};
|
||||
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
|
||||
Assert.Contains("You cannot have more Secrets Manager seats than Password Manager seats.", exception.Message);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
public void ValidateSecretsManagerPlan_ThrowsException_WhenSubtractingServiceAccounts(
|
||||
PlanType planType,
|
||||
SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == planType);
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = 4,
|
||||
AdditionalServiceAccounts = -5,
|
||||
AdditionalSeats = 5
|
||||
};
|
||||
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
|
||||
Assert.Contains("You can't subtract Service Accounts!", exception.Message);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.Free)]
|
||||
public void ValidateSecretsManagerPlan_ThrowsException_WhenPlanDoesNotAllowAdditionalUsers(
|
||||
PlanType planType,
|
||||
SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == planType);
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = 2,
|
||||
AdditionalServiceAccounts = 0,
|
||||
AdditionalSeats = 5
|
||||
};
|
||||
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
|
||||
Assert.Contains("Plan does not allow additional users.", exception.Message);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[BitAutoData(PlanType.TeamsAnnually)]
|
||||
[BitAutoData(PlanType.TeamsMonthly)]
|
||||
[BitAutoData(PlanType.EnterpriseAnnually)]
|
||||
[BitAutoData(PlanType.EnterpriseMonthly)]
|
||||
public void ValidateSecretsManagerPlan_ValidPlan_NoExceptionThrown(
|
||||
PlanType planType,
|
||||
SutProvider<OrganizationService> sutProvider)
|
||||
{
|
||||
var plan = StaticStore.SecretManagerPlans.FirstOrDefault(x => x.Type == planType);
|
||||
var signup = new OrganizationUpgrade
|
||||
{
|
||||
UseSecretsManager = true,
|
||||
AdditionalSmSeats = 2,
|
||||
AdditionalServiceAccounts = 0,
|
||||
AdditionalSeats = 4
|
||||
};
|
||||
|
||||
sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user