Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) · Lektion

Testa orkestrerade sagor

Lär er att testa orkestreringsbaserade sagor med enhetstester för kompensationsvägar, integrationstester med simulerade tjänstefel och verifiering från början till slut av att sagan slutförs.

Lektion 4 av 413 steg

Testa orkestrerade sagor är en gratis lektion i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) innehåller totalt 4 lektioner.

Varför testa sagor?

En orkestrerad saga samordnar flera tjänster genom en central orkestrerare. Ett fel i orkestreraren kan lämna systemet i ett inkonsekvent tillstånd mellan tjänsterna.

Det är svårare att testa sagor än en enskild funktion eftersom ni måste verifiera både den lyckliga vägen och varje kompenserande väg.

Utfördes varje steg i rätt ordning?
Utlöste fel rätt kompenserande åtgärder?
Är det slutliga tillståndet konsekvent?

Testpyramiden för sagor

Tillämpa den klassiska testpyramiden:

Enhetstester — orkestrerarens beslutslogik isolerad.
Integrationstester — orkestreraren kommunicerar med verkliga eller simulerade tjänster.
End-to-end-tester — hela sagan över alla tjänster.

De flesta tester bör vara enhetstester eftersom de är snabba och deterministiska.

Enhetstesta orkestreraren

Orkestreraren är ofta en tillståndsmaskin. Ni kan enhetstesta dess övergångar genom att mata in händelser och kontrollera nästa kommando.

def next_command(state, event):
    if state == 'STARTED' and event == 'PAYMENT_OK':
        return 'RESERVE_STOCK'
    if state == 'STARTED' and event == 'PAYMENT_FAILED':
        return 'ABORT'
    return 'NOOP'

print(next_command('STARTED', 'PAYMENT_OK'))
print(next_command('STARTED', 'PAYMENT_FAILED'))

Simulera tjänsteanrop

I enhetstester ersätter ni verkliga tjänsteanrop med mocks eller stubs. Då kan ni styra exakt vad varje steg returnerar.

Ni kan till exempel tvinga betaltjänsten att returnera ett fel så att ni kan kontrollera att orkestreraren utfärdar ett kompenserande kommando.

class FakePayment:
    def __init__(self, ok):
        self.ok = ok
    def charge(self, amount):
        return 'PAYMENT_OK' if self.ok else 'PAYMENT_FAILED'

print(FakePayment(False).charge(100))

Testa kompenserande vägar

Den mest riskfyllda delen av alla sagor är kompensation. Skriv för varje framåtriktat steg ett test som:

Utför stegen fram till en vald punkt.
Tvingar fram ett fel.
Kontrollerar att varje tidigare steg kompenseras i omvänd ordning.

executed = ['reserve_stock', 'charge_card']
compensations = list(reversed(executed))
print('Compensate in order:', compensations)

Integrationstester med testcontainers

Integrationstester kör orkestreraren mot verkliga beroenden i tillfälliga containrar (databaser, meddelandemäklare).

Verktyg som Testcontainers startar en verklig mäklare (t.ex. Kafka eller RabbitMQ), så att meddelandeflödet testas exakt som i produktion.

Simulera tjänstefel

För att testa motståndskraften injicerar ni fel: låt en nedströms tjänst returnera fel, löpa ut eller krascha mitt i en saga.

HTTP 500 från ett steg
Tidsgräns (inget svar)
Dubblettleverans av en händelse

Varje scenario ska lämna systemet i ett konsistent tillstånd.

Testa tidsgränser

Orkestratorer anger ofta en tidsgräns för varje steg. Om ett steg inte svarar bör sagan utlösa kompensation.

import time

def wait_for_step(timeout, elapsed):
    if elapsed > timeout:
        return 'TIMEOUT -> COMPENSATE'
    return 'OK'

print(wait_for_step(5, 7))
print(wait_for_step(5, 3))

Verifiera konsistens i sluttillståndet

Det viktigaste att verifiera är att systemet slutar i ett giltigt tillstånd. Efter en misslyckad saga ska inga pengar ha debiterats och inget lager ha reserverats.

Fråga varje tjänst och verifiera att invarianten gäller i alla tjänster.

Spela upp händelser igen i tester

Eftersom meddelanden kan levereras mer än en gång ska ni spela upp samma händelse två gånger i testerna och verifiera att sagans tillstånd är oförändrat andra gången. Det verifierar idempotens på orkestratornivå.

processed = set()

def handle(event_id):
    if event_id in processed:
        return 'IGNORED (duplicate)'
    processed.add(event_id)
    return 'PROCESSED'

print(handle('e1'))
print(handle('e1'))

Observerbarhet i tester

Lägg till verifieringar av loggar, mätvärden och trace-spann som genereras. En vältestad saga bör skapa ett tydligt revisionsspår så att ni kan rekonstruera exakt vad som inträffade när ett verkligt fel uppstår i produktion.

Snabb kontroll

Vilken testtyp är bäst lämpad för att snabbt och deterministiskt verifiera orkestratorns övergångslogik?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er hur orkestrerade sagor testas:

Använd testpyramiden: många enhetstester och färre integrations- och E2E-tester.
Mocka tjänster för att tvinga fram både lyckade flöden och felflöden.
Testa alltid kompensationsordningen och konsistensen i sluttillståndet.
Spela upp händelser igen för att bekräfta idempotens och injicera tidsgränser och fel.

Grundliga sagatester är det som gör distribuerade transaktioner tillförlitliga.

Gratis att börja

Lär dig Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Testa orkestrerade sagor” gratis?

Ja – hela texten till ”Testa orkestrerade sagor” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker), kan Ni uppgradera till CoddyKit PRO. Kursen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) innehåller totalt 4 lektioner.

Vad lär jag mig i ”Testa orkestrerade sagor”?

Lär er att testa orkestreringsbaserade sagor med enhetstester för kompensationsvägar, integrationstester med simulerade tjänstefel och verifiering från början till slut av att sagan slutförs. Ni övar på Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)?

Du behöver inga förkunskaper. Utbildningen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Testa orkestrerade sagor”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)-lektionen?

Ja. Varje Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)