collab: Use StripeClient in StripeBilling::subscribe_to_price (#31631)

This PR updates the `StripeBilling::subscribe_to_price` method to use
the `StripeClient` trait.

Release Notes:

- N/A

crates/collab/src/stripe_client/fake_stripe_client.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use anyhow::Result;
+use anyhow::{Result, anyhow};
 use async_trait::async_trait;
 use collections::HashMap;
 use parking_lot::Mutex;
@@ -8,11 +8,15 @@ use uuid::Uuid;
 
 use crate::stripe_client::{
     CreateCustomerParams, StripeClient, StripeCustomer, StripeCustomerId, StripeMeter,
-    StripeMeterId, StripePrice, StripePriceId,
+    StripeMeterId, StripePrice, StripePriceId, StripeSubscription, StripeSubscriptionId,
+    UpdateSubscriptionParams,
 };
 
 pub struct FakeStripeClient {
     pub customers: Arc<Mutex<HashMap<StripeCustomerId, StripeCustomer>>>,
+    pub subscriptions: Arc<Mutex<HashMap<StripeSubscriptionId, StripeSubscription>>>,
+    pub update_subscription_calls:
+        Arc<Mutex<Vec<(StripeSubscriptionId, UpdateSubscriptionParams)>>>,
     pub prices: Arc<Mutex<HashMap<StripePriceId, StripePrice>>>,
     pub meters: Arc<Mutex<HashMap<StripeMeterId, StripeMeter>>>,
 }
@@ -21,6 +25,8 @@ impl FakeStripeClient {
     pub fn new() -> Self {
         Self {
             customers: Arc::new(Mutex::new(HashMap::default())),
+            subscriptions: Arc::new(Mutex::new(HashMap::default())),
+            update_subscription_calls: Arc::new(Mutex::new(Vec::new())),
             prices: Arc::new(Mutex::new(HashMap::default())),
             meters: Arc::new(Mutex::new(HashMap::default())),
         }
@@ -52,6 +58,31 @@ impl StripeClient for FakeStripeClient {
         Ok(customer)
     }
 
+    async fn get_subscription(
+        &self,
+        subscription_id: &StripeSubscriptionId,
+    ) -> Result<StripeSubscription> {
+        self.subscriptions
+            .lock()
+            .get(subscription_id)
+            .cloned()
+            .ok_or_else(|| anyhow!("no subscription found for {subscription_id:?}"))
+    }
+
+    async fn update_subscription(
+        &self,
+        subscription_id: &StripeSubscriptionId,
+        params: UpdateSubscriptionParams,
+    ) -> Result<()> {
+        let subscription = self.get_subscription(subscription_id).await?;
+
+        self.update_subscription_calls
+            .lock()
+            .push((subscription.id, params));
+
+        Ok(())
+    }
+
     async fn list_prices(&self) -> Result<Vec<StripePrice>> {
         let prices = self.prices.lock().values().cloned().collect();
 

crates/collab/src/stripe_client/real_stripe_client.rs

@@ -4,11 +4,17 @@ use std::sync::Arc;
 use anyhow::{Context as _, Result};
 use async_trait::async_trait;
 use serde::Serialize;
-use stripe::{CreateCustomer, Customer, CustomerId, ListCustomers, Price, PriceId, Recurring};
+use stripe::{
+    CreateCustomer, Customer, CustomerId, ListCustomers, Price, PriceId, Recurring, Subscription,
+    SubscriptionId, SubscriptionItem, SubscriptionItemId, UpdateSubscriptionItems,
+    UpdateSubscriptionTrialSettings, UpdateSubscriptionTrialSettingsEndBehavior,
+    UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod,
+};
 
 use crate::stripe_client::{
     CreateCustomerParams, StripeClient, StripeCustomer, StripeCustomerId, StripeMeter, StripePrice,
-    StripePriceId, StripePriceRecurring,
+    StripePriceId, StripePriceRecurring, StripeSubscription, StripeSubscriptionId,
+    StripeSubscriptionItem, StripeSubscriptionItemId, UpdateSubscriptionParams,
 };
 
 pub struct RealStripeClient {
@@ -53,6 +59,46 @@ impl StripeClient for RealStripeClient {
         Ok(StripeCustomer::from(customer))
     }
 
+    async fn get_subscription(
+        &self,
+        subscription_id: &StripeSubscriptionId,
+    ) -> Result<StripeSubscription> {
+        let subscription_id = subscription_id.try_into()?;
+
+        let subscription = Subscription::retrieve(&self.client, &subscription_id, &[]).await?;
+
+        Ok(StripeSubscription::from(subscription))
+    }
+
+    async fn update_subscription(
+        &self,
+        subscription_id: &StripeSubscriptionId,
+        params: UpdateSubscriptionParams,
+    ) -> Result<()> {
+        let subscription_id = subscription_id.try_into()?;
+
+        stripe::Subscription::update(
+            &self.client,
+            &subscription_id,
+            stripe::UpdateSubscription {
+                items: params.items.map(|items| {
+                    items
+                        .into_iter()
+                        .map(|item| UpdateSubscriptionItems {
+                            price: item.price.map(|price| price.to_string()),
+                            ..Default::default()
+                        })
+                        .collect()
+                }),
+                trial_settings: params.trial_settings.map(Into::into),
+                ..Default::default()
+            },
+        )
+        .await?;
+
+        Ok(())
+    }
+
     async fn list_prices(&self) -> Result<Vec<StripePrice>> {
         let response = stripe::Price::list(
             &self.client,
@@ -108,6 +154,80 @@ impl From<Customer> for StripeCustomer {
     }
 }
 
+impl From<SubscriptionId> for StripeSubscriptionId {
+    fn from(value: SubscriptionId) -> Self {
+        Self(value.as_str().into())
+    }
+}
+
+impl TryFrom<&StripeSubscriptionId> for SubscriptionId {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &StripeSubscriptionId) -> Result<Self, Self::Error> {
+        Self::from_str(value.0.as_ref()).context("failed to parse Stripe subscription ID")
+    }
+}
+
+impl From<Subscription> for StripeSubscription {
+    fn from(value: Subscription) -> Self {
+        Self {
+            id: value.id.into(),
+            items: value.items.data.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<SubscriptionItemId> for StripeSubscriptionItemId {
+    fn from(value: SubscriptionItemId) -> Self {
+        Self(value.as_str().into())
+    }
+}
+
+impl From<SubscriptionItem> for StripeSubscriptionItem {
+    fn from(value: SubscriptionItem) -> Self {
+        Self {
+            id: value.id.into(),
+            price: value.price.map(Into::into),
+        }
+    }
+}
+
+impl From<crate::stripe_client::UpdateSubscriptionTrialSettings>
+    for UpdateSubscriptionTrialSettings
+{
+    fn from(value: crate::stripe_client::UpdateSubscriptionTrialSettings) -> Self {
+        Self {
+            end_behavior: value.end_behavior.into(),
+        }
+    }
+}
+
+impl From<crate::stripe_client::UpdateSubscriptionTrialSettingsEndBehavior>
+    for UpdateSubscriptionTrialSettingsEndBehavior
+{
+    fn from(value: crate::stripe_client::UpdateSubscriptionTrialSettingsEndBehavior) -> Self {
+        Self {
+            missing_payment_method: value.missing_payment_method.into(),
+        }
+    }
+}
+
+impl From<crate::stripe_client::UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod>
+    for UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod
+{
+    fn from(
+        value: crate::stripe_client::UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod,
+    ) -> Self {
+        match value {
+            crate::stripe_client::UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod::Cancel => Self::Cancel,
+            crate::stripe_client::UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod::CreateInvoice => {
+                Self::CreateInvoice
+            }
+            crate::stripe_client::UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod::Pause => Self::Pause,
+        }
+    }
+}
+
 impl From<PriceId> for StripePriceId {
     fn from(value: PriceId) -> Self {
         Self(value.as_str().into())