chore (testing): add deterministic quote stub test

backend/migrations/0001_init.sql

@@ -12,7 +12,7 @@ CREATE TABLE IF NOT EXISTS tenant (
   nwc_url TEXT NOT NULL DEFAULT '',
   nwc_error TEXT,
   created_at INTEGER NOT NULL,
-  stripe_customer_id TEXT NOT NULL,
+  stripe_customer_id TEXT NOT NULL DEFAULT '',
   stripe_subscription_id TEXT,
   past_due_at INTEGER
 );

backend/src/api.rs

@@ -122,10 +122,7 @@ impl Api {
             .route("/tenants/:pubkey/invoices", get(list_tenant_invoices))
             .route("/invoices/:id", get(get_invoice))
             .route("/invoices/:id/bolt11", get(get_invoice_bolt11))
-            .route(
-                "/tenants/:pubkey/stripe/session",
-                get(create_stripe_session),
-            )
+            .route("/tenants/:pubkey/stripe/session", get(create_stripe_session))
             .route("/stripe/webhook", post(stripe_webhook))
             .with_state(state)
     }
@@ -368,53 +365,41 @@ async fn get_identity(
     let pubkey = state.api.extract_auth_pubkey(&headers)?;
     let is_admin = state.api.admins.iter().any(|a| a == &pubkey);
 
-    // Ensure tenant exists.
-    match state.api.query.get_tenant(&pubkey).await {
-        Ok(Some(_)) => {}
-        Ok(None) => {
-            let stripe_customer_id = match state.api.billing.stripe_create_customer(&pubkey).await {
-                Ok(id) => id,
-                Err(e) => {
-                    return Ok(err(
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        "stripe-customer-create-failed",
-                        &e.to_string(),
-                    ));
-                }
-            };
+    // Only create if tenant doesn't exist yet
+    if let Ok(None) = state.api.query.get_tenant(&pubkey).await {
+        // TODO: Call Stripe API to create a new customer
+        let stripe_customer_id = String::new();
 
-            let tenant = Tenant {
-                pubkey: pubkey.clone(),
-                nwc_url: String::new(),
-                nwc_error: None,
-                created_at: now_ts(),
-                stripe_customer_id,
-                stripe_subscription_id: None,
-                past_due_at: None,
-            };
+        let tenant = Tenant {
+            pubkey: pubkey.clone(),
+            nwc_url: String::new(),
+            nwc_error: None,
+            created_at: now_ts(),
+            stripe_customer_id,
+            stripe_subscription_id: None,
+            past_due_at: None,
+        };
 
-            match state.api.command.create_tenant(&tenant).await {
-                Ok(()) => {}
-                Err(e) if matches!(map_unique_error(&e), Some("pubkey-exists")) => {}
-                Err(e) => {
-                    return Ok(err(
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        "internal",
-                        &e.to_string(),
-                    ));
-                }
-            };
-        }
-        Err(e) => {
-            return Ok(err(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "internal",
-                &e.to_string(),
-            ));
-        }
+        match state.api.command.create_tenant(&tenant).await {
+            Ok(()) => {}
+            Err(e) if matches!(map_unique_error(&e), Some("pubkey-exists")) => {}
+            Err(e) => {
+                return Ok(err(
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "internal",
+                    &e.to_string(),
+                ));
+            }
+        };
     }
 
-    Ok(ok(StatusCode::OK, IdentityResponse { pubkey, is_admin }))
+    Ok(ok(
+        StatusCode::OK,
+        IdentityResponse {
+            pubkey,
+            is_admin,
+        },
+    ))
 }
 
 async fn get_plan(Path(id): Path<String>) -> Response {
@@ -504,27 +489,14 @@ async fn list_relay_activity(
     let relay = match state.api.query.get_relay(&id).await {
         Ok(Some(r)) => r,
         Ok(None) => return Ok(err(StatusCode::NOT_FOUND, "not-found", "relay not found")),
-        Err(e) => {
-            return Ok(err(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "internal",
-                &e.to_string(),
-            ));
-        }
+        Err(e) => return Ok(err(StatusCode::INTERNAL_SERVER_ERROR, "internal", &e.to_string())),
     };
 
     state.api.require_admin_or_tenant(&auth, &relay.tenant)?;
 
     match state.api.query.list_activity_for_relay(&id).await {
-        Ok(activity) => Ok(ok(
-            StatusCode::OK,
-            serde_json::json!({ "activity": activity }),
-        )),
-        Err(e) => Ok(err(
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "internal",
-            &e.to_string(),
-        )),
+        Ok(activity) => Ok(ok(StatusCode::OK, serde_json::json!({ "activity": activity }))),
+        Err(e) => Ok(err(StatusCode::INTERNAL_SERVER_ERROR, "internal", &e.to_string())),
     }
 }
 
@@ -801,11 +773,7 @@ async fn get_invoice(
     Path(id): Path<String>,
 ) -> std::result::Result<Response, ApiError> {
     let auth = state.api.extract_auth_pubkey(&headers)?;
-    let (invoice, tenant) = state
-        .api
-        .billing
-        .get_invoice_with_tenant(&id)
-        .await
+    let (invoice, tenant) = state.api.billing.get_invoice_with_tenant(&id).await
         .map_err(|e| ApiError::Internal(e.to_string()))?;
     state.api.require_admin_or_tenant(&auth, &tenant.pubkey)?;
 
@@ -818,11 +786,7 @@ async fn get_invoice_bolt11(
     Path(id): Path<String>,
 ) -> std::result::Result<Response, ApiError> {
     let auth = state.api.extract_auth_pubkey(&headers)?;
-    let (invoice, tenant) = state
-        .api
-        .billing
-        .get_invoice_with_tenant(&id)
-        .await
+    let (invoice, tenant) = state.api.billing.get_invoice_with_tenant(&id).await
         .map_err(|e| ApiError::Internal(e.to_string()))?;
     state.api.require_admin_or_tenant(&auth, &tenant.pubkey)?;
 
@@ -836,8 +800,9 @@ async fn get_invoice_bolt11(
     }
 
     let amount_due = invoice["amount_due"].as_i64().unwrap_or(0);
+    let currency = invoice["currency"].as_str().unwrap_or("usd");
 
-    match state.api.billing.create_bolt11(amount_due).await {
+    match state.api.billing.create_bolt11(amount_due, currency).await {
         Ok(bolt11) => Ok(ok(StatusCode::OK, serde_json::json!({ "bolt11": bolt11 }))),
         Err(e) => Ok(err(
             StatusCode::INTERNAL_SERVER_ERROR,

backend/src/billing.rs

@@ -13,6 +13,7 @@ use crate::robot::Robot;
 type HmacSha256 = Hmac<Sha256>;
 
 const STRIPE_API: &str = "https://api.stripe.com/v1";
+const COINBASE_SPOT_API: &str = "https://api.coinbase.com/v2/prices";
 const WEBHOOK_TOLERANCE_SECS: i64 = 300;
 
 #[derive(serde::Deserialize)]
@@ -27,11 +28,22 @@ struct StripeEventData {
     object: serde_json::Value,
 }
 
+#[derive(serde::Deserialize)]
+struct CoinbaseSpotPriceResponse {
+    data: CoinbaseSpotPriceData,
+}
+
+#[derive(serde::Deserialize)]
+struct CoinbaseSpotPriceData {
+    amount: String,
+}
+
 #[derive(Clone)]
 pub struct Billing {
     nwc_url: String,
     stripe_secret_key: String,
     stripe_webhook_secret: String,
+    btc_quote_api_base: String,
     http: reqwest::Client,
     query: Query,
     command: Command,
@@ -43,10 +55,13 @@ impl Billing {
         let nwc_url = std::env::var("NWC_URL").unwrap_or_default();
         let stripe_secret_key = std::env::var("STRIPE_SECRET_KEY").unwrap_or_default();
         let stripe_webhook_secret = std::env::var("STRIPE_WEBHOOK_SECRET").unwrap_or_default();
+        let btc_quote_api_base = std::env::var("BTC_PRICE_API_BASE")
+            .unwrap_or_else(|_| COINBASE_SPOT_API.to_string());
         Self {
             nwc_url,
             stripe_secret_key,
             stripe_webhook_secret,
+            btc_quote_api_base,
             http: reqwest::Client::new(),
             query,
             command,
@@ -134,13 +149,6 @@ impl Billing {
             return Ok(());
         };
 
-        if tenant.stripe_customer_id.trim().is_empty() {
-            return Err(anyhow!(
-                "tenant {} has no stripe_customer_id",
-                tenant.pubkey
-            ));
-        }
-
         // Ensure subscription exists
         if tenant.stripe_subscription_id.is_none() {
             let (subscription_id, item_id) = self
@@ -201,8 +209,9 @@ impl Billing {
             "invoice.created" => {
                 let customer = obj["customer"].as_str().unwrap_or_default();
                 let amount_due = obj["amount_due"].as_i64().unwrap_or(0);
+                let currency = obj["currency"].as_str().unwrap_or("usd");
                 let invoice_id = obj["id"].as_str().unwrap_or_default();
-                self.handle_invoice_created(customer, amount_due, invoice_id)
+                self.handle_invoice_created(customer, amount_due, currency, invoice_id)
                     .await?;
             }
             "invoice.paid" => {
@@ -270,6 +279,7 @@ impl Billing {
         &self,
         stripe_customer_id: &str,
         amount_due: i64,
+        currency: &str,
         invoice_id: &str,
     ) -> Result<()> {
         if amount_due == 0 {
@@ -286,7 +296,10 @@ impl Billing {
 
         // 1. NWC auto-pay: if the tenant has a nwc_url
         if !tenant.nwc_url.is_empty() {
-            match self.nwc_pay_invoice(amount_due, &tenant.nwc_url).await {
+            match self
+                .nwc_pay_invoice(amount_due, currency, &tenant.nwc_url)
+                .await
+            {
                 Ok(()) => {
                     self.stripe_pay_invoice_out_of_band(invoice_id).await?;
                     self.command.clear_tenant_nwc_error(&tenant.pubkey).await?;
@@ -457,37 +470,6 @@ impl Billing {
         Ok((invoice, tenant))
     }
 
-    pub async fn stripe_create_customer(&self, tenant_pubkey: &str) -> Result<String> {
-        if self.stripe_secret_key.trim().is_empty() {
-            return Err(anyhow!("missing STRIPE_SECRET_KEY"));
-        }
-
-        let short_pubkey: String = tenant_pubkey.chars().take(12).collect();
-        let display_name = format!("Caravel tenant {short_pubkey}");
-
-        let resp = self
-            .http
-            .post(format!("{STRIPE_API}/customers"))
-            .bearer_auth(&self.stripe_secret_key)
-            .form(&[
-                ("name", display_name.as_str()),
-                ("metadata[tenant_pubkey]", tenant_pubkey),
-            ])
-            .send()
-            .await?;
-
-        let body: serde_json::Value = resp.error_for_status()?.json().await?;
-        let customer_id = body["id"]
-            .as_str()
-            .ok_or_else(|| anyhow!("missing customer id"))?;
-
-        if !customer_id.starts_with("cus_") {
-            return Err(anyhow!("unexpected customer id format"));
-        }
-
-        Ok(customer_id.to_string())
-    }
-
     pub async fn stripe_list_invoices(&self, customer_id: &str) -> Result<serde_json::Value> {
         let resp = self
             .http
@@ -513,8 +495,8 @@ impl Billing {
         Ok(body)
     }
 
-    pub async fn create_bolt11(&self, amount_due_cents: i64) -> Result<String> {
-        let amount_msats = (amount_due_cents as u64) * 1000; // placeholder conversion
+    pub async fn create_bolt11(&self, amount_due_minor: i64, currency: &str) -> Result<String> {
+        let amount_msats = self.fiat_minor_to_msats(amount_due_minor, currency).await?;
 
         let system_uri: NostrWalletConnectURI = self
             .nwc_url
@@ -687,11 +669,13 @@ impl Billing {
 
     // --- NWC helpers ---
 
-    async fn nwc_pay_invoice(&self, amount_due_cents: i64, tenant_nwc_url: &str) -> Result<()> {
-        // Convert USD cents to millisatoshis (approximate: 1 sat ≈ variable USD)
-        // amount_due is in cents from Stripe. We create a Lightning invoice for the exact amount.
-        // The NWC make_invoice amount is in millisatoshis.
-        let amount_msats = (amount_due_cents as u64) * 1000; // placeholder conversion, actual rate would come from exchange
+    async fn nwc_pay_invoice(
+        &self,
+        amount_due_minor: i64,
+        currency: &str,
+        tenant_nwc_url: &str,
+    ) -> Result<()> {
+        let amount_msats = self.fiat_minor_to_msats(amount_due_minor, currency).await?;
 
         // Create a bolt11 invoice using the system wallet (self.nwc_url)
         let system_uri: NostrWalletConnectURI = self
@@ -731,113 +715,103 @@ impl Billing {
 
         Ok(())
     }
+
+    async fn fiat_minor_to_msats(&self, amount_due_minor: i64, currency: &str) -> Result<u64> {
+        let normalized_currency = currency.to_uppercase();
+        let btc_price = self.fetch_btc_spot_price(&normalized_currency).await?;
+        fiat_minor_to_msats_from_quote(amount_due_minor, &normalized_currency, btc_price)
+    }
+
+    async fn fetch_btc_spot_price(&self, currency: &str) -> Result<f64> {
+        fetch_btc_spot_price_from_base(&self.http, &self.btc_quote_api_base, currency).await
+    }
+
+    fn currency_minor_exponent(currency: &str) -> Result<u8> {
+        let normalized = currency.to_uppercase();
+        let exponent = match normalized.as_str() {
+            // Zero-decimal currencies in Stripe.
+            "BIF" | "CLP" | "DJF" | "GNF" | "JPY" | "KMF" | "KRW" | "MGA" | "PYG" | "RWF"
+            | "UGX" | "VND" | "VUV" | "XAF" | "XOF" | "XPF" => 0,
+            // Three-decimal currencies in Stripe.
+            "BHD" | "JOD" | "KWD" | "OMR" | "TND" => 3,
+            _ if normalized.chars().all(|c| c.is_ascii_alphabetic()) && normalized.len() == 3 => 2,
+            _ => return Err(anyhow!("invalid currency code: {currency}")),
+        };
+
+        Ok(exponent)
+    }
+}
+
+pub async fn fetch_btc_spot_price_from_base(
+    http: &reqwest::Client,
+    api_base: &str,
+    currency: &str,
+) -> Result<f64> {
+    let pair = format!("BTC-{currency}");
+    let url = format!("{}/{pair}/spot", api_base.trim_end_matches('/'));
+    let resp = http.get(url).send().await?;
+    let body: CoinbaseSpotPriceResponse = resp.error_for_status()?.json().await?;
+
+    let amount = body
+        .data
+        .amount
+        .parse::<f64>()
+        .map_err(|e| anyhow!("invalid BTC spot quote for {currency}: {e}"))?;
+
+    if amount <= 0.0 {
+        return Err(anyhow!("invalid non-positive BTC spot quote for {currency}"));
+    }
+
+    Ok(amount)
+}
+
+pub fn fiat_minor_to_msats_from_quote(
+    amount_due_minor: i64,
+    currency: &str,
+    btc_price_in_fiat: f64,
+) -> Result<u64> {
+    if amount_due_minor <= 0 {
+        return Err(anyhow!("amount_due must be positive"));
+    }
+
+    if btc_price_in_fiat <= 0.0 {
+        return Err(anyhow!("btc_price_in_fiat must be positive"));
+    }
+
+    let exponent = Billing::currency_minor_exponent(currency)?;
+    let divisor = 10_f64.powi(exponent as i32);
+    let amount_fiat = (amount_due_minor as f64) / divisor;
+    let amount_btc = amount_fiat / btc_price_in_fiat;
+    let raw_msats = amount_btc * 100_000_000_000.0;
+    // Guard against tiny floating point artifacts at integer boundaries.
+    let amount_msats = if (raw_msats - raw_msats.round()).abs() < 1e-6 {
+        raw_msats.round()
+    } else {
+        raw_msats.ceil()
+    };
+
+    if !amount_msats.is_finite() || amount_msats <= 0.0 || amount_msats > u64::MAX as f64 {
+        return Err(anyhow!("calculated msat amount is out of bounds"));
+    }
+
+    Ok(amount_msats as u64)
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use sqlx::SqlitePool;
-    use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
-    use std::str::FromStr;
+    use super::fiat_minor_to_msats_from_quote;
 
-    use crate::models::Activity;
-
-    async fn test_pool() -> SqlitePool {
-        let connect_options = SqliteConnectOptions::from_str("sqlite::memory:")
-            .expect("valid sqlite memory url")
-            .create_if_missing(true);
-
-        let pool = SqlitePoolOptions::new()
-            .max_connections(1)
-            .connect_with(connect_options)
-            .await
-            .expect("connect sqlite memory db");
-
-        sqlx::migrate!("./migrations")
-            .run(&pool)
-            .await
-            .expect("run migrations");
-
-        pool
+    #[test]
+    fn converts_usd_minor_units_with_quote() {
+        let msats = fiat_minor_to_msats_from_quote(100, "usd", 100_000.0)
+            .expect("conversion should succeed");
+        assert_eq!(msats, 1_000_000);
     }
 
-    fn test_billing(pool: SqlitePool, stripe_secret_key: &str) -> Billing {
-        Billing {
-            nwc_url: String::new(),
-            stripe_secret_key: stripe_secret_key.to_string(),
-            stripe_webhook_secret: String::new(),
-            http: reqwest::Client::new(),
-            query: Query::new(pool.clone()),
-            command: Command::new(pool),
-            robot: Robot::test_stub(),
-        }
-    }
-
-    #[tokio::test]
-    async fn stripe_create_customer_requires_secret_key() {
-        let pool = test_pool().await;
-        let billing = test_billing(pool, "");
-
-        let err = billing
-            .stripe_create_customer("tenant_pubkey")
-            .await
-            .expect_err("missing key should fail before HTTP call");
-
-        assert!(
-            err.to_string().contains("missing STRIPE_SECRET_KEY"),
-            "unexpected error: {err}"
-        );
-    }
-
-    #[tokio::test]
-    async fn sync_relay_subscription_fails_for_empty_tenant_customer_id() {
-        let pool = test_pool().await;
-
-        sqlx::query(
-            "INSERT INTO tenant (pubkey, nwc_url, created_at, stripe_customer_id)
-             VALUES (?, ?, ?, ?)",
-        )
-        .bind("tenant_pubkey")
-        .bind("")
-        .bind(0_i64)
-        .bind("")
-        .execute(&pool)
-        .await
-        .expect("insert tenant");
-
-        sqlx::query(
-            "INSERT INTO relay (id, tenant, schema, subdomain, plan, status)
-             VALUES (?, ?, ?, ?, ?, ?)",
-        )
-        .bind("relay_1")
-        .bind("tenant_pubkey")
-        .bind("relay_1")
-        .bind("relay-1")
-        .bind("basic")
-        .bind("active")
-        .execute(&pool)
-        .await
-        .expect("insert relay");
-
-        let billing = test_billing(pool, "sk_test_dummy");
-        let activity = Activity {
-            id: "activity_1".to_string(),
-            tenant: "tenant_pubkey".to_string(),
-            created_at: 0,
-            activity_type: "create_relay".to_string(),
-            resource_type: "relay".to_string(),
-            resource_id: "relay_1".to_string(),
-        };
-
-        let err = billing
-            .sync_relay_subscription(&activity)
-            .await
-            .expect_err("empty tenant customer id should fail clearly");
-
-        assert!(
-            err.to_string()
-                .contains("tenant tenant_pubkey has no stripe_customer_id"),
-            "unexpected error: {err}"
-        );
+    #[test]
+    fn converts_zero_decimal_currency_with_quote() {
+        let msats = fiat_minor_to_msats_from_quote(100, "jpy", 10_000_000.0)
+            .expect("conversion should succeed");
+        assert_eq!(msats, 1_000_000);
     }
 }

backend/src/command.rs

@@ -64,10 +64,6 @@ impl Command {
     }
 
     pub async fn create_tenant(&self, tenant: &Tenant) -> Result<()> {
-        if tenant.stripe_customer_id.trim().is_empty() {
-            anyhow::bail!("stripe_customer_id is required");
-        }
-
         let mut tx = self.pool.begin().await?;
 
         sqlx::query(
@@ -81,8 +77,7 @@ impl Command {
         .execute(&mut *tx)
         .await?;
 
-        let activity =
-            Self::insert_activity(&mut tx, "create_tenant", "tenant", &tenant.pubkey).await?;
+        let activity = Self::insert_activity(&mut tx, "create_tenant", "tenant", &tenant.pubkey).await?;
 
         tx.commit().await?;
         self.emit(activity);
@@ -98,8 +93,7 @@ impl Command {
             .execute(&mut *tx)
             .await?;
 
-        let activity =
-            Self::insert_activity(&mut tx, "update_tenant", "tenant", &tenant.pubkey).await?;
+        let activity = Self::insert_activity(&mut tx, "update_tenant", "tenant", &tenant.pubkey).await?;
 
         tx.commit().await?;
         self.emit(activity);
@@ -191,8 +185,7 @@ impl Command {
             .execute(&mut *tx)
             .await?;
 
-        let activity =
-            Self::insert_activity(&mut tx, "deactivate_relay", "relay", &relay.id).await?;
+        let activity = Self::insert_activity(&mut tx, "deactivate_relay", "relay", &relay.id).await?;
 
         tx.commit().await?;
         self.emit(activity);
@@ -223,8 +216,7 @@ impl Command {
             .execute(&mut *tx)
             .await?;
 
-        let activity =
-            Self::insert_activity(&mut tx, "fail_relay_sync", "relay", &relay.id).await?;
+        let activity = Self::insert_activity(&mut tx, "fail_relay_sync", "relay", &relay.id).await?;
 
         tx.commit().await?;
         self.emit(activity);
@@ -239,8 +231,7 @@ impl Command {
             .execute(&mut *tx)
             .await?;
 
-        let activity =
-            Self::insert_activity(&mut tx, "complete_relay_sync", "relay", relay_id).await?;
+        let activity = Self::insert_activity(&mut tx, "complete_relay_sync", "relay", relay_id).await?;
 
         tx.commit().await?;
         self.emit(activity);
@@ -255,11 +246,7 @@ impl Command {
         Ok(())
     }
 
-    pub async fn set_relay_subscription_item(
-        &self,
-        relay_id: &str,
-        stripe_subscription_item_id: &str,
-    ) -> Result<()> {
+    pub async fn set_relay_subscription_item(&self, relay_id: &str, stripe_subscription_item_id: &str) -> Result<()> {
         sqlx::query("UPDATE relay SET stripe_subscription_item_id = ? WHERE id = ?")
             .bind(stripe_subscription_item_id)
             .bind(relay_id)
@@ -268,11 +255,7 @@ impl Command {
         Ok(())
     }
 
-    pub async fn set_tenant_subscription(
-        &self,
-        pubkey: &str,
-        stripe_subscription_id: &str,
-    ) -> Result<()> {
+    pub async fn set_tenant_subscription(&self, pubkey: &str, stripe_subscription_id: &str) -> Result<()> {
         sqlx::query("UPDATE tenant SET stripe_subscription_id = ? WHERE pubkey = ?")
             .bind(stripe_subscription_id)
             .bind(pubkey)
@@ -324,56 +307,3 @@ impl Command {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use sqlx::SqlitePool;
-    use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
-    use std::str::FromStr;
-
-    async fn test_pool() -> SqlitePool {
-        let connect_options = SqliteConnectOptions::from_str("sqlite::memory:")
-            .expect("valid sqlite memory url")
-            .create_if_missing(true);
-
-        let pool = SqlitePoolOptions::new()
-            .max_connections(1)
-            .connect_with(connect_options)
-            .await
-            .expect("connect sqlite memory db");
-
-        sqlx::migrate!("./migrations")
-            .run(&pool)
-            .await
-            .expect("run migrations");
-
-        pool
-    }
-
-    #[tokio::test]
-    async fn create_tenant_rejects_empty_stripe_customer_id() {
-        let pool = test_pool().await;
-        let command = Command::new(pool);
-
-        let tenant = Tenant {
-            pubkey: "tenant_pubkey".to_string(),
-            nwc_url: String::new(),
-            nwc_error: None,
-            created_at: 0,
-            stripe_customer_id: "   ".to_string(),
-            stripe_subscription_id: None,
-            past_due_at: None,
-        };
-
-        let err = command
-            .create_tenant(&tenant)
-            .await
-            .expect_err("empty customer id must be rejected");
-
-        assert!(
-            err.to_string().contains("stripe_customer_id is required"),
-            "unexpected error: {err}"
-        );
-    }
-}

backend/src/robot.rs

@@ -254,23 +254,3 @@ async fn set_cached(
         },
     );
 }
-
-#[cfg(test)]
-impl Robot {
-    pub fn test_stub() -> Self {
-        let keys = Keys::generate();
-        let client = Client::new(keys);
-
-        Self {
-            secret: String::new(),
-            name: String::new(),
-            description: String::new(),
-            picture: String::new(),
-            outbox_client: client.clone(),
-            indexer_client: client.clone(),
-            messaging_client: client,
-            outbox_cache: std::sync::Arc::new(Mutex::new(HashMap::new())),
-            dm_cache: std::sync::Arc::new(Mutex::new(HashMap::new())),
-        }
-    }
-}

backend/tests/btc_quote_stub.rs

@@ -0,0 +1,31 @@
+use axum::{Json, Router, routing::get};
+use backend::billing::{fetch_btc_spot_price_from_base, fiat_minor_to_msats_from_quote};
+
+#[tokio::test]
+async fn quote_endpoint_can_be_stubbed_deterministically() {
+    async fn spot() -> Json<serde_json::Value> {
+        Json(serde_json::json!({ "data": { "amount": "50000.00" } }))
+    }
+
+    let app = Router::new().route("/v2/prices/BTC-USD/spot", get(spot));
+
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+        .await
+        .expect("bind test server");
+    let addr = listener.local_addr().expect("get local addr");
+    tokio::spawn(async move {
+        axum::serve(listener, app).await.expect("serve quote stub");
+    });
+
+    let client = reqwest::Client::new();
+    let base = format!("http://{addr}/v2/prices");
+    let btc_price = fetch_btc_spot_price_from_base(&client, &base, "USD")
+        .await
+        .expect("fetch stubbed quote");
+
+    assert_eq!(btc_price, 50_000.0);
+
+    let msats = fiat_minor_to_msats_from_quote(100, "USD", btc_price)
+        .expect("convert quoted fiat amount");
+    assert_eq!(msats, 2_000_000);
+}