This PR has been updated to add tests for #1253

### Commits:
- Add tests for invoice payment succeeded functionality

This commit adds comprehensive unit tests for the invoice_payment_succeeded method in the StripeWebhookHandler class, covering:
- Setting delinquent status to false when payment succeeds
- Sending notification emails to owners and admins
- Handling cases with no matching owners
- Handling cases with multiple owners sharing same subscription

These tests ensure that the invoice payment success handling works correctly after recent modifications.
- Add tests for invoice payment failure functionality

This commit adds comprehensive unit tests for the invoice_payment_failed method in the StripeWebhookHandler class, covering:
- Skipping delinquency for payments requiring microdeposit verification
- Setting delinquent status to true for normal payment failures
- Sending notification emails to owners and admin users

These tests ensure that the recent changes to invoice payment failure handling work correctly.
- Add tests for Stripe webhook request handling

This commit adds unit tests for the webhook handling functionality in StripeWebhookHandler, including:
- Validation of webhook signatures
- Handling of supported and unsupported event types
- Error handling for missing configuration

These tests ensure that the webhook endpoint properly validates and routes Stripe events
to the appropriate handler methods.

Author: codecov-ai[bot]

billing/tests/test_invoice.py

@@ -0,0 +1,173 @@
+import unittest
+from datetime import datetime
+from unittest.mock import Mock, call, patch
+
+import stripe
+from django.test import TestCase
+from rest_framework.test import APITestCase
+from shared.django_apps.core.tests.factories import OwnerFactory
+
+from billing.views import StripeWebhookHandler
+
+
+class MockCard(object):
+    def __init__(self):
+        self.brand = "visa"
+        self.last4 = "1234"
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+
+class MockPaymentMethod(object):
+    def __init__(self, noCard=False):
+        if noCard:
+            self.card = None
+            return
+
+        self.card = MockCard()
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+
+class MockPaymentIntent(object):
+    def __init__(self, noCard=False):
+        self.payment_method = MockPaymentMethod(noCard)
+        self.status = "succeeded"
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def get(self, key, default=None):
+        return getattr(self, key, default)
+
+
+class InvoiceTests(TestCase):
+    def setUp(self):
+        self.owner = OwnerFactory(
+            stripe_customer_id="cus_123",
+            stripe_subscription_id="sub_123",
+            delinquent=True,
+        )
+        self.handler = StripeWebhookHandler()
+
+    @patch("services.task.TaskService.send_email")
+    def test_invoice_payment_succeeded_sets_delinquent_false(self, mocked_send_email):
+        """Test that invoice_payment_succeeded correctly updates delinquent status"""
+        # 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  # $240.00
+        mock_invoice.hosted_invoice_url = "https://stripe.com/invoice"
+
+        # Call the method being tested
+        self.handler.invoice_payment_succeeded(mock_invoice)
+
+        # Verify owner was updated
+        self.owner.refresh_from_db()
+        self.assertFalse(self.owner.delinquent)
+
+        # Verify email was sent to owner
+        mocked_send_email.assert_called_once_with(
+            to_addr=self.owner.email,
+            subject="You're all set",
+            template_name="success-after-failed-payment",
+            amount=240,
+            cta_link="https://stripe.com/invoice",
+            date=datetime.now().strftime("%B %-d, %Y"),
+        )
+
+    @patch("services.task.TaskService.send_email")
+    def test_invoice_payment_succeeded_with_multiple_admins(self, mocked_send_email):
+        """Test invoice_payment_succeeded sends emails to all admins"""
+        # Create admin owners
+        admin_1 = OwnerFactory(email="[email protected]")
+        admin_2 = OwnerFactory(email="[email protected]")
+        
+        # Set admins for the owner
+        self.owner.admins = [admin_1.ownerid, admin_2.ownerid]
+        self.owner.save()
+
+        # 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  # $240.00
+        mock_invoice.hosted_invoice_url = "https://stripe.com/invoice"
+
+        # Call the method being tested
+        self.handler.invoice_payment_succeeded(mock_invoice)
+
+        # Verify owner was updated
+        self.owner.refresh_from_db()
+        self.assertFalse(self.owner.delinquent)
+
+        # Verify emails were sent to owner and admins
+        expected_calls = [
+            call(
+                to_addr=self.owner.email,
+                subject="You're all set",
+                template_name="success-after-failed-payment",
+                amount=240,
+                cta_link="https://stripe.com/invoice",
+                date=datetime.now().strftime("%B %-d, %Y"),
+            ),
+            call(
+                to_addr=admin_1.email,
+                subject="You're all set",
+                template_name="success-after-failed-payment",
+                amount=240,
+                cta_link="https://stripe.com/invoice",
+                date=datetime.now().strftime("%B %-d, %Y"),
+            ),
+            call(
+                to_addr=admin_2.email,
+                subject="You're all set",
+                template_name="success-after-failed-payment",
+                amount=240,
+                cta_link="https://stripe.com/invoice",
+                date=datetime.now().strftime("%B %-d, %Y"),
+            ),
+        ]
+        mocked_send_email.assert_has_calls(expected_calls, any_order=True)
+
+    def test_invoice_payment_succeeded_no_matching_owners(self):
+        """Test handling when no matching owners are found"""
+        # Create a mock invoice with non-matching customer/subscription
+        mock_invoice = Mock()
+        mock_invoice.customer = "cus_nonexistent"
+        mock_invoice.subscription = "sub_nonexistent"
+        
+        # This should run without error, just return without action
+        self.handler.invoice_payment_succeeded(mock_invoice)
+        
+        # Verify owner was not updated
+        self.owner.refresh_from_db()
+        self.assertTrue(self.owner.delinquent)
+
+    def test_invoice_payment_succeeded_multiple_owners(self):
+        """Test handling when multiple owners match the customer/subscription"""
+        # Create another owner with the same customer/subscription
+        other_owner = OwnerFactory(
+            stripe_customer_id=self.owner.stripe_customer_id,
+            stripe_subscription_id=self.owner.stripe_subscription_id,
+            delinquent=True,
+        )
+        
+        # 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/invoice"
+        
+        # Call the method being tested
+        self.handler.invoice_payment_succeeded(mock_invoice)
+        
+        # Verify both owners were updated
+        self.owner.refresh_from_db()
+        other_owner.refresh_from_db()
+        self.assertFalse(self.owner.delinquent)
+        self.assertFalse(other_owner.delinquent)

