সরাসরি পর্বে যান
পর্ব ৭০ · ৮২-এর মধ্যে · মডিউল ১২

Microservice আর event-driven system-এর testing — queue, idempotency আর eventual consistency

Testing Microservices and Event-Driven Systems — Queues, Idempotency and Eventual Consistency

Taught in Bangla, this lesson assumes every message may arrive twice, late or out of order. Real pytest runs against four small local services (orders, broker, stock, notify) turn four of six tests red on a naive stock consumer and all green on an idempotent one. They show an outbox relay crash sending an event twice, a poison message moving to the dead-letter queue, and eventual consistency asserted with bounded polling instead of sleep. Real-broker examples are labelled as not run.

এই পর্বে যা শিখবেন

  • Monolith থেকে microservice-এ গেলে tester-এর কাজে কী বদলায়, আর কোন স্তরে কতটা test রাখবেন
  • Event-এর contract লেখা আর schema বদলের সময় breaking change ধরা
  • Duplicate, ক্রম ভাঙা আর poison message-এর test ডিজাইন করা, আর dead-letter queue যাচাই করা
  • Idempotent consumer, outbox আর saga-র compensation সত্যিই কাজ করে কি না, crash ঘটিয়ে প্রমাণ করা
  • sleep ছাড়া eventual consistency assert করা, আর correlation id দিয়ে কয়েক service-এর log জোড়া

১ · একটি অর্ডার, চারটি service — tester-এর চোখে কী বদলায়

পাড়ার মুদি দোকানে একজন মানুষ সব করেন: অর্ডার নেন, তাক থেকে মাল নামান, খাতায় স্টক কাটেন, আর ফোন করে জানান মাল তৈরি। ভুল হলে একজনকেই জিজ্ঞেস করতে হয়। বড় সুপারশপে কাজগুলো আলাদা টেবিলে: কাউন্টার অর্ডার নেয়, একটি চিরকুট গুদামে যায়, গুদাম স্টক কাটে, আরেকজন গ্রাহককে SMS পাঠান। প্রত্যেকে নিজের গতিতে কাজ করেন, একজন ছুটিতে থাকলে চিরকুট জমে থাকে। এখন ভুলের নতুন ধরন আসে: চিরকুট হারায়, দুবার পৌঁছায়, বা “অর্ডার বাতিল” চিরকুট “অর্ডার হয়েছে” চিরকুটের আগে পৌঁছায়।

