billing/pm-24665/license-file-generation-should-fail-for-unpaid-subscription

src/Core/Billing/Licenses/Queries/GetUserLicenseQuery.cs

@@ -1,5 +1,8 @@
-using Bit.Core.Billing.Models.Business;
+using Bit.Core.Billing.Constants;
+using Bit.Core.Billing.Models.Business;
+using Bit.Core.Billing.Services;
 using Bit.Core.Entities;
+using Bit.Core.Exceptions;
 using Bit.Core.Services;
 
 namespace Bit.Core.Billing.Licenses.Queries;
@@ -10,10 +13,26 @@ public interface IGetUserLicenseQuery
 }
 
 public class GetUserLicenseQuery(
-    IUserService userService) : IGetUserLicenseQuery
+    IUserService userService,
+    IStripePaymentService paymentService) : IGetUserLicenseQuery
 {
     public async Task<UserLicense> Run(User user)
     {
+        var subscriptionInfo = await paymentService.GetSubscriptionAsync(user);
+
+        if (subscriptionInfo.Subscription is null)
+        {
+            throw new BadRequestException("No active subscription found.");
+        }
+
+        if (subscriptionInfo.Subscription.Status is StripeConstants.SubscriptionStatus.Canceled
+            or StripeConstants.SubscriptionStatus.Incomplete
+            or StripeConstants.SubscriptionStatus.IncompleteExpired)
+        {
+            throw new BadRequestException(
+                "Unable to generate license due to a payment issue. Please update your billing information or contact support for assistance.");
+        }
+
         return await userService.GenerateLicenseAsync(user);
     }
 }

src/Core/Billing/Organizations/Queries/GetCloudOrganizationLicenseQuery.cs

@@ -3,13 +3,13 @@
 
 using Bit.Core.AdminConsole.Entities;
 using Bit.Core.AdminConsole.Repositories;
+using Bit.Core.Billing.Constants;
 using Bit.Core.Billing.Organizations.Models;
 using Bit.Core.Billing.Services;
 using Bit.Core.Enums;
 using Bit.Core.Exceptions;
 using Bit.Core.Models.Business;
 using Bit.Core.Platform.Installations;
-using Bit.Core.Services;
 
 namespace Bit.Core.Billing.Organizations.Queries;
 
@@ -25,20 +25,17 @@ public class GetCloudOrganizationLicenseQuery : IGetCloudOrganizationLicenseQuer
     private readonly IStripePaymentService _paymentService;
     private readonly ILicensingService _licensingService;
     private readonly IProviderRepository _providerRepository;
