iOS-Token-Bucket auf dem Cloud-Mac mit kontrollierter Zeit testen

iOS-Token-Bucket auf dem Cloud-Mac mit kontrollierter Zeit testen

iOS-Token-Bucket auf dem Cloud-Mac mit kontrollierter Zeit testen

Wenn ein Rate-Limiting-Test bei einem Remote-Testlauf gelegentlich eine Anfrage zu viel durchlässt, wird das schnell der Auslastung der Maschine zugeschrieben. Die eigentliche Ursache ist oft der Versuch, den Nachfüllzeitpunkt mit sleep abzupassen: Wacht der Thread ein paar Millisekunden später auf, hat der Test die Grenze bereits überschritten. Erst wenn der Token-Bucket am iOS-Anfrageeingang als reine Zustandsmaschine ausgeführt und auf dem Cloud-Mac mit expliziten Zeitwerten versorgt wird, lassen sich Algorithmusfehler von Verzögerungen durch die Thread-Planung unterscheiden.

Zuerst Kapazität und Nachfüllregeln festlegen

Dieser Artikel verwendet einen diskreten Token-Bucket: Er fasst zwei Tokens, erhält alle 250 Millisekunden ein weiteres Token und ist bei der Erstellung vollständig gefüllt. Jede Anfrage verbraucht die angegebene Anzahl an Tokens. Reicht das Guthaben nicht aus, wird sie sofort abgewiesen; eine Warteschlange gibt es nicht. Der Nachfüllzyklus beginnt mit der Initialisierung. Der Verbrauch setzt ihn nicht zurück.

Dieses Modell eignet sich, wenn kurze Lastspitzen begrenzt werden sollen, nach einer Leerlaufphase aber einige Aufgaben direkt hintereinander ausgeführt werden dürfen. Soll dagegen in jedem beliebigen gleitenden Zeitfenster eine feste Anzahl von Anfragen strikt eingehalten werden, ist ein Token-Bucket nicht geeignet. Die beiden Modelle verhalten sich an den Grenzen unterschiedlich.

Clientseitiges Rate-Limiting steuert nur, in welchem Tempo der Client selbst Anfragen sendet. Es ersetzt keine serverseitige Prüfung von Kontingenten. Ein Prozessneustart füllt den Bucket wieder vollständig auf; daraus lässt sich also auch keine geräte- oder prozessübergreifende Begrenzung ableiten.

Als Zeitbasis dienen monoton steigende, ganzzahlige Millisekundenwerte, nicht die Kalenderzeit. Die folgende Implementierung weist rückläufige Zeitwerte zurück, damit Fehler im Testaufbau den Zustand nicht unbemerkt verändern.

Den Kern mit injizierbarer Zeit implementieren

Speichern Sie den Code als TokenBucketChecks.swift. Der Kern greift weder auf das Netzwerk zu noch lässt er Threads warten; auch vom Lebenszyklus der App ist er unabhängig. Kapazität und Intervall müssen größer als null sein. Das ist eine Vorbedingung des Konstruktors: Externe Konfigurationswerte müssen geprüft werden, bevor eine Instanz erstellt wird.

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
    }
}

Die Implementierung prüft zuerst den freien Platz und addiert erst danach die Tokens. So vermeidet sie einen Überlauf, der nach langer Inaktivität durch direktes Addieren entstehen könnte. steps * interval ist höchstens so groß wie now - last; auch das Fortschreiben des Zeitpunkts kann daher den aktuellen Eingabewert nicht überschreiten.

Ist die Kapazitätsgrenze erreicht, werden keine zusätzlichen Tokens gespeichert. Die Phasenlage des Nachfüllzyklus bleibt jedoch erhalten. Wird beispielsweise bei 249 Millisekunden ein Token verbraucht, wird bei 250 Millisekunden trotzdem nachgefüllt. Das ist eine bewusste Modellentscheidung und keine exakte Zusicherung einer kontinuierlichen Durchschnittsrate.

Grenzfälle statt echter Wartezeiten testen

Hängen Sie die folgenden Tests an dieselbe Datei an. Die erste Gruppe prüft die Burst-Kapazität und die Nachfüllgrenzen, die zweite lange Leerlaufzeiten und ungültige Eingaben. Jede Assertion verwendet einen expliziten, nachvollziehbaren Zeitpunkt und hängt nicht davon ab, wie stark der Cloud-Rechner gerade ausgelastet ist.

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)
    ])
])

Führen Sie das Skript mit den Entwicklerwerkzeugen der vollständigen Xcode-Installation aus:

xcrun swift TokenBucketChecks.swift

Maßgeblich für das Testergebnis ist der Exit-Code des Befehls, nicht das Auftauchen eines bestimmten Wortes im Log. Dieses Skript prüft den gemeinsam verwendeten Swift-Algorithmus. Beim Übernehmen in ein iOS-Test-Target bleiben die Testmethoden erhalten; entfernen Sie das abschließende XCTMain, damit der Test-Runner die Testfälle selbst erkennt.