Software-এ প্রথমটি monolith: পুরো app একটি প্রোগ্রাম, একটি database. দ্বিতীয়টি microservices: ছোট ছোট service, প্রত্যেকের নিজের database, আর তারা কথা বলে network দিয়ে। কথা বলার দুই ধরন। সরাসরি HTTP ডাক, যেখানে ডাকা service উত্তর না দেওয়া পর্যন্ত ডাকা থেমে থাকে। আর event-driven ধরন, যেখানে একটি service শুধু একটি event প্রকাশ করে (“অর্ডার #৭০ হয়েছে”), আর যার দরকার সে শুনে নিজের কাজ করে। মাঝখানে বার্তা জমা রাখে একটি message broker, যেমন Kafka বা RabbitMQ.

মূল ধারণা

Monolith-এ “অর্ডার দিলাম, স্টক কমল কি?” প্রশ্নের উত্তর একটি transaction-এর ভেতরে, সঙ্গে সঙ্গে। Event-driven system-এ উত্তর আসে পরে, অন্য process থেকে, আর পথে বার্তা দুবার আসতে, দেরি করতে বা ক্রম বদলাতে পারে। তাই tester-এর প্রশ্নগুলো বদলায়: “ঠিক মান আসে কি?”-এর সঙ্গে যোগ হয় “কখন আসে, কতবার আসে, কোন ক্রমে আসে, আর না এলে কী হয়?”

Tester-এর চোখে পাঁচটি জিনিস বদলায়। এক, জোড়ের সংখ্যা বাড়ে: প্রতিটি service-এর মাঝে একটি network আর একটি চুক্তি, যার backward compatibility রক্ষা করতে হয়। দুই, test-এর পরিবেশ জটিল হয়: চারটি service, চারটি database, একটি broker. তিন, সময় ঢুকে পড়ে: ফল সঙ্গে সঙ্গে নয়, eventual consistency, “শেষ পর্যন্ত মিলবে”. চার, ব্যর্থতা আংশিক: একটি service বন্ধ, বাকিরা চালু। পাঁচ, কোনো একক log নেই; একটি অর্ডারের গল্প চারটি log-এ ছড়ানো। এই পর্বের প্রতিটি অংশ এর একটি করে সমস্যা ধরে।

“Microservices” নামটি জনপ্রিয় হয় ২০১৪ সালে James Lewis আর Martin Fowler-এর একটি প্রবন্ধে, যদিও ছোট, আলাদা deploy করা service-এর চিন্তা তার আগেও নানা নামে চলত। বার্তা দিয়ে দূরের অংশ জোড়ার ধারণা আরও পুরোনো: message-oriented middleware আর enterprise message queue ১৯৯০-এর দশকেই ব্যবসায় চালু ছিল। Kafka তৈরি হয় একটি বড় প্রতিষ্ঠানের ভেতরে, ২০১১ সালে উন্মুক্ত হয়, আর পরে Apache Software Foundation-এর প্রকল্প হয়। নকশার দিক (কখন service ভাঙবেন, queue আর pub/sub কীভাবে কাজ করে) পাবেন সিস্টেম ডিজাইন কোর্সের পর্ব ৪৭ আর পর্ব ৩১-এ; এখানে দৃষ্টি শুধু tester-এর: এই নকশা ঠিক কাজ করছে, তা প্রমাণ করবেন কীভাবে।

২ · Test-এর স্তর — pyramid, honeycomb আর service-level test

পর্ব ০৫-এ (Test-এর স্তর আর ধরন) দেখেছেন test pyramid: নিচে অনেক unit test, মাঝে কম integration test, ওপরে অল্প end-to-end. Microservice-এ অনেক দল এই আকার বদলানোর কথা বলে, কারণ ছোট service-এর ভেতরের logic প্রায়ই পাতলা, আর ভুলগুলো থাকে জোড়ে: ভুল JSON field, ভুল ধারণা করা ক্রম, হারানো retry. এই যুক্তিতে ২০১৮ সালের দিকে একটি music-streaming প্রতিষ্ঠানের প্রকৌশলীরা testing honeycomb-এর ছবি প্রস্তাব করেন বলে জানা যায়: মাঝখানে মোটা অংশ integration test (একটি service আর তার আসল database, নকল প্রতিবেশী), দুই প্রান্তে অল্প। এটি নিয়ম নয়, একটি পর্যবেক্ষণ; আপনার service-এ জটিল ব্যবসায়িক logic থাকলে unit test-ই বেশি লাগবে।

স্তরকী আসল, কী নকলবাজারঘরে কী ধরে
Unitশুধু একটি ফাংশন; broker, database নকলEvent যাচাইয়ের নিয়ম, saga-র সিদ্ধান্ত
Service-level (component)একটি service আর তার আসল database; broker আসল বা হালকা নকল; অন্য service নকলStock service duplicate পেলে কী করে
Contractশুধু দুই পক্ষের চুক্তি: request/response বা event-এর গঠনqty field-এর নাম বদলালে কে ভাঙবে
Integration (কয়েক service)দুই-তিনটি আসল service আর আসল brokerOutbox → broker → stock-এর পুরো পথ
End-to-endসব আসল, UI থেকেক্রেতার চোখে checkout; অল্প কয়েকটি

এই পর্বের ল্যাবের বেশিরভাগ test service-level আর ছোট integration: test নিজে HTTP দিয়ে order দেয়, বা broker-এ সরাসরি একটি তৈরি করা event রাখে (যাতে duplicate আর ক্রম ভাঙা ইচ্ছামতো বানানো যায়), তারপর stock service-এর উত্তর দেখে। Integration test-এর মূল কৌশল আর Testcontainers পর্ব ২৮-এ (Integration testing); নির্ভরতা নকল করার উপায় পর্ব ৩৪-এ (Service virtualization). এখানে নতুন হলো বার্তার আচরণ।

৩ · Event-এর contract — schema, version আর backward compatibility

পর্ব ৩২-এ (Contract testing) HTTP API-র জন্য consumer-driven contract আর Pact দেখেছেন: consumer লিখে দেয় সে কী পাঠায় আর কী আশা করে, provider তা যাচাই করে। Event-এ একই চিন্তা খাটে, শুধু দিক উল্টো: producer একটি event প্রকাশ করে, আর একাধিক consumer তা পড়ে, প্রত্যেকে আলাদা field. এই চুক্তির নাম event contract. Pact-এ এর জন্য আলাদা ধরন আছে, message pact, যেখানে HTTP ছাড়াই শুধু বার্তার গঠন যাচাই হয়।

বাজারঘরের OrderPlaced event-এর version 1:

{"event_id": "5899fb1d-…", "type": "OrderPlaced", "version": 1,
 "order_id": 1, "sku": "DAL-1KG", "qty": 2, "correlation_id": "test-cid-001"}

Stock service পড়ে event_id, order_id, sku আর qty; notify service পড়ে event_id, order_id আর correlation_id. এখন producer-এর দল version 2-এর দুটি প্রস্তাব আনল। কোনটি কাকে ভাঙবে? নিচের checker প্রতিটি consumer যা পড়ে, তা নতুন schema-র সাথে মেলায়: field আছে কি, ধরন একই কি, আর সবসময় পাঠানো হয় কি।

// What each consumer READS from an OrderPlaced event (consumer-driven)
const consumers = {
  stock:  { event_id: "string", order_id: "integer", sku: "string", qty: "integer" },
  notify: { event_id: "string", order_id: "integer", correlation_id: "string" },
};
// Two proposals for version 2 of the producer's schema: field -> [type, always sent?]
const proposals = {
  "v2-a (rename qty)":  { event_id: ["string", true], order_id: ["integer", true],
    sku: ["string", true], quantity: ["integer", true], correlation_id: ["string", true] },
  "v2-b (add fields)":  { event_id: ["string", true], order_id: ["string", true],
    sku: ["string", true], qty: ["integer", true], correlation_id: ["string", false],
    total_taka: ["integer", true] },
};
function check(reads, schema) {
  const problems = [];
  for (const [field, type] of Object.entries(reads)) {
    const f = schema[field];
    if (!f) problems.push(`${field}: removed`);
    else if (f[0] !== type) problems.push(`${field}: ${type} -> ${f[0]}`);
    else if (!f[1]) problems.push(`${field}: no longer always sent`);
  }
  return problems;
}
for (const [name, schema] of Object.entries(proposals)) {
  console.log(name);
  for (const [who, reads] of Object.entries(consumers)) {
    const p = check(reads, schema);
    console.log(`  ${who.padEnd(6)} ${p.length ? "BREAKING: " + p.join("; ") : "ok"}`);
  }
}

আসল আউটপুট:

v2-a (rename qty)
  stock  BREAKING: qty: removed
  notify ok
v2-b (add fields)
  stock  BREAKING: order_id: integer -> string
  notify BREAKING: order_id: integer -> string; correlation_id: no longer always sent

প্রথম প্রস্তাবে শুধু নামবদল (qty → quantity), অথচ stock ভাঙে, notify নয়: কারণ notify ওই field পড়েই না। Consumer-driven চিন্তার সুবিধা এটাই, “সব field-এর তালিকা” নয়, “কে কী পড়ে” দেখা। দ্বিতীয় প্রস্তাব “শুধু field যোগ করলাম” বলে নিরীহ দেখায়, কিন্তু চুপিচুপি order_id-এর ধরন বদলেছে আর correlation_id ঐচ্ছিক করেছে; দুটি consumer-ই ভাঙে। নতুন total_taka নিয়ে কেউ অভিযোগ করেনি, কারণ পুরোনো consumer অজানা field উপেক্ষা করে। নিরাপদ পথ: নতুন field যোগ করুন, পুরোনোটি কিছুদিন পাশাপাশি রাখুন, সব consumer নতুনটিতে গেলে তবে সরান।

বাস্তবে এই যাচাই হাতে লেখা হয় না। Schema registry নতুন schema নিবন্ধনের সময়ই compatibility নিয়ম (যেমন backward: নতুন schema দিয়ে পুরোনো বার্তা পড়া যায় কি) পরীক্ষা করে ভাঙা schema আটকায়; AsyncAPI নামের একটি উন্মুক্ত specification event-চালিত API-র নথি লেখার মানদণ্ড দেয়, যেমন OpenAPI দেয় HTTP-র জন্য। কোন বদল নিরাপদ, তার নিয়ম (schema evolution) সিস্টেম ডিজাইন কোর্সের পর্ব ১২-এ আছে। Tester-এর কাজ: প্রতিটি consumer যা পড়ে, তার একটি contract test, আর CI-তে schema বদলের প্রতিটি প্রস্তাবে সেই test চালানো।

Version field-কে ভরসা করবেন না একা: "version": 1 লেখা থাকলেও producer ভুলে ধরন বদলে ফেলতে পারে, যেমন উপরের v2-b-তে। Version শুধু ঘোষণা; প্রমাণ হলো consumer-এর contract test, আর কোনো consumer যে event বোঝে না, তার জন্য পরিষ্কার নিয়ম (বাতিল করে DLQ-তে পাঠানো, §৪).

৪ · বার্তার চারটি ঝুঁকি — duplicate, ক্রম, poison আর হারানো

Broker কীভাবে বার্তা পৌঁছায়, তার তিন রকম প্রতিশ্রুতি। At-most-once: বড়জোর একবার, হারাতে পারে। At-least-once: অন্তত একবার, দুবারও আসতে পারে। Exactly-once: ঠিক একবার, যা হারাতে পারে এমন network-এ শুধু পৌঁছানো দিয়ে সম্ভব নয়; বাস্তবে এর মানে “at-least-once পৌঁছানো + consumer-এর দিকে duplicate বাদ দেওয়া”. বেশিরভাগ system at-least-once বেছে নেয়, কারণ হারানো বার্তার চেয়ে duplicate সামলানো সহজ। কেন duplicate আসে? Consumer বার্তাটি নিয়ে কাজ শেষ করে broker-কে ack পাঠানোর আগেই মরে গেলে, বা ack পথে হারালে, broker ধরে নেয় কাজ হয়নি; একটি নির্দিষ্ট সময় (visibility timeout) পরে বার্তাটি আবার দেয়। বিস্তারিত সিস্টেম ডিজাইন কোর্সের পর্ব ৩৪-এ।

🔁 Duplicate

একই event দুবার। সরল consumer দুবার স্টক কাটে। Test: একই event_id ইচ্ছা করে দুবার পাঠান।

at-least-once-এর স্বাভাবিক ফল

🔀 ক্রম ভাঙা

Cancel আগে, placed পরে। ক্রম সাধারণত শুধু একই ordering key-এর ভেতরে নিশ্চিত, তাও retry-তে ভাঙতে পারে। Test: উল্টো ক্রমে পাঠান।

retry, partition, একাধিক consumer

☠️ Poison message

যে বার্তা প্রতিবার consumer-কে ব্যর্থ করে। সীমা না থাকলে চিরকাল ঘোরে আর পেছনের সবাইকে আটকায় (head-of-line blocking).

সমাধান: চেষ্টার সীমা + DLQ

🕳️ হারানো

Database-এ order লেখা হলো, কিন্তু event পাঠানোর আগে service মরল। কেউ জানল না। Test: ঠিক সেই মুহূর্তে crash ঘটান (§৬).

সমাধান: outbox

প্রথম ঝুঁকিটি হাতে-কলমে দেখুন। নিচের simulator ২০টি অর্ডারের event পাঠায়, আর প্রতিটি ack ২৫% সম্ভাবনায় হারায় (random seed স্থির, তাই ফল প্রতিবার একই)। তিনটি consumer: সরল, “মনে রাখে” কিন্তু শুধু memory-তে (আর মাঝপথে একবার restart হয়), আর মনে রাখে, restart ছাড়া।

import random
random.seed(70)
events = [{"id": f"e{i:02}", "qty": 1} for i in range(1, 21)]   # 20 orders, 1 unit each

def at_least_once(events, p_lost_ack=0.25):
    """The broker resends a message whenever the consumer's ack is lost."""
    out = []
    for ev in events:
        out.append(ev)
        while random.random() < p_lost_ack:
            out.append(ev)                      # same message, again
    return out

def consume(stream, dedupe, restart_at=None):
    stock, seen = 100, set()
    for n, ev in enumerate(stream):
        if n == restart_at:
            seen = set()                        # in-memory memory is gone after a restart
        if dedupe and ev["id"] in seen:
            continue
        seen.add(ev["id"])
        stock -= ev["qty"]
    return stock

stream = at_least_once(events)
dups = len(stream) - len(events)
print(f"orders: {len(events)}, deliveries: {len(stream)} ({dups} duplicates)")
print("expected stock     :", 100 - len(events))
print("naive consumer     :", consume(stream, dedupe=False))
print("dedupe in memory   :", consume(stream, dedupe=True, restart_at=13))
print("dedupe, no restart :", consume(stream, dedupe=True))
print("deliveries 12..15  :", [e["id"] for e in stream[11:15]])

আসল আউটপুট:

orders: 20, deliveries: 27 (7 duplicates)
expected stock     : 80
naive consumer     : 73
dedupe in memory   : 79
dedupe, no restart : 80
deliveries 12..15  : ['e10', 'e11', 'e11', 'e12']

২০টি অর্ডারে ২৭টি delivery: ৭টি duplicate. সরল consumer স্টক ৭৩ দেখায়, অর্থাৎ ৭টি ডাল কাগজে বিক্রি হয়েছে অথচ গুদামে আছে; পরে ক্রেতারা “স্টক নেই” দেখবেন, যদিও মাল তাকেই। Memory-তে মনে রাখা consumer প্রায় ঠিক, ৭৯: শেষ লাইনে দেখুন, ১৩ নম্বর delivery e11, তারপর restart, তারপর আবার e11. Restart-এ মনে রাখার set মুছে গেছে, তাই duplicate ঢুকে গেল। শিক্ষা দুটি: duplicate বাদ দেওয়ার চিহ্ন রাখতে হবে টেকসই জায়গায় (database), আর সেই চিহ্ন ও স্টক কমানো লিখতে হবে একই transaction-এ, যাতে একটি হলে অন্যটিও হয়। এমন consumer-এর নাম idempotent consumer. সাধারণ idempotency আর একসাথে আসা retry-র test পর্ব ৬২-এ (Concurrency আর async testing); এখানে একই ধারণা বার্তার জগতে।

নিচের stepper ল্যাবের আসল stock service-এর একটি run (§৫-এর শেষ test): event ধরে স্টক কমানো হলো, তারপর ack পাঠানোর আগেই process মরল। Broker ৮০০ ms পরে একই বার্তা আবার দিল।

1BEGIN IMMEDIATE2if event_id in processed:3  COMMIT; "duplicate"4INSERT processed(event_id)5state = order_state[id]6if Placed, state None:7  stock -= qty8COMMIT9ack(msg)
Stock service আর broker
delivery
processed
DAL stock
broker
  1. প্রথম delivery. অর্ডার ৫০৫-এর OrderPlaced, ৩টি ডাল। Broker বার্তাটি ৮০০ ms-এর জন্য এই consumer-এর নামে “ধার” দিয়েছে (lease). Transaction শুরু, তারপর প্রশ্ন: এই event_id আগে দেখেছি কি? না।
  2. চিহ্ন রাখা। processed টেবিলে event_id লেখা হলো, কিন্তু transaction এখনো খোলা: কিছুই স্থায়ী হয়নি।
  3. Effect আর commit. এই অর্ডারের আগের কোনো অবস্থা নেই, তাই স্টক ৮০ থেকে ৭৭, অবস্থা “placed”. COMMIT: চিহ্ন আর স্টক একসাথে স্থায়ী।
  4. Ack-এর আগে crash. Test ইচ্ছা করে process মেরেছে (STOCK_CRASH_BEFORE_ACK=1). Database-এ স্টক ৭৭, কিন্তু broker জানে না কাজ হয়েছে। Lease শেষ হলে বার্তা আবার দেওয়া হবে, যা at-least-once-এর প্রতিশ্রুতি।
  5. Restart আর দ্বিতীয় delivery. নতুন process, একই database. Broker একই বার্তা দিল, এবার try 2. আবার সেই প্রশ্ন।
  6. Duplicate ধরা পড়ল। event_id আগেই আছে, তাই effect ছাড়াই commit, তারপর ack. স্টক ৭৭ থাকল, test সবুজ। সরল consumer-এ (v1) একই test-এ স্টক হয়েছিল ৭৪: ৩টি ডাল দুবার কাটা।

৫ · ল্যাব — চারটি ছোট service আর সত্যিকারের test run

এই কম্পিউটারে কোনো message broker (Kafka, RabbitMQ বা Redis) বা Docker নেই, আর ইনস্টল করাও হয়নি। তাই ল্যাবের জন্য Python-এর standard library দিয়ে চারটি ছোট service লেখা হয়েছে, প্রতিটি নিজের 127.0.0.1 port-এ আর নিজের SQLite ফাইলে। এর মধ্যে broker একটি শেখানোর খেলনা, Kafka নয়: একটি topic, প্রতিটি consumer group-এর নিজের কপি, ৮০০ ms-এর lease, আর তিনবার ব্যর্থ হলে dead-letter queue. কিন্তু যে আচরণগুলো test করা হচ্ছে (duplicate, redelivery, DLQ), সেগুলো আসল broker-এরও মূল আচরণ, তাই test-এর কৌশল একই থাকে। Test চালিয়েছে pytest 9.2.0 (MIT লাইসেন্স), Python 3.14.4-এ, নিজের uv পরিবেশে; বাইরের কোনো অনুরোধ নেই, কোনো telemetry নেই।

ল্যাবের গঠন: একটি অর্ডারের event-এর পথ

Lab layout: orders, outbox relay, broker, two consumer groups and a DLQ

ল্যাব: pytest, orders আর outbox, relay, broker, stock আর notify consumer group, DLQ pytest · eventually() order দেয়, event বানায়, স্টক পড়ে orders · :8882 order + outbox সারি, এক transaction relay: sent=0 → publish → sent=1 broker · :8883 topic order-events · lease 800 ms · ৩ চেষ্টা stock · :8884 group stock dedupe + order state notify · :8885 group notify নকল SMS, সারি রাখে DLQ · stock:dead ৩ বার ব্যর্থ বার্তা প্রতিটি service-এর নিজের SQLite ফাইল সব port শুধু 127.0.0.1-এ
ছবি ৭০.১ — একটি OrderPlaced event: orders-এর outbox থেকে relay, broker-এর topic, তারপর দুটি consumer group-এর নিজের নিজের কপি। Stock-এর বার্তা তিনবার ব্যর্থ হলে DLQ-তে যায়।

Stock service-এর প্রথম সংস্করণ (v1) ইচ্ছা করে সরল লেখা হয়েছিল, যেমনটি তাড়াহুড়োয় লেখা হয়: প্রতিটি delivery-তে স্টক বদলায়। দ্বিতীয় সংস্করণ (v2) প্রতিটি event_id একটি টেবিলে মনে রাখে, আর প্রতিটি অর্ডারের অবস্থাও। দুটির মূল অংশ (ল্যাবে একটি environment variable দিয়ে সংস্করণ বাছা হয়):

def apply_v1(ev):                       # naive: every delivery changes stock
    con.execute("UPDATE stock SET qty = qty + ? WHERE sku=?",
                (TYPES[ev["type"]] * ev["qty"], ev["sku"]))

def apply_v2(ev):                       # dedupe + order state, one transaction
    con.execute("BEGIN IMMEDIATE")
    if con.execute("SELECT 1 FROM processed WHERE event_id=?", (ev["event_id"],)).fetchone():
        con.execute("COMMIT")
        return "duplicate, skipped"
    con.execute("INSERT INTO processed VALUES (?)", (ev["event_id"],))
    state = order_state(ev["order_id"])           # None, "placed" or "cancelled"
    delta = 0
    if ev["type"] == "OrderPlaced" and state is None:
        delta, new = -ev["qty"], "placed"
    elif ev["type"] == "OrderCancelled":
        delta, new = (ev["qty"] if state == "placed" else 0), "cancelled"
    else:
        new = state                               # placed after cancel: ignore
    ...                                           # UPDATE stock, save state, COMMIT

ছয়টি test, প্রতিটি নিজের ফাঁকা database নিয়ে চারটি service চালু করে, শেষে নিজের শুরু করা process-গুলো PID ধরে বন্ধ করে। তিনটির মূল অংশ:

def test_duplicate_delivery_changes_stock_once(system):
    ev = event("OrderPlaced", 501)                # qty 2, stock starts at 80
    publish(ev)
    publish(ev)                                   # same event_id twice
    eventually(lambda: _eq(acked("stock"), 2))
    assert stock() == 78

def test_cancel_arriving_before_placed(system):
    publish(event("OrderCancelled", 502))         # out of order: cancel first
    eventually(lambda: _eq(acked("stock"), 1))
    assert stock() == 80                          # nothing taken, nothing to give back
    publish(event("OrderPlaced", 502))
    eventually(lambda: _eq(acked("stock"), 2))
    assert stock() == 80

def test_poison_message_goes_to_dlq_and_queue_moves_on(system):
    publish({"type": "OrderPlaced", "version": 1, "order_id": "৫০৩", "sku": "DAL-1KG", "qty": 2})
    publish(event("OrderPlaced", 504, qty=1))
    eventually(lambda: _eq(stock(), 79))
    dead = eventually(lambda: _nonempty(dlq("stock")))
    assert dead[0]["attempts"] == 3 and "event_id" in dead[0]["reason"]

লক্ষ করুন, duplicate test-এ শুধু স্টক দেখা হয়নি: আগে অপেক্ষা করা হয়েছে যতক্ষণ না broker দুটি delivery-রই ack পায়। না হলে প্রথম বার্তা প্রক্রিয়া হতেই স্টক ৭৮ দেখে test সবুজ হয়ে যেত, দ্বিতীয়টি আসার আগেই; সরল consumer-ও পাস করত। Asynchronous test-এ “কখন দেখব” প্রশ্নটি assert-এর মতোই গুরুত্বপূর্ণ।

প্রথমে v1-এর বিরুদ্ধে। সত্যিকারের run (ল্যাবের path বদলে ~/bazarghar-events লেখা):

$ STOCK_IDEMPOTENT=0 uv run pytest -q --tb=line
.FF.FF                                                                   [100%]
================================== FAILURES ===================================
E   assert 76 == 78
     +  where 76 = stock()
~/bazarghar-events/tests/test_order_events.py:48: assert 76 == 78
E   assert 82 == 80
     +  where 82 = stock()
~/bazarghar-events/tests/test_order_events.py:54: assert 82 == 80
E   assert 76 == 78
     +  where 76 = stock()
~/bazarghar-events/tests/test_order_events.py:77: assert 76 == 78
E   assert 74 == 77
     +  where 74 = stock()
~/bazarghar-events/tests/test_order_events.py:88: assert 74 == 77
=========================== short test summary info ===========================
FAILED tests/test_order_events.py::test_duplicate_delivery_changes_stock_once
FAILED tests/test_order_events.py::test_cancel_arriving_before_placed - asser...
FAILED tests/test_order_events.py::test_relay_crash_after_publish_is_replayed_without_double_stock
FAILED tests/test_order_events.py::test_stock_crash_before_ack_is_redelivered_once_applied
4 failed, 2 passed in 17.03s

চারটি ব্যর্থতা, চারটি গল্প। Duplicate-এ ২টি ডাল দুবার কাটা: ৮০ থেকে ৭৬. আগে আসা cancel-এ স্টক ৮২: যে অর্ডারের মাল কখনো কাটা হয়নি, তার “ফেরত” যোগ হয়েছে; ওই মুহূর্তে দুটি না-থাকা ডাল বিক্রির জন্য দেখা যাচ্ছিল। শেষ দুটি crash-এর test: relay মরলে (§৬) আর stock service ack-এর আগে মরলে, দুই ক্ষেত্রেই আবার আসা বার্তায় দ্বিতীয়বার কাটা। মজার ব্যাপার, আগের একটি সংস্করণে cancel-এর test-টি শুধু শেষ অবস্থা দেখত (cancel, তারপর placed, শেষে ৮০), আর সরল consumer-ও পাস করছিল, কারণ +২ আর −২ মিলে শূন্য। মাঝের ভুল অবস্থা ধরতে assert বসাতে হয়েছে প্রথম বার্তার পরেই।

এবার v2. একই ছয়টি test, পরপর তিনবার:

$ uv run pytest -v
tests/test_order_events.py::test_order_reaches_stock_and_notify_with_same_correlation_id PASSED [ 16%]
tests/test_order_events.py::test_duplicate_delivery_changes_stock_once PASSED [ 33%]
tests/test_order_events.py::test_cancel_arriving_before_placed PASSED    [ 50%]
tests/test_order_events.py::test_poison_message_goes_to_dlq_and_queue_moves_on PASSED [ 66%]
tests/test_order_events.py::test_relay_crash_after_publish_is_replayed_without_double_stock PASSED [ 83%]
tests/test_order_events.py::test_stock_crash_before_ack_is_redelivered_once_applied PASSED [100%]
============================= 6 passed in 17.19s ==============================
(দ্বিতীয় ও তৃতীয় run: 6 passed in 17.14s, 6 passed in 17.08s)

Poison message-এর test-এর ভেতরে কী ঘটল, তা দেখতে একই দুটি বার্তা একটি ছোট script দিয়ে আবার পাঠানো হলো, আর stock service-এর log ও broker-এর DLQ পড়া হলো। সত্যিকারের আউটপুট:

[stock] cid=- msg 1 attempt 1 REJECTED: field event_id missing or not str
[stock] cid=- msg 1 attempt 2 REJECTED: field event_id missing or not str
[stock] cid=- msg 1 attempt 3 REJECTED: field event_id missing or not str
[stock] cid=bg-91c2 msg 2 attempt 1 OrderPlaced order 504: applied -1
DLQ: [{"id": 1, "attempts": 3, "reason": "field event_id missing or not str",
       "body": {"type": "OrderPlaced", "version": 1, "order_id": "৫০৩", "sku": "DAL-1KG", "qty": 2}}]
stats: {'messages': 2, 'deliveries': {'notify:ready': 2, 'stock:acked': 1, 'stock:dead': 1}}

ভাঙা বার্তায় event_id নেই আর order_id বাংলা অঙ্কে লেখা string. Poison message তিনবার প্রত্যাখ্যাত, তারপর DLQ-তে, কারণসহ। তার পরেই পেছনে আটকে থাকা ভালো বার্তা চলল। এই log দেখায় head-of-line blocking-ও: ভালো বার্তাটি তিন চেষ্টা শেষ হওয়া পর্যন্ত অপেক্ষা করেছে। DLQ-র test-এ তাই তিনটি জিনিস দেখুন: খারাপ বার্তা DLQ-তে গেল কি, কারণ লেখা আছে কি, আর ভালো বার্তা পরে চলল কি। শেষ লাইনে notify:ready: 2 এসেছে কারণ এই script-এ notify service চালু করা হয়নি; তার কপি জমে আছে, হারায়নি।

DLQ মানে শেষ নয়: DLQ-তে যাওয়া বার্তা একজন মানুষ দেখবেন, কারণ ঠিক করবেন, আর দরকার হলে আবার মূল সারিতে পাঠাবেন (redrive). তাই এর জন্যও test লাগে: DLQ-তে বার্তা জমলে alert যায় কি, আবার পাঠালে idempotent consumer তা একবারই প্রয়োগ করে কি, আর বার্তার body-তে ক্রেতার ব্যক্তিগত তথ্য থাকলে DLQ-র অনুমতি কে পায়।

৬ · Outbox — event না হারানো, আর relay crash-এর test

অর্ডার নেওয়ার কোড প্রায়ই এমন দেখায়: প্রথমে database-এ order লেখা, তারপর broker-এ event পাঠানো। একে বলে dual write: দুটি আলাদা জায়গায় দুটি আলাদা লেখা, মাঝখানে কোনো যৌথ transaction নেই। মাঝখানে process মরলে order আছে, event নেই; স্টক কখনো কমবে না, ক্রেতা SMS পাবেন না। উল্টো ক্রমে (আগে event, পরে database) মরলে event গেছে অথচ order নেই। সমাধান transactional outbox: order-এর সারি আর “পাঠাতে হবে” এমন event-এর সারি একই local transaction-এ একটি outbox টেবিলে লেখা; আলাদা একটি relay পরে outbox থেকে পড়ে broker-এ পাঠায় আর সারিটিকে “পাঠানো” চিহ্নিত করে। নকশার বিস্তারিত সিস্টেম ডিজাইন কোর্সের পর্ব ২৫-এ।

দুই পথের পার্থক্য সংখ্যায় দেখুন। ১০০০টি অর্ডার, আর প্রতিটি crash-এর জায়গায় ২% সম্ভাবনায় crash (seed স্থির):

import random
random.seed(2026)
N, P_CRASH = 1000, 0.02          # 1000 orders; a crash point fires 2% of the time

def dual_write():
    """save order, then publish: a crash in between loses the event forever"""
    saved = published = 0
    for _ in range(N):
        saved += 1                                  # COMMIT order
        if random.random() < P_CRASH:
            continue                                # crash: event never sent
        published += 1
    return saved, published

def outbox():
    """order + outbox row in ONE commit; relay publishes, then marks sent"""
    saved = published = 0
    for _ in range(N):
        saved += 1                                  # COMMIT order + outbox row
        while True:
            published += 1                          # relay publishes the row
            if random.random() < P_CRASH:
                continue                            # crash before 'sent=1': resend
            break
    return saved, published

for name, fn in (("dual write", dual_write), ("outbox", outbox)):
    saved, pub = fn()
    lost, extra = max(saved - pub, 0), max(pub - saved, 0)
    print(f"{name:10}  orders={saved}  events sent={pub}  lost={lost}  duplicates={extra}")

আসল আউটপুট:

dual write  orders=1000  events sent=981  lost=19  duplicates=0
outbox      orders=1000  events sent=1017  lost=0  duplicates=17

Dual write-এ ১৯টি অর্ডারের event চিরতরে হারাল, আর কোনো log-এ এর চিহ্ন নেই: সবচেয়ে বিপজ্জনক ধরনের ভুল। Outbox-এ একটিও হারায়নি, কিন্তু ১৭টি event দুবার গেছে: relay publish করে “পাঠানো” লেখার আগে মরলে, পরের বার একই সারি আবার পাঠায়। অর্থাৎ outbox হারানোকে duplicate-এ বদলে দেয়, আর duplicate সামলায় idempotent consumer. দুটি একসাথে test করতে হয়: শুধু outbox, বা শুধু idempotent consumer, কোনোটিই একা যথেষ্ট নয়। এই simulator-এ duplicate প্রতি অর্ডারে একবারের বেশিও হতে পারে; ২% সম্ভাবনায় তা বিরল।

এবার ল্যাবে একই ঘটনা সত্যিই ঘটানো হলো। Orders service-কে একটি switch দিয়ে চালু করা হয়েছে, যাতে relay প্রথম publish-এর পরেই, sent=1 লেখার আগে, process থেকে বেরিয়ে যায় (exit code ৩). Test সেই exit দেখে, switch ছাড়া service আবার চালু করে, আর দেখে কী হয়:

  1. Order + outboxCOMMITsent=0
  2. Relaypublishmessages=1
  3. Crashexit 3sent এখনো 0
  4. Restartpublishmessages=2
  5. Consumersdedupeস্টক ৭৮
orders.dbএকটি transaction
orders: id=1 mitu DAL-1KG qty=2 placed
outbox: event 5899fb1d… sent=0
# দুটি সারি একসাথে, নয়তো কোনোটিই নয়
relaysent=0 সারি পড়া
POST /publish → 201  (broker msg 1)
# এরপর UPDATE outbox SET sent=1 …
orders.logসত্যিকারের log
[orders] cid=test-cid-001 order 1 placed
[orders] cid=test-cid-001 relay CRASH after
  publishing OrderPlaced 5899fb1d
restartoutbox-এ sent=0 রয়ে গেছে
POST /publish → 201  (broker msg 2)
UPDATE outbox SET sent=1
broker: messages=2, একই event_id
stock.logসত্যিকারের log
msg 1 attempt 1 OrderPlaced order 1: applied -2
msg 2 attempt 1 OrderPlaced order 1:
  duplicate, skipped
notify.logলুকানো সংকেত
[notify] cid=test-cid-001 order 1 message stored
[notify] cid=test-cid-001 order 1 message stored
# টেবিলে সারি ১টি, log-এ ২ বার
  1. এক commit, দুই সারি। POST /orders একটি transaction খুলে order আর outbox-এর সারি লিখল, তারপর COMMIT. এখানে crash হলে দুটিই থাকে না, অর্ডারও হয়নি, event-ও না: কোনো অসঙ্গতি নেই।
  2. Relay পাঠাল। আলাদা thread প্রতি ৫০ ms-এ sent=0 সারি খোঁজে। Broker ২০১ দিল: বার্তা জমা হয়েছে।
  3. চিহ্ন দেওয়ার আগে crash. Switch চালু থাকায় relay sent=1 লেখার আগেই process থেকে বেরিয়ে গেল। Broker-এ event আছে, কিন্তু orders-এর database বলছে “এখনো পাঠানো হয়নি”.
  4. Restart, আবার পাঠানো। Test switch ছাড়া orders চালু করল। Relay একই সারি আবার পাঠাল, এবার চিহ্নও দিল। Broker-এ এখন দুটি বার্তা, একই event_id. Test এই সংখ্যাটিও assert করে, যাতে নিশ্চিত হয় duplicate সত্যিই তৈরি হয়েছিল; নইলে “স্টক ঠিক আছে” প্রমাণ করত না যে consumer duplicate সামলায়।
  5. Stock duplicate বাদ দিল। প্রথম বার্তায় −২, দ্বিতীয়টি “duplicate, skipped”. স্টক ৭৮, test সবুজ। v1-এ এখানে ৭৬.
  6. Notify-এর লুকানো সংকেত। Notify-এর টেবিলে INSERT OR IGNORE, তাই সারি একটিই। কিন্তু log দুবার “stored” বলছে, কারণ log লেখা হয় dedupe দেখার আগেই। আসল SMS পাঠানো হলে ক্রেতা দুটি SMS পেতেন। এই test স্টক দেখে, notify-এর বাইরের effect দেখে না: ঠিক এখানেই একটি নতুন test লাগে (অনুশীলন ৩).

Saga-র এক ঝলক: একটি অর্ডারে কয়েকটি service-এর কাজ লাগলে (স্টক রাখা, wallet-এ টাকা কাটা, delivery বুক করা), একটি বড় transaction সম্ভব নয়। Saga কাজটিকে ধাপে ভাগ করে, প্রতিটি ধাপ নিজে commit, আর পরের ধাপ ব্যর্থ হলে আগের ধাপের compensation চলে (যেমন রাখা স্টক ছেড়ে দেওয়া)। Saga দুইভাবে চলে: কেন্দ্রীয় পরিচালক (orchestration) বা event শুনে নিজে নিজে (choreography). এর test §৮-এ।

৭ · Eventual consistency assert করা — sleep নয়, সীমিত অপেক্ষা

বাসের টিকিট কাউন্টারে টাকা দিলেন; টিকিট সঙ্গে সঙ্গে হাতে, কিন্তু আসনের তালিকায় নাম ওঠে কয়েক মিনিট পরে। কেউ যদি টাকা দেওয়ার সঙ্গে সঙ্গে তালিকা দেখে বলেন “নাম নেই, তাই টিকিট হয়নি”, ভুল বলবেন। আবার “দশ মিনিট বসে থাকি, তারপর দেখি” বললেও দুই সমস্যা: নাম এক মিনিটে উঠলে নয় মিনিট নষ্ট, আর কোনোদিন এগারো মিনিট লাগলে ভুল রায়। ভালো উপায়: প্রতি কয়েক সেকেন্ডে তালিকা দেখা, নাম উঠলেই থামা, আর একটি সর্বোচ্চ সময় ঠিক করা, যার পরেও না উঠলে অভিযোগ।

Test-এ এটিই bounded polling. ল্যাবের helper:

def eventually(check, timeout=5.0, interval=0.05):
    """Bounded polling: retry `check` until it stops raising AssertionError, or time out."""
    deadline = time.monotonic() + timeout
    while True:
        try:
            return check()
        except AssertionError:
            if time.monotonic() > deadline:
                raise                    # the LAST real failure, with its values
            time.sleep(interval)

তিনটি নকশার সিদ্ধান্ত লক্ষ করুন। time.monotonic(), কারণ কম্পিউটারের ঘড়ি মাঝপথে বদলালেও এটি পেছনে যায় না। শুধু AssertionError ধরা, তাই কোডের অন্য ভুল (যেমন KeyError) সঙ্গে সঙ্গে লাল হয়, পাঁচ সেকেন্ড অপেক্ষা করে লুকায় না। আর সময় শেষে শেষ ব্যর্থতাটিই আবার ছোড়া, যাতে বার্তায় আসল মান থাকে (80 != 78), শুধু “timeout” নয়। একই কাজের জন্য তৈরি library-ও আছে (যেমন Java-তে Awaitility, Python-এ tenacity-র মতো retry library), কিন্তু নীতি একই।

একটি অর্ডার দিয়ে সত্যিকারের মাপ (একটি ছোট script, চারটি service চালু করে)। Script order দেয়, সঙ্গে সঙ্গে স্টক পড়ে, তারপর eventually দিয়ে অপেক্ষা করে, আর প্রতিটি poll-এর সময় ও মান রাখে:

POST /orders -> 201 id=1; stock read at once = 80
stock == 78 after 2 polls, 95 ms  ['29ms:80', '95ms:78']
[orders] cid=bg-7f3a order 1 placed
[stock] cid=bg-7f3a msg 1 attempt 1 OrderPlaced order 1: applied -2
[notify] cid=bg-7f3a order 1 message stored
Test যা দেখছে
সময়
কাজ
DAL stock
রায়
  1. Order দেওয়া। Orders service ২০১ দিল: অর্ডার আর outbox-এর সারি commit হয়েছে। কিন্তু স্টক বদলায় অন্য process-এ, পরে। ২০১ মানে “গ্রহণ করেছি”, “সব শেষ” নয়।
  2. সঙ্গে সঙ্গে পড়া। স্টক এখনো ৮০. এখানে assert stock() == 78 লিখলে test লাল, অথচ system ঠিক আছে। এটিই eventual consistency: কিছুক্ষণ পুরোনো মান দেখা স্বাভাবিক।
  3. Poll ১, ২৯ ms-এ। এখনো ৮০. eventually AssertionError ধরে, সময়সীমা পেরোয়নি দেখে ৫০ ms অপেক্ষা করে।
  4. Poll ২, ৯৫ ms-এ। ৭৮. Assert পাস, helper সঙ্গে সঙ্গে ফেরে; বাকি ৪.৯ সেকেন্ড নষ্ট হয় না। আটবার চালিয়ে মিলতে লেগেছে ৯৩ থেকে ১৫৯ ms, কখনো দুটি poll-এ, কখনো তিনটিতে।
  5. যদি কখনো না আসে। Consumer মরা বা event হারানো হলে স্টক ৮০-তেই থাকে। ৫ সেকেন্ড পরে helper শেষ ব্যর্থতাটি ছোড়ে: 80 != 78. Test লাল, স্পষ্ট কারণসহ। কত সময় দেবেন? স্বাভাবিক সময়ের অনেক গুণ (এখানে প্রায় ৫০ গুণ), যাতে ধীর CI-তে মিথ্যা লাল না হয়, কিন্তু এত বেশি নয় যে আসল ভুলে suite আধা ঘণ্টা ঝুলে থাকে।

sleep(2) কেন খারাপ: স্থির অপেক্ষা হয় অপ্রয়োজনে ধীর (এখানে ৯৫ ms-এর কাজে ২০০০ ms), নয়তো ধীর মেশিনে অপর্যাপ্ত, আর তখন test কখনো সবুজ কখনো লাল: flaky test. আর sleep-এর পরে একবার দেখা test-এর বার্তায় থাকে না কতক্ষণ চেষ্টা হয়েছিল। Flaky test-এর কারণ আর সমাধানের পূর্ণ আলোচনা পর্ব ৪০-এ (Flaky test).

Correlation id আর distributed tracing — চারটি log-এ একটি গল্প

উপরের আউটপুটের শেষ তিন লাইন তিনটি আলাদা service-এর log, অথচ একটি অর্ডারের গল্প। জোড়া দিয়েছে একটি correlation id: test অনুরোধের header-এ X-Correlation-Id: bg-7f3a পাঠিয়েছে, orders তা event-এ বসিয়েছে, আর প্রতিটি consumer নিজের log-এ লিখেছে। ল্যাবের প্রথম test এটি assert-ও করে: notify-এর সারিতে ঠিক test-cid-001 আছে কি না। কোনো service id হারিয়ে ফেললে (যেমন নতুন event version-এ field ঐচ্ছিক হলে, §৩) test লাল হয়।

Production-এ এর বড় রূপ distributed tracing: প্রতিটি অনুরোধ একটি trace, প্রতিটি service-এর কাজ একটি span, আর trace id যায় HTTP header-এ (W3C-র Trace Context মানদণ্ডের traceparent) বা বার্তার header-এ। OpenTelemetry এর একটি উন্মুক্ত মানদণ্ড আর SDK. Tester-এর জন্য এর দুটি ব্যবহার: test-এ trace id নিজে বানিয়ে পাঠানো, যাতে ব্যর্থ test-এর পুরো পথ পরে খুঁজে পাওয়া যায়; আর “trace-ভিত্তিক test”, যেখানে assert করা হয় একটি অনুরোধে কোন কোন service ডাকা হলো, কতবার। নকশা আর metric, log, trace-এর পার্থক্য সিস্টেম ডিজাইন কোর্সের পর্ব ৫০-এ।

৮ · Saga-র compensation, আসল broker আর service-এর পরিবেশ

Checkout-এর একটি ছোট saga: প্রথম ধাপে স্টক রাখা (reserve), দ্বিতীয় ধাপে wallet-এ টাকা কাটা। Wallet এখানে সবসময় নকল (test double, unittest.mock), কারণ লক্ষ্য saga-র সিদ্ধান্ত, wallet নয়। Requirement: “Wallet ব্যর্থ হলে অর্ডার বাতিল, আর রাখা স্টক ছেড়ে দিতে হবে।” নিচের কোডে একটি বাস্তব ভুল আছে; test requirement থেকে লেখা, কোড থেকে নয়:

import sys, unittest
from unittest import mock

def checkout_saga(order, stock, wallet):
    """step 1 reserve stock, step 2 charge (MOCK wallet); on failure undo step 1"""
    stock.reserve(order["sku"], order["qty"])
    try:
        wallet.charge(order["id"], order["total"])
    except ConnectionError:
        return "cancelled"                     # BUG: compensation (release) is missing
    return "paid"

class SagaTest(unittest.TestCase):
    def setUp(self):
        self.order = {"id": 70, "sku": "DAL-1KG", "qty": 2, "total": 330}
        self.stock, self.wallet = mock.Mock(), mock.Mock()

    def test_happy_path_reserves_and_charges(self):
        self.assertEqual(checkout_saga(self.order, self.stock, self.wallet), "paid")
        self.stock.reserve.assert_called_once_with("DAL-1KG", 2)
        self.stock.release.assert_not_called()

    def test_wallet_down_releases_the_reserved_stock(self):
        self.wallet.charge.side_effect = ConnectionError("wallet down")
        self.assertEqual(checkout_saga(self.order, self.stock, self.wallet), "cancelled")
        self.stock.release.assert_called_once_with("DAL-1KG", 2)

unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(
    unittest.defaultTestLoader.loadTestsFromTestCase(SagaTest))

আসল আউটপুট (traceback-এর মাঝের অংশ ছোট করা):

test_happy_path_reserves_and_charges (__main__.SagaTest.test_happy_path_reserves_and_charges) ... ok
test_wallet_down_releases_the_reserved_stock (__main__.SagaTest.test_wallet_down_releases_the_reserved_stock) ... FAIL

======================================================================
FAIL: test_wallet_down_releases_the_reserved_stock (__main__.SagaTest.test_wallet_down_releases_the_reserved_stock)
----------------------------------------------------------------------
Traceback (most recent call last):
  …
AssertionError: Expected 'release' to be called once. Called 0 times.

----------------------------------------------------------------------
Ran 2 tests in 0.003s

FAILED (failures=1)

সুখী পথ সবুজ। Wallet বন্ধ থাকলে অর্ডার “cancelled” ঠিকই, অথচ স্টক ছাড়া হয়নি: দুটি ডাল চিরকাল “রাখা” থাকবে, কেউ কিনতে পারবেন না। শুধু ফেরত মান ("cancelled") দেখলে test সবুজ হতো; compensation-এর effect দেখতে হয়েছে বলে ধরা পড়ল। Fix: except-এর ভেতরে stock.release(order["sku"], order["qty"]). Saga-র test-এ আরও তিনটি প্রশ্ন রাখুন: compensation নিজে ব্যর্থ হলে কী হয় (retry করে কি, শেষে মানুষের কাছে যায় কি), compensation দুবার চললে কি স্টক দুবার ফেরে (তাকেও idempotent হতে হবে), আর কোনো ধাপ “উত্তর হারানো” অবস্থায় থাকলে (টাকা কাটা হয়েছে কি না অজানা) saga কী করে। শেষটি পর্ব ৬৩-এ (Chaos আর resilience testing) দেখা wallet timeout-এর সমস্যার আত্মীয়।

আসল broker দিয়ে test — উদাহরণ, চালানো হয়নি

ল্যাবের খেলনা broker-এর বাইরে, Kafka বা RabbitMQ-র নিজস্ব আচরণ (partition, offset commit, consumer group-এর rebalance, broker-এর নিজের retry আর DLQ-র নিয়ম) যাচাই করতে আসল broker লাগে। পর্ব ২৮-এ দেখা Testcontainers প্রতিটি test run-এ একটি container-এ আসল broker চালাতে পারে। নিচের কোড শুধু ধাঁচ দেখানোর জন্য: এই কম্পিউটারে Docker নেই, তাই চালানো হয়নি, আর কোনো আউটপুট দেখানো হচ্ছে না। ব্যবহৃত package: testcontainers-python আর confluent-kafka-python (দুটিই Apache-2.0); নাম আর option অফিশিয়াল নথিতে মিলিয়ে নেবেন।

# উদাহরণ, চালানো হয়নি: এই কম্পিউটারে Docker নেই
from testcontainers.kafka import KafkaContainer
from confluent_kafka import Producer, Consumer

def test_order_event_roundtrip():
    with KafkaContainer() as kafka:                       # real broker in a container
        url = kafka.get_bootstrap_server()
        p = Producer({"bootstrap.servers": url})
        p.produce("order-events", key="501", value=b'{"event_id": "e-1", "type": "OrderPlaced"}')
        p.flush()
        c = Consumer({"bootstrap.servers": url, "group.id": "stock",
                      "auto.offset.reset": "earliest", "enable.auto.commit": False})
        c.subscribe(["order-events"])
        msg = c.poll(10.0)                                # bounded wait, not sleep
        assert msg is not None and msg.key() == b"501"

এখানে enable.auto.commit: False গুরুত্বপূর্ণ: offset (কতদূর পড়া হয়েছে) নিজে commit করলে তবেই “কাজ শেষ” ঘোষণা হয়, যা ল্যাবের ack-এর মতো। এই ধরনের container-ভিত্তিক test ধীর (container চালু হতে কয়েক সেকেন্ড), তাই সংখ্যায় অল্প রাখুন, আর বেশিরভাগ আচরণ ধরুন ল্যাবের মতো হালকা service-level test-এ। Cloud-এর queue আর event bus-এর ধরন পাবেন ক্লাউড ও DevOps কোর্সের পর্ব ৭০-এ।

Service-এর test environment

চারটি service মানে প্রতিটি test-এর জন্য চারটি পরিষ্কার database আর একটি খালি broker. ল্যাবে প্রতিটি test নিজের অস্থায়ী ফোল্ডারে নতুন SQLite ফাইল পায়, তাই এক test-এর বার্তা অন্য test-এ ঢোকে না। ভাগ করা staging-এ এটি কঠিন: অন্য দলের test-ও একই topic-এ বার্তা দিচ্ছে, আর আপনার consumer তাদের বার্তাও পায়। কয়েকটি প্রচলিত উপায়: প্রতি test run-এ আলাদা topic বা queue-র নাম (যেমন নামের শেষে run id), প্রতিটি test-এর বার্তায় নিজের correlation id দিয়ে শুধু নিজেরগুলো খোঁজা, আর ক্ষণস্থায়ী পরিবেশ। Docker Compose, seed আর data masking পর্ব ৬৫-এ (Test environment আর test data); কোন service আসল আর কোনটি নকল রাখবেন, তা পর্ব ৩৪-এ।

আরও গভীরে: Distributed system-এর ভুল খোঁজার দুটি প্রভাবশালী ধারা। একটি Kyle Kingsbury-র Jepsen (২০১৩ সাল থেকে), যা আসল database আর queue-তে network ভাগ করে আর process মেরে দেখে প্রতিশ্রুত consistency সত্যিই টেকে কি না; বহু জনপ্রিয় system-এ এটি নথিভুক্ত প্রতিশ্রুতির বাইরে আচরণ খুঁজে পেয়েছে বলে জানা যায়। অন্যটি deterministic simulation testing: পুরো distributed system-কে একটি process-এ, নকল ঘড়ি, নকল network আর একটি seed দিয়ে চালানো, যাতে যেকোনো বিরল ব্যর্থতা একই seed-এ হুবহু আবার ঘটে; FoundationDB-র দল এই পদ্ধতির জন্য পরিচিত। দুটির শিক্ষা এই পর্বের simulator-এর মতোই: ক্রম, duplicate আর crash-কে এলোমেলো ভাগ্যের হাতে না ছেড়ে নিয়ন্ত্রণযোগ্য input বানানো।

পরীক্ষা ও ইন্টারভিউতে (বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন সাধারণ):

  • At-least-once delivery-তে consumer-কে কেমন হতে হবে? — Idempotent: event_id টেকসই জায়গায় মনে রাখা, আর effect ও সেই চিহ্ন একই transaction-এ লেখা।
  • Dead-letter queue কী, আর তার test? — বারবার ব্যর্থ বার্তা সরিয়ে রাখার সারি; test-এ দেখুন বার্তা সীমার পরে DLQ-তে যায়, কারণ লেখা থাকে, আর পেছনের বার্তা চলে।
  • Outbox pattern কোন সমস্যা মেটায়, কী রেখে যায়? — Dual write-এ event হারানো মেটায়; কিন্তু relay crash-এ duplicate তৈরি করে, তাই consumer idempotent হতে হয়।
  • Eventual consistency-র test-এ sleep-এর বদলে কী? — সর্বোচ্চ সময়সহ বারবার দেখা (bounded polling); মিললেই থামে, না মিললে শেষ মানসহ ব্যর্থ।
  • Saga-র test-এ মূল জিনিস? — প্রতিটি ধাপ ব্যর্থ হলে আগের ধাপের compensation সত্যিই চলে কি, আর compensation idempotent কি।

৯ · AI-এর যুগে microservice আর event-এর test

AI সহকারীকে “আমার Kafka consumer-এর test লিখে দাও” বললে চেনা ভুলগুলো আসে। প্রতিটি বার্তা একবার করে, সঠিক ক্রমে পাঠিয়ে শুধু সুখী পথ দেখে: duplicate, উল্টো ক্রম, ভাঙা বার্তা কিছুই নেই, ফলে ল্যাবের v1-এর মতো consumer সব test পাস করে। Event পাঠিয়েই time.sleep(5), তারপর একবার assert. Broker-কে এত mock করে যে ack, redelivery আর lease-এর আসল পথটি test-এ থাকে না। কোডের বর্তমান আচরণ থেকে প্রত্যাশা লেখে (যেমন cancel আগে এলে স্টক ৮২ “সঠিক” ধরে নেয়), requirement থেকে নয়। Kafka বা RabbitMQ-র এমন config option, বা Pact-এর এমন function বানায়, যা নথিতে নেই। ভাঙা বার্তার জন্য অসীম retry রাখে, DLQ রাখে না। Test data-য় আসল ধাঁচের ফোন নম্বর বসায়। আর প্রায়ই না চালিয়েই লেখে “সব test পাস করেছে”.

AI-কে কাজ দেওয়ার সময় ঝুঁকিগুলো নিজেই তালিকায় দিয়ে দিন, আর কী দিয়ে প্রমাণ চান তা বলুন:

তুমি একজন QA engineer. বাজারঘরের stock service একটি queue থেকে OrderPlaced আর OrderCancelled event পড়ে স্টক বদলায়। Event-এর গঠন: event_id (string), type, version (1), order_id (integer), sku, qty (integer, > 0), correlation_id. Delivery at-least-once. Requirement: একই event_id দুবার এলে স্টক একবারই বদলাবে; cancel আগে এলে স্টক বাড়বে না; ভাঙা বার্তা তিনবার ব্যর্থ হলে DLQ-তে যাবে, কারণসহ, আর পেছনের বার্তা চলবে। pytest-এ service-level test লেখো, শর্ত: ১. প্রতিটি requirement-এর জন্য আলাদা test; প্রত্যাশা requirement থেকে, কোডের বর্তমান আচরণ থেকে নয়। ২. Duplicate, উল্টো ক্রম, ack-এর আগে consumer crash আর poison message, চারটিই থাকবে। ৩. কোনো time.sleep নয়; সর্বোচ্চ সময়সহ একটি eventually helper ব্যবহার করো, আর assert করার আগে নিশ্চিত হও সব delivery প্রক্রিয়া হয়েছে। ৪. Broker-কে পুরো mock করো না; আসল বা হালকা নকল broker-এর ack আর redelivery থাকবে। ৫. যে broker config বা library function-এর ব্যাপারে নিশ্চিত নও, বানিয়ে না লিখে আলাদা তালিকা দাও। ৬. Test data বানানো হবে; কোনো আসল নাম বা ফোন নম্বর নয়। চালানোর আগে "সব পাস" দাবি করবে না।

AI-এর লেখা microservice বা event test হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১কোনো broker “exactly-once” লিখলে tester কি duplicate-এর test বাদ দিতে পারেন?

না, আর কারণটি পুরোনো একটি তাত্ত্বিক ফলাফলে। “দুই সেনাপতির সমস্যা” (Two Generals’ Problem) নামের চিন্তা-পরীক্ষা দেখায়, যে network-এ বার্তা হারাতে পারে, সেখানে দুই পক্ষ নিশ্চিতভাবে একমত হতে পারে না যে শেষ বার্তাটি পৌঁছেছে। Consumer কাজ করে ack পাঠাল; ack হারালে broker জানে না কাজ হয়েছে কি না। দুটি পথই খোলা: আবার পাঠানো (duplicate-এর ঝুঁকি) বা না পাঠানো (হারানোর ঝুঁকি)। তাই শুধু পৌঁছানোর স্তরে “ঠিক একবার” অসম্ভব।

তাহলে কিছু broker exactly-once বলে কীভাবে? সাধারণত এর মানে একটি সীমিত পরিসরে নিশ্চয়তা। যেমন Kafka ২০১৭ সালের দিকে (০.১১ সংস্করণে) idempotent producer আর transaction যোগ করে, যাতে Kafka থেকে পড়ে, প্রক্রিয়া করে Kafka-তেই লেখার পুরো চক্রে ফল একবারই দেখা যায়। কিন্তু আপনার consumer যদি মাঝপথে একটি আলাদা SQLite বা PostgreSQL-এ স্টক কমায়, বা একটি SMS পাঠায়, সেই বাইরের effect ওই transaction-এর অংশ নয়। সেখানে duplicate-এর প্রশ্ন আবার আপনার কোডের।

Tester-এর জন্য বাস্তব শিক্ষা তিনটি। এক, প্রতিশ্রুতির পরিসর পড়ুন: “exactly-once” কোন দুই বিন্দুর মধ্যে? দুই, বাইরের effect (database, wallet, SMS, email) প্রতিটির জন্য আলাদা করে duplicate test রাখুন; ল্যাবের notify-এর log দুবার “stored” দেখিয়েছে ঠিক এই কারণে। তিন, broker-এর config-ও test-এর বিষয়: exactly-once-এর জন্য দরকারি setting কেউ বন্ধ করে দিলে আপনার duplicate test-ই প্রথম জানাবে।

আর একটি কথা: duplicate test সস্তা। একই বার্তা দুবার পাঠানো এক লাইনের কাজ। প্রতিশ্রুতি থাকলেও এই test রাখা মানে প্রতিশ্রুতি ভাঙার দিন আগেভাগে জানা।

মূল উপলব্ধি: Exactly-once কোনো broker-এর গুণ নয়, পুরো পথের গুণ; tester প্রতিটি বাইরের effect-এ duplicate পাঠিয়ে তা প্রমাণ করেন, বিজ্ঞাপন পড়ে নয়।

প্র ০২Microservice-এ test pyramid কি পুরোনো হয়ে গেছে? Honeycomb কি নতুন নিয়ম?

Test pyramid-এর ছবি জনপ্রিয় হয় Mike Cohn-এর ২০০৯ সালের বই “Succeeding with Agile”-এর মাধ্যমে। মূল যুক্তি ছিল খরচ আর গতির: unit test দ্রুত, সস্তা, ভুলের জায়গা স্পষ্ট দেখায়; UI দিয়ে end-to-end test ধীর, ভঙ্গুর, ব্যর্থ হলে কারণ খুঁজতে সময় লাগে। তাই নিচে বেশি, ওপরে কম। সেই সময়ের সাধারণ app ছিল একটি বড় monolith, যার ভেতরে প্রচুর logic.

Microservice-এ দুটি জিনিস বদলায়। অনেক service-এর ভেতরের logic পাতলা: একটি event নেওয়া, যাচাই করা, database-এ লেখা। এমন কোডে unit test প্রায়ই নিজের mock-কেই পরীক্ষা করে। অন্যদিকে ভুলগুলো জমে জোড়ে: ভুল field নাম, ভুল ধরন, ভুল ধরে নেওয়া ক্রম, হারানো ack. এই যুক্তিতে ২০১৮ সালের দিকে honeycomb-এর ছবি আসে বলে জানা যায়, যেখানে মাঝের integration স্তর মোটা। পরে অন্য লেখকেরা “testing trophy”-র মতো আরও আকারের কথাও বলেছেন।

কিন্তু এগুলো নিয়ম নয়, প্রসঙ্গের পর্যবেক্ষণ। বাজারঘরের stock service-এ apply_v2-এর ভেতরে অবস্থা-ভিত্তিক সিদ্ধান্ত আছে (placed, cancelled, আগে আসা cancel); এর জন্য দ্রুত unit test খুব কাজের। আবার duplicate আর crash-এর আচরণ শুধু আসল database আর broker থাকলেই দেখা যায়; সেখানে service-level test লাগে। Saga-র সিদ্ধান্ত (§৮) unit test-এ, outbox আর relay crash integration-এ। একটি দলের service-ভেদে আকার ভিন্ন হওয়াই স্বাভাবিক।

যে নীতি বদলায়নি: প্রতিটি ঝুঁকি সবচেয়ে সস্তা যে স্তরে নির্ভরযোগ্যভাবে ধরা যায়, সেখানে ধরুন। End-to-end test অল্প রাখুন, ক্রেতার মূল পথগুলোর জন্য। আর আকার নিয়ে তর্কের আগে প্রশ্ন করুন: গত কয়েক মাসের production bug-গুলো কোন স্তরে ধরা যেত?

মূল উপলব্ধি: Pyramid আর honeycomb দুটিই মানচিত্র, আইন নয়; আপনার service-এর ভুল কোথায় জন্মায়, সেখানেই test-এর ভার রাখুন।

প্র ০৩Contract test আর schema registry থাকলে কয়েক service জোড়া end-to-end test কি আর লাগে?

লাগে, কিন্তু অনেক কম, আর ভিন্ন উদ্দেশ্যে। Contract test আর schema registry একটি নির্দিষ্ট প্রশ্নের উত্তর দেয়: “দুই পক্ষ একই ভাষায় কথা বলছে কি?” Field আছে কি, ধরন মিলছে কি, নতুন version পুরোনো consumer ভাঙে কি। §৩-এর checker এর একটি খুদে রূপ, আর পর্ব ৩২-এ Pact দিয়ে HTTP-তে একই কাজ দেখেছেন। এগুলো দ্রুত, আর প্রতিটি দল নিজে নিজে চালাতে পারে; বড় পরিবেশ লাগে না।

যা contract দেখে না: আচরণ। Event-এর গঠন একদম ঠিক রেখেও stock service duplicate-এ দুবার কাটতে পারে, cancel আগে এলে স্টক বাড়াতে পারে, বা relay crash-এ event হারাতে পারে। এগুলো service-level আর integration test-এর বিষয়, যেমন §৫-এর ছয়টি test দেখিয়েছে। আবার কিছু ভুল দেখা যায় শুধু পুরো পথ একসাথে চললে: ভুল topic নাম, ভুল consumer group, configuration-এ এক service-এর timeout আরেকটির retry-র চেয়ে ছোট, বা নিরাপত্তার নিয়মে একটি service broker-এ লিখতেই পারে না।

তাই বাস্তব বিন্যাস প্রায় এমন: প্রতিটি consumer-এর contract test আর schema registry-র compatibility যাচাই প্রতিটি পরিবর্তনে; প্রতিটি service-এর service-level test (duplicate, ক্রম, poison, crash) প্রতিটি পরিবর্তনে; অল্প কয়েকটি পুরো পথের test (যেমন “অর্ডার থেকে SMS”) একটি স্থির পরিবেশে, deploy-এর আগে; আর production-এ synthetic monitoring, যা পর্ব ৬৬-এ (Production-এ testing) দেখেছেন। পুরো পথের test যত কম, তত বেশি নির্ভরযোগ্য রাখা সহজ।

একটি সতর্কতা: contract test-এর মান নির্ভর করে consumer কতটা সৎভাবে লিখেছে যে সে কী পড়ে। কেউ নতুন field পড়া শুরু করে contract হালনাগাদ না করলে registry আর contract দুটিই সবুজ, অথচ ভাঙন আসছে।

মূল উপলব্ধি: Contract ভাষা মেলায়, service-level test আচরণ মেলায়, অল্প end-to-end test জোড়ের configuration মেলায়; কোনোটি অন্যটির জায়গা নেয় না।

প্র ০৪Eventual consistency-র test-এ সর্বোচ্চ অপেক্ষার সময় কীভাবে ঠিক করবেন? ১ সেকেন্ড, ৫ সেকেন্ড, না ৩০?

সংখ্যাটি অনুমানে নয়, দুটি উৎস থেকে আসে। প্রথম উৎস requirement: ব্যবসা কতক্ষণ পুরোনো মান সহ্য করে? বাজারঘরে ধরুন product owner বললেন, “অর্ডারের পরে দুই সেকেন্ডের মধ্যে স্টক ঠিক দেখাতে হবে।” তাহলে এটি একটি non-functional requirement, আর এর জন্য আলাদা test দরকার, যা propagation-এর সময় মাপে আর সীমা পেরোলে লাল হয়। দ্বিতীয় উৎস মাপা তথ্য: ল্যাবে আটবারে ৯৩ থেকে ১৫৯ ms. CI-র ধীর মেশিনে হয়তো কয়েক গুণ।

Functional test (স্টক শেষ পর্যন্ত ঠিক হয় কি) আর timing test (কত দ্রুত ঠিক হয়) আলাদা রাখুন। Functional test-এর timeout উদার: স্বাভাবিক সময়ের অনেক গুণ, যাতে মেশিন ধীর হলেও মিথ্যা লাল না আসে। ল্যাবে ৫ সেকেন্ড, স্বাভাবিকের প্রায় ৫০ গুণ। এতে কোনো খরচ নেই, কারণ bounded polling মিললেই থামে; সবুজ test-এ ৫ সেকেন্ড কখনো খরচ হয় না, শুধু ভাঙা অবস্থায় হয়।

Timing test-এ অনেকবার মেপে percentile দেখুন, একবারের মান নয়: যেমন “১০০টি অর্ডারে p95 ≤ ২ সেকেন্ড”. Percentile আর SLO-ভিত্তিক test পর্ব ৫০-এ (SLO-ভিত্তিক test আর capacity planning) দেখেছেন। এই test-এর জায়গা সাধারণত performance বা staging-এর ধাপ, প্রতিটি commit-এর দ্রুত suite নয়।

কিছু ভুল এড়ান। Timeout এত বড় নয় যে consumer মরা থাকলে suite আধা ঘণ্টা ঝুলে থাকে; interval এত ছোট নয় যে poll-এর ভিড়ে system নিজেই ধীর হয়। আর timeout-এ লাল হলে প্রথম কাজ কারণ খোঁজা (consumer চালু কি, DLQ-তে কিছু গেছে কি), timeout বাড়ানো নয়।

মূল উপলব্ধি: Functional test-এ উদার সীমা আর দ্রুত থামা, timing test-এ requirement-এর সীমা আর অনেক মাপের percentile; দুটি প্রশ্ন, তাই দুটি আলাদা test লাগে।

প্র ০৫Saga-র compensation “undo” নয় কেন, আর এর test কেন সাধারণ rollback-এর test-এর চেয়ে কঠিন?

Saga-র ধারণা পাওয়া যায় Hector Garcia-Molina আর Kenneth Salem-এর ১৯৮৭ সালের একটি গবেষণাপত্রে, দীর্ঘ সময় ধরে চলা database transaction-এর প্রসঙ্গে। মূল কথা: একটি বড় কাজকে কয়েকটি ছোট transaction-এ ভাগ করুন, প্রতিটি নিজে commit, আর প্রতিটির জন্য একটি compensating transaction রাখুন, যা দরকারে তার প্রভাব উল্টে দেবে। Microservice-এর যুগে ধারণাটি আবার জনপ্রিয় হয়, কারণ আলাদা database-এ একটি যৌথ transaction (যেমন two-phase commit) প্রায়ই ব্যবহারিক নয়।

Compensation undo নয়, কারণ মাঝের সময়ে পৃথিবী এগিয়ে গেছে। Database rollback-এ কেউ কখনো অসম্পূর্ণ অবস্থা দেখেনি। Saga-তে প্রথম ধাপের commit সবার কাছে দৃশ্যমান: রাখা স্টক দেখে আরেকজন ক্রেতা “স্টক নেই” পেয়েছেন, বা wallet-এ টাকা কাটার SMS চলে গেছে। Compensation একটি নতুন কাজ (স্টক ছাড়া, refund), যা অতীত মোছে না, শুধু হিসাব মেলায়। কিছু কাজ উল্টানোই যায় না (পাঠানো SMS), সেখানে compensation হয় আরেকটি বার্তা।

Test তাই কঠিন। প্রতিটি ধাপের ব্যর্থতার জন্য আলাদা পথ: ধাপ ২ ব্যর্থ হলে ধাপ ১-এর compensation, ধাপ ৩ ব্যর্থ হলে ২ আর ১-এর, উল্টো ক্রমে। Compensation নিজেও ব্যর্থ হতে পারে, তাই retry আর শেষে মানুষের কাছে পাঠানোর পথ। Compensation দুবার চলতে পারে (at-least-once), তাই idempotent হতে হবে। আর মাঝের দৃশ্যমান অবস্থা নিয়ে প্রশ্ন: compensation চলার আগের কয়েক সেকেন্ডে অন্য ক্রেতা কী দেখলেন, তা কি গ্রহণযোগ্য? §৮-এর test একটি ধাপ দেখিয়েছে; পূর্ণ saga-য় এমন test-এর তালিকা ধাপের সংখ্যার সঙ্গে বাড়ে।

একটি কার্যকর কৌশল: saga-র সিদ্ধান্তকে একটি বিশুদ্ধ ফাংশনে রাখা (কোন ধাপ ব্যর্থ, কোন compensation চলবে), আর সেটির জন্য সব ব্যর্থতা-বিন্দু ধরে টেবিল-ভিত্তিক unit test; তারপর অল্প কয়েকটি integration test আসল service দিয়ে।

মূল উপলব্ধি: Compensation অতীত মোছে না, নতুন কাজ দিয়ে হিসাব মেলায়; তাই প্রতিটি ব্যর্থতা-বিন্দু, compensation-এর ব্যর্থতা আর তার duplicate, সবই আলাদা test-এর বিষয়।

অনুশীলন

প্রথমে নিজে উত্তর লিখুন, তারপর মিলিয়ে দেখুন।

  1. Spec থেকে test case: Requirement: “Stock service OrderCancelled পেলে সেই অর্ডারের কাটা স্টক ফেরত দেবে। একই event দুবার এলে একবারই ফেরত। যে অর্ডারের OrderPlaced এখনো আসেনি, তার cancel-এ স্টক বাড়বে না, পরে placed এলেও কাটা হবে না। qty অবশ্যই ধনাত্মক পূর্ণসংখ্যা; না হলে বার্তা বাতিল, তিন চেষ্টার পরে DLQ.” শুরুতে DAL-এর স্টক ৮০. অন্তত ছয়টি test case লিখুন: input বার্তার ক্রম আর প্রত্যাশিত স্টক।
    IDবার্তার ক্রম (qty 2)প্রত্যাশা
    TC1placed, তারপর cancelled৭৮, তারপর ৮০
    TC2placed, cancelled, একই cancelled আবারশেষে ৮০, ৮২ নয়
    TC3শুধু cancelled৮০ (প্রথম বার্তার পরেই assert)
    TC4cancelled, তারপর placed৮০, দুই ধাপেই
    TC5cancelled-এ qty: 0৩ চেষ্টা, DLQ-তে কারণসহ; স্টক অপরিবর্তিত
    TC6cancelled-এ qty: -2 বা "2"TC5-এর মতো
    TC7ভাঙা cancelled, তারপর ভালো placedDLQ-তে ১টি, স্টক ৭৮: পেছনের বার্তা চলেছে
    TC8placed, cancelled; consumer ack-এর আগে crash, restart৮০, ৮২ নয়

    qty-এর সীমানা পর্ব ০৮-এর মতো: ০ আর ১ (০ অবৈধ, ১ বৈধ), আর ধরনের ভুল (string). TC3 আর TC4 আলাদা রাখা জরুরি, কারণ §৫-এ দেখেছেন শুধু শেষ অবস্থা দেখলে ক্রম ভাঙার ভুল লুকিয়ে যায়।

  2. Failure পড়ুন: একটি দলের CI-তে নিচের ব্যর্থতা এল। Test-টি একই OrderPlaced (qty 3) পাঠায়, consumer-কে ack-এর আগে মেরে আবার চালু করে। স্টক শুরুতে ৮০. আউটপুট: E assert 74 == 77. কী ঘটেছে, আর consumer-এর কোডে কোন দুটি জিনিস খুঁজবেন?

    ৮০ − ৩ = ৭৭ প্রত্যাশিত, পাওয়া গেছে ৭৪ = ৮০ − ৩ − ৩. অর্থাৎ ack-এর আগে crash-এর পরে broker একই বার্তা আবার দিয়েছে (at-least-once-এর স্বাভাবিক আচরণ), আর consumer দ্বিতীয়বারও কেটেছে। খুঁজবেন: (১) consumer প্রতিটি event_id মনে রাখে কি না, আর তা memory-তে নয়, database-এ; (২) সেই চিহ্ন আর স্টক কমানো একই transaction-এ commit হয় কি না। চিহ্ন আলাদা transaction-এ লেখা হলে, দুটির মাঝখানে crash হলে একই ভুল আবার আসবে। Broker-কে দোষ দেবেন না: redelivery তার কাজ।

  3. Test-এর ভুল খুঁজুন: একজন সহকর্মী notify service-এর জন্য এই test লিখে বললেন, “duplicate-এ দুটি SMS যাবে না, প্রমাণ হলো।” কী কী সমস্যা দেখছেন?
    def test_no_duplicate_sms(system):
        ev = event("OrderPlaced", 601)
        publish(ev)
        time.sleep(2)
        publish(ev)
        time.sleep(2)
        notes = call("GET", NOTIFY + "/notifications?order_id=601")[1]
        assert len(notes) == 1
    • ভুল জিনিস মাপছে: টেবিলে INSERT OR IGNORE, তাই সারি সবসময় ১টি। কিন্তু §৬-এর stepper-এ দেখেছেন log দুবার “stored” বলে; আসল SMS পাঠানো হয় বাইরের effect-এ। Test-এ SMS পাঠানোর অংশটি একটি নকল sender (test double) দিয়ে বদলে assert করুন: sender.send ঠিক একবার ডাকা হয়েছে।
    • sleep: চার সেকেন্ড নষ্ট, আর ধীর মেশিনে যথেষ্ট না-ও হতে পারে। বদলে eventually দিয়ে অপেক্ষা করুন যতক্ষণ না broker-এ notify group-এর দুটি delivery-ই ack হয়েছে।
    • বাস্তব duplicate নয়: দুই সেকেন্ড ব্যবধানে দুটি আলাদা publish একটি সহজ ঘটনা। Crash-এর পরে redelivery-র test-ও রাখুন (ack-এর আগে process মারা)।
    • দাবি বড়, প্রমাণ ছোট: একটি test দেখে “প্রমাণ হলো” বলার আগে consumer থেকে dedupe সরিয়ে দেখুন test লাল হয় কি; এই test-টি হতো না, কারণ টেবিলের UNIQUE দুটি সংস্করণেই সারি ১টি রাখে।
  4. Outbox-এর test পরিকল্পনা: বাজারঘরের orders service-এ outbox আর relay আছে। কোন কোন জায়গায় crash ঘটিয়ে test করবেন, আর প্রতিটির পরে কী assert করবেন? অন্তত তিনটি crash-বিন্দু লিখুন।
    • Transaction-এর ভেতরে, commit-এর আগে: order আর outbox, কোনো সারিই নেই; broker-এ কিছু যায়নি; client ব্যর্থতা পেয়েছে। (Atomicity.)
    • Commit-এর পরে, relay publish-এর আগে: restart-এর পরে relay সারিটি পাঠায়; broker-এ ঠিক ১টি বার্তা; স্টক একবার কমে। (হারায় না।)
    • Publish-এর পরে, sent=1-এর আগে: broker-এ একই event_id-এর ২টি বার্তা; consumer একবার প্রয়োগ করে। (§৬-এর ল্যাব test.)
    • Broker বন্ধ থাকা অবস্থায়: relay ব্যর্থ হয়, সারি sent=0 থাকে; broker ফিরলে পাঠানো হয়। ক্রম: একই অর্ডারের placed আর cancelled আগের ক্রমেই যায় কি।

    প্রতিটির পরে একই তিনটি প্রশ্ন: কিছু হারাল কি, কিছু দুবার প্রয়োগ হলো কি, আর outbox-এ কোনো সারি চিরকাল sent=0 আটকে আছে কি।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমTransactional outbox দিয়ে একটি অর্ডারের event-এর পথ সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Order আর outbox-এর সারি একই transaction-এ commit
  2. Relay outbox থেকে sent=0 সারি পড়ে
  3. Relay event-টি broker-এ publish করে
  4. Relay সারিটিকে sent=1 চিহ্নিত করে
  5. Consumer event_id দেখে duplicate বাদ দিয়ে স্টক বদলায়
  6. Consumer broker-কে ack পাঠায়

একটি queue at-least-once delivery দেয়। Consumer-এর জন্য কোন test সবচেয়ে জরুরি?

  • বার্তা হারালে consumer কী করে
  • একই বার্তা দুবার এলে effect একবারই হয় কি
  • বার্তা কত দ্রুত পৌঁছায়
  • Broker সত্যিই at-least-once দেয় কি

একটি consumer প্রক্রিয়া করা event_id-গুলো Python-এর একটি set-এ রাখে। কোন অবস্থায় সে এখনো একই event দুবার প্রয়োগ করবে?

  • একই event পরপর দুবার এলে
  • দুটি ভিন্ন event_id-এর event এলে
  • প্রথম delivery-র পরে আর redelivery-র আগে process restart হলে
  • একটি poison message এলে

Dual write (আগে database-এ order, তারপর broker-এ event) আর transactional outbox-এর তুলনায় কোনটি সঠিক?

  • Dual write event হারাতে পারে; outbox হারায় না, কিন্তু duplicate পাঠাতে পারে
  • Outbox থাকলে consumer-এর idempotency আর লাগে না
  • দুটির আচরণ crash-এর সময় একই
  • Outbox-এ order আর outbox-এর সারি আলাদা transaction-এ লেখা হয়

স্টক আপডেট অন্য service-এ, asynchronously হয়। Test-এ “অর্ডারের পরে স্টক ৭৮” assert করার সবচেয়ে ভালো উপায় কোনটি?

  • Order-এর উত্তর পাওয়ার সঙ্গে সঙ্গে একবার পড়ে assert
  • time.sleep(3)-এর পরে একবার পড়ে assert
  • সীমা ছাড়া যতক্ষণ না ৭৮ হয় ততক্ষণ বারবার পড়া
  • ছোট বিরতিতে বারবার পড়া, একটি সর্বোচ্চ সময়সহ; সময় শেষে শেষ মানসহ ব্যর্থ

Producer OrderPlaced-এ qty-এর নাম বদলে quantity করতে চায়। Stock consumer qty পড়ে, notify consumer পড়ে না। কোন কথাটি সঠিক?

  • দুটি consumer-ই ভাঙবে
  • শুধু stock ভাঙবে; নিরাপদ পথ হলো কিছুদিন দুটি field পাশাপাশি পাঠানো
  • Version নম্বর ২ করলেই কেউ ভাঙবে না
  • নামবদল কখনো breaking change নয়

একটি saga প্রথম ধাপে স্টক রাখে, দ্বিতীয় ধাপে wallet-এ টাকা কাটে। Wallet ব্যর্থ হলে test-এ কী অবশ্যই assert করবেন?

  • শুধু ফেরত মান “cancelled” কি না
  • Wallet-এ টাকা কাটা হয়েছে কি না
  • রাখা স্টক ঠিক একবার ছেড়ে দেওয়া হয়েছে কি না (compensation-এর effect)
  • স্টক আবার রাখা হয়েছে কি না

একটি poison message এল, consumer প্রতিবার ব্যর্থ হয়, আর broker-এ চেষ্টার কোনো সীমা বা DLQ নেই। কী ঘটার সম্ভাবনা সবচেয়ে বেশি?

  • বার্তাটি চিরকাল ঘুরবে, আর পেছনের ভালো বার্তাগুলো আটকে থাকতে পারে
  • Broker বার্তাটি নিজে ঠিক করে আবার দেবে
  • বার্তাটি স্বয়ংক্রিয়ভাবে মুছে যাবে, ক্ষতি নেই
  • Broker ধরে নেবে বার্তাটি সফল, আর ack দেবে

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Event-driven system-এ নতুন প্রশ্ন: ফল কখন আসে, কতবার আসে, কোন ক্রমে আসে, আর না এলে কী হয়। Test-এর ভার রাখুন যেখানে ভুল জন্মায়: জোড়ে আর consumer-এর আচরণে।
  2. Event contract: প্রতিটি consumer যা পড়ে তার contract test; নামবদল, ধরন বদল আর “সবসময় পাঠানো” থেকে ঐচ্ছিক করা breaking change. Version নম্বর শুধু ঘোষণা।
  3. Duplicate, ক্রম, poison, crash: ইচ্ছা করে বানিয়ে পাঠান। সরল consumer-এ ছয়টির চারটি test লাল (৭৬, ৮২, ৭৬, ৭৪), idempotent consumer-এ ছয়টিই সবুজ। DLQ-তে কারণ লেখা থাকে কি আর পেছনের বার্তা চলে কি, দুটিই দেখুন।
  4. Outbox + idempotent consumer একসাথে: outbox হারানো ঠেকায় (১০০০-এ ১৯ বনাম ০), কিন্তু relay crash-এ duplicate পাঠায় (১৭টি). Saga-য় compensation-এর effect assert করুন, শুধু ফেরত মান নয়।
  5. Eventual consistency: sleep নয়, bounded polling; ল্যাবে ৯৫ ms-এ মিলল, সীমা ৫ সেকেন্ড। Correlation id দিয়ে কয়েক service-এর log জুড়ুন, আর test-এ তা assert-ও করুন।

পরের পর্বে: পর্ব ৭১ (Data pipeline আর ML model-এর testing — data check, model test আর drift)-এ event-এর বদলে ডেটার স্রোত: schema, null, duplicate id আর দেরিতে আসা ডেটার check, আর একটি ছোট model-এর invariance ও drift-এর test.

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান