This PR has been updated to add tests for #1253

### Commits:
- Add unit tests for modified billing webhook payment handlers

This commit adds tests for the streamlined invoice payment handling in the billing/views.py file:
- Tests for invoice_payment_succeeded function including delinquent status updates and email notifications
- Tests for invoice_payment_failed function including conditional delinquent status handling
- Tests for the payment intent verification flow

These tests ensure proper coverage of the modified payment handling logic in the billing webhook handler.
- Add unit tests for subscription handling in billing webhook

This commit adds tests for the subscription handling functionality in billing/views.py:
- Tests for customer_subscription_deleted including plan reset and repository deactivation
- Tests for customer_subscription_created including ID setting and plan updates
- Tests for the payment verification method used with asynchronous payment methods
- Tests for handling repositories when subscriptions change

These tests ensure the subscription lifecycle is properly handled in the Stripe webhook handler.
- Add unit tests for payment method handling in webhook handler

This commit adds tests for the payment method handling functionality in billing/views.py:
- Tests for delayed notification handling with bank account verification
- Tests for payment intent success handling
- Tests for payment method attachment and default setting

These tests ensure payment methods are properly handled for asynchronous payment flows.

Author: codecov-ai[bot]

billing/tests/test_invoice_functions.py

@@ -0,0 +1,131 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from django.test import TestCase
+
+from billing.views import StripeWebhookHandler
+from codecov_auth.tests.factories import OwnerFactory
+
+
+class TestInvoicePaymentSucceeded(TestCase):
+    def setUp(self):
+        self.handler = StripeWebhookHandler()
+        self.owner = OwnerFactory(
+            stripe_customer_id="cus_123",
+            stripe_subscription_id="sub_123",
+        )
+
+    @patch("billing.views.Owner.objects.filter")
+    def test_invoice_payment_succeeded_updates_delinquent_status(self, mock_filter):
+        mock_owners = Mock()
+        mock_filter.return_value = mock_owners
+
+        # Create a mock invoice object
+        mock_invoice = Mock()
+        mock_invoice.customer = self.owner.stripe_customer_id
+        mock_invoice.subscription = self.owner.stripe_subscription_id
+        mock_invoice.total = 24000
+        mock_invoice.hosted_invoice_url = "https://stripe.com"
+
+        # Call the handler method
+        self.handler.invoice_payment_succeeded(mock_invoice)
+
+        # Verify the owners were filtered and updated correctly
+        mock_filter.assert_called_once_with(
+            stripe_customer_id=self.owner.stripe_customer_id,
+        )
+        mock_owners.update.assert_called_once_with(delinquent=False)
+
+    @patch("billing.views.Owner.objects.filter")
+    @patch("billing.views.TaskService")
+    def test_invoice_payment_succeeded_sends_email_to_delinquent_owners(
+        self, mock_task_service, mock_filter
+    ):
+        # Setup mock owners with delinquent status
+        mock_owners = Mock()
+        mock_owners_list = [self.owner]
+        mock_filter.return_value = mock_owners
+        mock_owners.filter.return_value = mock_owners
+        mock_owners.__iter__.return_value = mock_owners_list
+        
+        # Setup delinquent status
+        self.owner.delinquent = True
+        self.owner.email = "[email protected]"
+        
+        # Setup task service mock
+        mock_task_service_instance = Mock()
+        mock_task_service.return_value = mock_task_service_instance
+
+        # Create a mock invoice object
+        mock_invoice = Mock()
+        mock_invoice.customer = self.owner.stripe_customer_id
+        mock_invoice.subscription = self.owner.stripe_subscription_id
+        mock_invoice.total = 24000
+        mock_invoice.hosted_invoice_url = "https://stripe.com"
+
+        # Call the handler method
+        self.handler.invoice_payment_succeeded(mock_invoice)
+
+        # Verify email was sent to delinquent owner
+        mock_task_service_instance.send_email.assert_called_with(
+            to_addr=self.owner.email,
+            subject="You're all set",
+            template_name="success-after-failed-payment",
+            amount=240,
+            cta_link="https://stripe.com",
+            date=unittest.mock.ANY,
+        )
+
+
+class TestInvoicePaymentFailed(TestCase):
+    def setUp(self):
+        self.handler = StripeWebhookHandler()
+        self.owner = OwnerFactory(
+            stripe_customer_id="cus_123",
+            stripe_subscription_id="sub_123",
+            delinquent=False
+        )
+
+    @patch("billing.views.stripe.PaymentIntent.retrieve")
+    @patch("billing.views.Owner.objects.filter")
+    def test_invoice_payment_failed_with_payment_method_sets_delinquent(
+        self, mock_filter, mock_retrieve_payment_intent
+    ):
+        # Setup mock owners
+        mock_owners = Mock()
+        mock_filter.return_value = mock_owners
+
+        # Create a mock invoice object with payment method
+        mock_invoice = Mock()
+        mock_invoice.customer = self.owner.stripe_customer_id
+        mock_invoice.subscription = self.owner.stripe_subscription_id
+        mock_invoice.total = 24000
+        mock_invoice.hosted_invoice_url = "https://stripe.com"
+        mock_invoice.payment_intent = "pi_123"
+        mock_invoice.default_payment_method = {}  # Not None
+
+        # Call the handler method
+        self.handler.invoice_payment_failed(mock_invoice)
+
+        # Verify owners were set to delinquent
+        mock_owners.update.assert_called_once_with(delinquent=True)
+
+    @patch("billing.views.stripe.PaymentIntent.retrieve")
+    @patch("billing.views.Owner.objects.filter")
+    def test_invoice_payment_failed_skips_delinquency_for_requires_action(
+        self, mock_filter, mock_retrieve_payment_intent
+    ):
+        # Setup payment intent that requires action
+        mock_payment_intent = Mock()
+        mock_payment_intent.status = "requires_action"
+        mock_payment_intent.next_action = {"type": "verify_with_microdeposits"}
+        mock_retrieve_payment_intent.return_value = mock_payment_intent
+
+        # Create a mock invoice object with no payment method
+        mock_invoice = Mock()
+        mock_invoice.payment_intent = "pi_123"
+        mock_invoice.default_payment_method = None
+
+        # No delinquent status should be set for this case
+        self.handler.invoice_payment_failed(mock_invoice)
+        mock_filter.assert_not_called()

