add garbage collection for incomplete subscriptions

Author: ashutoshgngwr

src/integrationTest/java/com/trynoice/api/subscription/entities/SubscriptionRepositoryTest.java

@@ -0,0 +1,77 @@
+package com.trynoice.api.subscription.entities;
+
+import lombok.val;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.persistence.EntityManager;
+import java.time.OffsetDateTime;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@SpringBootTest
+@Transactional
+public class SubscriptionRepositoryTest {
+
+    @Autowired
+    private EntityManager entityManager;
+
+    @Autowired
+    private SubscriptionRepository subscriptionRepository;
+
+    @Test
+    void deleteAllIncompleteCreatedBefore() {
+        val plan = entityManager.merge(
+            SubscriptionPlan.builder()
+                .provider(SubscriptionPlan.Provider.STRIPE)
+                .providedId("test-provided-id")
+                .billingPeriodMonths((short) 1)
+                .priceInIndianPaise(100)
+                .trialPeriodDays((short) 0)
+                .build());
+
+        val customer = entityManager.merge(
+            Customer.builder()
+                .userId(1)
+                .build());
+
+        val now = OffsetDateTime.now();
+        val stale = now.minusDays(1);
+
+        val completed = IntStream.range(0, 5)
+            .mapToObj(i -> subscriptionRepository.save(
+                Subscription.builder()
+                    .createdAt(i % 2 == 0 ? now : stale)
+                    .customer(customer)
+                    .plan(plan)
+                    .providedId("test-provided-id-" + i)
+                    .startAt(OffsetDateTime.now())
+                    .endAt(OffsetDateTime.now().minusHours(1))
+                    .isAutoRenewing(i % 2 == 0)
+                    .build()))
+            .collect(Collectors.toUnmodifiableList());
+
+        val incomplete = IntStream.range(5, 10)
+            .mapToObj(i -> subscriptionRepository.save(
+                Subscription.builder()
+                    .createdAt(i % 2 == 0 ? stale : now)
+                    .customer(customer)
+                    .plan(plan)
+                    .providedId(null)
+                    .startAt(null)
+                    .endAt(null)
+                    .isAutoRenewing(true)
+                    .build()))
+            .collect(Collectors.toUnmodifiableList());
+
+        subscriptionRepository.deleteAllIncompleteCreatedBefore(stale.plusMinutes(1));
+
+        completed.forEach(s -> assertTrue(subscriptionRepository.existsById(s.getId())));
+        incomplete.forEach(s -> assertEquals(s.getCreatedAt().isEqual(stale), !subscriptionRepository.existsById(s.getId())));
+    }
+}

src/main/java/com/trynoice/api/subscription/SubscriptionConfiguration.java

@@ -38,4 +38,7 @@ class SubscriptionConfiguration {
 
     @NotNull
     private final Duration cacheTtl;
+
+    @NotNull
+    private final Duration removeIncompleteSubscriptionsAfter;
 }

src/main/java/com/trynoice/api/subscription/SubscriptionScheduledTasks.java

@@ -0,0 +1,34 @@
+package com.trynoice.api.subscription;
+
+import lombok.NonNull;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+/**
+ * Collection of scheduled tasks for {@link SubscriptionService}.
+ */
+@Component
+@Slf4j
+class SubscriptionScheduledTasks {
+
+    private final SubscriptionService subscriptionService;
+
+    @Autowired
+    SubscriptionScheduledTasks(@NonNull SubscriptionService subscriptionService) {
+        this.subscriptionService = subscriptionService;
+    }
+
+    @Scheduled(cron = "${app.subscriptions.garbage-collection-schedule}")
+    void garbageCollection() {
+        log.info("performing garbage collection");
+        subscriptionService.performGarbageCollection();
+    }
+
+    @Scheduled(fixedRateString = "${app.subscriptions.foreign-exchange-rate-refresh-interval-millis}")
+    void updateForeignExchangeRates() {
+        log.info("updating foreign exchange rates");
+        subscriptionService.updateForeignExchangeRates();
+    }
+}

src/main/java/com/trynoice/api/subscription/SubscriptionService.java

@@ -44,7 +44,6 @@
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
 import org.springframework.integration.annotation.ServiceActivator;
-import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.event.TransactionPhase;
@@ -805,11 +804,16 @@ public void onUserDeleted(@NonNull AccountServiceContract.UserDeletedEvent event
             });
     }
 
