fix(ui-tests): tap the uncovered strip of a wallet card (#763)

* fix(ui-tests): tap the uncovered strip of a wallet card

`selectFirstCurrency()` and `selectUsdfCurrency()` call `tap()`, which aims
at the element's frame centre. `TokenCardStack` lays its cards coincident in
a `ZStack` and offsets each one 64pt below the card behind it, so on a 224pt
card the centre belongs to whichever card is drawn in front — that is the
card the tap opens. On the test account both helpers missed: the first
currency row opened Dollars, and the Dollars row opened the token below it.

Tap 32pt below the card's top edge instead, inside the strip no other card
covers. The offset is in points rather than a fraction of the frame because
the Dollars card's `$` watermark overflows its bounds and inflates its
accessibility frame by ~19pt on each side, so the same fraction lands deeper
there than on a plain card.

`isHittable` reports `true` on a fully covered card, so the helper has
nothing it can assert. The guard goes at the destination: the convert tests
now call `assertHeldTokenReached()` / `assertDollarsReached()`, which check
Buy More and Withdraw. `assertHeldCurrencyReached()` checks Convert, which
both held layouts show — that is why the wrong card went unnoticed.

* fix(ui-tests): assert the Give flow reached a token, not Dollars

`navigateToGiveAmount()` documents that it picks the first non-USDF card,
but checks that with `assertHeldCurrencyReached()`, which looks for the
Convert tile that Dollars shows too. The check passes on either card, so it
does not hold the helper to what it promises. `assertHeldTokenReached()`
looks for Buy More, which only a token has.

Author: bmc08gt

FlipcashUITests/Regression/ConvertBetweenTokensRegressionTests.swift

@@ -37,7 +37,7 @@ final class ConvertBetweenTokensRegressionTests: BaseUITestCase {
         // Wallet tab → first non-USDF card → its info page.
         wallet.open(from: self)
         wallet.selectFirstCurrency()
-        currencyInfo.assertHeldCurrencyReached()
+        currencyInfo.assertHeldTokenReached()
 
         waitAndTap(currencyInfo.convertButton)
         convert.assertAmountStepReached()

FlipcashUITests/Regression/ConvertFromDollarsRegressionTests.swift

@@ -40,7 +40,7 @@ final class ConvertFromDollarsRegressionTests: BaseUITestCase {
         // Wallet tab → the Dollars card → its info page.
         wallet.open(from: self)
         wallet.selectUsdfCurrency()
-        currencyInfo.assertHeldCurrencyReached()
+        currencyInfo.assertDollarsReached()
 
         // Convert → $0.01 → Next. Dollars can't be its own destination, so the
         // amount screen opens on a token already.

FlipcashUITests/Regression/ConvertToDollarsRegressionTests.swift

@@ -38,7 +38,7 @@ final class ConvertToDollarsRegressionTests: BaseUITestCase {
         // Wallet tab → first non-USDF card → its info page.
         wallet.open(from: self)
         wallet.selectFirstCurrency()
-        currencyInfo.assertHeldCurrencyReached()
+        currencyInfo.assertHeldTokenReached()
 
         // Convert → $0.01 → Next. The destination is already Dollars.
         waitAndTap(currencyInfo.convertButton)

FlipcashUITests/Support/BaseUITestCase.swift

@@ -193,7 +193,7 @@ class BaseUITestCase: XCTestCase {
 
         wallet.open(from: self)
         wallet.selectFirstCurrency()
-        currencyInfo.assertHeldCurrencyReached(timeout: 30)
+        currencyInfo.assertHeldTokenReached(timeout: 30)
         waitAndTap(currencyInfo.giveButton)
 
         XCTAssertTrue(

FlipcashUITests/Support/Screens/CurrencyInfoScreen.swift

@@ -62,6 +62,27 @@ struct CurrencyInfoUIScreen {
         )
     }
 
+    /// Asserts the page for a held currency that is *not* Dollars.
+    ///
+    /// Give and Convert are on both held layouts, so a test that only checks
+    /// those cannot tell a token's page from the Dollars page — which is how a
+    /// wallet tap that opened the wrong card used to pass. Buy More is the tile
+    /// only a token has.
+    func assertHeldTokenReached(timeout: TimeInterval = 10) {
+        XCTAssertTrue(
+            buyMoreButton.waitForExistence(timeout: timeout),
+            "Expected a held token's CurrencyInfoScreen, with a Buy More tile — Dollars shows Withdraw there"
+        )
+    }
+
+    /// Asserts the Dollars page, which swaps Buy More for Withdraw.
+    func assertDollarsReached(timeout: TimeInterval = 10) {
+        XCTAssertTrue(
+            withdrawButton.waitForExistence(timeout: timeout),
+            "Expected the Dollars CurrencyInfoScreen, with a Withdraw tile — a token shows Buy More there"
+        )
+    }
+
     /// Asserts the page for a currency the account doesn't hold.
     func assertUnheldCurrencyReached(timeout: TimeInterval = 10) {
         XCTAssertTrue(

FlipcashUITests/Support/Screens/WalletScreen.swift

@@ -10,6 +10,10 @@ import XCTest
 @MainActor
 struct WalletScreen {
 
+    /// How far below a card's top edge to tap: half the deck's 64pt per-card
+    /// reveal, so the point sits inside the strip no card overlaps.
+    private static let visibleStripInset: CGFloat = 32
+
     private let app: XCUIApplication
 
     init(app: XCUIApplication) {
@@ -26,6 +30,9 @@ struct WalletScreen {
     /// stacked cards rather than a `List`. The USDF card carries the distinct
     /// identifier "currency-row-usdf" so this selector reliably targets an
     /// investable token regardless of where USDF sorts.
+    ///
+    /// Tap it with ``selectFirstCurrency()``, never with `tap()` — see
+    /// ``tapVisibleStrip(of:)``.
     var firstCurrencyRow: XCUIElement {
         app.buttons.matching(identifier: "currency-row").firstMatch
     }
@@ -87,22 +94,45 @@ struct WalletScreen {
         testCase.scrollUpToAndTap(createCurrencyTile, in: scrollView)
     }
 
-    /// Selects the first currency card and verifies CurrencyInfoScreen is reached.
+    /// Opens the first non-USDF currency's info page.
     func selectFirstCurrency() {
         XCTAssertTrue(
             firstCurrencyRow.waitForExistence(timeout: 30),
             "Expected at least one currency in the Wallet"
         )
-        firstCurrencyRow.tap()
+        tapVisibleStrip(of: firstCurrencyRow)
     }
 
-    /// Selects the USDF (Dollars) card — the source for a convert that buys
+    /// Opens the USDF (Dollars) info page — the source for a convert that buys
     /// more of a currency the account already holds.
+    ///
+    /// Dollars needs the strip tap as much as a token does: it sorts by value
+    /// like every other card, so anything worth less is drawn on top of it and
+    /// a centre tap opens that card instead.
     func selectUsdfCurrency() {
         XCTAssertTrue(
             usdfRow.waitForExistence(timeout: 30),
             "Expected the USDF card in the Wallet"
         )
-        usdfRow.tap()
+        tapVisibleStrip(of: usdfRow)
+    }
+
+    /// Taps the middle of a card's uncovered top strip.
+    ///
+    /// `TokenCardStack` lays the cards coincident and offsets each one
+    /// `fannedReveal` (64pt) below the card behind it, so all a card leaves
+    /// uncovered is that top sliver — the frame centre `XCUIElement.tap()` aims
+    /// at belongs to the card in front, which is the one the tap then opens. A
+    /// covered card still reports `isHittable == true`, so there is nothing to
+    /// assert here; the guard is `assertHeldTokenReached()` at the destination.
+    ///
+    /// The offset is in points from the top edge rather than a fraction of the
+    /// frame, because the Dollars card's watermark overflows its bounds and
+    /// inflates its accessibility frame — the same fraction lands lower there
+    /// than on a plain card.
+    private func tapVisibleStrip(of card: XCUIElement) {
+        card.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0))
+            .withOffset(CGVector(dx: 0, dy: Self.visibleStripInset))
+            .tap()
     }
 }