billing/tests/test_payment_method_handlers.py

@@ -0,0 +1,75 @@
+from unittest.mock import Mock, patch
+
+from django.test import TestCase
+
+from billing.views import StripeWebhookHandler
+from codecov_auth.tests.factories import OwnerFactory
+
+
+class TestPaymentMethodHandlers(TestCase):
+    def setUp(self):
+        self.handler = StripeWebhookHandler()
+        self.owner = OwnerFactory(
+            stripe_customer_id="cus_123",
+            stripe_subscription_id="sub_123",
+        )
+
+    @patch("billing.views.stripe.PaymentMethod.attach")
+    @patch("billing.views.stripe.Customer.modify")
+    @patch("billing.views.stripe.Subscription.modify")
+    @patch("billing.views.stripe.PaymentMethod.retrieve")
+    @patch("billing.views.Owner.objects.filter")
+    def test_check_and_handle_delayed_notification_payment_methods(
+        self,
+        mock_filter,
+        mock_retrieve,
+        mock_sub_modify,
+        mock_customer_modify,
+        mock_attach,
+    ):
+        # Setup mock owners
+        mock_owners = Mock()
+        mock_filter.return_value = mock_owners
+        mock_owners.values_list.return_value = [["sub_123"]]
+
+        # Setup mock payment method
+        mock_payment_method = Mock()
+        mock_payment_method.type = "us_bank_account"
+        mock_payment_method.us_bank_account = {}
+        mock_payment_method.id = "pm_123"
+        mock_retrieve.return_value = mock_payment_method
+
+        # Call the handler method
+        self.handler._check_and_handle_delayed_notification_payment_methods(
+            "cus_123", "pm_123"
+        )
+
+        # Verify payment method was attached to customer
+        mock_attach.assert_called_once_with(mock_payment_method, customer="cus_123")
+        
+        # Verify customer was updated with default payment method
+        mock_customer_modify.assert_called_once_with(
+            "cus_123",
+            invoice_settings={"default_payment_method": mock_payment_method},
+        )
+        
+        # Verify subscription was updated with default payment method
+        mock_sub_modify.assert_called_once_with(
+            "sub_123", 
+            default_payment_method=mock_payment_method
+        )
+
+    @patch("billing.views.logging.Logger.info")
+    @patch("billing.views.StripeWebhookHandler._check_and_handle_delayed_notification_payment_methods")
+    def test_payment_intent_succeeded(self, mock_check, mock_log_info):
+        # Create mock payment intent
+        mock_payment_intent = Mock()
+        mock_payment_intent.id = "pi_123"
+        mock_payment_intent.customer = "cus_123"
+        mock_payment_intent.payment_method = "pm_123"
+
+        # Call the handler method
+        self.handler.payment_intent_succeeded(mock_payment_intent)
+
+        # Verify delayed notification method was called
+        mock_check.assert_called_once_with("cus_123", "pm_123")

