Fix broken unsubscribe from stripe.

Author: dagstuan

SkredvarselGarminWeb/SkredvarselGarminWeb.Tests/StripeServiceTests.cs

@@ -0,0 +1,98 @@
+using AwesomeAssertions;
+
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.Logging;
+
+using NSubstitute;
+
+using SkredvarselGarminWeb.Database;
+using SkredvarselGarminWeb.Entities;
+using SkredvarselGarminWeb.Entities.Mappers;
+using SkredvarselGarminWeb.Helpers;
+using SkredvarselGarminWeb.Services;
+
+using Stripe;
+
+namespace SkredvarselGarminWeb.Tests;
+
+public class StripeServiceTests
+{
+    private readonly SkredvarselDbContext _dbContext;
+    private readonly StripeService _stripeService;
+
+    public StripeServiceTests()
+    {
+        var dbContextOptions = new DbContextOptionsBuilder<SkredvarselDbContext>()
+            .UseInMemoryDatabase($"StripeServiceTests-{Guid.NewGuid()}")
+            .ConfigureWarnings(builder => builder.Ignore(InMemoryEventId.TransactionIgnoredWarning))
+            .Options;
+
+        _dbContext = new SkredvarselDbContext(dbContextOptions);
+        _dbContext.Database.EnsureDeleted();
+        _dbContext.Database.EnsureCreated();
+
+        _stripeService = new StripeService(
+            _dbContext,
+            Substitute.For<IStripeClient>(),
+            Substitute.For<INotificationService>(),
+            Substitute.For<IDateTimeNowProvider>(),
+            Substitute.For<ILogger<StripeService>>());
+    }
+
+    [Fact]
+    public void ToStripeSubscriptionStatus_should_map_active_subscription_scheduled_for_cancellation_to_unsubscribed()
+    {
+        var subscription = CreateStripeSubscription(status: "active", cancelAtPeriodEnd: true);
+
+        var status = subscription.ToStripeSubscriptionStatus();
+
+        status.Should().Be(StripeSubscriptionStatus.UNSUBSCRIBED);
+    }
+
+    [Fact]
+    public void ToStripeSubscriptionStatus_should_map_canceled_subscription_even_when_cancel_at_period_end_is_true()
+    {
+        var subscription = CreateStripeSubscription(status: "canceled", cancelAtPeriodEnd: true);
+
+        var status = subscription.ToStripeSubscriptionStatus();
+
+        status.Should().Be(StripeSubscriptionStatus.CANCELED);
+    }
+
+    [Fact]
+    public void ToStripeSubscriptionStatus_should_map_active_subscription_with_cancel_at_to_unsubscribed()
+    {
+        var subscription = CreateStripeSubscription(status: "active", cancelAt: DateTime.UtcNow.AddDays(30));
+
+        var status = subscription.ToStripeSubscriptionStatus();
+
+        status.Should().Be(StripeSubscriptionStatus.UNSUBSCRIBED);
+    }
+
+    private static Subscription CreateStripeSubscription(
+        string id = "sub_123",
+        string status = "active",
+        bool cancelAtPeriodEnd = false,
+        DateTime? cancelAt = null,
+        DateTime? currentPeriodEnd = null)
+    {
+        return new Subscription
+        {
+            Id = id,
+            Status = status,
+            CancelAtPeriodEnd = cancelAtPeriodEnd,
+            CancelAt = cancelAt,
+            Items = new StripeList<SubscriptionItem>
+            {
+                Data =
+                [
+                    new SubscriptionItem
+                    {
+                        CurrentPeriodEnd = currentPeriodEnd ?? new DateTime(2026, 4, 24, 0, 0, 0, DateTimeKind.Utc)
+                    }
+                ]
+            }
+        };
+    }
+}

SkredvarselGarminWeb/SkredvarselGarminWeb/Entities/Mappers/StripeSubscriptionStatusMapper.cs

@@ -6,17 +6,28 @@ namespace SkredvarselGarminWeb.Entities.Mappers;
 
 public static class StripeSubscriptionStatusMapper
 {
-    public static StripeSubscriptionStatus ToStripeSubscriptionStatus(this Subscription subscription) => (subscription.Status, subscription.CancelAtPeriodEnd) switch
+    public static StripeSubscriptionStatus ToStripeSubscriptionStatus(this Subscription subscription)
     {
-        ("active", false) => StripeSubscriptionStatus.ACTIVE,
-        ("active", true) => StripeSubscriptionStatus.UNSUBSCRIBED,
-        ("canceled", false) => StripeSubscriptionStatus.CANCELED,
-        ("incomplete", false) => StripeSubscriptionStatus.INCOMPLETE,
-        ("incomplete_expired", false) => StripeSubscriptionStatus.INCOMPLETE_EXPIRED,
-        ("past_due", false) => StripeSubscriptionStatus.PAST_DUE,
-        ("paused", false) => StripeSubscriptionStatus.PAUSED,
-        ("trialing", false) => StripeSubscriptionStatus.TRIALING,
-        ("unpaid", false) => StripeSubscriptionStatus.UNPAID,
-        _ => throw new InvalidEnumArgumentException(nameof(subscription.Status))
-    };
+        if (subscription.Status == "canceled")
+        {
+            return StripeSubscriptionStatus.CANCELED;
+        }
+
+        if ((subscription.CancelAtPeriodEnd || subscription.CancelAt != null) && subscription.Status is "active" or "trialing")
+        {
+            return StripeSubscriptionStatus.UNSUBSCRIBED;
+        }
+
+        return subscription.Status switch
+        {
+            "active" => StripeSubscriptionStatus.ACTIVE,
+            "incomplete" => StripeSubscriptionStatus.INCOMPLETE,
+            "incomplete_expired" => StripeSubscriptionStatus.INCOMPLETE_EXPIRED,
+            "past_due" => StripeSubscriptionStatus.PAST_DUE,
+            "paused" => StripeSubscriptionStatus.PAUSED,
+            "trialing" => StripeSubscriptionStatus.TRIALING,
+            "unpaid" => StripeSubscriptionStatus.UNPAID,
+            _ => throw new InvalidEnumArgumentException(nameof(subscription.Status))
+        };
+    }
 }

SkredvarselGarminWeb/SkredvarselGarminWeb/Services/StripeService.cs

@@ -12,13 +12,14 @@ namespace SkredvarselGarminWeb.Services;
 
 public class StripeService(
     SkredvarselDbContext dbContext,
+    IStripeClient stripeClient,
     INotificationService notificationService,
     IDateTimeNowProvider dateTimeNowProvider,
     ILogger<StripeService> logger) : IStripeService
 {
-    private static Subscription GetStripeSubscription(string subscriptionId)
+    private Subscription GetStripeSubscription(string subscriptionId)
     {
-        var service = new StripeSubscriptionService();
+        var service = new StripeSubscriptionService(stripeClient);
         return service.Get(subscriptionId);
     }
 
@@ -92,17 +93,35 @@ public void HandleSubscriptionUpdated(Subscription subscription)
     {
         using var transaction = dbContext.Database.BeginTransaction();
 
-        var subscriptionInDb = dbContext.StripeSubscriptions.SingleOrDefault(s => s.SubscriptionId == subscription.Id);
+        var latestSubscription = GetStripeSubscription(subscription.Id);
+
+        logger.LogInformation(
+            "Processing stripe subscription update for {subscriptionId} with status {status} and cancelAtPeriodEnd {cancelAtPeriodEnd}.",
+            latestSubscription.Id,
+            latestSubscription.Status,
+            latestSubscription.CancelAtPeriodEnd);
+
+        var subscriptionInDb = dbContext.StripeSubscriptions.SingleOrDefault(s => s.SubscriptionId == latestSubscription.Id);
 
         if (subscriptionInDb == null)
         {
-            logger.LogInformation("Received subscription updated event for subscription not in local database.");
+            logger.LogInformation(
+                "Received subscription updated event for subscription {subscriptionId} not in local database.",
+                latestSubscription.Id);
             transaction.Commit();
             return;
         }
 
-        subscriptionInDb.Status = subscription.ToStripeSubscriptionStatus();
-        subscriptionInDb.NextChargeDate = DateOnly.FromDateTime(subscription.Items.Data[0].CurrentPeriodEnd);
+        var updatedStatus = latestSubscription.ToStripeSubscriptionStatus();
+
+        logger.LogInformation(
+            "Updating local stripe subscription {subscriptionId} from {previousStatus} to {updatedStatus}.",
+            latestSubscription.Id,
+            subscriptionInDb.Status,
+            updatedStatus);
+
+        subscriptionInDb.Status = updatedStatus;
+        subscriptionInDb.NextChargeDate = DateOnly.FromDateTime(latestSubscription.Items.Data[0].CurrentPeriodEnd);
 
         dbContext.SaveChanges();