Tester un seau à jetons iOS sur un Mac cloud avec une horloge contrôlée

Tester un seau à jetons iOS sur un Mac cloud avec une horloge contrôlée

Tester un seau à jetons iOS sur un Mac cloud avec une horloge contrôlée

Lors de tests à distance, il arrive qu’un limiteur de débit laisse passer une requête de trop. On l’attribue facilement à la charge de la machine. Le véritable problème vient souvent de l’utilisation de sleep pour estimer l’instant de recharge : quelques millisecondes de retard au réveil du thread suffisent à franchir la limite temporelle. En isolant le seau à jetons qui contrôle les requêtes iOS dans une machine à états pure, puis en lui fournissant des instants explicites sur un Mac cloud, on peut distinguer une erreur d’algorithme d’un retard d’ordonnancement.

Définir d’abord la capacité et les règles de recharge

Nous utilisons ici un seau à jetons discret : il contient au maximum deux jetons, reçoit un jeton toutes les 250 millisecondes et démarre plein. Chaque requête consomme le nombre de jetons indiqué ; si le solde est insuffisant, elle est immédiatement refusée, sans mise en file d’attente. Les périodes de recharge sont comptées depuis l’initialisation ; une consommation ne relance pas le cycle.

Ce modèle convient pour limiter les rafales tout en autorisant quelques tâches consécutives après une période d’inactivité. En revanche, il ne convient pas si l’exigence est de ne jamais dépasser un nombre fixe de requêtes dans une fenêtre glissante quelconque : les deux modèles se comportent différemment aux limites.

La limitation côté client ne contrôle que le rythme des requêtes qu’il émet. Elle ne remplace pas la vérification des quotas côté serveur. Un redémarrage du processus remplit à nouveau le seau : ce mécanisme ne permet donc pas de revendiquer une limitation commune à plusieurs appareils ou processus.

Le temps est exprimé en millisecondes entières issues d’une horloge monotone, sans consulter l’heure civile. L’implémentation ci-dessous refuse les valeurs qui remontent dans le temps, afin qu’une erreur dans les données de test ne modifie pas silencieusement l’état.

Implémenter un cœur à temps injectable

Enregistrez ce code dans TokenBucketChecks.swift. Le cœur n’accède pas au réseau, ne met aucun thread en attente et ne dépend pas du cycle de vie de l’application. La capacité et la période doivent être strictement positives : c’est une précondition de construction. Toute configuration externe doit être validée avant la création de l’instance.

import Dispatch
import XCTest

struct TokenBucket {
    let capacity: UInt64
    let interval: UInt64
    private(set) var tokens: UInt64
    private var last: UInt64

    init(capacity: UInt64, interval: UInt64, now: UInt64) {
        precondition(capacity > 0 && interval > 0)
        self.capacity = capacity
        self.interval = interval
        self.tokens = capacity
        self.last = now
    }

    mutating func take(_ cost: UInt64 = 1, at now: UInt64) -> Bool {
        guard now >= last else { return false }

        let steps = (now - last) / interval
        if steps > 0 {
            let room = capacity - tokens
            if steps >= room {
                tokens = capacity
            } else {
                tokens += steps
            }
            last += steps * interval
        }

        guard cost > 0 && cost <= tokens else { return false }
        tokens -= cost
        return true
    }
}

On compare d’abord le nombre de périodes écoulées à la place disponible, avant d’ajouter les jetons. Cela évite un dépassement d’entier dû à une addition directe après une longue inactivité. Comme steps * interval ne dépasse pas now - last, l’avancement du repère temporel ne peut pas non plus dépasser l’instant fourni.

Une fois la capacité atteinte, aucun jeton supplémentaire n’est stocké, mais le cycle de recharge conserve sa phase. Par exemple, une consommation à 249 millisecondes n’empêche pas la recharge à 250 millisecondes. C’est un choix explicite de modélisation, et non la garantie exacte d’un débit moyen continu.

Remplacer les attentes réelles par des tests aux limites

Ajoutez les tests suivants à la suite, dans le même fichier. Le premier vérifie la capacité de rafale et les limites de recharge ; le second couvre les longues périodes d’inactivité et les entrées invalides. Chaque assertion utilise un instant explicite et justifiable, indépendamment de la charge du Mac cloud au moment du test.

final class BucketTests: XCTestCase {
    func testBurstAndRefill() {
        var bucket = TokenBucket(capacity: 2, interval: 250, now: 0)
        XCTAssertTrue(bucket.take(at: 0))
        XCTAssertTrue(bucket.take(at: 0))
        XCTAssertFalse(bucket.take(at: 249))
        XCTAssertTrue(bucket.take(at: 250))
        XCTAssertTrue(bucket.take(at: 749))
        XCTAssertTrue(bucket.take(at: 750))
        XCTAssertFalse(bucket.take(at: 750))
    }