-    private readonly IFeatureService _featureService;
 
     public GetCloudOrganizationLicenseQuery(
         IInstallationRepository installationRepository,
         IStripePaymentService paymentService,
         ILicensingService licensingService,
-        IProviderRepository providerRepository,
-        IFeatureService featureService)
+        IProviderRepository providerRepository)
     {
         _installationRepository = installationRepository;
         _paymentService = paymentService;
         _licensingService = licensingService;
         _providerRepository = providerRepository;
-        _featureService = featureService;
     }
 
     public async Task<OrganizationLicense> GetLicenseAsync(Organization organization, Guid installationId,
@@ -51,6 +48,20 @@ public async Task<OrganizationLicense> GetLicenseAsync(Organization organization
         }
 
         var subscriptionInfo = await GetSubscriptionAsync(organization);
+
+        if (subscriptionInfo.Subscription is null)
+        {
+            throw new BadRequestException("No active subscription found.");
+        }
+
+        if (subscriptionInfo.Subscription.Status is StripeConstants.SubscriptionStatus.Canceled
+            or StripeConstants.SubscriptionStatus.Incomplete
+            or StripeConstants.SubscriptionStatus.IncompleteExpired)
+        {
+            throw new BadRequestException(
+                "Unable to generate license due to a payment issue. Please update your billing information or contact support for assistance.");
+        }
+
         var license = new OrganizationLicense(organization, subscriptionInfo, installationId, _licensingService, version);
         license.Token = await _licensingService.CreateOrganizationTokenAsync(organization, installationId, subscriptionInfo);
 

test/Core.Test/Billing/Licenses/Queries/GetUserLicenseQueryTests.cs

@@ -0,0 +1,154 @@
+using Bit.Core.Billing.Licenses.Queries;
+using Bit.Core.Billing.Models.Business;
+using Bit.Core.Billing.Services;
+using Bit.Core.Entities;
+using Bit.Core.Exceptions;
+using Bit.Core.Models.Business;
+using Bit.Core.Services;
+using Bit.Test.Common.AutoFixture;
+using Bit.Test.Common.AutoFixture.Attributes;
+using NSubstitute;
+using Stripe;
+using Xunit;
+
+namespace Bit.Core.Test.Billing.Licenses.Queries;
+
+[SutProviderCustomize]
+public class GetUserLicenseQueryTests
+{
+    [Theory]
+    [BitAutoData]
+    public async Task RunAsync_CanceledSubscription_Throws(
+        SutProvider<GetUserLicenseQuery> sutProvider,
+        User user)
+    {
+        var subInfo = new SubscriptionInfo
+        {
+            Subscription = new SubscriptionInfo.BillingSubscription(new Subscription { Status = "canceled" })
+        };
+        sutProvider.GetDependency<IStripePaymentService>()
+            .GetSubscriptionAsync(user)
+            .Returns(subInfo);
+
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () =>
+            await sutProvider.Sut.Run(user));
+        Assert.Contains("Unable to generate license due to a payment issue", exception.Message);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task RunAsync_IncompleteSubscription_Throws(
+        SutProvider<GetUserLicenseQuery> sutProvider,
+        User user)
+    {
+        var subInfo = new SubscriptionInfo
+        {
+            Subscription = new SubscriptionInfo.BillingSubscription(new Subscription { Status = "incomplete" })
+        };
+        sutProvider.GetDependency<IStripePaymentService>()
+            .GetSubscriptionAsync(user)
+            .Returns(subInfo);
+
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () =>
+            await sutProvider.Sut.Run(user));
+        Assert.Contains("Unable to generate license due to a payment issue", exception.Message);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task RunAsync_IncompleteExpiredSubscription_Throws(
+        SutProvider<GetUserLicenseQuery> sutProvider,
+        User user)
+    {
+        var subInfo = new SubscriptionInfo
+        {
+            Subscription = new SubscriptionInfo.BillingSubscription(new Subscription { Status = "incomplete_expired" })
+        };
+        sutProvider.GetDependency<IStripePaymentService>()
+            .GetSubscriptionAsync(user)
+            .Returns(subInfo);
+
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () =>
+            await sutProvider.Sut.Run(user));
+        Assert.Contains("Unable to generate license due to a payment issue", exception.Message);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task RunAsync_NullSubscription_Throws(
+        SutProvider<GetUserLicenseQuery> sutProvider,
+        User user)
+    {
+        var subInfo = new SubscriptionInfo { Subscription = null };
+        sutProvider.GetDependency<IStripePaymentService>()
+            .GetSubscriptionAsync(user)
+            .Returns(subInfo);
+
+        var exception = await Assert.ThrowsAsync<BadRequestException>(async () =>
+            await sutProvider.Sut.Run(user));
+        Assert.Contains("No active subscription found", exception.Message);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task RunAsync_ActiveSubscription_Succeeds(
+        SutProvider<GetUserLicenseQuery> sutProvider,
+        User user, UserLicense userLicense)
+    {
+        var subInfo = new SubscriptionInfo
+        {
+            Subscription = new SubscriptionInfo.BillingSubscription(new Subscription { Status = "active" })
+        };
+        sutProvider.GetDependency<IStripePaymentService>()
+            .GetSubscriptionAsync(user)
+            .Returns(subInfo);
+        sutProvider.GetDependency<IUserService>().GenerateLicenseAsync(user).Returns(userLicense);
+
+        var result = await sutProvider.Sut.Run(user);
+
+        Assert.NotNull(result);
+        Assert.Equal(userLicense, result);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task RunAsync_TrialingSubscription_Succeeds(
+        SutProvider<GetUserLicenseQuery> sutProvider,
+        User user, UserLicense userLicense)
+    {
+        var subInfo = new SubscriptionInfo
+        {
+            Subscription = new SubscriptionInfo.BillingSubscription(new Subscription { Status = "trialing" })
+        };
+        sutProvider.GetDependency<IStripePaymentService>()
+            .GetSubscriptionAsync(user)
+            .Returns(subInfo);
+        sutProvider.GetDependency<IUserService>().GenerateLicenseAsync(user).Returns(userLicense);
+
+        var result = await sutProvider.Sut.Run(user);
+
+        Assert.NotNull(result);
+        Assert.Equal(userLicense, result);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async Task RunAsync_PastDueSubscription_Succeeds(
+        SutProvider<GetUserLicenseQuery> sutProvider,
+        User user, UserLicense userLicense)
+    {
+        var subInfo = new SubscriptionInfo
+        {
+            Subscription = new SubscriptionInfo.BillingSubscription(new Subscription { Status = "past_due" })
+        };
+        sutProvider.GetDependency<IStripePaymentService>()
+            .GetSubscriptionAsync(user)
+            .Returns(subInfo);
+        sutProvider.GetDependency<IUserService>().GenerateLicenseAsync(user).Returns(userLicense);
+
+        var result = await sutProvider.Sut.Run(user);
+
+        Assert.NotNull(result);
+        Assert.Equal(userLicense, result);
+    }
+}