fix subscription cancel proration

Author: turip

openmeter/billing/worker/subscriptionsync/service/sync_test.go

@@ -506,7 +506,7 @@ func (s *SubscriptionHandlerTestSuite) TestInArrearsProratingGathering() {
 		}
 	})
 
-	s.Run("canceling the subscription DOES NOT cause the existing item to be pro-rated", func() {
+	s.Run("canceling the subscription inside the service period causes the existing item to be pro-rated", func() {
 		// this test needs items longer than subscription.BillingCadence
 		clock.SetTime(s.mustParseTime("2024-01-01T10:00:00Z"))
 
@@ -551,7 +551,7 @@ func (s *SubscriptionHandlerTestSuite) TestInArrearsProratingGathering() {
 		})
 		price, err := flatFeeLine.Price.AsFlat()
 		s.NoError(err)
-		s.Equal(price.Amount.InexactFloat64(), 9.0, "failed for line %v", flatFeeLine.ID)
+		s.Equal(price.Amount.InexactFloat64(), 3.07, "failed for line %v", flatFeeLine.ID)
 		s.Equal(price.PaymentTerm, productcatalog.InArrearsPaymentTerm, "failed for line %v", flatFeeLine.ID)
 	})
 }
@@ -649,6 +649,171 @@ func (s *SubscriptionHandlerTestSuite) TestInAdvanceGatheringSyncNonBillableAmou
 	})
 }
 