billing/tests/test_invoice_failure.py

@@ -0,0 +1,163 @@
+import unittest
+from datetime import datetime
+from unittest.mock import Mock, call, patch
+
+import stripe
+from django.test import TestCase
+from rest_framework.test import APITestCase
+from shared.django_apps.core.tests.factories import OwnerFactory
+
+from billing.views import StripeWebhookHandler
+
+
+class MockCard(object):
+    def __init__(self):
+        self.brand = "visa"
+        self.last4 = "1234"
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+
+class MockPaymentMethod(object):
+    def __init__(self, noCard=False):
+        if noCard:
+            self.card = None
+            return
+
+        self.card = MockCard()
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+
+class MockPaymentIntent(object):
+    def __init__(self, noCard=False, status="succeeded", next_action=None):
+        self.payment_method = MockPaymentMethod(noCard)
+        self.status = status
+        self.next_action = next_action or {}
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def get(self, key, default=None):
+        return getattr(self, key, default)
+
+
+class InvoiceFailureTests(TestCase):
+    def setUp(self):
+        self.owner = OwnerFactory(
+            stripe_customer_id="cus_123",
+            stripe_subscription_id="sub_123",
+            delinquent=False,
+        )
+        self.handler = StripeWebhookHandler()
+
+    @patch("stripe.PaymentIntent.retrieve")
+    def test_invoice_payment_failed_skips_delinquency_for_microdeposit_verification(self, mock_retrieve):
+        """Test that delinquency is skipped when waiting for microdeposit verification"""
+        # Set up the payment intent to indicate microdeposit verification
+        mock_retrieve.return_value = MockPaymentIntent(
+            status="requires_action", 
+            next_action={"type": "verify_with_microdeposits"}
+        )
+        
+        # Create a mock invoice
+        mock_invoice = Mock()
+        mock_invoice.customer = self.owner.stripe_customer_id
+        mock_invoice.subscription = self.owner.stripe_subscription_id
+        mock_invoice.default_payment_method = None
+        mock_invoice.payment_intent = "pi_123"
+        
+        # Call the method being tested
+        self.handler.invoice_payment_failed(mock_invoice)
+        
+        # Verify owner delinquent status was not changed
+        self.owner.refresh_from_db()
+        self.assertFalse(self.owner.delinquent)
+        
+        # Verify payment intent was retrieved
+        mock_retrieve.assert_called_once_with("pi_123")
+
+    @patch("stripe.PaymentIntent.retrieve")
+    @patch("services.task.TaskService.send_email")
+    def test_invoice_payment_failed_sets_delinquent_true(self, mock_send_email, mock_retrieve):
+        """Test that invoice_payment_failed sets delinquent status to True"""
+        # Setup payment intent with a normal failure (not microdeposits)
+        mock_retrieve.return_value = MockPaymentIntent()
+        
+        # Create a mock invoice
+        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/invoice"
+        mock_invoice.default_payment_method = {}
+        mock_invoice.payment_intent = "pi_123"
+        mock_invoice.__getitem__ = lambda self, key: getattr(self, key)
+        
+        # Call the method being tested
+        self.handler.invoice_payment_failed(mock_invoice)
+        
+        # Verify owner delinquent status was changed
+        self.owner.refresh_from_db()
+        self.assertTrue(self.owner.delinquent)
+        
+        # Verify email was sent to owner
+        mock_send_email.assert_called_with(
+            to_addr=self.owner.email,
+            subject="Your Codecov payment failed",
+            template_name="failed-payment",
+            name=self.owner.username,
+            amount=240,
+            card_type="visa",
+            last_four="1234",
+            cta_link="https://stripe.com/invoice",
+            date=datetime.now().strftime("%B %-d, %Y"),
+        )
+
+    @patch("stripe.PaymentIntent.retrieve")
+    @patch("services.task.TaskService.send_email")
+    def test_invoice_payment_failed_with_multiple_admins(self, mock_send_email, mock_retrieve):
+        """Test that invoice_payment_failed sends emails to all admins"""
+        # Create admin owners
+        admin_1 = OwnerFactory(email="[email protected]", username="admin1")
+        admin_2 = OwnerFactory(email="[email protected]", username="admin2")
+        
+        # Set admins for the owner
+        self.owner.admins = [admin_1.ownerid, admin_2.ownerid]
+        self.owner.save()
+        
+        # Setup payment intent with normal failure
+        mock_retrieve.return_value = MockPaymentIntent()
+        
+        # Create a mock invoice
+        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/invoice"
+        mock_invoice.default_payment_method = {}
+        mock_invoice.payment_intent = "pi_123"
+        mock_invoice.__getitem__ = lambda self, key: getattr(self, key)
+        
+        # Call the method being tested
+        self.handler.invoice_payment_failed(mock_invoice)
+        
+        # Verify owner delinquent status was changed
+        self.owner.refresh_from_db()
+        self.assertTrue(self.owner.delinquent)
+        
+        # Verify emails were sent to owner and all admins
+        self.assertEqual(mock_send_email.call_count, 3)
+        mock_send_email.assert_any_call(
+            to_addr=admin_1.email,
+            subject="Your Codecov payment failed",
+            template_name="failed-payment",
+            name=admin_1.username,
+            amount=240,
+            card_type="visa",
+            last_four="1234",
+            cta_link="https://stripe.com/invoice",
+            date=datetime.now().strftime("%B %-d, %Y"),
+        )