@stamhoofd/backend 2.141.0 → 2.143.0

package/src/helpers/StripeSettlementSync.ts

@@ -1,9 +1,10 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Payment, StripeAccount } from '@stamhoofd/models';
+import { Organization, Payment, StripeAccount } from '@stamhoofd/models';
 import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
 import { PaymentSettlement } from '@stamhoofd/models/models/PaymentSettlement.js';
 import type { Settlement } from '@stamhoofd/models/models/Settlement.js';
 import type { SettlementCharge } from '@stamhoofd/models/models/SettlementCharge.js';
+import type { AbortSignal } from '@stamhoofd/queues';
 import { PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
 import { ApplicationFeeType } from '@stamhoofd/structures/settlements/ApplicationFeeType.js';
 import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
@@ -17,6 +18,27 @@ import { passthroughFetch } from './passthroughFetch.js';
 import { getPaymentIdForStripeCharge } from './getPaymentIdForStripeCharge.js';
 import { WebmasterReport } from './WebmasterReport.js';
 
+/**
+ * Who paid an application fee: normally the organization of the Stripe account it was deducted
+ * from, and otherwise the organization our own charge metadata names.
+ */
+type ApplicationFeePayer = {
+    organizationId: string;
+
+    /**
+     * NULL when we no longer have the stripe_accounts row the fee was deducted from.
+     */
+    stripeAccountId: string | null;
+
+    /**
+     * Whether our records of this payer are still complete. Only false when its stripe_accounts
+     * row is gone, which means its organization was deleted: what can't be resolved anymore is
+     * then the consequence of that deletion, not a problem to repair. A deleted account keeps its
+     * row, and its organization keeps its payments, so those stay strictly checked.
+     */
+    intact: boolean;
+};
+
 /**
  * Walks paid payouts and stores every balance transaction in them: payments become
  * payment_settlements rows, everything else becomes settlement_charges rows. One walker for both
@@ -37,6 +59,38 @@ export class StripeSettlementSync {
      */
     private fetchedCharges = new Map<string, Stripe.Charge>();
 
+    /**
+     * Stripe accounts already reported as unattributable, so a month of their fees is one problem
+     * instead of thousands.
+     */
+    static #reportedUnattributedAccounts = new Set<string>();
+
+    /**
+     * For tests only.
+     */
+    static resetWarnings() {
+        this.#reportedUnattributedAccounts.clear();
+    }
+
+    /**
+     * A fee we can't fully attribute is stored anyway (it is our income), so it would otherwise
+     * only exist as a number nobody looks at: the invoicer skips it, and no payout of the payer
+     * links it. Reported once per account, so someone decides whether to repair or write it off.
+     */
+    static reportUnattributedFee(payingAccountId: string, payer: ApplicationFeePayer | null) {
+        if (this.#reportedUnattributedAccounts.has(payingAccountId)) {
+            return;
+        }
+        this.#reportedUnattributedAccounts.add(payingAccountId);
+
+        WebmasterReport.report(
+            'Applicatiekosten van Stripe account ' + payingAccountId + ' worden niet aangerekend',
+            payer
+                ? 'Dat account staat niet meer in onze database. De kosten zijn wel opgeslagen op vereniging ' + payer.organizationId + ', maar worden niet automatisch gefactureerd.'
+                : 'Dat account en de vereniging erachter staan niet meer in onze database. De kosten zijn opgeslagen als niet-aanrekenbare inkomsten.',
+        );
+    }
+
     constructor({ secretKey, stripeAccount }: { secretKey: string; stripeAccount?: StripeAccount | null }) {
         this.stripeAccount = stripeAccount ?? null;
 
@@ -58,7 +112,7 @@ export class StripeSettlementSync {
      * Sync all paid payouts that arrived in the window. A failing payout is marked, reported and
      * skipped so the other payouts still sync; the summary tells the caller how bad it was.
      */
-    async syncPayouts({ start, end, force = false }: { start: Date; end?: Date; force?: boolean }): Promise<{ synced: number; skipped: number; failed: number }> {
+    async syncPayouts({ start, end, force = false, abort }: { start: Date; end?: Date; force?: boolean; abort?: AbortSignal }): Promise<{ synced: number; skipped: number; failed: number }> {
         const result = { synced: 0, skipped: 0, failed: 0 };
 
         // Fail once up front when no organization can own these payouts, instead of once per payout
@@ -74,14 +128,20 @@ export class StripeSettlementSync {
             },
             limit: 100,
         })) {
+            abort?.throwIfAborted();
+
             try {
-                const { skipped } = await this.syncPayout(payout, { force });
+                const { skipped } = await this.syncPayout(payout, { force, abort });
                 if (skipped) {
                     result.skipped += 1;
                 } else {
                     result.synced += 1;
                 }
             } catch (e) {
+                // An interrupted payout is not a failing payout: counting or reporting it would
+                // turn every restart into a wave of problems to look into
+                abort?.throwIfAborted();
+
                 console.error('Failed to sync Stripe payout ' + payout.id, e);
                 result.failed += 1;
 
@@ -97,7 +157,7 @@ export class StripeSettlementSync {
     /**
      * Re-sync one payout by its id, e.g. to retry a settlement that stayed unsynced.
      */
-    async syncPayoutById(externalId: string, options: { force?: boolean } = {}): Promise<{ settlement: Settlement; skipped: boolean }> {
+    async syncPayoutById(externalId: string, options: { force?: boolean; abort?: AbortSignal } = {}): Promise<{ settlement: Settlement; skipped: boolean }> {
         const payout = await this.stripe.payouts.retrieve(externalId);
         return await this.syncPayout(payout, options);
     }
@@ -108,7 +168,7 @@ export class StripeSettlementSync {
      * in the settlement links later. A broken fee doesn't block storing the others, but the walk
      * still fails loudly at the end: a month is only invoiced after a run without errors.
      */
-    async syncFees({ start, end }: { start: Date; end: Date }) {
+    async syncFees({ start, end, abort }: { start: Date; end: Date; abort?: AbortSignal }) {
         if (this.stripeAccount) {
             throw new SimpleError({
                 code: 'invalid_scope',
@@ -122,26 +182,35 @@ export class StripeSettlementSync {
         // billed). When it is already paid out, its payout needs the derived line for it
         const invoicedFeeBalanceItemIds = new Set<string>();
 
-        for await (const transaction of this.stripe.balanceTransactions.list({
-            type: 'application_fee',
-            created: {
-                gte: Math.floor(start.getTime() / 1000),
-                lte: Math.floor(end.getTime() / 1000),
-            },
-            expand: ['data.source', 'data.source.originating_transaction'],
-            limit: 100,
-        })) {
-            try {
-                const { fees } = await this.#handleApplicationFee(transaction);
-                for (const fee of fees) {
-                    if (fee.balanceItemId && fee.settlementId) {
-                        invoicedFeeBalanceItemIds.add(fee.balanceItemId);
-                    }
+        try {
+            for await (const transaction of this.stripe.balanceTransactions.list({
+                type: 'application_fee',
+                created: {
+                    gte: Math.floor(start.getTime() / 1000),
+                    lte: Math.floor(end.getTime() / 1000),
+                },
+                expand: ['data.source', 'data.source.originating_transaction'],
+                limit: 100,
+            })) {
+                abort?.throwIfAborted();
+
+                try {
+                    await this.#handleApplicationFee(transaction, { invoicedFeeBalanceItemIds });
+                } catch (e) {
+                    // The month is only invoiced after a walk without errors, so an interrupted
+                    // walk has to stop the walk itself instead of joining the errors of its
+                    // transactions
+                    abort?.throwIfAborted();
+
+                    console.error('Failed to sync application fee transaction ' + transaction.id, e);
+                    errors.push(e);
                 }
-            } catch (e) {
-                console.error('Failed to sync application fee transaction ' + transaction.id, e);
-                errors.push(e);
             }
+        } catch (e) {
+            // The payouts of the fees stored so far still need their derived lines, but failing to
+            // update them may not hide what broke the walk
+            await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]).catch(console.error);
+            throw e;
         }
 
         await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]);
@@ -155,25 +224,21 @@ export class StripeSettlementSync {
     }
 
     /**
-     * Stores one application_fee balance transaction: per non-zero part the payer's negative
-     * deduction charge (its settlement link belongs to the payer's own payout walk) and the
-     * application fee row. The platform payout walk passes `settlementId` to link the fee rows to
-     * the payout that contains them. Throws instead of writing a guessed row: missing serviceFee
-     * metadata, an unknown Stripe account or an unresolvable payment all mean someone has to look
-     * at it first.
+     * Stores the SettlementCharge for the connected account (costs) and ApplicationFee for the platform account (revenue), related to an application fee in Stripe.
      */
-    async #handleApplicationFee(transaction: Stripe.BalanceTransaction, options: { settlementId?: string } = {}): Promise<{ fees: ApplicationFee[]; charges: SettlementCharge[] }> {
+    async #handleApplicationFee(transaction: Stripe.BalanceTransaction, options: {
+        settlementId?: string;
+
+        /**
+         * Collects the balance items of the invoiced fees stored here, so their fee payments can
+         * be updated afterwards. Filled while storing, not from the return value: a fee that is
+         * stored before a later one throws still needs its derived line.
+         */
+        invoicedFeeBalanceItemIds?: Set<string>;
+    } = {}): Promise<{ fees: ApplicationFee[]; charges: SettlementCharge[] }> {
         const fee = transaction.source as Stripe.ApplicationFee;
         const payingAccountId = typeof fee.account === 'string' ? fee.account : fee.account.id;
 
-        const payingStripeAccount = await StripeAccount.select().where('accountId', payingAccountId).first(false);
-        if (!payingStripeAccount) {
-            throw new SimpleError({
-                code: 'stripe_account_not_found',
-                message: 'No Stripe account found for ' + payingAccountId,
-            });
-        }
-
         const originatingTransaction = fee.originating_transaction;
         if (!originatingTransaction || typeof originatingTransaction === 'string') {
             throw new SimpleError({
@@ -181,28 +246,18 @@ export class StripeSettlementSync {
                 message: 'Application fee ' + fee.id + ' has no expanded originating transaction',
             });
         }
-
+        const originatingCharge = originatingTransaction as Stripe.Charge;
         const details = ApplicationFeeDetails.fromStripe(transaction);
-
-        const paymentId = await getPaymentIdForStripeCharge(originatingTransaction as Stripe.Charge, {
+        const resolvedPaymentId = await getPaymentIdForStripeCharge(originatingCharge, {
             stripePlatform: this.stripePlatform,
         });
+        const resolvedPayment = (resolvedPaymentId ? await Payment.getByID(resolvedPaymentId) : null) ?? null;
 
-        if (!paymentId) {
-            throw new SimpleError({
-                code: 'payment_not_found',
-                message: 'No payment found for application fee ' + fee.id,
-            });
-        }
+        const payer = await this.#resolveApplicationFeePayer(payingAccountId, originatingCharge, resolvedPayment);
+        const paymentId = this.#getApplicationFeePaymentId(fee, payer, { paymentId: resolvedPaymentId, payment: resolvedPayment });
 
-        // Charge metadata is writable by the connected account's owner: the fee is deducted from
-        // this account, so it can only be about a payment of its own organization
-        const payment = await Payment.getByID(paymentId);
-        if (!payment || payment.organizationId !== payingStripeAccount.organizationId) {
-            throw new SimpleError({
-                code: 'payment_scope_mismatch',
-                message: 'Payment ' + paymentId + ' of application fee ' + fee.id + ' does not belong to organization ' + payingStripeAccount.organizationId,
-            });
+        if (!payer?.stripeAccountId) {
+            StripeSettlementSync.reportUnattributedFee(payingAccountId, payer);
         }
 
         const occurredAt = new Date(transaction.created * 1000);
@@ -222,39 +277,122 @@ export class StripeSettlementSync {
                 continue;
             }
 
-            const charge = await SettlementService.upsertCharge({
-                type: chargeType,
-                externalId: fee.id + ':' + chargeType,
-                amount: -amount,
-                applicationFeeId: fee.id,
-                paymentId,
-
-                // The charge sits in the paying organization's payout
-                organizationId: payingStripeAccount.organizationId,
-                stripeAccountId: payingStripeAccount.id,
-                occurredAt,
-
-                // settlementId (settlement of the paying organization where the costs are deducted): still unknown, will be filled when looping the payouts of the paying organization
-            });
-            charges.push(charge);
+            const charge = payer
+                ? await SettlementService.upsertCharge({
+                        type: chargeType,
+                        externalId: fee.id + ':' + chargeType,
+                        amount: -amount,
+                        applicationFeeId: fee.id,
+
+                        // Unresolvable stays undefined: a re-sync may not clear earlier stored links
+                        paymentId: paymentId ?? undefined,
+                        organizationId: payer.organizationId ?? undefined,
+                        stripeAccountId: payer.stripeAccountId ?? undefined,
+                        occurredAt,
+
+                        // settlementId (settlement of the paying organization where the costs are deducted): still unknown, will be filled when looping the payouts of the paying organization
+                    })
+                : null;
+
+            if (charge) {
+                charges.push(charge);
+            }
 
-            fees.push(await ApplicationFeeService.upsertFee({
+            const storedFee = await ApplicationFeeService.upsertFee({
                 externalId: fee.id,
                 type: feeType,
                 amount,
                 organizationId: receivingOrganizationId,
-                payingOrganizationId: payingStripeAccount.organizationId,
-                payingStripeAccountId: payingStripeAccount.id,
-                payingPaymentId: paymentId,
-                settlementChargeId: charge.id,
+
+                // Unresolvable stays undefined: a re-sync may not clear earlier stored links
+                payingOrganizationId: payer?.organizationId ?? undefined,
+                payingStripeAccountId: payer?.stripeAccountId ?? undefined,
+                payingPaymentId: paymentId ?? undefined,
+                settlementChargeId: charge?.id ?? undefined,
+                settlementId: options.settlementId,
                 occurredAt,
-                ...(options.settlementId !== undefined ? { settlementId: options.settlementId } : {}),
-            }));
+            });
+            fees.push(storedFee);
+
+            // An invoiced fee is explained by the derived line of its fee payment instead of by
+            // itself, so the payouts it sits in have to rebuild those lines
+            if (storedFee.balanceItemId && storedFee.settlementId) {
+                options.invoicedFeeBalanceItemIds?.add(storedFee.balanceItemId);
+            }
         }
 
         return { fees, charges };
     }
 
+    /**
+     * The organization an application fee was deducted from. Its Stripe account is the first
+     * source. A deleted organization takes its stripe_accounts row with it, and accounts deleted
+     * before we started keeping deleted ones are gone too; what is left of the payment then still
+     * names the organization: our own payment row first, and otherwise the metadata we wrote on the
+     * charge. Only a destination charge has an originating transaction, and that charge sits on our
+     * platform account, so the connected account could not have changed either.
+     *
+     * NULL when even that organization no longer exists: the fee is then income without a payer.
+     */
+    async #resolveApplicationFeePayer(payingAccountId: string, originatingCharge: Stripe.Charge, payment: Payment | null): Promise<ApplicationFeePayer | null> {
+        const stripeAccount = await StripeAccount.select().where('accountId', payingAccountId).first(false);
+        if (stripeAccount) {
+            return {
+                organizationId: stripeAccount.organizationId,
+                stripeAccountId: stripeAccount.id,
+                intact: true,
+            };
+        }
+
+        if (payment?.organizationId) {
+            return { organizationId: payment.organizationId, stripeAccountId: null, intact: false };
+        }
+
+        const organizationId = originatingCharge.metadata?.organization;
+        if (!organizationId || !await Organization.getByID(organizationId)) {
+            return null;
+        }
+
+        return { organizationId, stripeAccountId: null, intact: false };
+    }
+
+    /**
+     * The payer's payment an application fee was charged on. Charge metadata is writable by the
+     * connected account's owner: the fee is deducted from this account, so it can only be about a
+     * payment of its own organization.
+     *
+     * A payer whose records are no longer intact keeps whatever still resolves: its payments may
+     * have been deleted with its account, so a missing one is expected instead of something to
+     * repair.
+     */
+    #getApplicationFeePaymentId(fee: Stripe.ApplicationFee, payer: ApplicationFeePayer | null, { paymentId, payment }: { paymentId: string | null; payment: Payment | null }): string | null {
+        if (!payer) {
+            return null;
+        }
+
+        if (!paymentId) {
+            if (!payer.intact) {
+                return null;
+            }
+            throw new SimpleError({
+                code: 'payment_not_found',
+                message: 'No payment found for application fee ' + fee.id,
+            });
+        }
+
+        if (!payment || payment.organizationId !== payer.organizationId) {
+            if (!payer.intact) {
+                return null;
+            }
+            throw new SimpleError({
+                code: 'payment_scope_mismatch',
+                message: 'Payment ' + paymentId + ' of application fee ' + fee.id + ' does not belong to organization ' + payer.organizationId,
+            });
+        }
+
+        return paymentId;
+    }
+
     /**
      * The organization that owns the walked account: the connected account's organization, or the
      * platform membership organization for our own platform account (resolved once per instance).
@@ -264,7 +402,7 @@ export class StripeSettlementSync {
         return this.#organizationId;
     }
 
-    async syncPayout(payout: Stripe.Payout, { force = false }: { force?: boolean } = {}): Promise<{ settlement: Settlement; skipped: boolean }> {
+    async syncPayout(payout: Stripe.Payout, { force = false, abort }: { force?: boolean; abort?: AbortSignal } = {}): Promise<{ settlement: Settlement; skipped: boolean }> {
         // All amounts are stored in the same unit: a payout in another currency would be stored as
         // a plausible but wrong number
         if (payout.currency && payout.currency.toUpperCase() !== 'EUR') {
@@ -274,7 +412,7 @@ export class StripeSettlementSync {
             });
         }
 
-        return await SettlementService.lock(PaymentProvider.Stripe, payout.id, async () => {
+        return await SettlementService.lock(PaymentProvider.Stripe, payout.id, async (signal) => {
             const settlement = await SettlementService.upsertSettlement({
                 provider: PaymentProvider.Stripe,
                 externalId: payout.id,
@@ -312,17 +450,23 @@ export class StripeSettlementSync {
             }
 
             try {
-                await this.#walkPayout(payout, settlement);
+                await this.#walkPayout(payout, settlement, signal);
             } catch (e) {
-                await SettlementService.markSyncFailed(settlement);
+                // A walk that was interrupted stored only part of the payout: it has to be walked
+                // again, but it didn't fail
+                if (signal.isAborted) {
+                    await SettlementService.markSyncInterrupted(settlement);
+                } else {
+                    await SettlementService.markSyncFailed(settlement);
+                }
                 throw e;
             }
 
             return { settlement, skipped: false };
-        });
+        }, { abort });
     }
 
-    async #walkPayout(payout: Stripe.Payout, settlement: Settlement) {
+    async #walkPayout(payout: Stripe.Payout, settlement: Settlement, abort: AbortSignal) {
         const reported = new ReportedRows();
         let transactionCount = 0;
 
@@ -330,31 +474,45 @@ export class StripeSettlementSync {
         // payments' derived lines must follow
         const invoicedFeeBalanceItemIds = new Set<string>();
 
-        for await (const transaction of this.stripe.balanceTransactions.list({
-            payout: payout.id,
-            limit: 100,
-            expand: this.stripeAccount
-                ? ['data.source', 'data.source.application_fee', 'data.source.application_fee.originating_transaction', 'data.source.charge']
-                : ['data.source', 'data.source.originating_transaction', 'data.source.charge'],
-        })) {
-            transactionCount += 1;
-            await this.#handleTransaction(transaction, settlement, reported, invoicedFeeBalanceItemIds);
-        }
+        try {
+            for await (const transaction of this.stripe.balanceTransactions.list({
+                payout: payout.id,
+                limit: 100,
+                expand: this.stripeAccount
+                    ? ['data.source', 'data.source.application_fee', 'data.source.application_fee.originating_transaction', 'data.source.charge']
+                    : ['data.source', 'data.source.originating_transaction', 'data.source.charge'],
+            })) {
+                // Between two transactions is a safe point to stop: only a complete walk sweeps
+                // and marks the settlement synced, so an interrupted one is re-walked from scratch
+                abort.throwIfAborted();
+
+                transactionCount += 1;
+                await this.#handleTransaction(transaction, settlement, reported, invoicedFeeBalanceItemIds);
+            }
 
-        // Stripe reported nothing for money that did move: storing that as a complete sync would
-        // silently hide the whole payout
-        if (transactionCount === 0 && settlement.amount !== 0) {
-            throw new SimpleError({
-                code: 'empty_payout',
-                message: 'Payout ' + payout.id + ' of ' + settlement.amount + ' has no balance transactions',
-            });
-        }
+            // Stripe reported nothing for money that did move: storing that as a complete sync
+            // would silently hide the whole payout
+            if (transactionCount === 0 && settlement.amount !== 0) {
+                throw new SimpleError({
+                    code: 'empty_payout',
+                    message: 'Payout ' + payout.id + ' of ' + settlement.amount + ' has no balance transactions',
+                });
+            }
 
-        const { unlinkedFees } = await SettlementService.sweepSettlement(settlement, reported);
-        for (const fee of unlinkedFees) {
-            if (fee.balanceItemId) {
-                invoicedFeeBalanceItemIds.add(fee.balanceItemId);
+            // Only a complete walk may sweep: it can't tell a row that moved away from one this
+            // walk never reached
+            const { unlinkedFees } = await SettlementService.sweepSettlement(settlement, reported);
+            for (const fee of unlinkedFees) {
+                if (fee.balanceItemId) {
+                    invoicedFeeBalanceItemIds.add(fee.balanceItemId);
+                }
             }
+        } catch (e) {
+            // The fee payments still follow the fees this walk linked before it broke (a fee may
+            // never sit in a payout that has no line for it), but failing to update them may not
+            // hide what broke the walk
+            await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]).catch(console.error);
+            throw e;
         }
 
         await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]);
@@ -422,15 +580,8 @@ export class StripeSettlementSync {
 
             case 'application_fee': {
                 // The fee rows, now linked to the platform payout that contains them
-                const { fees } = await this.#handleApplicationFee(transaction, { settlementId: settlement.id });
+                const { fees } = await this.#handleApplicationFee(transaction, { settlementId: settlement.id, invoicedFeeBalanceItemIds });
                 reported.applicationFees(fees);
-                for (const fee of fees) {
-                    if (fee.balanceItemId) {
-                        // Make sure we update the AccountDeduction payments and settlements that are connected to this
-                        // application fee.
-                        invoicedFeeBalanceItemIds.add(fee.balanceItemId);
-                    }
-                }
                 await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId: null });
                 return;
             }

package/src/helpers/StripeSettlementSyncRunner.test.ts

@@ -1,7 +1,9 @@
 import type { Organization } from '@stamhoofd/models';
 import { OrganizationFactory } from '@stamhoofd/models';
 import { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import { AbortSignal } from '@stamhoofd/queues';
 import { PaymentProvider } from '@stamhoofd/structures';
+import { STExpect } from '@stamhoofd/test-utils';
 import { v4 as uuidv4 } from 'uuid';
 
 import { StripeMocker } from '../../tests/helpers/StripeMocker.js';
@@ -63,4 +65,20 @@ describe('Helper.StripeSettlementSyncRunner', () => {
         const fresh = await Settlement.getByID(settlement.id);
         expect(fresh!.syncFailureCount).toBe(5);
     });
+
+    test('an interrupted retry does not count towards the cap', async () => {
+        const settlement = await createUnsyncedSettlement(1);
+
+        const abort = new AbortSignal();
+        abort.abort();
+
+        const runner = new StripeSettlementSyncRunner({ secretKey: STAMHOOFD.STRIPE_SECRET_KEY! });
+        await expect(runner.retryUnsyncedSettlements({ windowStart, abort })).rejects.toThrow(
+            STExpect.simpleError({ code: 'queue-aborted' }),
+        );
+
+        // A restart is not an attempt: the payout is still waiting for a real one
+        const fresh = await Settlement.getByID(settlement.id);
+        expect(fresh!.syncFailureCount).toBe(1);
+    });
 });