+func (s *SubscriptionHandlerTestSuite) TestInAdvanceFlatFeeCancelAtFirstBillingBoundaryKeepsInitialProration() {
+	ctx := s.T().Context()
+	startAt := s.mustParseTime("2024-01-21T21:55:18Z")
+	billingAnchor := s.mustParseTime("2024-01-01T00:00:00Z")
+	firstBillingBoundary := s.mustParseTime("2024-02-01T00:00:00Z")
+	expectedProratedPrice := productcatalog.NewPriceFrom(productcatalog.FlatPrice{
+		Amount:      alpacadecimal.NewFromFloat(6.51),
+		PaymentTerm: productcatalog.InAdvancePaymentTerm,
+	})
+	expectedFullPrice := productcatalog.NewPriceFrom(productcatalog.FlatPrice{
+		Amount:      alpacadecimal.NewFromFloat(20),
+		PaymentTerm: productcatalog.InAdvancePaymentTerm,
+	})
+
+	clock.FreezeTime(startAt)
+	defer clock.UnFreeze()
+	s.enableProrating()
+
+	// given:
+	// - a subscription starts mid-period but bills on the first of the month
+	// - the first in-advance flat fee line is generated with alignment proration
+	// when:
+	// - renewal is canceled at the first billing boundary before the pending line is invoiced
+	// then:
+	// - the cancel resync keeps the initial prorated price instead of replacing it with the full period price
+	planEntity, err := s.PlanService.CreatePlan(ctx, plan.CreatePlanInput{
+		NamespacedModel: models.NamespacedModel{
+			Namespace: s.Namespace,
+		},
+		Plan: productcatalog.Plan{
+			PlanMeta: productcatalog.PlanMeta{
+				Name:           "Test Plan",
+				Key:            "test-plan",
+				Version:        1,
+				Currency:       currency.USD,
+				BillingCadence: datetime.MustParseDuration(s.T(), "P1M"),
+				ProRatingConfig: productcatalog.ProRatingConfig{
+					Enabled: true,
+					Mode:    productcatalog.ProRatingModeProratePrices,
+				},
+			},
+			Phases: []productcatalog.Phase{
+				{
+					PhaseMeta: s.phaseMeta("first-phase", ""),
+					RateCards: productcatalog.RateCards{
+						&productcatalog.UsageBasedRateCard{
+							RateCardMeta: productcatalog.RateCardMeta{
+								Key:  "in-advance",
+								Name: "in-advance",
+								Price: productcatalog.NewPriceFrom(productcatalog.FlatPrice{
+									Amount:      alpacadecimal.NewFromFloat(20),
+									PaymentTerm: productcatalog.InAdvancePaymentTerm,
+								}),
+							},
+							BillingCadence: datetime.MustParseDuration(s.T(), "P1M"),
+						},
+					},
+				},
+			},
+		},
+	})
+	s.NoError(err)
+
+	subscriptionPlan, err := s.SubscriptionPlanAdapter.GetVersion(ctx, s.Namespace, productcatalogsubscription.PlanRefInput{
+		Key:     planEntity.Key,
+		Version: lo.ToPtr(1),
+	})
+	s.NoError(err)
+
+	subsView, err := s.SubscriptionWorkflowService.CreateFromPlan(ctx, subscriptionworkflow.CreateSubscriptionWorkflowInput{
+		ChangeSubscriptionWorkflowInput: subscriptionworkflow.ChangeSubscriptionWorkflowInput{
+			Timing: subscription.Timing{
+				Custom: lo.ToPtr(startAt),
+			},
+			Name: "subs-1",
+		},
+		Namespace:     s.Namespace,
+		CustomerID:    s.Customer.ID,
+		BillingAnchor: lo.ToPtr(billingAnchor),
+	}, subscriptionPlan)
+	s.NoError(err)
+
+	s.NoError(s.Service.SyncByView(ctx, subsView, firstBillingBoundary))
+
+	gatheringInvoice := s.gatheringInvoice(ctx, s.Namespace, s.Customer.ID)
+	s.expectLines(gatheringInvoice, subsView.Subscription.ID, []expectedLine{
+		{
+			Matcher: recurringLineMatcher{
+				PhaseKey:  "first-phase",
+				ItemKey:   "in-advance",
+				Version:   0,
+				PeriodMin: 0,
+				PeriodMax: 0,
+			},
+			Price: mo.Some(expectedProratedPrice),
+			Periods: []timeutil.ClosedPeriod{
+				{
+					From: startAt,
+					To:   firstBillingBoundary,
+				},
+			},
+			InvoiceAt: mo.Some([]time.Time{startAt}),
+			AdditionalChecks: func(line billing.GenericInvoiceLine) {
+				flatPrice, err := line.GetPrice().AsFlat()
+				s.NoError(err)
+				s.False(flatPrice.Amount.Equal(alpacadecimal.NewFromFloat(20)))
+			},
+		},
+		{
+			Matcher: recurringLineMatcher{
+				PhaseKey:  "first-phase",
+				ItemKey:   "in-advance",
+				Version:   0,
+				PeriodMin: 1,
+				PeriodMax: 1,
+			},
+			Price: mo.Some(expectedFullPrice),
+			Periods: []timeutil.ClosedPeriod{
+				{
+					From: firstBillingBoundary,
+					To:   s.mustParseTime("2024-03-01T00:00:00Z"),
+				},
+			},
+			InvoiceAt: mo.Some([]time.Time{firstBillingBoundary}),
+		},
+	})
+
+	clock.FreezeTime(startAt.Add(13 * time.Second))
+	subscriptionModel, err := s.SubscriptionService.Cancel(ctx, subsView.Subscription.NamespacedID, subscription.Timing{
+		Custom: lo.ToPtr(firstBillingBoundary),
+	})
+	s.NoError(err)
+
+	subsView, err = s.SubscriptionService.GetView(ctx, subscriptionModel.NamespacedID)
+	s.NoError(err)
+
+	s.NoError(s.Service.SyncByView(ctx, subsView, firstBillingBoundary))
+
+	gatheringInvoice = s.gatheringInvoice(ctx, s.Namespace, s.Customer.ID)
+	s.expectLines(gatheringInvoice, subsView.Subscription.ID, []expectedLine{
+		{
+			Matcher: recurringLineMatcher{
+				PhaseKey:  "first-phase",
+				ItemKey:   "in-advance",
+				Version:   0,
+				PeriodMin: 0,
+				PeriodMax: 0,
+			},
+			Price: mo.Some(expectedProratedPrice),
+			Periods: []timeutil.ClosedPeriod{
+				{
+					From: startAt,
+					To:   firstBillingBoundary,
+				},
+			},
+			InvoiceAt: mo.Some([]time.Time{startAt}),
+			AdditionalChecks: func(line billing.GenericInvoiceLine) {
+				flatPrice, err := line.GetPrice().AsFlat()
+				s.NoError(err)
+				s.False(flatPrice.Amount.Equal(alpacadecimal.NewFromFloat(20)))
+			},
+		},
+	})
+}
+
 func (s *SubscriptionHandlerTestSuite) TestInAdvanceGatheringSyncNonBillableAmount() {
 	ctx := s.T().Context()
 	clock.FreezeTime(s.mustParseTime("2024-01-01T00:00:00Z"))

openmeter/billing/worker/subscriptionsync/service/targetstate/targetstateitem.go

@@ -142,10 +142,6 @@ func (r StateItem) shouldProrate() bool {
 		return false
 	}
 
-	if r.Subscription.ActiveTo != nil && !r.Subscription.ActiveTo.After(r.ServicePeriod.To) {
-		return false
-	}
-
 	switch r.Subscription.ProRatingConfig.Mode {
 	case productcatalog.ProRatingModeProratePrices:
 		return true