Zulip server and web application. Open-source team chat that helps teams stay productive and focused.
tests: Move billing library tests into test_billing_lib.
Alex Vandiver2af998cfc997
diff --git a/corporate/tests/test_billing_lib.py b/corporate/tests/test_billing_lib.pynew file mode 100644index 00000000000..b4aa062be2f--- /dev/null+++ b/corporate/tests/test_billing_lib.py@@ -0,0 +1,1975 @@+import itertools+import typing+import uuid+from datetime import date, datetime, time, timedelta, timezone+from decimal import Decimal+from typing import cast+from unittest import mock+from unittest.mock import Mock, patch++import stripe+import time_machine+from django.conf import settings+from django.utils.timezone import now as timezone_now++from corporate.lib.stripe import (+ BillingError,+ BillingSessionAuditLogEventError,+ BillingSessionEventType,+ BillingUserCounts,+ InvalidBillingScheduleError,+ InvalidTierError,+ RealmBillingSession,+ RemoteRealmBillingSession,+ RemoteServerBillingSession,+ SupportRequestError,+ SupportType,+ SupportViewRequest,+ UpdatePlanRequest,+ add_months,+ compute_plan_parameters,+ get_next_billing_cycle_for_plan,+ get_plan_renewal_or_end_date,+ get_price_per_license,+ invoice_plans_as_needed,+ is_realm_on_free_trial,+ next_month,+)+from corporate.lib.test_stripe_class import StripeTestCase, mock_stripe+from corporate.models.customers import Customer, get_customer_by_realm+from corporate.models.licenses import LicenseLedger+from corporate.models.plans import (+ CustomerPlan,+ CustomerPlanOffer,+ get_current_plan_by_customer,+ get_current_plan_by_realm,+)+from zerver.actions.create_user import (+ do_activate_mirror_dummy_user,+ do_create_user,+ do_reactivate_user,+)+from zerver.actions.users import change_user_is_active, do_deactivate_user+from zerver.lib.test_classes import ZulipTestCase+from zerver.lib.timestamp import datetime_to_timestamp+from zerver.lib.utils import assert_is_not_none+from zerver.models import Message, Realm, RealmAuditLog, Recipient, UserProfile+from zerver.models.realm_audit_logs import AuditLogEventType+from zerver.models.realms import get_realm+from zerver.models.users import get_system_bot+from zilencer.models import (+ RemoteRealm,+ RemoteRealmAuditLog,+ RemoteRealmBillingUser,+ RemoteServerBillingUser,+ RemoteZulipServer,+ RemoteZulipServerAuditLog,+)+++class BillingHelpersTest(ZulipTestCase):+ def test_next_month(self) -> None:+ anchor = datetime(2019, 12, 31, 1, 2, 3, tzinfo=timezone.utc)+ period_boundaries = [+ anchor,+ datetime(2020, 1, 31, 1, 2, 3, tzinfo=timezone.utc),+ # Test that this is the 28th even during leap years+ datetime(2020, 2, 28, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 3, 31, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 4, 30, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 5, 31, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 6, 30, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 7, 31, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 8, 31, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 9, 30, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 10, 31, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 11, 30, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2020, 12, 31, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2021, 1, 31, 1, 2, 3, tzinfo=timezone.utc),+ datetime(2021, 2, 28, 1, 2, 3, tzinfo=timezone.utc),+ ]+ with self.assertRaises(AssertionError):+ add_months(anchor, -1)+ # Explicitly test add_months for each value of MAX_DAY_FOR_MONTH and+ # for crossing a year boundary+ for i, boundary in enumerate(period_boundaries):+ self.assertEqual(add_months(anchor, i), boundary)+ # Test next_month for small values+ for last, next_ in itertools.pairwise(period_boundaries):+ self.assertEqual(next_month(anchor, last), next_)+ # Test next_month for large values+ period_boundaries = [dt.replace(year=dt.year + 100) for dt in period_boundaries]+ for last, next_ in itertools.pairwise(period_boundaries):+ self.assertEqual(next_month(anchor, last), next_)++ def test_compute_plan_parameters(self) -> None:+ anchor = datetime(2019, 12, 31, 1, 2, 3, tzinfo=timezone.utc)+ month_later = datetime(2020, 1, 31, 1, 2, 3, tzinfo=timezone.utc)+ year_later = datetime(2020, 12, 31, 1, 2, 3, tzinfo=timezone.utc)+ customer_with_discount = Customer.objects.create(+ realm=get_realm("lear"),+ monthly_discounted_price=600,+ annual_discounted_price=6000,+ required_plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ )+ customer_no_discount = Customer.objects.create(realm=get_realm("zulip"))+ test_cases = [+ # Annual standard no customer+ (+ (+ CustomerPlan.TIER_CLOUD_STANDARD,+ CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ None,+ ),+ (anchor, month_later, year_later, 8000),+ ),+ # Annual standard with discount+ (+ (+ CustomerPlan.TIER_CLOUD_STANDARD,+ CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ customer_with_discount,+ ),+ (anchor, month_later, year_later, 6000),+ ),+ # Annual standard customer but no discount+ (+ (+ CustomerPlan.TIER_CLOUD_STANDARD,+ CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ customer_no_discount,+ ),+ (anchor, month_later, year_later, 8000),+ ),+ # Annual plus customer with discount but different tier than required for discount+ (+ (+ CustomerPlan.TIER_CLOUD_PLUS,+ CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ customer_with_discount,+ ),+ (anchor, month_later, year_later, 12000),+ ),+ # Monthly standard no customer+ (+ (+ CustomerPlan.TIER_CLOUD_STANDARD,+ CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ None,+ ),+ (anchor, month_later, month_later, 800),+ ),+ # Monthly standard with discount+ (+ (+ CustomerPlan.TIER_CLOUD_STANDARD,+ CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ customer_with_discount,+ ),+ (anchor, month_later, month_later, 600),+ ),+ # Monthly standard customer but no discount+ (+ (+ CustomerPlan.TIER_CLOUD_STANDARD,+ CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ customer_no_discount,+ ),+ (anchor, month_later, month_later, 800),+ ),+ # Monthly plus customer with discount but different tier than required for discount+ (+ (+ CustomerPlan.TIER_CLOUD_PLUS,+ CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ customer_with_discount,+ ),+ (anchor, month_later, month_later, 1200),+ ),+ ]+ # compute_plan_parameters truncates microseconds in the anchor datetime.+ with time_machine.travel(anchor + timedelta(microseconds=654321), tick=False):+ for (tier, billing_schedule, customer), output in test_cases:+ output_ = compute_plan_parameters(+ tier,+ billing_schedule,+ customer,+ )+ self.assertEqual(output_, output)++ def test_get_price_per_license(self) -> None:+ standard_discounted_customer = Customer.objects.create(+ realm=get_realm("lear"),+ monthly_discounted_price=400,+ annual_discounted_price=4000,+ required_plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ )+ plus_discounted_customer = Customer.objects.create(+ realm=get_realm("zulip"),+ monthly_discounted_price=600,+ annual_discounted_price=6000,+ required_plan_tier=CustomerPlan.TIER_CLOUD_PLUS,+ )+ self.assertEqual(+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_STANDARD, CustomerPlan.BILLING_SCHEDULE_ANNUAL+ ),+ 8000,+ )+ self.assertEqual(+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_STANDARD, CustomerPlan.BILLING_SCHEDULE_MONTHLY+ ),+ 800,+ )+ self.assertEqual(+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_STANDARD,+ CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ standard_discounted_customer,+ ),+ 400,+ )++ self.assertEqual(+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_ANNUAL+ ),+ 12000,+ )+ self.assertEqual(+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_MONTHLY+ ),+ 1200,+ )+ self.assertEqual(+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_PLUS,+ CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ # Wrong tier so discount not applied.+ standard_discounted_customer,+ ),+ 1200,+ )+ self.assertEqual(+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_PLUS,+ CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ plus_discounted_customer,+ ),+ 600,+ )++ with self.assertRaisesRegex(InvalidBillingScheduleError, "Unknown billing_schedule: 1000"):+ get_price_per_license(CustomerPlan.TIER_CLOUD_STANDARD, 1000)++ with self.assertRaisesRegex(InvalidTierError, "Unknown tier: 4"):+ get_price_per_license(+ CustomerPlan.TIER_CLOUD_ENTERPRISE, CustomerPlan.BILLING_SCHEDULE_ANNUAL+ )++ def test_get_plan_renewal_or_end_date(self) -> None:+ realm = get_realm("zulip")+ customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")+ billing_cycle_anchor = timezone_now()+ plan = CustomerPlan.objects.create(+ customer=customer,+ status=CustomerPlan.ACTIVE,+ billing_cycle_anchor=billing_cycle_anchor,+ billing_schedule=CustomerPlan.BILLING_SCHEDULE_MONTHLY,+ tier=CustomerPlan.TIER_CLOUD_STANDARD,+ )+ renewal_date = get_plan_renewal_or_end_date(plan, billing_cycle_anchor)+ self.assertEqual(renewal_date, add_months(billing_cycle_anchor, 1))++ # When the plan ends 2 days before the start of the next billing cycle,+ # the function should return the end_date.+ plan_end_date = add_months(billing_cycle_anchor, 1) - timedelta(days=2)+ plan.end_date = plan_end_date+ plan.save(update_fields=["end_date"])+ renewal_date = get_plan_renewal_or_end_date(plan, billing_cycle_anchor)+ self.assertEqual(renewal_date, plan_end_date)++ def test_update_or_create_stripe_customer_logic(self) -> None:+ user = self.example_user("hamlet")+ # No existing Customer object+ with patch(+ "corporate.lib.stripe.BillingSession.create_stripe_customer", return_value="returned"+ ) as mocked1:+ billing_session = RealmBillingSession(user)+ returned = billing_session.update_or_create_stripe_customer()+ mocked1.assert_called_once()+ self.assertEqual(returned, "returned")++ customer = Customer.objects.create(realm=get_realm("zulip"))+ # Customer exists but stripe_customer_id is None+ with patch(+ "corporate.lib.stripe.BillingSession.create_stripe_customer", return_value="returned"+ ) as mocked2:+ billing_session = RealmBillingSession(user)+ returned = billing_session.update_or_create_stripe_customer()+ mocked2.assert_called_once()+ self.assertEqual(returned, "returned")++ customer.stripe_customer_id = "cus_12345"+ customer.save()+ # Customer exists, replace payment source+ with patch("corporate.lib.stripe.BillingSession.replace_payment_method") as mocked3:+ billing_session = RealmBillingSession(user)+ returned_customer = billing_session.update_or_create_stripe_customer("pm_card_visa")+ mocked3.assert_called_once()+ self.assertEqual(returned_customer, customer)++ # Customer exists, do nothing+ with patch("corporate.lib.stripe.BillingSession.replace_payment_method") as mocked4:+ billing_session = RealmBillingSession(user)+ returned_customer = billing_session.update_or_create_stripe_customer(None)+ mocked4.assert_not_called()+ self.assertEqual(returned_customer, customer)++ def test_get_customer_by_realm(self) -> None:+ realm = get_realm("zulip")++ self.assertEqual(get_customer_by_realm(realm), None)++ customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")+ self.assertEqual(get_customer_by_realm(realm), customer)++ def test_get_current_plan_by_customer(self) -> None:+ realm = get_realm("zulip")+ customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")++ self.assertEqual(get_current_plan_by_customer(customer), None)++ plan = CustomerPlan.objects.create(+ customer=customer,+ status=CustomerPlan.ACTIVE,+ billing_cycle_anchor=timezone_now(),+ billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ tier=CustomerPlan.TIER_CLOUD_STANDARD,+ )+ self.assertEqual(get_current_plan_by_customer(customer), plan)++ plan.status = CustomerPlan.DOWNGRADE_AT_END_OF_CYCLE+ plan.save(update_fields=["status"])+ self.assertEqual(get_current_plan_by_customer(customer), plan)++ plan.status = CustomerPlan.ENDED+ plan.save(update_fields=["status"])+ self.assertEqual(get_current_plan_by_customer(customer), None)++ plan.status = CustomerPlan.NEVER_STARTED+ plan.save(update_fields=["status"])+ self.assertEqual(get_current_plan_by_customer(customer), None)++ def test_get_current_plan_by_realm(self) -> None:+ realm = get_realm("zulip")++ self.assertEqual(get_current_plan_by_realm(realm), None)++ customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")+ self.assertEqual(get_current_plan_by_realm(realm), None)++ plan = CustomerPlan.objects.create(+ customer=customer,+ status=CustomerPlan.ACTIVE,+ billing_cycle_anchor=timezone_now(),+ billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ tier=CustomerPlan.TIER_CLOUD_STANDARD,+ )+ self.assertEqual(get_current_plan_by_realm(realm), plan)++ def test_is_realm_on_free_trial(self) -> None:+ realm = get_realm("zulip")+ self.assertFalse(is_realm_on_free_trial(realm))++ customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")+ plan = CustomerPlan.objects.create(+ customer=customer,+ status=CustomerPlan.ACTIVE,+ billing_cycle_anchor=timezone_now(),+ billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ tier=CustomerPlan.TIER_CLOUD_STANDARD,+ )+ self.assertFalse(is_realm_on_free_trial(realm))++ plan.status = CustomerPlan.FREE_TRIAL+ plan.save(update_fields=["status"])+ self.assertTrue(is_realm_on_free_trial(realm))++ def test_deactivate_reactivate_remote_server(self) -> None:+ server_uuid = str(uuid.uuid4())+ remote_server = RemoteZulipServer.objects.create(+ uuid=server_uuid,+ api_key="magic_secret_api_key",+ hostname="demo.example.com",+ contact_email="[email protected]",+ )+ self.assertFalse(remote_server.deactivated)+ remote_server_billing_user = RemoteServerBillingUser.objects.create(+ remote_server=remote_server, email="[email protected]"+ )++ billing_session = RemoteServerBillingSession(remote_server, remote_server_billing_user)+ billing_session.do_deactivate_remote_server()++ remote_server = RemoteZulipServer.objects.get(uuid=server_uuid)+ remote_realm_audit_log = RemoteZulipServerAuditLog.objects.filter(+ event_type=AuditLogEventType.REMOTE_SERVER_DEACTIVATED+ ).last()+ assert remote_realm_audit_log is not None+ self.assertTrue(remote_server.deactivated)+ self.assertEqual(remote_realm_audit_log.acting_remote_user, remote_server_billing_user)++ # Try to deactivate a remote server that is already deactivated+ with self.assertLogs("corporate.stripe", "WARN") as warning_log:+ billing_session.do_deactivate_remote_server()+ self.assertEqual(+ warning_log.output,+ [+ (+ "WARNING:corporate.stripe:Cannot deactivate remote server with ID "+ f"{remote_server.id}, server has already been deactivated."+ )+ ],+ )++ billing_session.do_reactivate_remote_server()+ remote_server.refresh_from_db()+ self.assertFalse(remote_server.deactivated)+ remote_realm_audit_log = RemoteZulipServerAuditLog.objects.latest("id")+ self.assertEqual(+ remote_realm_audit_log.event_type, AuditLogEventType.REMOTE_SERVER_REACTIVATED+ )+ self.assertEqual(remote_realm_audit_log.server, remote_server)++ with self.assertLogs("corporate.stripe", "WARN") as warning_log:+ billing_session.do_reactivate_remote_server()+ self.assertEqual(+ warning_log.output,+ [+ (+ "WARNING:corporate.stripe:Cannot reactivate remote server with ID "+ f"{remote_server.id}, server is already active."+ )+ ],+ )++ def test_initialize_fixed_price_plan_realm(self) -> None:+ billing_cycle_anchor = datetime(2012, 1, 1, 1, 1, 1, tzinfo=timezone.utc)+ realm = get_realm("zulip")++ # Requires a Customer object for the billing entity.+ billing_session = RealmBillingSession(None, realm)+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_customer",+ billing_context.exception.error_description,+ )++ # Requires that the Customer object is linked to a+ # customer ID in Stripe.+ billing_session.update_or_create_customer()+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_stripe_id",+ billing_context.exception.error_description,+ )++ # Requires a fixed price plan offer to be configured+ # for the customer.+ customer = billing_session.get_customer()+ assert customer is not None+ customer.stripe_customer_id = "cus_123"+ customer.save(update_fields=["stripe_customer_id"])+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_plan_offer",+ billing_context.exception.error_description,+ )++ billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)+ billing_session.configure_fixed_price_plan(1000, None)+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_SELF_HOSTED)+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.fixed_price, 100000)+ self.assertEqual(plan.billing_cycle_anchor, billing_cycle_anchor)+ license_ledger = LicenseLedger.objects.filter(plan=plan, is_renewal=True).last()+ assert license_ledger is not None+ self.assertEqual(license_ledger.event_time, billing_cycle_anchor)++ # Confirm that if there is an active paid plan for the+ # customer, a new plan can not be initialized.+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "on_paid_plan",+ billing_context.exception.error_description,+ )++ def test_initialize_fixed_price_plan_remote_realm(self) -> None:+ billing_cycle_anchor = datetime(2012, 1, 1, 1, 1, 1, tzinfo=timezone.utc)+ server_uuid = str(uuid.uuid4())+ remote_server = RemoteZulipServer.objects.create(+ uuid=server_uuid,+ api_key="magic_secret_api_key",+ hostname="demo.example.com",+ contact_email="[email protected]",+ )+ realm_uuid = str(uuid.uuid4())+ remote_realm = RemoteRealm.objects.create(+ server=remote_server,+ uuid=realm_uuid,+ uuid_owner_secret="dummy-owner-secret",+ host="dummy-hostname",+ realm_date_created=timezone_now(),+ )++ # Requires a Customer object for the billing entity.+ billing_session = RemoteRealmBillingSession(remote_realm)+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_customer",+ billing_context.exception.error_description,+ )++ # Requires that the Customer object is linked to a+ # customer ID in Stripe.+ billing_session.update_or_create_customer()+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_stripe_id",+ billing_context.exception.error_description,+ )++ # Requires a fixed price plan offer to be configured+ # for the customer.+ customer = billing_session.get_customer()+ assert customer is not None+ customer.stripe_customer_id = "cus_123"+ customer.save(update_fields=["stripe_customer_id"])+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_plan_offer",+ billing_context.exception.error_description,+ )++ billing_session.set_required_plan_tier(CustomerPlan.TIER_SELF_HOSTED_BASIC)+ billing_session.configure_fixed_price_plan(1200, None)+ self.assertEqual(remote_realm.plan_type, RemoteRealm.PLAN_TYPE_SELF_MANAGED)+ with mock.patch(+ "corporate.lib.stripe.RemoteRealmBillingSession.current_counts_for_billed_users",+ return_value=BillingUserCounts(60, 0),+ ):+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(remote_realm.plan_type, RemoteRealm.PLAN_TYPE_BASIC)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.fixed_price, 120000)+ self.assertEqual(plan.billing_cycle_anchor, billing_cycle_anchor)+ license_ledger = LicenseLedger.objects.filter(plan=plan, is_renewal=True).last()+ assert license_ledger is not None+ self.assertEqual(license_ledger.event_time, billing_cycle_anchor)++ # Confirm that if there is an active paid plan for the+ # customer, a new plan can not be initialized.+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "on_paid_plan",+ billing_context.exception.error_description,+ )++ def test_initialize_fixed_price_plan_remote_server(self) -> None:+ billing_cycle_anchor = datetime(2012, 1, 1, 1, 1, 1, tzinfo=timezone.utc)+ server_uuid = str(uuid.uuid4())+ remote_server = RemoteZulipServer.objects.create(+ uuid=server_uuid,+ api_key="magic_secret_api_key",+ hostname="demo.example.com",+ contact_email="[email protected]",+ )++ # Requires a Customer object for the billing entity.+ billing_session = RemoteServerBillingSession(remote_server)+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_customer",+ billing_context.exception.error_description,+ )++ # Requires that the Customer object is linked to a+ # customer ID in Stripe.+ billing_session.update_or_create_customer()+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_stripe_id",+ billing_context.exception.error_description,+ )++ # Requires a fixed price plan offer to be configured+ # for the customer.+ customer = billing_session.get_customer()+ assert customer is not None+ customer.stripe_customer_id = "cus_123"+ customer.save(update_fields=["stripe_customer_id"])+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "no_plan_offer",+ billing_context.exception.error_description,+ )++ billing_session.set_required_plan_tier(CustomerPlan.TIER_SELF_HOSTED_BASIC)+ billing_session.configure_fixed_price_plan(1200, None)+ self.assertEqual(remote_server.plan_type, RemoteRealm.PLAN_TYPE_SELF_MANAGED)+ with mock.patch(+ "corporate.lib.stripe.RemoteServerBillingSession.current_counts_for_billed_users",+ return_value=BillingUserCounts(60, 0),+ ):+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(remote_server.plan_type, RemoteRealm.PLAN_TYPE_BASIC)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.fixed_price, 120000)+ self.assertEqual(plan.billing_cycle_anchor, billing_cycle_anchor)+ license_ledger = LicenseLedger.objects.filter(plan=plan, is_renewal=True).last()+ assert license_ledger is not None+ self.assertEqual(license_ledger.event_time, billing_cycle_anchor)++ # Confirm that if there is an active paid plan for the+ # customer, a new plan can not be initialized.+ with self.assertRaises(BillingError) as billing_context:+ billing_session.initialize_prepaid_fixed_price_plan(+ plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,+ billing_cycle_anchor=billing_cycle_anchor,+ )+ self.assertEqual(+ "on_paid_plan",+ billing_context.exception.error_description,+ )+++class LicenseLedgerTest(StripeTestCase):+ def test_add_plan_renewal_if_needed(self) -> None:+ with time_machine.travel(self.now, tick=False):+ self.local_upgrade(+ self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False+ )+ self.assertEqual(LicenseLedger.objects.count(), 1)+ plan = CustomerPlan.objects.get()+ # Plan hasn't renewed yet+ realm = plan.customer.realm+ billing_session = RealmBillingSession(user=None, realm=realm)+ billing_session.make_end_of_cycle_updates_if_needed(+ plan, self.next_year - timedelta(days=1)+ )+ self.assertEqual(LicenseLedger.objects.count(), 1)+ # Plan needs to renew+ # TODO: do_deactivate_user for a user, so that licenses_at_next_renewal != licenses+ new_plan, ledger_entry = billing_session.make_end_of_cycle_updates_if_needed(+ plan, self.next_year+ )+ self.assertIsNone(new_plan)+ self.assertEqual(LicenseLedger.objects.count(), 2)+ assert ledger_entry is not None+ self.assertEqual(ledger_entry.plan, plan)+ self.assertTrue(ledger_entry.is_renewal)+ self.assertEqual(ledger_entry.event_time, self.next_year)+ self.assertEqual(ledger_entry.licenses, self.seat_count)+ self.assertEqual(ledger_entry.licenses_at_next_renewal, self.seat_count)+ # Plan needs to renew, but we already added the plan_renewal ledger entry+ billing_session.make_end_of_cycle_updates_if_needed(+ plan, self.next_year + timedelta(days=1)+ )+ self.assertEqual(LicenseLedger.objects.count(), 2)++ def test_update_license_ledger_if_needed(self) -> None:+ realm = get_realm("zulip")+ billing_session = RealmBillingSession(user=None, realm=realm)+ # Test no Customer+ billing_session.update_license_ledger_if_needed(self.now)+ self.assertFalse(LicenseLedger.objects.exists())+ # Test plan not automanaged+ with time_machine.travel(self.now, tick=False):+ self.local_upgrade(+ self.seat_count + 1, False, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False+ )+ plan = CustomerPlan.objects.get()+ self.assertEqual(LicenseLedger.objects.count(), 1)+ self.assertEqual(plan.licenses(), self.seat_count + 1)+ self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count + 1)+ billing_session.update_license_ledger_if_needed(self.now)+ self.assertEqual(LicenseLedger.objects.count(), 1)+ # Test no active plan+ plan.automanage_licenses = True+ plan.status = CustomerPlan.ENDED+ plan.save(update_fields=["automanage_licenses", "status"])+ billing_session.update_license_ledger_if_needed(self.now)+ self.assertEqual(LicenseLedger.objects.count(), 1)+ # Test update needed+ plan.status = CustomerPlan.ACTIVE+ plan.save(update_fields=["status"])+ billing_session.update_license_ledger_if_needed(self.now)+ self.assertEqual(LicenseLedger.objects.count(), 2)++ def test_update_license_ledger_for_automanaged_plan(self) -> None:+ realm = get_realm("zulip")+ with time_machine.travel(self.now, tick=False):+ self.local_upgrade(+ self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False+ )+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.licenses(), self.seat_count)+ self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count)++ billing_session = RealmBillingSession(user=None, realm=realm)+ # Simple increase+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=23):+ billing_session.update_license_ledger_for_automanaged_plan(plan, self.now)+ self.assertEqual(plan.licenses(), 23)+ self.assertEqual(plan.licenses_at_next_renewal(), 23)+ # Decrease+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=20):+ billing_session.update_license_ledger_for_automanaged_plan(plan, self.now)+ self.assertEqual(plan.licenses(), 23)+ self.assertEqual(plan.licenses_at_next_renewal(), 20)+ # Increase, but not past high watermark+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=21):+ billing_session.update_license_ledger_for_automanaged_plan(plan, self.now)+ self.assertEqual(plan.licenses(), 23)+ self.assertEqual(plan.licenses_at_next_renewal(), 21)+ # Increase, but after renewal date, and below last year's high watermark+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=22):+ billing_session.update_license_ledger_for_automanaged_plan(+ plan, self.next_year + timedelta(seconds=1)+ )+ self.assertEqual(plan.licenses(), 22)+ self.assertEqual(plan.licenses_at_next_renewal(), 22)++ ledger_entries = list(+ LicenseLedger.objects.values_list(+ "is_renewal", "event_time", "licenses", "licenses_at_next_renewal"+ ).order_by("id")+ )+ self.assertEqual(+ ledger_entries,+ [+ (True, self.now, self.seat_count, self.seat_count),+ (False, self.now, 23, 23),+ (False, self.now, 23, 20),+ (False, self.now, 23, 21),+ (True, self.next_year, 21, 21),+ (False, self.next_year + timedelta(seconds=1), 22, 22),+ ],+ )++ def test_update_license_ledger_for_manual_plan(self) -> None:+ realm = get_realm("zulip")++ with time_machine.travel(self.now, tick=False):+ self.local_upgrade(+ self.seat_count + 1, False, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False+ )++ billing_session = RealmBillingSession(user=None, realm=realm)+ plan = get_current_plan_by_realm(realm)+ assert plan is not None++ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):+ billing_session.update_license_ledger_for_manual_plan(+ plan, self.now, licenses=self.seat_count + 3+ )+ self.assertEqual(plan.licenses(), self.seat_count + 3)+ self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count + 3)++ with (+ patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count),+ self.assertRaises(AssertionError),+ ):+ billing_session.update_license_ledger_for_manual_plan(+ plan, self.now, licenses=self.seat_count+ )++ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):+ billing_session.update_license_ledger_for_manual_plan(+ plan, self.now, licenses_at_next_renewal=self.seat_count+ )+ self.assertEqual(plan.licenses(), self.seat_count + 3)+ self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count)++ with (+ patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count),+ self.assertRaises(AssertionError),+ ):+ billing_session.update_license_ledger_for_manual_plan(+ plan, self.now, licenses_at_next_renewal=self.seat_count - 1+ )++ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):+ billing_session.update_license_ledger_for_manual_plan(+ plan, self.now, licenses=self.seat_count + 10+ )+ self.assertEqual(plan.licenses(), self.seat_count + 10)+ self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count + 10)++ billing_session.make_end_of_cycle_updates_if_needed(plan, self.next_year)+ self.assertEqual(plan.licenses(), self.seat_count + 10)++ ledger_entries = list(+ LicenseLedger.objects.values_list(+ "is_renewal", "event_time", "licenses", "licenses_at_next_renewal"+ ).order_by("id")+ )++ self.assertEqual(+ ledger_entries,+ [+ (True, self.now, self.seat_count + 1, self.seat_count + 1),+ (False, self.now, self.seat_count + 3, self.seat_count + 3),+ (False, self.now, self.seat_count + 3, self.seat_count),+ (False, self.now, self.seat_count + 10, self.seat_count + 10),+ (True, self.next_year, self.seat_count + 10, self.seat_count + 10),+ ],+ )++ with self.assertRaises(AssertionError):+ billing_session.update_license_ledger_for_manual_plan(plan, self.now)++ def test_user_changes(self) -> None:+ self.local_upgrade(self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False)+ user = do_create_user("email", "password", get_realm("zulip"), "name", acting_user=None)+ do_deactivate_user(user, acting_user=None)+ do_reactivate_user(user, acting_user=None)++ # Not a proper use of do_activate_mirror_dummy_user, but fine for this test+ change_user_is_active(user, False)+ user.is_mirror_dummy = True+ user.save(update_fields=["is_mirror_dummy"])+ do_activate_mirror_dummy_user(user, acting_user=None)+ # Add a guest user+ guest = do_create_user(+ "guest_email",+ "guest_password",+ get_realm("zulip"),+ "guest_name",+ role=UserProfile.ROLE_GUEST,+ acting_user=None,+ )+ # Change guest user role to member+ self.set_user_role(guest, UserProfile.ROLE_MEMBER)+ # Change again to moderator, no LicenseLedger created+ self.set_user_role(guest, UserProfile.ROLE_MODERATOR)+ ledger_entries = list(+ LicenseLedger.objects.values_list(+ "is_renewal", "licenses", "licenses_at_next_renewal"+ ).order_by("id")+ )+ self.assertEqual(+ ledger_entries,+ [+ (True, self.seat_count, self.seat_count),+ (False, self.seat_count + 1, self.seat_count + 1),+ (False, self.seat_count + 1, self.seat_count),+ (False, self.seat_count + 1, self.seat_count + 1),+ (False, self.seat_count + 1, self.seat_count + 1),+ (False, self.seat_count + 1, self.seat_count + 1),+ (False, self.seat_count + 2, self.seat_count + 2),+ ],+ )++ def test_toggle_license_management(self) -> None:+ self.local_upgrade(self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False)+ plan = get_current_plan_by_realm(get_realm("zulip"))+ assert plan is not None+ self.assertEqual(plan.automanage_licenses, True)+ self.assertEqual(plan.licenses(), self.seat_count)+ self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count)+ billing_session = RealmBillingSession(user=None, realm=get_realm("zulip"))+ update_plan_request = UpdatePlanRequest(+ status=None,+ licenses=None,+ licenses_at_next_renewal=None,+ schedule=None,+ toggle_license_management=True,+ )+ billing_session.do_update_plan(update_plan_request)+ plan.refresh_from_db()+ self.assertEqual(plan.automanage_licenses, False)++ billing_session.do_update_plan(update_plan_request)+ plan.refresh_from_db()+ self.assertEqual(plan.automanage_licenses, True)+++class InvoiceTest(StripeTestCase):+ def test_invoicing_status_is_started(self) -> None:+ # local_upgrade uses hamlet as user, therefore realm is zulip.+ self.local_upgrade(self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ plan.invoicing_status = CustomerPlan.INVOICING_STATUS_STARTED+ plan.save(update_fields=["invoicing_status"])+ with self.assertRaises(NotImplementedError):+ billing_session = RealmBillingSession(realm=get_realm("zulip"))+ billing_session.invoice_plan(assert_is_not_none(CustomerPlan.objects.first()), self.now)++ def test_invoice_plan_without_stripe_customer(self) -> None:+ # local_upgrade uses hamlet as user, therefore realm is zulip.+ realm = get_realm("zulip")+ self.local_upgrade(+ self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, False, False+ )+ plan = get_current_plan_by_realm(realm)+ assert plan is not None+ plan.customer.stripe_customer_id = None+ plan.customer.save(update_fields=["stripe_customer_id"])+ with self.assertRaises(BillingError) as context:+ billing_session = RealmBillingSession(realm=realm)+ billing_session.invoice_plan(plan, timezone_now())+ self.assertRegex(+ context.exception.error_description,+ "Customer has a paid plan without a Stripe customer ID:",+ )++ @mock_stripe()+ def test_validate_licenses_for_manual_plan_management(self, *mocks: Mock) -> None:+ user = self.example_user("hamlet")+ self.login_user(user)++ # Upgrade with one extra license+ with (+ time_machine.travel(self.now, tick=False),+ patch("corporate.lib.stripe.MIN_INVOICED_LICENSES", 3),+ ):+ self.upgrade(invoice=True, licenses=self.seat_count + 1)++ # Set renewal licenses to current seat count+ with (+ time_machine.travel(self.now, tick=False),+ patch("corporate.lib.stripe.MIN_INVOICED_LICENSES", 3),+ ):+ result = self.client_billing_patch(+ "/billing/plan",+ {"licenses_at_next_renewal": self.seat_count},+ )+ self.assert_json_success(result)++ # Add an extra user+ do_create_user(+ "email-extra-user",+ "password-extra-user",+ get_realm("zulip"),+ "name-extra-user",+ acting_user=None,+ )+ with self.assertLogs("corporate.stripe", level="ERROR") as m:+ invoice_plans_as_needed(self.next_year)+ self.assertIn(+ "ERROR:corporate.stripe:Invoicing failed: Customer.id:",+ m.output[0],+ )+ self.assertIn(+ "Customer has not manually updated plan for current license count:",+ m.output[0],+ )++ @mock_stripe()+ def test_invoice_plan(self, *mocks: Mock) -> None:+ user = self.example_user("hamlet")+ self.login_user(user)+ with time_machine.travel(self.now, tick=False):+ self.add_card_and_upgrade(user)+ realm = get_realm("zulip")+ billing_session = RealmBillingSession(user=user, realm=realm)+ # Increase+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 3):+ billing_session.update_license_ledger_if_needed(self.now + timedelta(days=100))+ # Decrease+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):+ billing_session.update_license_ledger_if_needed(self.now + timedelta(days=200))+ # Increase, but not past high watermark+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 1):+ billing_session.update_license_ledger_if_needed(self.now + timedelta(days=300))+ # Increase, but after renewal date, and below last year's high watermark+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 2):+ billing_session.update_license_ledger_if_needed(self.now + timedelta(days=400))+ # Increase, but after event_time+ with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 3):+ billing_session.update_license_ledger_if_needed(self.now + timedelta(days=500))+ plan = CustomerPlan.objects.first()+ assert plan is not None+ billing_session.invoice_plan(plan, self.now + timedelta(days=400))+ stripe_customer_id = plan.customer.stripe_customer_id+ assert stripe_customer_id is not None+ [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))+ self.assertIsNotNone(invoice0.status_transitions.finalized_at)+ [item0, item1, item2] = iter(invoice0.lines)++ self.assertEqual(item0.amount, int(8000 * (1 - ((400 - 366) / 365)) + 0.5))+ self.assertEqual(item0.description, "Additional Zulip Cloud Standard license")+ self.assertFalse(item0.discountable)+ self.assertEqual(item0.period.start, datetime_to_timestamp(self.now + timedelta(days=400)))+ self.assertEqual(+ item0.period.end, datetime_to_timestamp(self.now + timedelta(days=2 * 365 + 1))+ )+ self.assertEqual(item0.quantity, 1)++ self.assertEqual(item1.amount, 3 * int(8000 * (366 - 100) / 366 + 0.5))+ self.assertEqual(item1.description, "Additional Zulip Cloud Standard license")+ self.assertFalse(item1.discountable)+ self.assertEqual(item1.period.start, datetime_to_timestamp(self.now + timedelta(days=100)))+ self.assertEqual(item1.period.end, datetime_to_timestamp(self.now + timedelta(days=366)))+ self.assertEqual(item1.quantity, 3)++ self.assertEqual(item2.amount, 8000 * (self.seat_count + 1))+ self.assertEqual(item2.description, "Zulip Cloud Standard - renewal")+ self.assertFalse(item2.discountable)+ self.assertEqual(item2.period.start, datetime_to_timestamp(self.now + timedelta(days=366)))+ self.assertEqual(+ item2.period.end, datetime_to_timestamp(self.now + timedelta(days=2 * 365 + 1))+ )+ self.assertEqual(item2.quantity, self.seat_count + 1)++ @mock_stripe()+ def test_invoice_plan_bundle_additional_licenses(self, *mocks: Mock) -> None:+ user = self.example_user("hamlet")+ self.login_user(user)+ with time_machine.travel(self.now, tick=False):+ self.add_card_and_upgrade(user)+ realm = get_realm("zulip")+ billing_session = RealmBillingSession(user=user, realm=realm)+ # Increase by 300 additional licenses in the first month of the+ # annual plan.+ updated_seat_count = self.seat_count+ for i in range(50):+ updated_seat_count += 1+ with patch(+ "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count+ ):+ billing_session.update_license_ledger_if_needed(+ self.now + timedelta(days=10, seconds=i)+ )+ for i in range(100):+ updated_seat_count += 1+ with patch(+ "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count+ ):+ billing_session.update_license_ledger_if_needed(+ self.now + timedelta(days=15, seconds=i)+ )+ for i in range(100):+ updated_seat_count += 1+ with patch(+ "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count+ ):+ billing_session.update_license_ledger_if_needed(+ self.now + timedelta(days=20, seconds=i)+ )+ # Remove 20 active licenses to confirm we're still handling these ledger entries+ # correctly when bundling.+ for i in range(20):+ updated_seat_count -= 1+ with patch(+ "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count+ ):+ billing_session.update_license_ledger_if_needed(+ self.now + timedelta(days=22, seconds=i)+ )+ for i in range(70):+ updated_seat_count += 1+ with patch(+ "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count+ ):+ billing_session.update_license_ledger_if_needed(+ self.now + timedelta(days=25, seconds=i)+ )+ plan = CustomerPlan.objects.first()+ assert plan is not None+ billing_session.invoice_plan(plan, self.next_month)+ stripe_customer_id = plan.customer.stripe_customer_id+ assert stripe_customer_id is not None+ [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))+ self.assertIsNotNone(invoice0.status_transitions.finalized_at)+ [item0, item1, item2, item3] = iter(invoice0.lines.data)++ self.assertEqual(item0.amount, 50 * int(8000 * (366 - 25) / 366 + 0.5))+ self.assertEqual(item0.description, "Additional Zulip Cloud Standard license")+ self.assertFalse(item0.discountable)+ # We have to adjust the start datetime for the 20 license ledger+ # entries (by 20 seconds) that were for licenses that were already+ # paid for in the billing period.+ self.assertEqual(+ item0.period.start, datetime_to_timestamp(self.now + timedelta(days=25, seconds=20))+ )+ self.assertEqual(item0.period.end, datetime_to_timestamp(self.next_year))+ self.assertEqual(item0.quantity, 50)++ self.assertEqual(item1.amount, 100 * int(8000 * (366 - 20) / 366 + 0.5))+ self.assertEqual(item1.description, "Additional Zulip Cloud Standard license")+ self.assertFalse(item1.discountable)+ self.assertEqual(item1.period.start, datetime_to_timestamp(self.now + timedelta(days=20)))+ self.assertEqual(item1.period.end, datetime_to_timestamp(self.next_year))+ self.assertEqual(item1.quantity, 100)++ self.assertEqual(item2.amount, 100 * int(8000 * (366 - 15) / 366 + 0.5))+ self.assertEqual(item2.description, "Additional Zulip Cloud Standard license")+ self.assertFalse(item2.discountable)+ self.assertEqual(item2.period.start, datetime_to_timestamp(self.now + timedelta(days=15)))+ self.assertEqual(item2.period.end, datetime_to_timestamp(self.next_year))+ self.assertEqual(item2.quantity, 100)++ self.assertEqual(item3.amount, 50 * int(8000 * (366 - 10) / 366 + 0.5))+ self.assertEqual(item3.description, "Additional Zulip Cloud Standard license")+ self.assertFalse(item3.discountable)+ self.assertEqual(item3.period.start, datetime_to_timestamp(self.now + timedelta(days=10)))+ self.assertEqual(item3.period.end, datetime_to_timestamp(self.next_year))+ self.assertEqual(item3.quantity, 50)++ @mock_stripe()+ def test_fixed_price_plans(self, *mocks: Mock) -> None:+ # Also tests charge_automatically=False+ user = self.example_user("hamlet")+ self.login_user(user)+ with time_machine.travel(self.now, tick=False):+ self.upgrade(invoice=True)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ plan.fixed_price = 100+ plan.price_per_license = 0+ plan.save(update_fields=["fixed_price", "price_per_license"])+ user.realm.refresh_from_db()+ billing_session = RealmBillingSession(realm=user.realm)+ billing_session.invoice_plan(plan, self.next_year)+ stripe_customer_id = plan.customer.stripe_customer_id+ assert stripe_customer_id is not None+ [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))+ self.assertEqual(invoice0.collection_method, "send_invoice")+ [item] = iter(invoice0.lines)+ self.assertEqual(item.amount, 100)+ self.assertEqual(item.description, "Zulip Cloud Standard - renewal")+ self.assertFalse(item.discountable)+ self.assertEqual(item.period.start, datetime_to_timestamp(self.next_year))+ self.assertEqual(+ item.period.end, datetime_to_timestamp(self.next_year + timedelta(days=365))+ )+ self.assertEqual(item.quantity, 1)++ @mock_stripe()+ def test_upgrade_to_fixed_price_plus_plan(self, *mocks: Mock) -> None:+ iago = self.example_user("iago")+ hamlet = self.example_user("hamlet")+ realm = get_realm("zulip")+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_SELF_HOSTED)++ self.login_user(hamlet)+ with time_machine.travel(self.now, tick=False):+ self.upgrade(invoice=True)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertIsNone(plan.end_date)+ self.assertEqual(plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)+ realm.refresh_from_db()+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)++ next_billing_cycle = get_next_billing_cycle_for_plan(plan)+ plan_end_date_string = next_billing_cycle.date().isoformat()+ plan_end_date = datetime.combine(+ date.fromisoformat(plan_end_date_string), time(0, 0, 0), tzinfo=timezone.utc+ )++ self.logout()+ self.login_user(iago)++ result = self.client_post(+ "/activity/support",+ {+ "realm_id": f"{realm.id}",+ "required_plan_tier": f"{CustomerPlanOffer.TIER_CLOUD_PLUS}",+ },+ )+ self.assert_in_success_response(+ ["Required plan tier for zulip set to Zulip Cloud Plus."],+ result,+ )++ with time_machine.travel(self.now, tick=False):+ result = self.client_post(+ "/activity/support",+ {+ "realm_id": f"{realm.id}",+ "plan_end_date": plan_end_date_string,+ },+ )+ self.assert_in_success_response(+ [f"Current plan for zulip updated to end on {plan_end_date_string}."],+ result,+ )++ plan.refresh_from_db()+ self.assertEqual(plan.end_date, plan_end_date)++ result = self.client_post(+ "/activity/support",+ {+ "realm_id": f"{realm.id}",+ "fixed_price": 360,+ },+ )+ self.assert_in_success_response(+ [f"Fixed price Zulip Cloud Plus plan scheduled to start on {plan_end_date_string}."],+ result,+ )++ plan.refresh_from_db()+ self.assertEqual(plan.status, CustomerPlan.SWITCH_PLAN_TIER_AT_PLAN_END)+ self.assertEqual(plan.next_invoice_date, plan_end_date)+ new_plan = CustomerPlan.objects.filter(fixed_price__isnull=False).first()+ assert new_plan is not None+ self.assertEqual(new_plan.next_invoice_date, plan_end_date)+ self.assertEqual(+ new_plan.invoicing_status, CustomerPlan.INVOICING_STATUS_INITIAL_INVOICE_TO_BE_SENT+ )++ with time_machine.travel(next_billing_cycle, tick=False):+ invoice_plans_as_needed()++ plan.refresh_from_db()+ self.assertEqual(plan.status, CustomerPlan.ENDED)+ self.assertEqual(plan.next_invoice_date, None)++ new_plan.refresh_from_db()+ self.assertEqual(new_plan.tier, CustomerPlan.TIER_CLOUD_PLUS)+ self.assertIsNotNone(new_plan.fixed_price)+ self.assertIsNone(new_plan.price_per_license)++ realm.refresh_from_db()+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_PLUS)++ # Visit /billing+ self.logout()+ self.login_user(hamlet)+ with time_machine.travel(plan_end_date + timedelta(days=1), tick=False):+ response = self.client_get(f"{self.billing_session.billing_base_url}/billing/")+ for substring in [+ "Zulip Cloud Plus",+ "Annual",+ "Invoice",+ "This is a fixed-price plan",+ "You will be contacted by Zulip Sales",+ ]:+ self.assert_in_response(substring, response)+ self.assert_not_in_success_response(["Update card"], response)++ def test_no_invoice_needed(self) -> None:+ # local_upgrade uses hamlet as user, therefore realm is zulip.+ with time_machine.travel(self.now, tick=False):+ self.local_upgrade(+ self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False+ )+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.next_invoice_date, self.next_month)+ # Test this doesn't make any calls to stripe.Invoice or stripe.InvoiceItem+ assert plan.customer.realm is not None+ billing_session = RealmBillingSession(realm=plan.customer.realm)+ billing_session.invoice_plan(plan, self.next_month)+ plan = CustomerPlan.objects.first()+ # Test that we still update next_invoice_date+ assert plan is not None+ self.assertEqual(plan.next_invoice_date, self.next_month + timedelta(days=29))++ def test_invoice_plans_as_needed(self) -> None:+ with time_machine.travel(self.now, tick=False):+ self.local_upgrade(+ self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False+ )+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.next_invoice_date, self.next_month)+ # Test nothing needed to be done+ with patch("corporate.lib.stripe.BillingSession.invoice_plan") as mocked:+ invoice_plans_as_needed(self.next_month - timedelta(days=1))+ mocked.assert_not_called()+ # Test something needing to be done+ invoice_plans_as_needed(self.next_month)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.next_invoice_date, self.next_month + timedelta(days=29))++ @mock_stripe()+ def test_invoice_for_additional_license(self, *mocks: Mock) -> None:+ user = self.example_user("hamlet")+ self.login_user(user)+ with time_machine.travel(self.now, tick=False):+ self.add_card_and_upgrade(user)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.next_invoice_date, self.next_month)+ assert plan.customer.realm is not None+ realm = plan.customer.realm++ # Adding a guest user and then changing their role to member+ # should invoice for a pro-rated license at the next invoice+ # date on a plan with annual billing.+ with time_machine.travel(self.now + timedelta(days=5), tick=False):+ user = do_create_user(+ "email",+ "password",+ realm,+ "name",+ role=UserProfile.ROLE_GUEST,+ acting_user=None,+ )++ with time_machine.travel(self.now + timedelta(days=10), tick=False):+ self.set_user_role(user, UserProfile.ROLE_MEMBER)++ billing_session = RealmBillingSession(realm=realm)+ billing_session.invoice_plan(plan, self.next_month)+ plan = CustomerPlan.objects.first()+ assert plan is not None+ self.assertEqual(plan.next_invoice_date, self.next_month + timedelta(days=29))+ stripe_customer_id = plan.customer.stripe_customer_id+ assert stripe_customer_id is not None+ [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))+ self.assertIsNotNone(invoice0.status_transitions.finalized_at)+ [item0] = iter(invoice0.lines)+ self.assertEqual(item0.amount, int(8000 * (1 - ((366 - 356) / 366)) + 0.5))+ self.assertEqual(item0.description, "Additional Zulip Cloud Standard license")+ self.assertEqual(item0.quantity, 1)+++class TestTestClasses(ZulipTestCase):+ def test_subscribe_realm_to_manual_license_management_plan(self) -> None:+ realm = get_realm("zulip")+ plan, ledger = self.subscribe_realm_to_manual_license_management_plan(+ realm, 50, 60, CustomerPlan.BILLING_SCHEDULE_ANNUAL+ )++ plan.refresh_from_db()+ self.assertEqual(plan.automanage_licenses, False)+ self.assertEqual(plan.billing_schedule, CustomerPlan.BILLING_SCHEDULE_ANNUAL)+ self.assertEqual(plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)+ self.assertEqual(plan.licenses(), 50)+ self.assertEqual(plan.licenses_at_next_renewal(), 60)++ ledger.refresh_from_db()+ self.assertEqual(ledger.plan, plan)+ self.assertEqual(ledger.licenses, 50)+ self.assertEqual(ledger.licenses_at_next_renewal, 60)++ realm.refresh_from_db()+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)++ def test_subscribe_realm_to_monthly_plan_on_manual_license_management(self) -> None:+ realm = get_realm("zulip")+ plan, ledger = self.subscribe_realm_to_monthly_plan_on_manual_license_management(+ realm, 20, 30+ )++ plan.refresh_from_db()+ self.assertEqual(plan.automanage_licenses, False)+ self.assertEqual(plan.billing_schedule, CustomerPlan.BILLING_SCHEDULE_MONTHLY)+ self.assertEqual(plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)+ self.assertEqual(plan.licenses(), 20)+ self.assertEqual(plan.licenses_at_next_renewal(), 30)++ ledger.refresh_from_db()+ self.assertEqual(ledger.plan, plan)+ self.assertEqual(ledger.licenses, 20)+ self.assertEqual(ledger.licenses_at_next_renewal, 30)++ realm.refresh_from_db()+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)+++class TestRealmBillingSession(StripeTestCase):+ def test_get_audit_log_error(self) -> None:+ user = self.example_user("hamlet")+ billing_session = RealmBillingSession(user)+ fake_audit_log = typing.cast(BillingSessionEventType, 0)+ with self.assertRaisesRegex(+ BillingSessionAuditLogEventError, "Unknown audit log event type: 0"+ ):+ billing_session.get_audit_log_event(event_type=fake_audit_log)++ def test_get_customer(self) -> None:+ user = self.example_user("hamlet")+ billing_session = RealmBillingSession(user)+ customer = billing_session.get_customer()+ self.assertEqual(customer, None)++ customer = Customer.objects.create(realm=user.realm, stripe_customer_id="cus_12345")+ self.assertEqual(billing_session.get_customer(), customer)+++class TestSupportBillingHelpers(StripeTestCase):+ @mock_stripe()+ def test_attach_discount_to_realm(self, *mocks: Mock) -> None:+ # Attach discount before Stripe customer exists+ support_admin = self.example_user("iago")+ user = self.example_user("hamlet")+ billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)++ # Cannot attach discount without a required_plan_tier set.+ with self.assertRaises(AssertionError):+ billing_session.attach_discount_to_customer(+ monthly_discounted_price=120,+ annual_discounted_price=1200,+ )+ billing_session.update_or_create_customer()++ with self.assertRaises(AssertionError):+ billing_session.attach_discount_to_customer(+ monthly_discounted_price=120,+ annual_discounted_price=1200,+ )++ billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)+ billing_session.attach_discount_to_customer(+ monthly_discounted_price=120,+ annual_discounted_price=1200,+ )+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.REALM_DISCOUNT_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {+ "new_annual_discounted_price": 1200,+ "new_monthly_discounted_price": 120,+ "old_annual_discounted_price": 0,+ "old_monthly_discounted_price": 0,+ }+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)+ self.login_user(user)+ # Check that the discount appears in page_params+ self.assert_in_success_response(["85"], self.client_get("/upgrade/"))+ # Check that the customer was charged the discounted amount+ self.add_card_and_upgrade(user)+ customer = Customer.objects.first()+ assert customer is not None+ assert customer.stripe_customer_id is not None+ [charge] = iter(stripe.Charge.list(customer=customer.stripe_customer_id))+ self.assertEqual(1200 * self.seat_count, charge.amount)+ stripe_customer_id = customer.stripe_customer_id+ assert stripe_customer_id is not None+ [invoice] = iter(stripe.Invoice.list(customer=stripe_customer_id))+ self.assertEqual(+ [1200 * self.seat_count],+ [item.amount for item in invoice.lines],+ )+ # Check CustomerPlan reflects the discount+ plan = CustomerPlan.objects.get(price_per_license=1200, discount="85")++ # Attach discount to existing Stripe customer+ plan.status = CustomerPlan.ENDED+ plan.save(update_fields=["status"])+ billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)+ billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)+ billing_session.attach_discount_to_customer(+ monthly_discounted_price=600,+ annual_discounted_price=6000,+ )+ with time_machine.travel(self.now, tick=False):+ self.add_card_and_upgrade(+ user, license_management="automatic", billing_modality="charge_automatically"+ )+ [charge, _] = iter(stripe.Charge.list(customer=customer.stripe_customer_id))+ self.assertEqual(6000 * self.seat_count, charge.amount)+ stripe_customer_id = customer.stripe_customer_id+ assert stripe_customer_id is not None+ [invoice, _] = iter(stripe.Invoice.list(customer=stripe_customer_id))+ self.assertEqual(+ [6000 * self.seat_count],+ [item.amount for item in invoice.lines],+ )+ plan = CustomerPlan.objects.get(price_per_license=6000, discount=Decimal(25))++ billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)+ billing_session.attach_discount_to_customer(+ monthly_discounted_price=400,+ annual_discounted_price=4000,+ )+ plan.refresh_from_db()+ self.assertEqual(plan.price_per_license, 4000)+ self.assertEqual(plan.discount, "50")+ customer.refresh_from_db()+ self.assertEqual(customer.monthly_discounted_price, 400)+ self.assertEqual(customer.annual_discounted_price, 4000)+ # Fast forward the next_invoice_date to next year.+ plan.next_invoice_date = self.next_year+ plan.save(update_fields=["next_invoice_date"])+ invoice_plans_as_needed(self.next_year + timedelta(days=10))+ stripe_customer_id = customer.stripe_customer_id+ assert stripe_customer_id is not None+ [invoice, _, _] = iter(stripe.Invoice.list(customer=stripe_customer_id))+ self.assertEqual([4000 * self.seat_count], [item.amount for item in invoice.lines])+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.REALM_DISCOUNT_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {+ "new_annual_discounted_price": 4000,+ "new_monthly_discounted_price": 400,+ "old_annual_discounted_price": 6000,+ "old_monthly_discounted_price": 600,+ }+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)+ self.assertEqual(realm_audit_log.acting_user, support_admin)++ # Confirm that once a plan has been purchased and is active,+ # approving a full sponsorship (our version of 100% discount) fails.+ with self.assertRaisesRegex(+ SupportRequestError,+ "Customer on plan Zulip Cloud Standard. Please end current plan before approving sponsorship!",+ ):+ billing_session.approve_sponsorship()++ @mock_stripe()+ def test_add_minimum_licenses(self, *mocks: Mock) -> None:+ min_licenses = 25+ support_view_request = SupportViewRequest(+ support_type=SupportType.update_minimum_licenses, minimum_licenses=min_licenses+ )+ support_admin = self.example_user("iago")+ user = self.example_user("hamlet")+ billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)++ billing_session.update_or_create_customer()+ with self.assertRaisesRegex(+ SupportRequestError,+ "Discount for zulip must be updated before setting a minimum number of licenses.",+ ):+ billing_session.process_support_view_request(support_view_request)++ billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)+ billing_session.attach_discount_to_customer(+ monthly_discounted_price=400,+ annual_discounted_price=4000,+ )+ message = billing_session.process_support_view_request(support_view_request)+ self.assertEqual("Minimum licenses for zulip changed to 25 from 0.", message)+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.CUSTOMER_PROPERTY_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {"old_value": None, "new_value": 25, "property": "minimum_licenses"}+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)++ self.login_user(user)+ self.add_card_and_upgrade(user)+ customer = billing_session.get_customer()+ assert customer is not None+ assert customer.stripe_customer_id is not None+ [charge] = iter(stripe.Charge.list(customer=customer.stripe_customer_id))+ self.assertEqual(4000 * min_licenses, charge.amount)++ min_licenses = 50+ support_view_request = SupportViewRequest(+ support_type=SupportType.update_minimum_licenses, minimum_licenses=min_licenses+ )+ with self.assertRaisesRegex(+ SupportRequestError,+ "Cannot set minimum licenses; active plan already exists for zulip.",+ ):+ billing_session.process_support_view_request(support_view_request)++ def test_set_required_plan_tier(self) -> None:+ valid_plan_tier = CustomerPlan.TIER_CLOUD_STANDARD+ support_view_request = SupportViewRequest(+ support_type=SupportType.update_required_plan_tier,+ required_plan_tier=valid_plan_tier,+ )+ support_admin = self.example_user("iago")+ user = self.example_user("hamlet")+ billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)+ customer = billing_session.get_customer()+ assert customer is None++ # Set valid plan tier - creates Customer object+ message = billing_session.process_support_view_request(support_view_request)+ self.assertEqual("Required plan tier for zulip set to Zulip Cloud Standard.", message)+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.CUSTOMER_PROPERTY_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {+ "old_value": None,+ "new_value": valid_plan_tier,+ "property": "required_plan_tier",+ }+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)+ customer = billing_session.get_customer()+ assert customer is not None+ self.assertEqual(customer.required_plan_tier, valid_plan_tier)+ self.assertEqual(customer.monthly_discounted_price, 0)+ self.assertEqual(customer.annual_discounted_price, 0)++ # Check that discount is only applied to set plan tier+ billing_session.attach_discount_to_customer(+ monthly_discounted_price=400,+ annual_discounted_price=4000,+ )+ customer.refresh_from_db()+ self.assertEqual(customer.monthly_discounted_price, 400)+ self.assertEqual(customer.annual_discounted_price, 4000)++ monthly_discounted_price = customer.get_discounted_price_for_plan(+ valid_plan_tier, CustomerPlan.BILLING_SCHEDULE_MONTHLY+ )+ self.assertEqual(monthly_discounted_price, customer.monthly_discounted_price)+ annual_discounted_price = customer.get_discounted_price_for_plan(+ valid_plan_tier, CustomerPlan.BILLING_SCHEDULE_ANNUAL+ )+ self.assertEqual(annual_discounted_price, customer.annual_discounted_price)+ monthly_discounted_price = customer.get_discounted_price_for_plan(+ CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_MONTHLY+ )+ self.assertEqual(monthly_discounted_price, None)+ annual_discounted_price = customer.get_discounted_price_for_plan(+ CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_ANNUAL+ )+ self.assertEqual(annual_discounted_price, None)++ # Try to set invalid plan tier+ invalid_plan_tier = CustomerPlan.TIER_SELF_HOSTED_BASE+ support_view_request = SupportViewRequest(+ support_type=SupportType.update_required_plan_tier,+ required_plan_tier=invalid_plan_tier,+ )+ with self.assertRaisesRegex(SupportRequestError, "Invalid plan tier for zulip."):+ billing_session.process_support_view_request(support_view_request)++ # Cannot set required plan tier to None before setting discount to 0.+ support_view_request = SupportViewRequest(+ support_type=SupportType.update_required_plan_tier, required_plan_tier=0+ )+ with self.assertRaisesRegex(+ SupportRequestError,+ "Discount for zulip must be 0 before setting required plan tier to None.",+ ):+ billing_session.process_support_view_request(support_view_request)++ billing_session.attach_discount_to_customer(+ monthly_discounted_price=0,+ annual_discounted_price=0,+ )+ message = billing_session.process_support_view_request(support_view_request)+ self.assertEqual("Required plan tier for zulip set to None.", message)+ customer.refresh_from_db()+ self.assertIsNone(customer.required_plan_tier)+ discount_for_standard_plan = customer.get_discounted_price_for_plan(+ valid_plan_tier, CustomerPlan.BILLING_SCHEDULE_MONTHLY+ )+ self.assertEqual(discount_for_standard_plan, None)+ discount_for_plus_plan = customer.get_discounted_price_for_plan(+ CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_MONTHLY+ )+ self.assertEqual(discount_for_plus_plan, None)+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.CUSTOMER_PROPERTY_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {+ "old_value": valid_plan_tier,+ "new_value": None,+ "property": "required_plan_tier",+ }+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)++ def test_approve_realm_sponsorship(self) -> None:+ realm = get_realm("zulip")+ self.assertNotEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD_FREE)++ support_admin = self.example_user("iago")+ billing_session = RealmBillingSession(user=support_admin, realm=realm, support_session=True)+ billing_session.approve_sponsorship()+ self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD_FREE)++ expected_message = (+ "Your organization's request for sponsored hosting has been approved! You have been upgraded to Zulip Cloud Standard, free of charge. :tada:"+ "\n\nIf you could [list Zulip as a sponsor on your website](/help/linking-to-zulip-website), we would really appreciate it!"+ )+ sender = get_system_bot(settings.NOTIFICATION_BOT, realm.id)++ # Organization owners get the notification bot message+ bot_and_desdemona_recipient = self.get_dm_group_recipient(+ sender, self.example_user("desdemona")+ )+ message_to_owner = Message.objects.filter(+ realm_id=realm.id, sender=sender.id, recipient=bot_and_desdemona_recipient+ ).first()+ assert message_to_owner is not None+ self.assertEqual(message_to_owner.content, expected_message)+ self.assertEqual(message_to_owner.recipient.type, Recipient.DIRECT_MESSAGE_GROUP)++ # Hamlet is in `can_manage_billing_group` so should get the notification bot message+ bot_and_hamlet_recipient = self.get_dm_group_recipient(sender, self.example_user("hamlet"))+ message_to_hamlet = Message.objects.filter(+ realm_id=realm.id, sender=sender.id, recipient=bot_and_hamlet_recipient+ ).last()+ assert message_to_hamlet is not None+ self.assertEqual(message_to_hamlet.content, expected_message)+ self.assertEqual(message_to_hamlet.recipient.type, Recipient.DIRECT_MESSAGE_GROUP)++ def test_update_realm_sponsorship_status(self) -> None:+ lear = get_realm("lear")+ iago = self.example_user("iago")+ billing_session = RealmBillingSession(user=iago, realm=lear, support_session=True)+ billing_session.update_customer_sponsorship_status(True)+ customer = get_customer_by_realm(realm=lear)+ assert customer is not None+ self.assertTrue(customer.sponsorship_pending)+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.REALM_SPONSORSHIP_PENDING_STATUS_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {"sponsorship_pending": True}+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)+ self.assertEqual(realm_audit_log.acting_user, iago)++ def test_update_realm_billing_modality(self) -> None:+ realm = get_realm("zulip")+ customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")+ plan = CustomerPlan.objects.create(+ customer=customer,+ status=CustomerPlan.ACTIVE,+ billing_cycle_anchor=timezone_now(),+ billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,+ tier=CustomerPlan.TIER_CLOUD_STANDARD,+ )+ self.assertEqual(plan.charge_automatically, False)++ support_admin = self.example_user("iago")+ billing_session = RealmBillingSession(user=support_admin, realm=realm, support_session=True)+ billing_session.update_billing_modality_of_current_plan(True)+ plan.refresh_from_db()+ self.assertEqual(plan.charge_automatically, True)+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.REALM_BILLING_MODALITY_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {"charge_automatically": plan.charge_automatically}+ self.assertEqual(realm_audit_log.acting_user, support_admin)+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)++ billing_session.update_billing_modality_of_current_plan(False)+ plan.refresh_from_db()+ self.assertEqual(plan.charge_automatically, False)+ realm_audit_log = RealmAuditLog.objects.filter(+ event_type=AuditLogEventType.REALM_BILLING_MODALITY_CHANGED+ ).last()+ assert realm_audit_log is not None+ expected_extra_data = {"charge_automatically": plan.charge_automatically}+ self.assertEqual(realm_audit_log.acting_user, support_admin)+ self.assertEqual(realm_audit_log.extra_data, expected_extra_data)++ @mock_stripe()+ def test_switch_realm_from_standard_to_plus_plan(self, *mocks: Mock) -> None:+ user = self.example_user("hamlet")+ self.login_user(user)+ self.add_card_and_upgrade(user)+ customer = get_customer_by_realm(user.realm)+ assert customer is not None+ original_plan = get_current_plan_by_customer(customer)+ assert original_plan is not None+ self.assertEqual(original_plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)++ support_admin = self.example_user("iago")+ billing_session = RealmBillingSession(+ user=support_admin, realm=user.realm, support_session=True+ )+ support_request = SupportViewRequest(+ support_type=SupportType.modify_plan,+ plan_modification="upgrade_plan_tier",+ new_plan_tier=CustomerPlan.TIER_CLOUD_PLUS,+ )+ # Freeze time so the prorated credit (computed inside+ # ``change_plan_tier`` from ``timezone_now()``) doesn't drift+ # between fixture regenerations.+ with time_machine.travel(self.now, tick=False):+ success_message = billing_session.process_support_view_request(support_request)+ self.assertEqual(success_message, "zulip upgraded to Zulip Cloud Plus")+ customer.refresh_from_db()+ new_plan = get_current_plan_by_customer(customer)+ assert new_plan is not None+ self.assertEqual(new_plan.tier, CustomerPlan.TIER_CLOUD_PLUS)++ @mock_stripe()+ def test_downgrade_realm_and_void_open_invoices(self, *mocks: Mock) -> None:+ user = self.example_user("hamlet")+ self.login_user(user)+ with time_machine.travel(self.now, tick=False):+ self.upgrade(invoice=True)+ customer = get_customer_by_realm(user.realm)+ assert customer is not None+ original_plan = get_current_plan_by_customer(customer)+ assert original_plan is not None+ self.assertEqual(original_plan.status, CustomerPlan.ACTIVE)++ support_admin = self.example_user("iago")+ billing_session = RealmBillingSession(+ user=support_admin, realm=user.realm, support_session=True+ )++ # Send renewal invoice.+ invoice_plans_as_needed(self.now + timedelta(days=367))++ support_request = SupportViewRequest(+ support_type=SupportType.modify_plan,+ plan_modification="downgrade_now_void_open_invoices",+ )+ success_message = billing_session.process_support_view_request(support_request)+ self.assertEqual(success_message, "zulip downgraded and voided 1 open invoices")+ original_plan.refresh_from_db()+ self.assertEqual(original_plan.status, CustomerPlan.ENDED)+++class TestRemoteBillingWriteAuditLog(StripeTestCase):+ def test_write_audit_log(self) -> None:+ support_admin = self.example_user("iago")+ server_uuid = str(uuid.uuid4())+ remote_server = RemoteZulipServer.objects.create(+ uuid=server_uuid,+ api_key="magic_secret_api_key",+ hostname="demo.example.com",+ contact_email="[email protected]",+ )+ realm_uuid = str(uuid.uuid4())+ remote_realm = RemoteRealm.objects.create(+ server=remote_server,+ uuid=realm_uuid,+ uuid_owner_secret="dummy-owner-secret",+ host="dummy-hostname",+ realm_date_created=timezone_now(),+ )+ remote_realm_billing_user = RemoteRealmBillingUser.objects.create(+ remote_realm=remote_realm, email="[email protected]", user_uuid=uuid.uuid4()+ )+ remote_server_billing_user = RemoteServerBillingUser.objects.create(+ remote_server=remote_server, email="[email protected]"+ )+ event_time = timezone_now()++ def assert_audit_log(+ audit_log: RemoteRealmAuditLog | RemoteZulipServerAuditLog,+ acting_remote_user: RemoteRealmBillingUser | RemoteServerBillingUser | None,+ acting_support_user: UserProfile | None,+ event_type: int,+ event_time: datetime,+ ) -> None:+ self.assertEqual(audit_log.event_type, event_type)+ self.assertEqual(audit_log.event_time, event_time)+ self.assertEqual(audit_log.acting_remote_user, acting_remote_user)+ self.assertEqual(audit_log.acting_support_user, acting_support_user)++ for session_class, audit_log_class, remote_object, remote_user in [+ (+ RemoteRealmBillingSession,+ RemoteRealmAuditLog,+ remote_realm,+ remote_realm_billing_user,+ ),+ (+ RemoteServerBillingSession,+ RemoteZulipServerAuditLog,+ remote_server,+ remote_server_billing_user,+ ),+ ]:+ # Necessary cast or mypy doesn't understand that we can use Django's+ # model .objects. style queries on this.+ audit_log_model = cast(+ type[RemoteRealmAuditLog] | type[RemoteZulipServerAuditLog], audit_log_class+ )+ assert isinstance(remote_user, RemoteRealmBillingUser | RemoteServerBillingUser)+ # No acting user:+ session = session_class(remote_object)+ session.write_to_audit_log(+ # This "ordinary billing" event type value gets translated by write_to_audit_log+ # into a AuditLogEventType.CUSTOMER_PLAN_CREATED value.+ event_type=BillingSessionEventType.CUSTOMER_PLAN_CREATED,+ event_time=event_time,+ )+ audit_log = audit_log_model.objects.latest("id")+ assert_audit_log(+ audit_log, None, None, AuditLogEventType.CUSTOMER_PLAN_CREATED, event_time+ )++ session = session_class(remote_object, remote_billing_user=remote_user)+ session.write_to_audit_log(+ event_type=BillingSessionEventType.CUSTOMER_PLAN_CREATED,+ event_time=event_time,+ )+ audit_log = audit_log_model.objects.latest("id")+ assert_audit_log(+ audit_log, remote_user, None, AuditLogEventType.CUSTOMER_PLAN_CREATED, event_time+ )++ session = session_class(+ remote_object, remote_billing_user=None, support_staff=support_admin+ )+ session.write_to_audit_log(+ event_type=BillingSessionEventType.CUSTOMER_PLAN_CREATED,+ event_time=event_time,+ )+ audit_log = audit_log_model.objects.latest("id")+ assert_audit_log(+ audit_log, None, support_admin, AuditLogEventType.CUSTOMER_PLAN_CREATED, event_time+ )diff --git a/corporate/tests/test_stripe.py b/corporate/tests/test_stripe.pyindex f9ced1fe829..e1703b19c74 100644--- a/corporate/tests/test_stripe.py+++ b/corporate/tests/test_stripe.py@@ -1,12 +1,9 @@-import itertools-import typingimport uuidfrom collections.abc import Mapping, Sequencefrom dataclasses import dataclass-from datetime import date, datetime, time, timedelta, timezone+from datetime import timedeltafrom decimal import Decimal-from typing import Any, cast-from unittest import mock+from typing import Anyfrom unittest.mock import Mock, patchimport orjson@@ -25,33 +22,18 @@ from corporate.lib.stripe import (MIN_INVOICED_LICENSES,STRIPE_API_VERSION,BillingError,- BillingSessionAuditLogEventError,- BillingSessionEventType,- BillingUserCounts,InitialUpgradeRequest,- InvalidBillingScheduleError,- InvalidTierError,RealmBillingSession,- RemoteRealmBillingSession,- RemoteServerBillingSession,StripeCardError,- SupportRequestError,- SupportType,- SupportViewRequest,UpdatePlanRequest,add_months,catch_stripe_errors,- compute_plan_parameters,customer_has_credit_card_as_default_payment_method,customer_has_last_n_invoices_open,downgrade_small_realms_behind_on_payments_as_needed,get_latest_seat_count,- get_next_billing_cycle_for_plan,- get_plan_renewal_or_end_date,get_price_per_license,invoice_plans_as_needed,- is_realm_on_free_trial,- next_month,sign_string,stripe_customer_has_credit_card_as_default_payment_method,stripe_get_customer,@@ -62,35 +44,21 @@ from corporate.models.customers import Customer, get_customer_by_realmfrom corporate.models.licenses import LicenseLedgerfrom corporate.models.plans import (CustomerPlan,- CustomerPlanOffer,get_current_plan_by_customer,get_current_plan_by_realm,)from corporate.models.stripe_state import Event, Invoicefrom zerver.actions.create_realm import do_create_realm-from zerver.actions.create_user import (- do_activate_mirror_dummy_user,- do_create_user,- do_reactivate_user,-)from zerver.actions.realm_settings import do_deactivate_realm, do_reactivate_realm-from zerver.actions.users import change_user_is_active, do_deactivate_user+from zerver.actions.users import do_deactivate_userfrom zerver.lib.exceptions import JsonableErrorfrom zerver.lib.test_classes import ZulipTestCasefrom zerver.lib.timestamp import datetime_to_timestamp, timestamp_to_datetimefrom zerver.lib.utils import assert_is_not_none-from zerver.models import Message, Realm, RealmAuditLog, Recipient, UserProfile+from zerver.models import Realm, RealmAuditLog, UserProfilefrom zerver.models.realm_audit_logs import AuditLogEventTypefrom zerver.models.realms import get_realm-from zerver.models.users import get_system_bot-from zilencer.models import (- RemoteRealm,- RemoteRealmAuditLog,- RemoteRealmBillingUser,- RemoteServerBillingUser,- RemoteZulipServer,- RemoteZulipServerAuditLog,-)+from zilencer.models import RemoteZulipServerclass StripeTest(StripeTestCase):@@ -4537,1911 +4505,3 @@ class RequiresBillingAccessTest(StripeTestCase):content_type="application/json",)self.assert_json_success(response)---class BillingHelpersTest(ZulipTestCase):- def test_next_month(self) -> None:- anchor = datetime(2019, 12, 31, 1, 2, 3, tzinfo=timezone.utc)- period_boundaries = [- anchor,- datetime(2020, 1, 31, 1, 2, 3, tzinfo=timezone.utc),- # Test that this is the 28th even during leap years- datetime(2020, 2, 28, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 3, 31, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 4, 30, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 5, 31, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 6, 30, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 7, 31, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 8, 31, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 9, 30, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 10, 31, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 11, 30, 1, 2, 3, tzinfo=timezone.utc),- datetime(2020, 12, 31, 1, 2, 3, tzinfo=timezone.utc),- datetime(2021, 1, 31, 1, 2, 3, tzinfo=timezone.utc),- datetime(2021, 2, 28, 1, 2, 3, tzinfo=timezone.utc),- ]- with self.assertRaises(AssertionError):- add_months(anchor, -1)- # Explicitly test add_months for each value of MAX_DAY_FOR_MONTH and- # for crossing a year boundary- for i, boundary in enumerate(period_boundaries):- self.assertEqual(add_months(anchor, i), boundary)- # Test next_month for small values- for last, next_ in itertools.pairwise(period_boundaries):- self.assertEqual(next_month(anchor, last), next_)- # Test next_month for large values- period_boundaries = [dt.replace(year=dt.year + 100) for dt in period_boundaries]- for last, next_ in itertools.pairwise(period_boundaries):- self.assertEqual(next_month(anchor, last), next_)-- def test_compute_plan_parameters(self) -> None:- anchor = datetime(2019, 12, 31, 1, 2, 3, tzinfo=timezone.utc)- month_later = datetime(2020, 1, 31, 1, 2, 3, tzinfo=timezone.utc)- year_later = datetime(2020, 12, 31, 1, 2, 3, tzinfo=timezone.utc)- customer_with_discount = Customer.objects.create(- realm=get_realm("lear"),- monthly_discounted_price=600,- annual_discounted_price=6000,- required_plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- )- customer_no_discount = Customer.objects.create(realm=get_realm("zulip"))- test_cases = [- # Annual standard no customer- (- (- CustomerPlan.TIER_CLOUD_STANDARD,- CustomerPlan.BILLING_SCHEDULE_ANNUAL,- None,- ),- (anchor, month_later, year_later, 8000),- ),- # Annual standard with discount- (- (- CustomerPlan.TIER_CLOUD_STANDARD,- CustomerPlan.BILLING_SCHEDULE_ANNUAL,- customer_with_discount,- ),- (anchor, month_later, year_later, 6000),- ),- # Annual standard customer but no discount- (- (- CustomerPlan.TIER_CLOUD_STANDARD,- CustomerPlan.BILLING_SCHEDULE_ANNUAL,- customer_no_discount,- ),- (anchor, month_later, year_later, 8000),- ),- # Annual plus customer with discount but different tier than required for discount- (- (- CustomerPlan.TIER_CLOUD_PLUS,- CustomerPlan.BILLING_SCHEDULE_ANNUAL,- customer_with_discount,- ),- (anchor, month_later, year_later, 12000),- ),- # Monthly standard no customer- (- (- CustomerPlan.TIER_CLOUD_STANDARD,- CustomerPlan.BILLING_SCHEDULE_MONTHLY,- None,- ),- (anchor, month_later, month_later, 800),- ),- # Monthly standard with discount- (- (- CustomerPlan.TIER_CLOUD_STANDARD,- CustomerPlan.BILLING_SCHEDULE_MONTHLY,- customer_with_discount,- ),- (anchor, month_later, month_later, 600),- ),- # Monthly standard customer but no discount- (- (- CustomerPlan.TIER_CLOUD_STANDARD,- CustomerPlan.BILLING_SCHEDULE_MONTHLY,- customer_no_discount,- ),- (anchor, month_later, month_later, 800),- ),- # Monthly plus customer with discount but different tier than required for discount- (- (- CustomerPlan.TIER_CLOUD_PLUS,- CustomerPlan.BILLING_SCHEDULE_MONTHLY,- customer_with_discount,- ),- (anchor, month_later, month_later, 1200),- ),- ]- # compute_plan_parameters truncates microseconds in the anchor datetime.- with time_machine.travel(anchor + timedelta(microseconds=654321), tick=False):- for (tier, billing_schedule, customer), output in test_cases:- output_ = compute_plan_parameters(- tier,- billing_schedule,- customer,- )- self.assertEqual(output_, output)-- def test_get_price_per_license(self) -> None:- standard_discounted_customer = Customer.objects.create(- realm=get_realm("lear"),- monthly_discounted_price=400,- annual_discounted_price=4000,- required_plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- )- plus_discounted_customer = Customer.objects.create(- realm=get_realm("zulip"),- monthly_discounted_price=600,- annual_discounted_price=6000,- required_plan_tier=CustomerPlan.TIER_CLOUD_PLUS,- )- self.assertEqual(- get_price_per_license(- CustomerPlan.TIER_CLOUD_STANDARD, CustomerPlan.BILLING_SCHEDULE_ANNUAL- ),- 8000,- )- self.assertEqual(- get_price_per_license(- CustomerPlan.TIER_CLOUD_STANDARD, CustomerPlan.BILLING_SCHEDULE_MONTHLY- ),- 800,- )- self.assertEqual(- get_price_per_license(- CustomerPlan.TIER_CLOUD_STANDARD,- CustomerPlan.BILLING_SCHEDULE_MONTHLY,- standard_discounted_customer,- ),- 400,- )-- self.assertEqual(- get_price_per_license(- CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_ANNUAL- ),- 12000,- )- self.assertEqual(- get_price_per_license(- CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_MONTHLY- ),- 1200,- )- self.assertEqual(- get_price_per_license(- CustomerPlan.TIER_CLOUD_PLUS,- CustomerPlan.BILLING_SCHEDULE_MONTHLY,- # Wrong tier so discount not applied.- standard_discounted_customer,- ),- 1200,- )- self.assertEqual(- get_price_per_license(- CustomerPlan.TIER_CLOUD_PLUS,- CustomerPlan.BILLING_SCHEDULE_MONTHLY,- plus_discounted_customer,- ),- 600,- )-- with self.assertRaisesRegex(InvalidBillingScheduleError, "Unknown billing_schedule: 1000"):- get_price_per_license(CustomerPlan.TIER_CLOUD_STANDARD, 1000)-- with self.assertRaisesRegex(InvalidTierError, "Unknown tier: 4"):- get_price_per_license(- CustomerPlan.TIER_CLOUD_ENTERPRISE, CustomerPlan.BILLING_SCHEDULE_ANNUAL- )-- def test_get_plan_renewal_or_end_date(self) -> None:- realm = get_realm("zulip")- customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")- billing_cycle_anchor = timezone_now()- plan = CustomerPlan.objects.create(- customer=customer,- status=CustomerPlan.ACTIVE,- billing_cycle_anchor=billing_cycle_anchor,- billing_schedule=CustomerPlan.BILLING_SCHEDULE_MONTHLY,- tier=CustomerPlan.TIER_CLOUD_STANDARD,- )- renewal_date = get_plan_renewal_or_end_date(plan, billing_cycle_anchor)- self.assertEqual(renewal_date, add_months(billing_cycle_anchor, 1))-- # When the plan ends 2 days before the start of the next billing cycle,- # the function should return the end_date.- plan_end_date = add_months(billing_cycle_anchor, 1) - timedelta(days=2)- plan.end_date = plan_end_date- plan.save(update_fields=["end_date"])- renewal_date = get_plan_renewal_or_end_date(plan, billing_cycle_anchor)- self.assertEqual(renewal_date, plan_end_date)-- def test_update_or_create_stripe_customer_logic(self) -> None:- user = self.example_user("hamlet")- # No existing Customer object- with patch(- "corporate.lib.stripe.BillingSession.create_stripe_customer", return_value="returned"- ) as mocked1:- billing_session = RealmBillingSession(user)- returned = billing_session.update_or_create_stripe_customer()- mocked1.assert_called_once()- self.assertEqual(returned, "returned")-- customer = Customer.objects.create(realm=get_realm("zulip"))- # Customer exists but stripe_customer_id is None- with patch(- "corporate.lib.stripe.BillingSession.create_stripe_customer", return_value="returned"- ) as mocked2:- billing_session = RealmBillingSession(user)- returned = billing_session.update_or_create_stripe_customer()- mocked2.assert_called_once()- self.assertEqual(returned, "returned")-- customer.stripe_customer_id = "cus_12345"- customer.save()- # Customer exists, replace payment source- with patch("corporate.lib.stripe.BillingSession.replace_payment_method") as mocked3:- billing_session = RealmBillingSession(user)- returned_customer = billing_session.update_or_create_stripe_customer("pm_card_visa")- mocked3.assert_called_once()- self.assertEqual(returned_customer, customer)-- # Customer exists, do nothing- with patch("corporate.lib.stripe.BillingSession.replace_payment_method") as mocked4:- billing_session = RealmBillingSession(user)- returned_customer = billing_session.update_or_create_stripe_customer(None)- mocked4.assert_not_called()- self.assertEqual(returned_customer, customer)-- def test_get_customer_by_realm(self) -> None:- realm = get_realm("zulip")-- self.assertEqual(get_customer_by_realm(realm), None)-- customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")- self.assertEqual(get_customer_by_realm(realm), customer)-- def test_get_current_plan_by_customer(self) -> None:- realm = get_realm("zulip")- customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")-- self.assertEqual(get_current_plan_by_customer(customer), None)-- plan = CustomerPlan.objects.create(- customer=customer,- status=CustomerPlan.ACTIVE,- billing_cycle_anchor=timezone_now(),- billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,- tier=CustomerPlan.TIER_CLOUD_STANDARD,- )- self.assertEqual(get_current_plan_by_customer(customer), plan)-- plan.status = CustomerPlan.DOWNGRADE_AT_END_OF_CYCLE- plan.save(update_fields=["status"])- self.assertEqual(get_current_plan_by_customer(customer), plan)-- plan.status = CustomerPlan.ENDED- plan.save(update_fields=["status"])- self.assertEqual(get_current_plan_by_customer(customer), None)-- plan.status = CustomerPlan.NEVER_STARTED- plan.save(update_fields=["status"])- self.assertEqual(get_current_plan_by_customer(customer), None)-- def test_get_current_plan_by_realm(self) -> None:- realm = get_realm("zulip")-- self.assertEqual(get_current_plan_by_realm(realm), None)-- customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")- self.assertEqual(get_current_plan_by_realm(realm), None)-- plan = CustomerPlan.objects.create(- customer=customer,- status=CustomerPlan.ACTIVE,- billing_cycle_anchor=timezone_now(),- billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,- tier=CustomerPlan.TIER_CLOUD_STANDARD,- )- self.assertEqual(get_current_plan_by_realm(realm), plan)-- def test_is_realm_on_free_trial(self) -> None:- realm = get_realm("zulip")- self.assertFalse(is_realm_on_free_trial(realm))-- customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")- plan = CustomerPlan.objects.create(- customer=customer,- status=CustomerPlan.ACTIVE,- billing_cycle_anchor=timezone_now(),- billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,- tier=CustomerPlan.TIER_CLOUD_STANDARD,- )- self.assertFalse(is_realm_on_free_trial(realm))-- plan.status = CustomerPlan.FREE_TRIAL- plan.save(update_fields=["status"])- self.assertTrue(is_realm_on_free_trial(realm))-- def test_deactivate_reactivate_remote_server(self) -> None:- server_uuid = str(uuid.uuid4())- remote_server = RemoteZulipServer.objects.create(- uuid=server_uuid,- api_key="magic_secret_api_key",- hostname="demo.example.com",- contact_email="[email protected]",- )- self.assertFalse(remote_server.deactivated)- remote_server_billing_user = RemoteServerBillingUser.objects.create(- remote_server=remote_server, email="[email protected]"- )-- billing_session = RemoteServerBillingSession(remote_server, remote_server_billing_user)- billing_session.do_deactivate_remote_server()-- remote_server = RemoteZulipServer.objects.get(uuid=server_uuid)- remote_realm_audit_log = RemoteZulipServerAuditLog.objects.filter(- event_type=AuditLogEventType.REMOTE_SERVER_DEACTIVATED- ).last()- assert remote_realm_audit_log is not None- self.assertTrue(remote_server.deactivated)- self.assertEqual(remote_realm_audit_log.acting_remote_user, remote_server_billing_user)-- # Try to deactivate a remote server that is already deactivated- with self.assertLogs("corporate.stripe", "WARN") as warning_log:- billing_session.do_deactivate_remote_server()- self.assertEqual(- warning_log.output,- [- (- "WARNING:corporate.stripe:Cannot deactivate remote server with ID "- f"{remote_server.id}, server has already been deactivated."- )- ],- )-- billing_session.do_reactivate_remote_server()- remote_server.refresh_from_db()- self.assertFalse(remote_server.deactivated)- remote_realm_audit_log = RemoteZulipServerAuditLog.objects.latest("id")- self.assertEqual(- remote_realm_audit_log.event_type, AuditLogEventType.REMOTE_SERVER_REACTIVATED- )- self.assertEqual(remote_realm_audit_log.server, remote_server)-- with self.assertLogs("corporate.stripe", "WARN") as warning_log:- billing_session.do_reactivate_remote_server()- self.assertEqual(- warning_log.output,- [- (- "WARNING:corporate.stripe:Cannot reactivate remote server with ID "- f"{remote_server.id}, server is already active."- )- ],- )-- def test_initialize_fixed_price_plan_realm(self) -> None:- billing_cycle_anchor = datetime(2012, 1, 1, 1, 1, 1, tzinfo=timezone.utc)- realm = get_realm("zulip")-- # Requires a Customer object for the billing entity.- billing_session = RealmBillingSession(None, realm)- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_customer",- billing_context.exception.error_description,- )-- # Requires that the Customer object is linked to a- # customer ID in Stripe.- billing_session.update_or_create_customer()- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_stripe_id",- billing_context.exception.error_description,- )-- # Requires a fixed price plan offer to be configured- # for the customer.- customer = billing_session.get_customer()- assert customer is not None- customer.stripe_customer_id = "cus_123"- customer.save(update_fields=["stripe_customer_id"])- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_plan_offer",- billing_context.exception.error_description,- )-- billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)- billing_session.configure_fixed_price_plan(1000, None)- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_SELF_HOSTED)- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.fixed_price, 100000)- self.assertEqual(plan.billing_cycle_anchor, billing_cycle_anchor)- license_ledger = LicenseLedger.objects.filter(plan=plan, is_renewal=True).last()- assert license_ledger is not None- self.assertEqual(license_ledger.event_time, billing_cycle_anchor)-- # Confirm that if there is an active paid plan for the- # customer, a new plan can not be initialized.- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "on_paid_plan",- billing_context.exception.error_description,- )-- def test_initialize_fixed_price_plan_remote_realm(self) -> None:- billing_cycle_anchor = datetime(2012, 1, 1, 1, 1, 1, tzinfo=timezone.utc)- server_uuid = str(uuid.uuid4())- remote_server = RemoteZulipServer.objects.create(- uuid=server_uuid,- api_key="magic_secret_api_key",- hostname="demo.example.com",- contact_email="[email protected]",- )- realm_uuid = str(uuid.uuid4())- remote_realm = RemoteRealm.objects.create(- server=remote_server,- uuid=realm_uuid,- uuid_owner_secret="dummy-owner-secret",- host="dummy-hostname",- realm_date_created=timezone_now(),- )-- # Requires a Customer object for the billing entity.- billing_session = RemoteRealmBillingSession(remote_realm)- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_customer",- billing_context.exception.error_description,- )-- # Requires that the Customer object is linked to a- # customer ID in Stripe.- billing_session.update_or_create_customer()- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_stripe_id",- billing_context.exception.error_description,- )-- # Requires a fixed price plan offer to be configured- # for the customer.- customer = billing_session.get_customer()- assert customer is not None- customer.stripe_customer_id = "cus_123"- customer.save(update_fields=["stripe_customer_id"])- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_plan_offer",- billing_context.exception.error_description,- )-- billing_session.set_required_plan_tier(CustomerPlan.TIER_SELF_HOSTED_BASIC)- billing_session.configure_fixed_price_plan(1200, None)- self.assertEqual(remote_realm.plan_type, RemoteRealm.PLAN_TYPE_SELF_MANAGED)- with mock.patch(- "corporate.lib.stripe.RemoteRealmBillingSession.current_counts_for_billed_users",- return_value=BillingUserCounts(60, 0),- ):- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(remote_realm.plan_type, RemoteRealm.PLAN_TYPE_BASIC)- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.fixed_price, 120000)- self.assertEqual(plan.billing_cycle_anchor, billing_cycle_anchor)- license_ledger = LicenseLedger.objects.filter(plan=plan, is_renewal=True).last()- assert license_ledger is not None- self.assertEqual(license_ledger.event_time, billing_cycle_anchor)-- # Confirm that if there is an active paid plan for the- # customer, a new plan can not be initialized.- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "on_paid_plan",- billing_context.exception.error_description,- )-- def test_initialize_fixed_price_plan_remote_server(self) -> None:- billing_cycle_anchor = datetime(2012, 1, 1, 1, 1, 1, tzinfo=timezone.utc)- server_uuid = str(uuid.uuid4())- remote_server = RemoteZulipServer.objects.create(- uuid=server_uuid,- api_key="magic_secret_api_key",- hostname="demo.example.com",- contact_email="[email protected]",- )-- # Requires a Customer object for the billing entity.- billing_session = RemoteServerBillingSession(remote_server)- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_customer",- billing_context.exception.error_description,- )-- # Requires that the Customer object is linked to a- # customer ID in Stripe.- billing_session.update_or_create_customer()- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_stripe_id",- billing_context.exception.error_description,- )-- # Requires a fixed price plan offer to be configured- # for the customer.- customer = billing_session.get_customer()- assert customer is not None- customer.stripe_customer_id = "cus_123"- customer.save(update_fields=["stripe_customer_id"])- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "no_plan_offer",- billing_context.exception.error_description,- )-- billing_session.set_required_plan_tier(CustomerPlan.TIER_SELF_HOSTED_BASIC)- billing_session.configure_fixed_price_plan(1200, None)- self.assertEqual(remote_server.plan_type, RemoteRealm.PLAN_TYPE_SELF_MANAGED)- with mock.patch(- "corporate.lib.stripe.RemoteServerBillingSession.current_counts_for_billed_users",- return_value=BillingUserCounts(60, 0),- ):- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_SELF_HOSTED_BASIC,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(remote_server.plan_type, RemoteRealm.PLAN_TYPE_BASIC)- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.fixed_price, 120000)- self.assertEqual(plan.billing_cycle_anchor, billing_cycle_anchor)- license_ledger = LicenseLedger.objects.filter(plan=plan, is_renewal=True).last()- assert license_ledger is not None- self.assertEqual(license_ledger.event_time, billing_cycle_anchor)-- # Confirm that if there is an active paid plan for the- # customer, a new plan can not be initialized.- with self.assertRaises(BillingError) as billing_context:- billing_session.initialize_prepaid_fixed_price_plan(- plan_tier=CustomerPlan.TIER_CLOUD_STANDARD,- billing_cycle_anchor=billing_cycle_anchor,- )- self.assertEqual(- "on_paid_plan",- billing_context.exception.error_description,- )---class LicenseLedgerTest(StripeTestCase):- def test_add_plan_renewal_if_needed(self) -> None:- with time_machine.travel(self.now, tick=False):- self.local_upgrade(- self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False- )- self.assertEqual(LicenseLedger.objects.count(), 1)- plan = CustomerPlan.objects.get()- # Plan hasn't renewed yet- realm = plan.customer.realm- billing_session = RealmBillingSession(user=None, realm=realm)- billing_session.make_end_of_cycle_updates_if_needed(- plan, self.next_year - timedelta(days=1)- )- self.assertEqual(LicenseLedger.objects.count(), 1)- # Plan needs to renew- # TODO: do_deactivate_user for a user, so that licenses_at_next_renewal != licenses- new_plan, ledger_entry = billing_session.make_end_of_cycle_updates_if_needed(- plan, self.next_year- )- self.assertIsNone(new_plan)- self.assertEqual(LicenseLedger.objects.count(), 2)- assert ledger_entry is not None- self.assertEqual(ledger_entry.plan, plan)- self.assertTrue(ledger_entry.is_renewal)- self.assertEqual(ledger_entry.event_time, self.next_year)- self.assertEqual(ledger_entry.licenses, self.seat_count)- self.assertEqual(ledger_entry.licenses_at_next_renewal, self.seat_count)- # Plan needs to renew, but we already added the plan_renewal ledger entry- billing_session.make_end_of_cycle_updates_if_needed(- plan, self.next_year + timedelta(days=1)- )- self.assertEqual(LicenseLedger.objects.count(), 2)-- def test_update_license_ledger_if_needed(self) -> None:- realm = get_realm("zulip")- billing_session = RealmBillingSession(user=None, realm=realm)- # Test no Customer- billing_session.update_license_ledger_if_needed(self.now)- self.assertFalse(LicenseLedger.objects.exists())- # Test plan not automanaged- with time_machine.travel(self.now, tick=False):- self.local_upgrade(- self.seat_count + 1, False, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False- )- plan = CustomerPlan.objects.get()- self.assertEqual(LicenseLedger.objects.count(), 1)- self.assertEqual(plan.licenses(), self.seat_count + 1)- self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count + 1)- billing_session.update_license_ledger_if_needed(self.now)- self.assertEqual(LicenseLedger.objects.count(), 1)- # Test no active plan- plan.automanage_licenses = True- plan.status = CustomerPlan.ENDED- plan.save(update_fields=["automanage_licenses", "status"])- billing_session.update_license_ledger_if_needed(self.now)- self.assertEqual(LicenseLedger.objects.count(), 1)- # Test update needed- plan.status = CustomerPlan.ACTIVE- plan.save(update_fields=["status"])- billing_session.update_license_ledger_if_needed(self.now)- self.assertEqual(LicenseLedger.objects.count(), 2)-- def test_update_license_ledger_for_automanaged_plan(self) -> None:- realm = get_realm("zulip")- with time_machine.travel(self.now, tick=False):- self.local_upgrade(- self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False- )- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.licenses(), self.seat_count)- self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count)-- billing_session = RealmBillingSession(user=None, realm=realm)- # Simple increase- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=23):- billing_session.update_license_ledger_for_automanaged_plan(plan, self.now)- self.assertEqual(plan.licenses(), 23)- self.assertEqual(plan.licenses_at_next_renewal(), 23)- # Decrease- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=20):- billing_session.update_license_ledger_for_automanaged_plan(plan, self.now)- self.assertEqual(plan.licenses(), 23)- self.assertEqual(plan.licenses_at_next_renewal(), 20)- # Increase, but not past high watermark- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=21):- billing_session.update_license_ledger_for_automanaged_plan(plan, self.now)- self.assertEqual(plan.licenses(), 23)- self.assertEqual(plan.licenses_at_next_renewal(), 21)- # Increase, but after renewal date, and below last year's high watermark- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=22):- billing_session.update_license_ledger_for_automanaged_plan(- plan, self.next_year + timedelta(seconds=1)- )- self.assertEqual(plan.licenses(), 22)- self.assertEqual(plan.licenses_at_next_renewal(), 22)-- ledger_entries = list(- LicenseLedger.objects.values_list(- "is_renewal", "event_time", "licenses", "licenses_at_next_renewal"- ).order_by("id")- )- self.assertEqual(- ledger_entries,- [- (True, self.now, self.seat_count, self.seat_count),- (False, self.now, 23, 23),- (False, self.now, 23, 20),- (False, self.now, 23, 21),- (True, self.next_year, 21, 21),- (False, self.next_year + timedelta(seconds=1), 22, 22),- ],- )-- def test_update_license_ledger_for_manual_plan(self) -> None:- realm = get_realm("zulip")-- with time_machine.travel(self.now, tick=False):- self.local_upgrade(- self.seat_count + 1, False, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False- )-- billing_session = RealmBillingSession(user=None, realm=realm)- plan = get_current_plan_by_realm(realm)- assert plan is not None-- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):- billing_session.update_license_ledger_for_manual_plan(- plan, self.now, licenses=self.seat_count + 3- )- self.assertEqual(plan.licenses(), self.seat_count + 3)- self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count + 3)-- with (- patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count),- self.assertRaises(AssertionError),- ):- billing_session.update_license_ledger_for_manual_plan(- plan, self.now, licenses=self.seat_count- )-- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):- billing_session.update_license_ledger_for_manual_plan(- plan, self.now, licenses_at_next_renewal=self.seat_count- )- self.assertEqual(plan.licenses(), self.seat_count + 3)- self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count)-- with (- patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count),- self.assertRaises(AssertionError),- ):- billing_session.update_license_ledger_for_manual_plan(- plan, self.now, licenses_at_next_renewal=self.seat_count - 1- )-- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):- billing_session.update_license_ledger_for_manual_plan(- plan, self.now, licenses=self.seat_count + 10- )- self.assertEqual(plan.licenses(), self.seat_count + 10)- self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count + 10)-- billing_session.make_end_of_cycle_updates_if_needed(plan, self.next_year)- self.assertEqual(plan.licenses(), self.seat_count + 10)-- ledger_entries = list(- LicenseLedger.objects.values_list(- "is_renewal", "event_time", "licenses", "licenses_at_next_renewal"- ).order_by("id")- )-- self.assertEqual(- ledger_entries,- [- (True, self.now, self.seat_count + 1, self.seat_count + 1),- (False, self.now, self.seat_count + 3, self.seat_count + 3),- (False, self.now, self.seat_count + 3, self.seat_count),- (False, self.now, self.seat_count + 10, self.seat_count + 10),- (True, self.next_year, self.seat_count + 10, self.seat_count + 10),- ],- )-- with self.assertRaises(AssertionError):- billing_session.update_license_ledger_for_manual_plan(plan, self.now)-- def test_user_changes(self) -> None:- self.local_upgrade(self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False)- user = do_create_user("email", "password", get_realm("zulip"), "name", acting_user=None)- do_deactivate_user(user, acting_user=None)- do_reactivate_user(user, acting_user=None)-- # Not a proper use of do_activate_mirror_dummy_user, but fine for this test- change_user_is_active(user, False)- user.is_mirror_dummy = True- user.save(update_fields=["is_mirror_dummy"])- do_activate_mirror_dummy_user(user, acting_user=None)- # Add a guest user- guest = do_create_user(- "guest_email",- "guest_password",- get_realm("zulip"),- "guest_name",- role=UserProfile.ROLE_GUEST,- acting_user=None,- )- # Change guest user role to member- self.set_user_role(guest, UserProfile.ROLE_MEMBER)- # Change again to moderator, no LicenseLedger created- self.set_user_role(guest, UserProfile.ROLE_MODERATOR)- ledger_entries = list(- LicenseLedger.objects.values_list(- "is_renewal", "licenses", "licenses_at_next_renewal"- ).order_by("id")- )- self.assertEqual(- ledger_entries,- [- (True, self.seat_count, self.seat_count),- (False, self.seat_count + 1, self.seat_count + 1),- (False, self.seat_count + 1, self.seat_count),- (False, self.seat_count + 1, self.seat_count + 1),- (False, self.seat_count + 1, self.seat_count + 1),- (False, self.seat_count + 1, self.seat_count + 1),- (False, self.seat_count + 2, self.seat_count + 2),- ],- )-- def test_toggle_license_management(self) -> None:- self.local_upgrade(self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False)- plan = get_current_plan_by_realm(get_realm("zulip"))- assert plan is not None- self.assertEqual(plan.automanage_licenses, True)- self.assertEqual(plan.licenses(), self.seat_count)- self.assertEqual(plan.licenses_at_next_renewal(), self.seat_count)- billing_session = RealmBillingSession(user=None, realm=get_realm("zulip"))- update_plan_request = UpdatePlanRequest(- status=None,- licenses=None,- licenses_at_next_renewal=None,- schedule=None,- toggle_license_management=True,- )- billing_session.do_update_plan(update_plan_request)- plan.refresh_from_db()- self.assertEqual(plan.automanage_licenses, False)-- billing_session.do_update_plan(update_plan_request)- plan.refresh_from_db()- self.assertEqual(plan.automanage_licenses, True)---class InvoiceTest(StripeTestCase):- def test_invoicing_status_is_started(self) -> None:- # local_upgrade uses hamlet as user, therefore realm is zulip.- self.local_upgrade(self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False)- plan = CustomerPlan.objects.first()- assert plan is not None- plan.invoicing_status = CustomerPlan.INVOICING_STATUS_STARTED- plan.save(update_fields=["invoicing_status"])- with self.assertRaises(NotImplementedError):- billing_session = RealmBillingSession(realm=get_realm("zulip"))- billing_session.invoice_plan(assert_is_not_none(CustomerPlan.objects.first()), self.now)-- def test_invoice_plan_without_stripe_customer(self) -> None:- # local_upgrade uses hamlet as user, therefore realm is zulip.- realm = get_realm("zulip")- self.local_upgrade(- self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, False, False- )- plan = get_current_plan_by_realm(realm)- assert plan is not None- plan.customer.stripe_customer_id = None- plan.customer.save(update_fields=["stripe_customer_id"])- with self.assertRaises(BillingError) as context:- billing_session = RealmBillingSession(realm=realm)- billing_session.invoice_plan(plan, timezone_now())- self.assertRegex(- context.exception.error_description,- "Customer has a paid plan without a Stripe customer ID:",- )-- @mock_stripe()- def test_validate_licenses_for_manual_plan_management(self, *mocks: Mock) -> None:- user = self.example_user("hamlet")- self.login_user(user)-- # Upgrade with one extra license- with (- time_machine.travel(self.now, tick=False),- patch("corporate.lib.stripe.MIN_INVOICED_LICENSES", 3),- ):- self.upgrade(invoice=True, licenses=self.seat_count + 1)-- # Set renewal licenses to current seat count- with (- time_machine.travel(self.now, tick=False),- patch("corporate.lib.stripe.MIN_INVOICED_LICENSES", 3),- ):- result = self.client_billing_patch(- "/billing/plan",- {"licenses_at_next_renewal": self.seat_count},- )- self.assert_json_success(result)-- # Add an extra user- do_create_user(- "email-extra-user",- "password-extra-user",- get_realm("zulip"),- "name-extra-user",- acting_user=None,- )- with self.assertLogs("corporate.stripe", level="ERROR") as m:- invoice_plans_as_needed(self.next_year)- self.assertIn(- "ERROR:corporate.stripe:Invoicing failed: Customer.id:",- m.output[0],- )- self.assertIn(- "Customer has not manually updated plan for current license count:",- m.output[0],- )-- @mock_stripe()- def test_invoice_plan(self, *mocks: Mock) -> None:- user = self.example_user("hamlet")- self.login_user(user)- with time_machine.travel(self.now, tick=False):- self.add_card_and_upgrade(user)- realm = get_realm("zulip")- billing_session = RealmBillingSession(user=user, realm=realm)- # Increase- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 3):- billing_session.update_license_ledger_if_needed(self.now + timedelta(days=100))- # Decrease- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count):- billing_session.update_license_ledger_if_needed(self.now + timedelta(days=200))- # Increase, but not past high watermark- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 1):- billing_session.update_license_ledger_if_needed(self.now + timedelta(days=300))- # Increase, but after renewal date, and below last year's high watermark- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 2):- billing_session.update_license_ledger_if_needed(self.now + timedelta(days=400))- # Increase, but after event_time- with patch("corporate.lib.stripe.get_latest_seat_count", return_value=self.seat_count + 3):- billing_session.update_license_ledger_if_needed(self.now + timedelta(days=500))- plan = CustomerPlan.objects.first()- assert plan is not None- billing_session.invoice_plan(plan, self.now + timedelta(days=400))- stripe_customer_id = plan.customer.stripe_customer_id- assert stripe_customer_id is not None- [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))- self.assertIsNotNone(invoice0.status_transitions.finalized_at)- [item0, item1, item2] = iter(invoice0.lines)-- self.assertEqual(item0.amount, int(8000 * (1 - ((400 - 366) / 365)) + 0.5))- self.assertEqual(item0.description, "Additional Zulip Cloud Standard license")- self.assertFalse(item0.discountable)- self.assertEqual(item0.period.start, datetime_to_timestamp(self.now + timedelta(days=400)))- self.assertEqual(- item0.period.end, datetime_to_timestamp(self.now + timedelta(days=2 * 365 + 1))- )- self.assertEqual(item0.quantity, 1)-- self.assertEqual(item1.amount, 3 * int(8000 * (366 - 100) / 366 + 0.5))- self.assertEqual(item1.description, "Additional Zulip Cloud Standard license")- self.assertFalse(item1.discountable)- self.assertEqual(item1.period.start, datetime_to_timestamp(self.now + timedelta(days=100)))- self.assertEqual(item1.period.end, datetime_to_timestamp(self.now + timedelta(days=366)))- self.assertEqual(item1.quantity, 3)-- self.assertEqual(item2.amount, 8000 * (self.seat_count + 1))- self.assertEqual(item2.description, "Zulip Cloud Standard - renewal")- self.assertFalse(item2.discountable)- self.assertEqual(item2.period.start, datetime_to_timestamp(self.now + timedelta(days=366)))- self.assertEqual(- item2.period.end, datetime_to_timestamp(self.now + timedelta(days=2 * 365 + 1))- )- self.assertEqual(item2.quantity, self.seat_count + 1)-- @mock_stripe()- def test_invoice_plan_bundle_additional_licenses(self, *mocks: Mock) -> None:- user = self.example_user("hamlet")- self.login_user(user)- with time_machine.travel(self.now, tick=False):- self.add_card_and_upgrade(user)- realm = get_realm("zulip")- billing_session = RealmBillingSession(user=user, realm=realm)- # Increase by 300 additional licenses in the first month of the- # annual plan.- updated_seat_count = self.seat_count- for i in range(50):- updated_seat_count += 1- with patch(- "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count- ):- billing_session.update_license_ledger_if_needed(- self.now + timedelta(days=10, seconds=i)- )- for i in range(100):- updated_seat_count += 1- with patch(- "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count- ):- billing_session.update_license_ledger_if_needed(- self.now + timedelta(days=15, seconds=i)- )- for i in range(100):- updated_seat_count += 1- with patch(- "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count- ):- billing_session.update_license_ledger_if_needed(- self.now + timedelta(days=20, seconds=i)- )- # Remove 20 active licenses to confirm we're still handling these ledger entries- # correctly when bundling.- for i in range(20):- updated_seat_count -= 1- with patch(- "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count- ):- billing_session.update_license_ledger_if_needed(- self.now + timedelta(days=22, seconds=i)- )- for i in range(70):- updated_seat_count += 1- with patch(- "corporate.lib.stripe.get_latest_seat_count", return_value=updated_seat_count- ):- billing_session.update_license_ledger_if_needed(- self.now + timedelta(days=25, seconds=i)- )- plan = CustomerPlan.objects.first()- assert plan is not None- billing_session.invoice_plan(plan, self.next_month)- stripe_customer_id = plan.customer.stripe_customer_id- assert stripe_customer_id is not None- [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))- self.assertIsNotNone(invoice0.status_transitions.finalized_at)- [item0, item1, item2, item3] = iter(invoice0.lines.data)-- self.assertEqual(item0.amount, 50 * int(8000 * (366 - 25) / 366 + 0.5))- self.assertEqual(item0.description, "Additional Zulip Cloud Standard license")- self.assertFalse(item0.discountable)- # We have to adjust the start datetime for the 20 license ledger- # entries (by 20 seconds) that were for licenses that were already- # paid for in the billing period.- self.assertEqual(- item0.period.start, datetime_to_timestamp(self.now + timedelta(days=25, seconds=20))- )- self.assertEqual(item0.period.end, datetime_to_timestamp(self.next_year))- self.assertEqual(item0.quantity, 50)-- self.assertEqual(item1.amount, 100 * int(8000 * (366 - 20) / 366 + 0.5))- self.assertEqual(item1.description, "Additional Zulip Cloud Standard license")- self.assertFalse(item1.discountable)- self.assertEqual(item1.period.start, datetime_to_timestamp(self.now + timedelta(days=20)))- self.assertEqual(item1.period.end, datetime_to_timestamp(self.next_year))- self.assertEqual(item1.quantity, 100)-- self.assertEqual(item2.amount, 100 * int(8000 * (366 - 15) / 366 + 0.5))- self.assertEqual(item2.description, "Additional Zulip Cloud Standard license")- self.assertFalse(item2.discountable)- self.assertEqual(item2.period.start, datetime_to_timestamp(self.now + timedelta(days=15)))- self.assertEqual(item2.period.end, datetime_to_timestamp(self.next_year))- self.assertEqual(item2.quantity, 100)-- self.assertEqual(item3.amount, 50 * int(8000 * (366 - 10) / 366 + 0.5))- self.assertEqual(item3.description, "Additional Zulip Cloud Standard license")- self.assertFalse(item3.discountable)- self.assertEqual(item3.period.start, datetime_to_timestamp(self.now + timedelta(days=10)))- self.assertEqual(item3.period.end, datetime_to_timestamp(self.next_year))- self.assertEqual(item3.quantity, 50)-- @mock_stripe()- def test_fixed_price_plans(self, *mocks: Mock) -> None:- # Also tests charge_automatically=False- user = self.example_user("hamlet")- self.login_user(user)- with time_machine.travel(self.now, tick=False):- self.upgrade(invoice=True)- plan = CustomerPlan.objects.first()- assert plan is not None- plan.fixed_price = 100- plan.price_per_license = 0- plan.save(update_fields=["fixed_price", "price_per_license"])- user.realm.refresh_from_db()- billing_session = RealmBillingSession(realm=user.realm)- billing_session.invoice_plan(plan, self.next_year)- stripe_customer_id = plan.customer.stripe_customer_id- assert stripe_customer_id is not None- [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))- self.assertEqual(invoice0.collection_method, "send_invoice")- [item] = iter(invoice0.lines)- self.assertEqual(item.amount, 100)- self.assertEqual(item.description, "Zulip Cloud Standard - renewal")- self.assertFalse(item.discountable)- self.assertEqual(item.period.start, datetime_to_timestamp(self.next_year))- self.assertEqual(- item.period.end, datetime_to_timestamp(self.next_year + timedelta(days=365))- )- self.assertEqual(item.quantity, 1)-- @mock_stripe()- def test_upgrade_to_fixed_price_plus_plan(self, *mocks: Mock) -> None:- iago = self.example_user("iago")- hamlet = self.example_user("hamlet")- realm = get_realm("zulip")- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_SELF_HOSTED)-- self.login_user(hamlet)- with time_machine.travel(self.now, tick=False):- self.upgrade(invoice=True)- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertIsNone(plan.end_date)- self.assertEqual(plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)- realm.refresh_from_db()- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)-- next_billing_cycle = get_next_billing_cycle_for_plan(plan)- plan_end_date_string = next_billing_cycle.date().isoformat()- plan_end_date = datetime.combine(- date.fromisoformat(plan_end_date_string), time(0, 0, 0), tzinfo=timezone.utc- )-- self.logout()- self.login_user(iago)-- result = self.client_post(- "/activity/support",- {- "realm_id": f"{realm.id}",- "required_plan_tier": f"{CustomerPlanOffer.TIER_CLOUD_PLUS}",- },- )- self.assert_in_success_response(- ["Required plan tier for zulip set to Zulip Cloud Plus."],- result,- )-- with time_machine.travel(self.now, tick=False):- result = self.client_post(- "/activity/support",- {- "realm_id": f"{realm.id}",- "plan_end_date": plan_end_date_string,- },- )- self.assert_in_success_response(- [f"Current plan for zulip updated to end on {plan_end_date_string}."],- result,- )-- plan.refresh_from_db()- self.assertEqual(plan.end_date, plan_end_date)-- result = self.client_post(- "/activity/support",- {- "realm_id": f"{realm.id}",- "fixed_price": 360,- },- )- self.assert_in_success_response(- [f"Fixed price Zulip Cloud Plus plan scheduled to start on {plan_end_date_string}."],- result,- )-- plan.refresh_from_db()- self.assertEqual(plan.status, CustomerPlan.SWITCH_PLAN_TIER_AT_PLAN_END)- self.assertEqual(plan.next_invoice_date, plan_end_date)- new_plan = CustomerPlan.objects.filter(fixed_price__isnull=False).first()- assert new_plan is not None- self.assertEqual(new_plan.next_invoice_date, plan_end_date)- self.assertEqual(- new_plan.invoicing_status, CustomerPlan.INVOICING_STATUS_INITIAL_INVOICE_TO_BE_SENT- )-- with time_machine.travel(next_billing_cycle, tick=False):- invoice_plans_as_needed()-- plan.refresh_from_db()- self.assertEqual(plan.status, CustomerPlan.ENDED)- self.assertEqual(plan.next_invoice_date, None)-- new_plan.refresh_from_db()- self.assertEqual(new_plan.tier, CustomerPlan.TIER_CLOUD_PLUS)- self.assertIsNotNone(new_plan.fixed_price)- self.assertIsNone(new_plan.price_per_license)-- realm.refresh_from_db()- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_PLUS)-- # Visit /billing- self.logout()- self.login_user(hamlet)- with time_machine.travel(plan_end_date + timedelta(days=1), tick=False):- response = self.client_get(f"{self.billing_session.billing_base_url}/billing/")- for substring in [- "Zulip Cloud Plus",- "Annual",- "Invoice",- "This is a fixed-price plan",- "You will be contacted by Zulip Sales",- ]:- self.assert_in_response(substring, response)- self.assert_not_in_success_response(["Update card"], response)-- def test_no_invoice_needed(self) -> None:- # local_upgrade uses hamlet as user, therefore realm is zulip.- with time_machine.travel(self.now, tick=False):- self.local_upgrade(- self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False- )- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.next_invoice_date, self.next_month)- # Test this doesn't make any calls to stripe.Invoice or stripe.InvoiceItem- assert plan.customer.realm is not None- billing_session = RealmBillingSession(realm=plan.customer.realm)- billing_session.invoice_plan(plan, self.next_month)- plan = CustomerPlan.objects.first()- # Test that we still update next_invoice_date- assert plan is not None- self.assertEqual(plan.next_invoice_date, self.next_month + timedelta(days=29))-- def test_invoice_plans_as_needed(self) -> None:- with time_machine.travel(self.now, tick=False):- self.local_upgrade(- self.seat_count, True, CustomerPlan.BILLING_SCHEDULE_ANNUAL, True, False- )- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.next_invoice_date, self.next_month)- # Test nothing needed to be done- with patch("corporate.lib.stripe.BillingSession.invoice_plan") as mocked:- invoice_plans_as_needed(self.next_month - timedelta(days=1))- mocked.assert_not_called()- # Test something needing to be done- invoice_plans_as_needed(self.next_month)- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.next_invoice_date, self.next_month + timedelta(days=29))-- @mock_stripe()- def test_invoice_for_additional_license(self, *mocks: Mock) -> None:- user = self.example_user("hamlet")- self.login_user(user)- with time_machine.travel(self.now, tick=False):- self.add_card_and_upgrade(user)- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.next_invoice_date, self.next_month)- assert plan.customer.realm is not None- realm = plan.customer.realm-- # Adding a guest user and then changing their role to member- # should invoice for a pro-rated license at the next invoice- # date on a plan with annual billing.- with time_machine.travel(self.now + timedelta(days=5), tick=False):- user = do_create_user(- "email",- "password",- realm,- "name",- role=UserProfile.ROLE_GUEST,- acting_user=None,- )-- with time_machine.travel(self.now + timedelta(days=10), tick=False):- self.set_user_role(user, UserProfile.ROLE_MEMBER)-- billing_session = RealmBillingSession(realm=realm)- billing_session.invoice_plan(plan, self.next_month)- plan = CustomerPlan.objects.first()- assert plan is not None- self.assertEqual(plan.next_invoice_date, self.next_month + timedelta(days=29))- stripe_customer_id = plan.customer.stripe_customer_id- assert stripe_customer_id is not None- [invoice0, _invoice1] = iter(stripe.Invoice.list(customer=stripe_customer_id))- self.assertIsNotNone(invoice0.status_transitions.finalized_at)- [item0] = iter(invoice0.lines)- self.assertEqual(item0.amount, int(8000 * (1 - ((366 - 356) / 366)) + 0.5))- self.assertEqual(item0.description, "Additional Zulip Cloud Standard license")- self.assertEqual(item0.quantity, 1)---class TestTestClasses(ZulipTestCase):- def test_subscribe_realm_to_manual_license_management_plan(self) -> None:- realm = get_realm("zulip")- plan, ledger = self.subscribe_realm_to_manual_license_management_plan(- realm, 50, 60, CustomerPlan.BILLING_SCHEDULE_ANNUAL- )-- plan.refresh_from_db()- self.assertEqual(plan.automanage_licenses, False)- self.assertEqual(plan.billing_schedule, CustomerPlan.BILLING_SCHEDULE_ANNUAL)- self.assertEqual(plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)- self.assertEqual(plan.licenses(), 50)- self.assertEqual(plan.licenses_at_next_renewal(), 60)-- ledger.refresh_from_db()- self.assertEqual(ledger.plan, plan)- self.assertEqual(ledger.licenses, 50)- self.assertEqual(ledger.licenses_at_next_renewal, 60)-- realm.refresh_from_db()- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)-- def test_subscribe_realm_to_monthly_plan_on_manual_license_management(self) -> None:- realm = get_realm("zulip")- plan, ledger = self.subscribe_realm_to_monthly_plan_on_manual_license_management(- realm, 20, 30- )-- plan.refresh_from_db()- self.assertEqual(plan.automanage_licenses, False)- self.assertEqual(plan.billing_schedule, CustomerPlan.BILLING_SCHEDULE_MONTHLY)- self.assertEqual(plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)- self.assertEqual(plan.licenses(), 20)- self.assertEqual(plan.licenses_at_next_renewal(), 30)-- ledger.refresh_from_db()- self.assertEqual(ledger.plan, plan)- self.assertEqual(ledger.licenses, 20)- self.assertEqual(ledger.licenses_at_next_renewal, 30)-- realm.refresh_from_db()- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD)---class TestRealmBillingSession(StripeTestCase):- def test_get_audit_log_error(self) -> None:- user = self.example_user("hamlet")- billing_session = RealmBillingSession(user)- fake_audit_log = typing.cast(BillingSessionEventType, 0)- with self.assertRaisesRegex(- BillingSessionAuditLogEventError, "Unknown audit log event type: 0"- ):- billing_session.get_audit_log_event(event_type=fake_audit_log)-- def test_get_customer(self) -> None:- user = self.example_user("hamlet")- billing_session = RealmBillingSession(user)- customer = billing_session.get_customer()- self.assertEqual(customer, None)-- customer = Customer.objects.create(realm=user.realm, stripe_customer_id="cus_12345")- self.assertEqual(billing_session.get_customer(), customer)---class TestSupportBillingHelpers(StripeTestCase):- @mock_stripe()- def test_attach_discount_to_realm(self, *mocks: Mock) -> None:- # Attach discount before Stripe customer exists- support_admin = self.example_user("iago")- user = self.example_user("hamlet")- billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)-- # Cannot attach discount without a required_plan_tier set.- with self.assertRaises(AssertionError):- billing_session.attach_discount_to_customer(- monthly_discounted_price=120,- annual_discounted_price=1200,- )- billing_session.update_or_create_customer()-- with self.assertRaises(AssertionError):- billing_session.attach_discount_to_customer(- monthly_discounted_price=120,- annual_discounted_price=1200,- )-- billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)- billing_session.attach_discount_to_customer(- monthly_discounted_price=120,- annual_discounted_price=1200,- )- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.REALM_DISCOUNT_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {- "new_annual_discounted_price": 1200,- "new_monthly_discounted_price": 120,- "old_annual_discounted_price": 0,- "old_monthly_discounted_price": 0,- }- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)- self.login_user(user)- # Check that the discount appears in page_params- self.assert_in_success_response(["85"], self.client_get("/upgrade/"))- # Check that the customer was charged the discounted amount- self.add_card_and_upgrade(user)- customer = Customer.objects.first()- assert customer is not None- assert customer.stripe_customer_id is not None- [charge] = iter(stripe.Charge.list(customer=customer.stripe_customer_id))- self.assertEqual(1200 * self.seat_count, charge.amount)- stripe_customer_id = customer.stripe_customer_id- assert stripe_customer_id is not None- [invoice] = iter(stripe.Invoice.list(customer=stripe_customer_id))- self.assertEqual(- [1200 * self.seat_count],- [item.amount for item in invoice.lines],- )- # Check CustomerPlan reflects the discount- plan = CustomerPlan.objects.get(price_per_license=1200, discount="85")-- # Attach discount to existing Stripe customer- plan.status = CustomerPlan.ENDED- plan.save(update_fields=["status"])- billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)- billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)- billing_session.attach_discount_to_customer(- monthly_discounted_price=600,- annual_discounted_price=6000,- )- with time_machine.travel(self.now, tick=False):- self.add_card_and_upgrade(- user, license_management="automatic", billing_modality="charge_automatically"- )- [charge, _] = iter(stripe.Charge.list(customer=customer.stripe_customer_id))- self.assertEqual(6000 * self.seat_count, charge.amount)- stripe_customer_id = customer.stripe_customer_id- assert stripe_customer_id is not None- [invoice, _] = iter(stripe.Invoice.list(customer=stripe_customer_id))- self.assertEqual(- [6000 * self.seat_count],- [item.amount for item in invoice.lines],- )- plan = CustomerPlan.objects.get(price_per_license=6000, discount=Decimal(25))-- billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)- billing_session.attach_discount_to_customer(- monthly_discounted_price=400,- annual_discounted_price=4000,- )- plan.refresh_from_db()- self.assertEqual(plan.price_per_license, 4000)- self.assertEqual(plan.discount, "50")- customer.refresh_from_db()- self.assertEqual(customer.monthly_discounted_price, 400)- self.assertEqual(customer.annual_discounted_price, 4000)- # Fast forward the next_invoice_date to next year.- plan.next_invoice_date = self.next_year- plan.save(update_fields=["next_invoice_date"])- invoice_plans_as_needed(self.next_year + timedelta(days=10))- stripe_customer_id = customer.stripe_customer_id- assert stripe_customer_id is not None- [invoice, _, _] = iter(stripe.Invoice.list(customer=stripe_customer_id))- self.assertEqual([4000 * self.seat_count], [item.amount for item in invoice.lines])- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.REALM_DISCOUNT_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {- "new_annual_discounted_price": 4000,- "new_monthly_discounted_price": 400,- "old_annual_discounted_price": 6000,- "old_monthly_discounted_price": 600,- }- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)- self.assertEqual(realm_audit_log.acting_user, support_admin)-- # Confirm that once a plan has been purchased and is active,- # approving a full sponsorship (our version of 100% discount) fails.- with self.assertRaisesRegex(- SupportRequestError,- "Customer on plan Zulip Cloud Standard. Please end current plan before approving sponsorship!",- ):- billing_session.approve_sponsorship()-- @mock_stripe()- def test_add_minimum_licenses(self, *mocks: Mock) -> None:- min_licenses = 25- support_view_request = SupportViewRequest(- support_type=SupportType.update_minimum_licenses, minimum_licenses=min_licenses- )- support_admin = self.example_user("iago")- user = self.example_user("hamlet")- billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)-- billing_session.update_or_create_customer()- with self.assertRaisesRegex(- SupportRequestError,- "Discount for zulip must be updated before setting a minimum number of licenses.",- ):- billing_session.process_support_view_request(support_view_request)-- billing_session.set_required_plan_tier(CustomerPlan.TIER_CLOUD_STANDARD)- billing_session.attach_discount_to_customer(- monthly_discounted_price=400,- annual_discounted_price=4000,- )- message = billing_session.process_support_view_request(support_view_request)- self.assertEqual("Minimum licenses for zulip changed to 25 from 0.", message)- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.CUSTOMER_PROPERTY_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {"old_value": None, "new_value": 25, "property": "minimum_licenses"}- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)-- self.login_user(user)- self.add_card_and_upgrade(user)- customer = billing_session.get_customer()- assert customer is not None- assert customer.stripe_customer_id is not None- [charge] = iter(stripe.Charge.list(customer=customer.stripe_customer_id))- self.assertEqual(4000 * min_licenses, charge.amount)-- min_licenses = 50- support_view_request = SupportViewRequest(- support_type=SupportType.update_minimum_licenses, minimum_licenses=min_licenses- )- with self.assertRaisesRegex(- SupportRequestError,- "Cannot set minimum licenses; active plan already exists for zulip.",- ):- billing_session.process_support_view_request(support_view_request)-- def test_set_required_plan_tier(self) -> None:- valid_plan_tier = CustomerPlan.TIER_CLOUD_STANDARD- support_view_request = SupportViewRequest(- support_type=SupportType.update_required_plan_tier,- required_plan_tier=valid_plan_tier,- )- support_admin = self.example_user("iago")- user = self.example_user("hamlet")- billing_session = RealmBillingSession(support_admin, realm=user.realm, support_session=True)- customer = billing_session.get_customer()- assert customer is None-- # Set valid plan tier - creates Customer object- message = billing_session.process_support_view_request(support_view_request)- self.assertEqual("Required plan tier for zulip set to Zulip Cloud Standard.", message)- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.CUSTOMER_PROPERTY_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {- "old_value": None,- "new_value": valid_plan_tier,- "property": "required_plan_tier",- }- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)- customer = billing_session.get_customer()- assert customer is not None- self.assertEqual(customer.required_plan_tier, valid_plan_tier)- self.assertEqual(customer.monthly_discounted_price, 0)- self.assertEqual(customer.annual_discounted_price, 0)-- # Check that discount is only applied to set plan tier- billing_session.attach_discount_to_customer(- monthly_discounted_price=400,- annual_discounted_price=4000,- )- customer.refresh_from_db()- self.assertEqual(customer.monthly_discounted_price, 400)- self.assertEqual(customer.annual_discounted_price, 4000)-- monthly_discounted_price = customer.get_discounted_price_for_plan(- valid_plan_tier, CustomerPlan.BILLING_SCHEDULE_MONTHLY- )- self.assertEqual(monthly_discounted_price, customer.monthly_discounted_price)- annual_discounted_price = customer.get_discounted_price_for_plan(- valid_plan_tier, CustomerPlan.BILLING_SCHEDULE_ANNUAL- )- self.assertEqual(annual_discounted_price, customer.annual_discounted_price)- monthly_discounted_price = customer.get_discounted_price_for_plan(- CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_MONTHLY- )- self.assertEqual(monthly_discounted_price, None)- annual_discounted_price = customer.get_discounted_price_for_plan(- CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_ANNUAL- )- self.assertEqual(annual_discounted_price, None)-- # Try to set invalid plan tier- invalid_plan_tier = CustomerPlan.TIER_SELF_HOSTED_BASE- support_view_request = SupportViewRequest(- support_type=SupportType.update_required_plan_tier,- required_plan_tier=invalid_plan_tier,- )- with self.assertRaisesRegex(SupportRequestError, "Invalid plan tier for zulip."):- billing_session.process_support_view_request(support_view_request)-- # Cannot set required plan tier to None before setting discount to 0.- support_view_request = SupportViewRequest(- support_type=SupportType.update_required_plan_tier, required_plan_tier=0- )- with self.assertRaisesRegex(- SupportRequestError,- "Discount for zulip must be 0 before setting required plan tier to None.",- ):- billing_session.process_support_view_request(support_view_request)-- billing_session.attach_discount_to_customer(- monthly_discounted_price=0,- annual_discounted_price=0,- )- message = billing_session.process_support_view_request(support_view_request)- self.assertEqual("Required plan tier for zulip set to None.", message)- customer.refresh_from_db()- self.assertIsNone(customer.required_plan_tier)- discount_for_standard_plan = customer.get_discounted_price_for_plan(- valid_plan_tier, CustomerPlan.BILLING_SCHEDULE_MONTHLY- )- self.assertEqual(discount_for_standard_plan, None)- discount_for_plus_plan = customer.get_discounted_price_for_plan(- CustomerPlan.TIER_CLOUD_PLUS, CustomerPlan.BILLING_SCHEDULE_MONTHLY- )- self.assertEqual(discount_for_plus_plan, None)- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.CUSTOMER_PROPERTY_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {- "old_value": valid_plan_tier,- "new_value": None,- "property": "required_plan_tier",- }- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)-- def test_approve_realm_sponsorship(self) -> None:- realm = get_realm("zulip")- self.assertNotEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD_FREE)-- support_admin = self.example_user("iago")- billing_session = RealmBillingSession(user=support_admin, realm=realm, support_session=True)- billing_session.approve_sponsorship()- self.assertEqual(realm.plan_type, Realm.PLAN_TYPE_STANDARD_FREE)-- expected_message = (- "Your organization's request for sponsored hosting has been approved! You have been upgraded to Zulip Cloud Standard, free of charge. :tada:"- "\n\nIf you could [list Zulip as a sponsor on your website](/help/linking-to-zulip-website), we would really appreciate it!"- )- sender = get_system_bot(settings.NOTIFICATION_BOT, realm.id)-- # Organization owners get the notification bot message- bot_and_desdemona_recipient = self.get_dm_group_recipient(- sender, self.example_user("desdemona")- )- message_to_owner = Message.objects.filter(- realm_id=realm.id, sender=sender.id, recipient=bot_and_desdemona_recipient- ).first()- assert message_to_owner is not None- self.assertEqual(message_to_owner.content, expected_message)- self.assertEqual(message_to_owner.recipient.type, Recipient.DIRECT_MESSAGE_GROUP)-- # Hamlet is in `can_manage_billing_group` so should get the notification bot message- bot_and_hamlet_recipient = self.get_dm_group_recipient(sender, self.example_user("hamlet"))- message_to_hamlet = Message.objects.filter(- realm_id=realm.id, sender=sender.id, recipient=bot_and_hamlet_recipient- ).last()- assert message_to_hamlet is not None- self.assertEqual(message_to_hamlet.content, expected_message)- self.assertEqual(message_to_hamlet.recipient.type, Recipient.DIRECT_MESSAGE_GROUP)-- def test_update_realm_sponsorship_status(self) -> None:- lear = get_realm("lear")- iago = self.example_user("iago")- billing_session = RealmBillingSession(user=iago, realm=lear, support_session=True)- billing_session.update_customer_sponsorship_status(True)- customer = get_customer_by_realm(realm=lear)- assert customer is not None- self.assertTrue(customer.sponsorship_pending)- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.REALM_SPONSORSHIP_PENDING_STATUS_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {"sponsorship_pending": True}- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)- self.assertEqual(realm_audit_log.acting_user, iago)-- def test_update_realm_billing_modality(self) -> None:- realm = get_realm("zulip")- customer = Customer.objects.create(realm=realm, stripe_customer_id="cus_12345")- plan = CustomerPlan.objects.create(- customer=customer,- status=CustomerPlan.ACTIVE,- billing_cycle_anchor=timezone_now(),- billing_schedule=CustomerPlan.BILLING_SCHEDULE_ANNUAL,- tier=CustomerPlan.TIER_CLOUD_STANDARD,- )- self.assertEqual(plan.charge_automatically, False)-- support_admin = self.example_user("iago")- billing_session = RealmBillingSession(user=support_admin, realm=realm, support_session=True)- billing_session.update_billing_modality_of_current_plan(True)- plan.refresh_from_db()- self.assertEqual(plan.charge_automatically, True)- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.REALM_BILLING_MODALITY_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {"charge_automatically": plan.charge_automatically}- self.assertEqual(realm_audit_log.acting_user, support_admin)- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)-- billing_session.update_billing_modality_of_current_plan(False)- plan.refresh_from_db()- self.assertEqual(plan.charge_automatically, False)- realm_audit_log = RealmAuditLog.objects.filter(- event_type=AuditLogEventType.REALM_BILLING_MODALITY_CHANGED- ).last()- assert realm_audit_log is not None- expected_extra_data = {"charge_automatically": plan.charge_automatically}- self.assertEqual(realm_audit_log.acting_user, support_admin)- self.assertEqual(realm_audit_log.extra_data, expected_extra_data)-- @mock_stripe()- def test_switch_realm_from_standard_to_plus_plan(self, *mocks: Mock) -> None:- user = self.example_user("hamlet")- self.login_user(user)- self.add_card_and_upgrade(user)- customer = get_customer_by_realm(user.realm)- assert customer is not None- original_plan = get_current_plan_by_customer(customer)- assert original_plan is not None- self.assertEqual(original_plan.tier, CustomerPlan.TIER_CLOUD_STANDARD)-- support_admin = self.example_user("iago")- billing_session = RealmBillingSession(- user=support_admin, realm=user.realm, support_session=True- )- support_request = SupportViewRequest(- support_type=SupportType.modify_plan,- plan_modification="upgrade_plan_tier",- new_plan_tier=CustomerPlan.TIER_CLOUD_PLUS,- )- # Freeze time so the prorated credit (computed inside- # ``change_plan_tier`` from ``timezone_now()``) doesn't drift- # between fixture regenerations.- with time_machine.travel(self.now, tick=False):- success_message = billing_session.process_support_view_request(support_request)- self.assertEqual(success_message, "zulip upgraded to Zulip Cloud Plus")- customer.refresh_from_db()- new_plan = get_current_plan_by_customer(customer)- assert new_plan is not None- self.assertEqual(new_plan.tier, CustomerPlan.TIER_CLOUD_PLUS)-- @mock_stripe()- def test_downgrade_realm_and_void_open_invoices(self, *mocks: Mock) -> None:- user = self.example_user("hamlet")- self.login_user(user)- with time_machine.travel(self.now, tick=False):- self.upgrade(invoice=True)- customer = get_customer_by_realm(user.realm)- assert customer is not None- original_plan = get_current_plan_by_customer(customer)- assert original_plan is not None- self.assertEqual(original_plan.status, CustomerPlan.ACTIVE)-- support_admin = self.example_user("iago")- billing_session = RealmBillingSession(- user=support_admin, realm=user.realm, support_session=True- )-- # Send renewal invoice.- invoice_plans_as_needed(self.now + timedelta(days=367))-- support_request = SupportViewRequest(- support_type=SupportType.modify_plan,- plan_modification="downgrade_now_void_open_invoices",- )- success_message = billing_session.process_support_view_request(support_request)- self.assertEqual(success_message, "zulip downgraded and voided 1 open invoices")- original_plan.refresh_from_db()- self.assertEqual(original_plan.status, CustomerPlan.ENDED)---class TestRemoteBillingWriteAuditLog(StripeTestCase):- def test_write_audit_log(self) -> None:- support_admin = self.example_user("iago")- server_uuid = str(uuid.uuid4())- remote_server = RemoteZulipServer.objects.create(- uuid=server_uuid,- api_key="magic_secret_api_key",- hostname="demo.example.com",- contact_email="[email protected]",- )- realm_uuid = str(uuid.uuid4())- remote_realm = RemoteRealm.objects.create(- server=remote_server,- uuid=realm_uuid,- uuid_owner_secret="dummy-owner-secret",- host="dummy-hostname",- realm_date_created=timezone_now(),- )- remote_realm_billing_user = RemoteRealmBillingUser.objects.create(- remote_realm=remote_realm, email="[email protected]", user_uuid=uuid.uuid4()- )- remote_server_billing_user = RemoteServerBillingUser.objects.create(- remote_server=remote_server, email="[email protected]"- )- event_time = timezone_now()-- def assert_audit_log(- audit_log: RemoteRealmAuditLog | RemoteZulipServerAuditLog,- acting_remote_user: RemoteRealmBillingUser | RemoteServerBillingUser | None,- acting_support_user: UserProfile | None,- event_type: int,- event_time: datetime,- ) -> None:- self.assertEqual(audit_log.event_type, event_type)- self.assertEqual(audit_log.event_time, event_time)- self.assertEqual(audit_log.acting_remote_user, acting_remote_user)- self.assertEqual(audit_log.acting_support_user, acting_support_user)-- for session_class, audit_log_class, remote_object, remote_user in [- (- RemoteRealmBillingSession,- RemoteRealmAuditLog,- remote_realm,- remote_realm_billing_user,- ),- (- RemoteServerBillingSession,- RemoteZulipServerAuditLog,- remote_server,- remote_server_billing_user,- ),- ]:- # Necessary cast or mypy doesn't understand that we can use Django's- # model .objects. style queries on this.- audit_log_model = cast(- type[RemoteRealmAuditLog] | type[RemoteZulipServerAuditLog], audit_log_class- )- assert isinstance(remote_user, RemoteRealmBillingUser | RemoteServerBillingUser)- # No acting user:- session = session_class(remote_object)- session.write_to_audit_log(- # This "ordinary billing" event type value gets translated by write_to_audit_log- # into a AuditLogEventType.CUSTOMER_PLAN_CREATED value.- event_type=BillingSessionEventType.CUSTOMER_PLAN_CREATED,- event_time=event_time,- )- audit_log = audit_log_model.objects.latest("id")- assert_audit_log(- audit_log, None, None, AuditLogEventType.CUSTOMER_PLAN_CREATED, event_time- )-- session = session_class(remote_object, remote_billing_user=remote_user)- session.write_to_audit_log(- event_type=BillingSessionEventType.CUSTOMER_PLAN_CREATED,- event_time=event_time,- )- audit_log = audit_log_model.objects.latest("id")- assert_audit_log(- audit_log, remote_user, None, AuditLogEventType.CUSTOMER_PLAN_CREATED, event_time- )-- session = session_class(- remote_object, remote_billing_user=None, support_staff=support_admin- )- session.write_to_audit_log(- event_type=BillingSessionEventType.CUSTOMER_PLAN_CREATED,- event_time=event_time,- )- audit_log = audit_log_model.objects.latest("id")- assert_audit_log(- audit_log, None, support_admin, AuditLogEventType.CUSTOMER_PLAN_CREATED, event_time- )diff --git a/tools/test-backend b/tools/test-backendindex c8eaeede402..6db4a29f2f1 100755--- a/tools/test-backend+++ b/tools/test-backend@@ -385,6 +385,7 @@ def main() -> None:if options.generate_stripe_fixtures:if full_suite:suites = [+ "corporate.tests.test_billing_lib","corporate.tests.test_sponsorship","corporate.tests.test_stripe","corporate.tests.test_stripe_remote_realm",