billing/tests/test_subscription_handlers.py

@@ -0,0 +1,182 @@
+from unittest.mock import Mock, patch
+
+from django.test import TestCase
+
+from billing.constants import DEFAULT_FREE_PLAN
+from billing.models import Plan
+from billing.views import StripeWebhookHandler
+from codecov_auth.tests.factories import OwnerFactory
+from core.tests.factories import RepositoryFactory
+
+
+class TestSubscriptionHandlers(TestCase):
+    def setUp(self):
+        self.handler = StripeWebhookHandler()
+        self.owner = OwnerFactory(
+            stripe_customer_id="cus_123",
+            stripe_subscription_id="sub_123",
+            plan="users-pr-inappy",
+            plan_user_count=10,
+            plan_auto_activate=True
+        )
+
+    @patch("billing.views.Owner.objects.filter")
+    def test_customer_subscription_deleted_sets_free_plan(self, mock_filter):
+        # Setup mock owners
+        mock_owners = Mock()
+        mock_filter.return_value = mock_owners
+
+        # Create mock subscription
+        mock_subscription = Mock()
+        mock_subscription.id = self.owner.stripe_subscription_id
+        mock_subscription.customer = self.owner.stripe_customer_id
+        mock_subscription.plan = {"name": self.owner.plan}
+        mock_subscription.status = "active"
+
+        # Call the handler method
+        self.handler.customer_subscription_deleted(mock_subscription)
+
+        # Verify owners were updated correctly
+        mock_owners.update.assert_called_with(
+            plan=DEFAULT_FREE_PLAN,
+            plan_user_count=1,
+            plan_activated_users=None,
+            stripe_subscription_id=None
+        )
+
+    @patch("billing.views.StripeWebhookHandler._has_unverified_initial_payment_method")
+    @patch("billing.views.Owner.objects.get")
+    @patch("billing.views.PlanService")
+    def test_customer_subscription_created_sets_subscription_ids(
+        self, mock_plan_service, mock_get, mock_has_unverified
+    ):
+        # Mock owner instance and plan service
+        mock_owner = Mock()
+        mock_get.return_value = mock_owner
+        mock_plan_service_instance = Mock()
+        mock_plan_service.return_value = mock_plan_service_instance
+        mock_has_unverified.return_value = False
+
+        # Create mock subscription with metadata
+        mock_subscription = Mock()
+        mock_subscription.id = "new_sub_123"
+        mock_subscription.customer = "new_cus_123"
+        mock_subscription.plan.id = "plan_pro_yearly"
+        mock_subscription.quantity = 5
+        mock_subscription.metadata.get.return_value = self.owner.ownerid
+
+        # Call the handler method
+        self.handler.customer_subscription_created(mock_subscription)
+
+        # Verify owner was retrieved and updated correctly
+        mock_get.assert_called_with(ownerid=self.owner.ownerid)
+        self.assertEqual(mock_owner.stripe_subscription_id, "new_sub_123")
+        self.assertEqual(mock_owner.stripe_customer_id, "new_cus_123")
+        mock_owner.save.assert_called_once()
+
+        # Verify plan was updated
+        mock_plan_service.assert_called_with(current_org=mock_owner)
+        mock_plan_service_instance.expire_trial_when_upgrading.assert_called_once()
+        mock_plan_service_instance.update_plan.assert_called_once()
+
+    @patch("billing.views.StripeWebhookHandler._has_unverified_initial_payment_method")
+    @patch("billing.views.Owner.objects.get")
+    @patch("billing.views.PlanService")
+    def test_customer_subscription_created_early_returns_if_unverified(
+        self, mock_plan_service, mock_get, mock_has_unverified
+    ):
+        # Mock owner instance and unverified payment method
+        mock_owner = Mock()
+        mock_get.return_value = mock_owner
+        mock_has_unverified.return_value = True
+
+        # Create mock subscription with metadata
+        mock_subscription = Mock()
+        mock_subscription.id = "new_sub_123"
+        mock_subscription.customer = "new_cus_123"
+        mock_subscription.plan.id = "plan_pro_yearly"
+        mock_subscription.metadata.get.return_value = self.owner.ownerid
+
+        # Call the handler method
+        self.handler.customer_subscription_created(mock_subscription)
+
+        # Verify owner was updated but plan was not
+        mock_get.assert_called_with(ownerid=self.owner.ownerid)
+        self.assertEqual(mock_owner.stripe_subscription_id, "new_sub_123")
+        self.assertEqual(mock_owner.stripe_customer_id, "new_cus_123")
+        mock_owner.save.assert_called_once()
+
+        # Verify plan service was not used to update plan
+        mock_plan_service_instance = mock_plan_service.return_value
+        mock_plan_service_instance.update_plan.assert_not_called()
+
+    @patch("billing.views.stripe.Invoice.retrieve")
+    def test_has_unverified_initial_payment_method(self, mock_invoice_retrieve):
+        # Mock subscription and payment intent requiring action
+        mock_subscription = Mock()
+        mock_subscription.latest_invoice = "inv_123"
+
+        mock_invoice = Mock()
+        mock_invoice.payment_intent = "pi_123"
+        mock_invoice_retrieve.return_value = mock_invoice
+
+        mock_payment_intent = Mock()
+        mock_payment_intent.status = "requires_action"
+        mock_payment_intent.next_action = {"type": "verify_with_microdeposits"}
+
+        with patch("billing.views.stripe.PaymentIntent.retrieve", return_value=mock_payment_intent):
+            result = self.handler._has_unverified_initial_payment_method(mock_subscription)
+
+        self.assertTrue(result)
+        mock_invoice_retrieve.assert_called_once_with("inv_123")
+
+    @patch("billing.views.stripe.Invoice.retrieve")
+    def test_has_unverified_initial_payment_method_returns_false_when_succeeded(self, mock_invoice_retrieve):
+        # Mock subscription and payment intent that succeeded
+        mock_subscription = Mock()
+        mock_subscription.latest_invoice = "inv_123"
+
+        mock_invoice = Mock()
+        mock_invoice.payment_intent = "pi_123"
+        mock_invoice_retrieve.return_value = mock_invoice
+
+        mock_payment_intent = Mock()
+        mock_payment_intent.status = "succeeded"
+
+        with patch("billing.views.stripe.PaymentIntent.retrieve", return_value=mock_payment_intent):
+            result = self.handler._has_unverified_initial_payment_method(mock_subscription)
+
+        self.assertFalse(result)
+        mock_invoice_retrieve.assert_called_once_with("inv_123")
+
+    @patch("billing.views.Owner.objects.filter")
+    @patch("billing.views.Repository.objects.filter")
+    def test_customer_subscription_deleted_deactivates_repositories(
+        self, mock_repo_filter, mock_owner_filter
+    ):
+        # Create mock repositories
+        mock_repos = Mock()
+        mock_repo_filter.return_value = mock_repos
+
+        # Setup mock owners
+        mock_owners = Mock()
+        mock_owner_filter.return_value = mock_owners
+        mock_owners.__iter__.return_value = [self.owner]
+
+        # Create test repositories
+        RepositoryFactory(author=self.owner, activated=True, active=True)
+        RepositoryFactory(author=self.owner, activated=True, active=True)
+
+        # Create mock subscription
+        mock_subscription = Mock()
+        mock_subscription.id = self.owner.stripe_subscription_id
+        mock_subscription.customer = self.owner.stripe_customer_id
+        mock_subscription.plan = {"name": self.owner.plan}
+        mock_subscription.status = "active"
+
+        # Call the handler method
+        self.handler.customer_subscription_deleted(mock_subscription)
+
+        # Verify repositories were deactivated
+        mock_repo_filter.assert_called_with(author=self.owner)
+        mock_repos.update.assert_called_with(activated=False, active=False)