Address review: document all-types tax filtering; add non-card, per-country, and wiring tests (MOBILESDK-4697)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Committed-By-Agent: claude
Committed-By-Agent: codex
Co-authored-by: codex <noreply@openai.com>
Committed-By-Agent: codex
Co-authored-by: codex <noreply@openai.com>

Author: 3 people

paymentsheet/src/main/java/com/stripe/android/common/validation/BillingDetailsValidation.kt

@@ -11,7 +11,7 @@ import com.stripe.android.uicore.elements.IdentifierSpec
 internal fun PaymentMethod.hasSufficientBillingDetailsForAutomaticTax(): Boolean {
     val address = billingDetails?.address ?: return false
     // Saved-PM billing details come from the API and are not guaranteed uppercase, unlike the
-    // CountryConfig-sourced value the CardBillingAddressElement form passes. Uppercase before the
+    // CountryConfig-sourced value the billing-address form passes. Uppercase before the
     // map lookup; do not "simplify" this away.
     val country = address.country?.uppercase()
     if (country.isNullOrBlank()) return false

paymentsheet/src/main/java/com/stripe/android/paymentsheet/state/PaymentMethodFilter.kt

@@ -48,6 +48,9 @@ internal class DefaultPaymentMethodFilter @Inject constructor() : PaymentMethodF
             params.cardBrandFilter.isAccepted(paymentMethod) &&
                 fundingAccepted &&
                 paymentMethod.isSupportedWithBillingConfig(params.billingDetailsCollectionConfiguration) &&
+                // Intentionally applies to every saved PM type, not just cards: pay-server's
+                // confirm-time tax guard (finalize_payment_taxes) is not payment-method-type gated,
+                // so any SPM whose billing address can't resolve a tax location 400s at confirm.
                 (
                     !params.requiresBillingAddressForAutomaticTax ||
                         paymentMethod.hasSufficientBillingDetailsForAutomaticTax()

paymentsheet/src/test/java/com/stripe/android/paymentsheet/state/CreateCustomerStateTest.kt

@@ -192,6 +192,34 @@ internal class CreateCustomerStateTest {
 
             val filterCall = filterCalls.awaitItem()
             assertThat(filterCall.paymentMethods).isEqualTo(cards)
+            // Default metadata does not require a billing address for automatic tax.
+            assertThat(filterCall.params.requiresBillingAddressForAutomaticTax).isFalse()
+        }
+    }
+
+    @Test
+    fun `Threads requiresBillingAddressForAutomaticTax into the filter params`() = runScenario {
+        val cards = PaymentMethodFactory.cards(3)
+
+        FakePaymentMethodFilter.test(filteredPaymentMethods = cards) {
+            createCustomerState(
+                initializationMode = DEFAULT_INITIALIZATION_MODE,
+                elementsSession = DEFAULT_ELEMENTS_SESSION.copy(
+                    customer = createElementsSessionCustomer(paymentMethods = cards),
+                ),
+                metadata = PaymentMethodMetadataFactory.create(
+                    checkoutSessionResponse = CheckoutSessionResponseFactory.create(
+                        automaticTaxEnabled = true,
+                        taxAddressSource = CheckoutSessionResponse.TaxAddressSource.BILLING,
+                    ),
+                )
+                    .copy(customerMetadata = CUSTOMER_SESSION_METADATA),
+                savedSelection = CompletableDeferred(SavedSelection.None),
+                paymentMethodFilter = paymentMethodFilter,
+            )
+
+            val filterCall = filterCalls.awaitItem()
+            assertThat(filterCall.params.requiresBillingAddressForAutomaticTax).isTrue()
         }
     }
 

paymentsheet/src/test/java/com/stripe/android/paymentsheet/state/DefaultPaymentMethodFilterTest.kt

@@ -270,6 +270,62 @@ class DefaultPaymentMethodFilterTest {
         assertThat(observed).isEmpty()
     }
 
+    @Test
+    fun `Applies automatic-tax filter to non-card SPMs too`() = runTest {
+        // pay-server's confirm-time tax guard is not payment-method-type gated, so a bank-account
+        // SPM with an insufficient tax address 400s at confirm just like a card; the filter must
+        // drop it as well. Guards against a future card-only regression.
+        val completeBank = PaymentMethodFactory.usBankAccount().copy(
+            id = "pm_bank_complete",
+            billingDetails = PaymentMethod.BillingDetails(
+                address = Address(
+                    line1 = "1 Market St",
+                    city = "San Francisco",
+                    state = "CA",
+                    postalCode = "94111",
+                    country = "US",
+                ),
+            ),
+        )
+        val incompleteBank = PaymentMethodFactory.usBankAccount().copy(
+            id = "pm_bank_incomplete",
+            billingDetails = PaymentMethod.BillingDetails(
+                // Missing line1 and state for a US address.
+                address = Address(city = "San Francisco", postalCode = "94111", country = "US"),
+            ),
+        )
+
+        val observed = filter(
+            paymentMethods = listOf(completeBank, incompleteBank),
+            requiresBillingAddressForAutomaticTax = true,
+        )
+
+        assertThat(observed).containsExactly(completeBank)
+    }
+
+    @Test
+    fun `Applies per-country automatic-tax fields at the filter boundary`() = runTest {
+        // CA requires only a postal code (not the US line1/city/state set), proving the per-country
+        // lookup is consulted at the filter boundary rather than hardcoding US behavior.
+        val caComplete = PaymentMethodFactory.card(id = "pm_ca_complete").update(
+            last4 = "1000",
+            addCbcNetworks = false,
+            brand = CardBrand.Visa,
+        ).copy(billingDetails = PaymentMethod.BillingDetails(address = Address(postalCode = "K1A0B1", country = "CA")))
+        val caMissingPostal = PaymentMethodFactory.card(id = "pm_ca_missing").update(
+            last4 = "1000",
+            addCbcNetworks = false,
+            brand = CardBrand.Visa,
+        ).copy(billingDetails = PaymentMethod.BillingDetails(address = Address(country = "CA")))
+
+        val observed = filter(
+            paymentMethods = listOf(caComplete, caMissingPostal),
+            requiresBillingAddressForAutomaticTax = true,
+        )
+
+        assertThat(observed).containsExactly(caComplete)
+    }
+
     private suspend fun filter(
         paymentMethods: List<PaymentMethod>,
         billingDetailsCollectionConfiguration: PaymentSheet.BillingDetailsCollectionConfiguration =