-    @Scheduled(fixedRateString = "${app.subscriptions.foreign-exchange-rate-refresh-interval-millis}")
     void updateForeignExchangeRates() {
         exchangeRatesProvider.maybeUpdateRates();
     }
 
+    @Transactional(rollbackFor = Throwable.class)
+    public void performGarbageCollection() {
+        val deleteBefore = OffsetDateTime.now().minus(subscriptionConfig.getRemoveIncompleteSubscriptionsAfter());
+        subscriptionRepository.deleteAllIncompleteCreatedBefore(deleteBefore);
+    }
+
     private void evictIsSubscribedCache(long userId) {
         cache.evictIfPresent(String.format("isSubscribed:%d", userId));
     }

src/main/java/com/trynoice/api/subscription/entities/SubscriptionRepository.java

@@ -3,11 +3,13 @@
 import lombok.NonNull;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.time.OffsetDateTime;
 import java.util.List;
 import java.util.Optional;
 
@@ -64,4 +66,17 @@ public interface SubscriptionRepository extends PagingAndSortingRepository<Subsc
     @Transactional(readOnly = true)
     @Query("select e from Subscription e where e.customer.userId = ?1 and e.startAt < now() and e.endAt > now()")
     Optional<Subscription> findActiveByCustomerUserId(@NonNull Long customerUserId);
+
+    /**
+     * Deletes all entities from the database that have {@literal null} {@link
+     * Subscription#getProvidedId()}, {@link Subscription#getStartAt()} and {@link
+     * Subscription#getEndAt()}, and were created before the given {@code createdBefore} timestamp.
+     *
+     * @param createdBefore a not {@literal null} timestamp to remove incomplete entities that were
+     *                      created before this instant.
+     */
+    @Modifying(flushAutomatically = true, clearAutomatically = true)
+    @Transactional
+    @Query("delete from Subscription e where e.providedId is null and e.startAt is null and e.endAt is null and e.createdAt < ?1")
+    void deleteAllIncompleteCreatedBefore(@NonNull OffsetDateTime createdBefore);
 }

src/main/resources/application.properties

@@ -72,7 +72,8 @@ app.auth.sign-in-reattempt-max-delay=6h
 # and access tokens using cookies.
 app.auth.cookie-domain=
 
-# A Spring cron-like expression to specify a garbage collection schedule for the account service.
+# A Spring cron-like expression to specify a garbage collection schedule for the
+# account service.
 app.auth.garbage-collection-schedule=0 0 0 * * *
 
 # During garbage collection, permanently delete accounts that were deactivated
@@ -121,6 +122,15 @@ app.subscriptions.cache-ttl=5m
 # Refresh interval for foreign exchange rates (in milliseconds).
 app.subscriptions.foreign-exchange-rate-refresh-interval-millis=3600000
 
+# A Spring cron-like expression to specify a garbage collection schedule for
+# the subscription service.
+app.subscriptions.garbage-collection-schedule=0 0 0 * * *
+
+# During garbage collection, permanently delete subscription entities that were
+# initiated before this duration, but their payment flow was never completed, so
+# they never became active.
+app.subscriptions.remove-incomplete-subscriptions-after=7d
+
 # S3 bucket prefix where the sound library is hosted (excluding the library
 # version). e.g. if the current library version is hosted at
 # `s3://bucket-name/v0.1.0`, then this value should be `s3://bucket-name`.

src/test/java/com/trynoice/api/subscription/SubscriptionServiceTest.java

@@ -41,6 +41,7 @@
 import org.springframework.data.domain.Sort;
 
 import java.io.IOException;
+import java.time.Duration;
 import java.time.OffsetDateTime;
 import java.util.HashMap;
 import java.util.List;
@@ -56,6 +57,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.mock;
@@ -481,6 +483,18 @@ void isUserSubscribed() {
             assertEquals(isSubscribed, service.isUserSubscribed(userId)));
     }
 
+    @Test
+    void performGarbageCollection() {
+        when(subscriptionConfiguration.getRemoveIncompleteSubscriptionsAfter())
+            .thenReturn(Duration.ofHours(1L));
+
+        service.performGarbageCollection();
+
+        val now = OffsetDateTime.now();
+        verify(subscriptionRepository, times(1)).deleteAllIncompleteCreatedBefore(
+            argThat(t -> t.isBefore(now.minusMinutes(59)) && t.isAfter(now.minusMinutes(61))));
+    }
+
     @NonNull
     private static SubscriptionPlan buildSubscriptionPlan(@NonNull SubscriptionPlan.Provider provider, @NonNull String providedId) {
         return SubscriptionPlan.builder()