Ergänzend empfehlen sich Tests mit einer Kapazität von eins, dem Verbrauch der gesamten Kapazität in einem Aufruf, einem Initialisierungszeitpunkt ungleich null sowie Eingaben nahe UInt64.max. Führen Sie keine „Toleranz von ein paar Millisekunden“ ein, nur um einen fehlgeschlagenen Test zum Bestehen zu bringen. Sonst wird aus dem deterministischen Test wieder ein zeitabhängiger Test.

Monotone Uhr und serialisierten Zugriff anbinden

Produktionscode kann Millisekunden über DispatchTime.now().uptimeNanoseconds / 1_000_000 beziehen. Initialisierung und spätere Anfragen müssen dieselbe Zeitquelle verwenden. Serverzeit, Wanduhrzeit oder ein relativer Zähler seit dem App-Start dürfen nicht damit vermischt werden.

Teilen sich mehrere Tasks einen Bucket, müssen das Auslesen der Zeit, das Nachfüllen und der Verbrauch in derselben Actor-Methode erfolgen, ohne ein await innerhalb dieser Methode. Bei einer Sperre muss die Zeit ebenfalls erst nach dem Sperren ausgelesen werden. Andernfalls könnte ein Aufruf, der seine Zeit früher erfasst hat, später in den kritischen Abschnitt gelangen und als zeitlich rückläufig abgewiesen werden.

Regeln für Ruhezustand und Neuerstellung festlegen

Dieser Artikel sichert nicht zu, dass während des Systemruhezustands Guthaben angesammelt wird. Soll die Schlafzeit laut Produktanforderung mitgezählt werden, muss eine Uhr mit passender Semantik gewählt und gesondert getestet werden. Wird der Bucket nach dem Beenden der App neu erstellt, ist er wieder vollständig gefüllt. Ist das nicht akzeptabel, braucht es ein zusätzliches Persistenzprotokoll; allein den Token-Bestand zu speichern reicht nicht aus.

Aus Fehlern konkrete Handlungsschritte ableiten

Prüfen Sie vor dem Commit jeden Punkt einzeln: Der anfängliche Burst entspricht exakt der Kapazität; eine Millisekunde vor dem Nachfüllen wird die Anfrage abgewiesen; genau an der Grenze wird sie zugelassen; auch nach mehreren Intervallen wird die Kapazität nicht überschritten; Anfragen mit Kosten von null oder oberhalb der Kapazität werden abgewiesen; rückläufige Zeitwerte verändern den Zustand nicht.

Treten Fehler erst nach der Einbindung in die App auf, prüfen Sie zuerst, ob mehrere Buckets angelegt werden, ob vor jeder Anfrage eine neue Instanz erstellt wird und ob Wiederholungsversuche denselben zentralen Einstiegspunkt umgehen. Bestehen die Tests, während Anfragen weiterhin zu dicht aufeinanderfolgen, müssen Kapazität und Intervall überprüft werden. Zusätzliche Wartezeiten würden den Unterschied nur verdecken.

Halten Sie abschließend die Ergebnisse der Algorithmustests und der Integrationstests getrennt fest. Erstere beantworten die Frage: „Sind die Zustandsübergänge korrekt?“ Letztere klären: „Laufen wirklich alle Anfragen durch denselben Rate-Limiting-Einstiegspunkt?“ Werden diese beiden Fragen getrennt betrachtet, bleiben Remote-Tests reproduzierbar, und die nächste Regression lässt sich leichter eingrenzen.

Häufig gestellte Fragen

Warum sollte man Nachfülltests nicht mit sleep schreiben?

Ein Thread wird nach sleep nicht zwingend zum erwarteten Zeitpunkt fortgesetzt. Injizierte ganzzahlige Zeitwerte erlauben Tests direkt vor der Grenze, exakt an der Grenze und nach mehreren Intervallen.

Ist dieser Token-Bucket nebenläufigkeitssicher?

Nicht ohne zusätzliche Absicherung. Uhr lesen, Tokens nachfüllen und abbuchen müssen gemeinsam innerhalb desselben Actors oder unter derselben Sperre serialisiert werden.

Lassen Sie Ihr Projekt entscheiden, welchen Mac Sie mieten

Für native Builds und Tests im Simulator eignet sich ein gemieteter, dedizierter Mac mit Apple Silicon. Bei langfristiger Vollzeitentwicklung an einem festen Standort lohnt sich auch der Vergleich mit dem Kauf eines Geräts. Tagesweise mieten Sie flexibel zum Testen; bei dauerhafter Nutzung können Sie Monats- oder Quartalstarife in Betracht ziehen.

Remote-Mac mieten

Im nächsten Schritt den passenden Tarif für Ihre Projektphase wählen

Prüfen Sie zuerst Modell, Laufzeit und Zugang und entscheiden Sie dann, ob sich das Mieten lohnt.