    func testIdleCapAndInvalidInputs() {
        var bucket = TokenBucket(capacity: 2, interval: 250, now: 0)
        XCTAssertTrue(bucket.take(2, at: 0))
        XCTAssertTrue(bucket.take(at: 10_000))
        XCTAssertTrue(bucket.take(at: 10_000))
        XCTAssertFalse(bucket.take(at: 10_000))

        let before = bucket.tokens
        XCTAssertFalse(bucket.take(at: 9_999))
        XCTAssertEqual(bucket.tokens, before)
        XCTAssertFalse(bucket.take(0, at: 10_000))
        XCTAssertFalse(bucket.take(3, at: 10_000))
    }
}

XCTMain([
    testCase([
        ("testBurstAndRefill", BucketTests.testBurstAndRefill),
        ("testIdleCapAndInvalidInputs", BucketTests.testIdleCapAndInvalidInputs)
    ])
])

Exécutez le fichier avec les outils de développement de l’installation complète de Xcode :

xcrun swift TokenBucketChecks.swift

Retenez le code de sortie de la commande comme critère de validation, plutôt que la présence d’un mot dans les journaux. Ce script vérifie l’algorithme Swift partagé. Pour le transférer dans une cible de tests iOS, conservez les méthodes de test et retirez l’appel à XCTMain en fin de script : le lanceur de tests se chargera de découvrir les cas.

Il est conseillé d’ajouter des cas avec une capacité d’un jeton, une consommation de toute la capacité en une seule fois, un instant d’initialisation non nul et des entrées proches de UInt64.max. N’assouplissez pas les assertions en accordant « quelques millisecondes de tolérance » pour faire passer un test en échec : vous transformeriez à nouveau un test déterministe en test dépendant du minutage.

Raccorder une horloge monotone et sérialiser l’accès

En production, les millisecondes peuvent être obtenues avec DispatchTime.now().uptimeNanoseconds / 1_000_000. L’initialisation et les requêtes suivantes doivent utiliser la même source de temps, sans y mélanger l’heure du serveur, l’heure civile ou un compteur relatif au démarrage de l’application.

Lorsque plusieurs tâches partagent le même seau, regroupez la lecture de l’heure, la recharge et le débit des jetons dans une seule méthode d’actor, sans aucun await à l’intérieur. Avec un verrou, lisez également l’heure après son acquisition. Sinon, un appel ayant lu l’heure en premier peut entrer plus tard dans la section critique et être considéré comme un retour en arrière.

Préciser les règles de veille et de recréation

Ce modèle ne garantit pas que les jetons s’accumulent pendant la veille du système. Si le produit doit comptabiliser cette durée, choisissez une horloge dont la sémantique répond à cette exigence et testez ce comportement séparément. Recréer le seau après l’arrêt de l’application rétablit sa capacité maximale. Si cela n’est pas acceptable, il faut un protocole de persistance supplémentaire ; enregistrer uniquement le solde ne suffit pas.

Tirer des échecs des conclusions exploitables

Avant de soumettre le code, vérifiez chaque point : la rafale initiale correspond exactement à la capacité ; une requête est refusée une milliseconde avant la recharge ; elle est acceptée à l’instant de recharge ; plusieurs périodes écoulées ne permettent pas de dépasser la capacité ; les requêtes de coût nul ou supérieur à la capacité sont refusées ; une valeur temporelle antérieure ne modifie pas l’état.

Si les échecs n’apparaissent qu’après l’intégration dans l’application, vérifiez d’abord qu’il n’existe pas plusieurs seaux, que l’instance n’est pas recréée avant chaque requête et que les nouvelles tentatives passent bien par le même point d’entrée. Si les tests réussissent mais que les requêtes restent trop rapprochées, réexaminez la capacité et la période au lieu d’ajouter des attentes pour masquer l’écart.

Enfin, consignez séparément les résultats des tests de l’algorithme et des tests d’intégration. Les premiers répondent à la question « les transitions d’état sont-elles correctes ? », les seconds à « toutes les requêtes passent-elles réellement par le même point de limitation ? ». Cette séparation rend les tests à distance reproductibles et facilite le diagnostic de la prochaine régression.

Questions fréquentes

Pourquoi éviter sleep pour tester la recharge ?

Le réveil du thread ne se produit pas nécessairement à l’instant attendu. Des instants entiers injectés permettent de tester juste avant la recharge, exactement au seuil et après plusieurs périodes.

Le seau à jetons accepte-t-il des appels concurrents ?

Pas sans protection supplémentaire. La lecture de l’horloge, la recharge et le débit doivent être sérialisés ensemble dans le même acteur ou sous le même verrou.

Laissez votre projet déterminer le Mac à louer

Pour compiler en natif et déboguer avec le simulateur, louez un Mac dédié équipé d’une puce Apple Silicon pour vos tests. Si vous développez à temps plein sur le long terme et travaillez toujours au même endroit, l’achat mérite aussi d’être envisagé. La location à la journée offre plus de flexibilité pour tester ; pour une utilisation prolongée, optez plutôt pour un forfait mensuel ou trimestriel.

Louer un Mac à distance

Étape suivante : choisissez une offre selon l’avancement du projet

Comparez d’abord les modèles, les durées et les options de connexion avant de décider si vous souhaitez louer.