সরাসরি পর্বে যান
পর্ব ৩৪ · ৮২-এর মধ্যে · মডিউল ৫

Service virtualization — mock server আর নির্ভরতা আলাদা করা

Service Virtualization — Mock Servers and Isolating Dependencies

Taught in Bangla, this lesson replaces dependencies you do not control, such as a wallet or SMS gateway, with a controlled virtual service, comparing stubs, mocks, fakes and sandboxes. A real WireMock 3.13.2 run injects a 1.5 second delay, a connection reset and stateful scenarios, catching a client that makes a new Idempotency-Key on every retry. Prism 5.16.0 builds a mock from the Bazarghar OpenAPI whose error shape differs from the real API, and VCR.py shows record and replay with its stale-cassette risk.

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

  • Stub, mock, fake, virtual service আর provider-এর sandbox-এর পার্থক্য, আর কোনটি কোন test-এ
  • Mock server কীভাবে request মেলায়: priority, matcher, near-miss আর request journal
  • WireMock দিয়ে delay, timeout, connection reset আর stateful scenario বসিয়ে retry-এর কোড পরীক্ষা করা
  • OpenAPI থেকে mock বানানো, আর mock ও আসল API-র মধ্যে contract drift ধরা
  • VCR.py দিয়ে record আর replay, আর cassette কখন বিপজ্জনক

১ · যে নির্ভরতা আপনার হাতে নেই

দমকল বাহিনী বছরে কয়েকবার কারখানায় অগ্নিনির্বাপণ মহড়া করে। আসল আগুন লাগানো হয় না; ধোঁয়ার যন্ত্র, সাইরেন আর একটি লিখিত দৃশ্যপট থাকে: “তিনতলার সিঁড়ি বন্ধ, পূর্ব দিকের দরজা দিয়ে বের হতে হবে।” মহড়ার সুবিধা হলো, বিপদটি ঠিক যখন, যেভাবে চান, তখন ঘটানো যায়, বারবার, কারও ক্ষতি ছাড়া। আসল আগুনের জন্য অপেক্ষা করে প্রস্তুতি যাচাই করা যায় না।

বাজারঘরের checkout-এর শেষ ধাপে টাকা কাটে একটি mobile wallet. Delivery-র জন্য অর্ডার যায় courier-এর API-তে, আর গ্রাহক পান একটি SMS. এই তিনটি সেবা অন্য প্রতিষ্ঠানের, আপনার নিয়ন্ত্রণের বাইরে। Test-এ এদের আসলটি ব্যবহার করলে পাঁচটি সমস্যা:

  • খরচ আর ঝুঁকি: আসল wallet-এ আসল টাকা কাটে, আসল SMS আসল নম্বরে যায়।
  • ধীর আর অনিশ্চিত: বাইরের network, rate limit, আর রক্ষণাবেক্ষণের সময় সেবা বন্ধ। আপনার test লাল, অথচ আপনার কোডে দোষ নেই; এটিই flaky test-এর সবচেয়ে চেনা উৎস।
  • বিপদ ঘটানো যায় না: Wallet কখন timeout দেবে, কখন “ব্যালান্স নেই” বলবে, তা আপনি ঠিক করতে পারেন না। অথচ সবচেয়ে দামি bug ঠিক এই পথগুলোতে।
  • Test data: একই অ্যাকাউন্ট সবাই ব্যবহার করে; আরেকজনের test আপনার data বদলে দেয়।
  • এখনো তৈরি হয়নি: নতুন courier-এর API আগামী মাসে আসবে, কিন্তু বাজারঘরের দিকের কোড এখনই লিখতে আর test করতে হবে।

সমাধান সেই মহড়ার মতো: আসল সেবার জায়গায় একটি নিয়ন্ত্রিত নকল, যাকে test নিজে বলে দেয় কখন কী ঘটবে। Unit test-এর স্তরে এর নাম test double, আর তা আপনি পর্ব ২৪-এ গভীরভাবে দেখেছেন। এই পর্বে নকলটি এক ধাপ বাইরে যায়: আলাদা একটি server, যা network-এ আসল সেবার মতো ঠিকানায় HTTP-তে উত্তর দেয়। এর নাম service virtualization, আর নকল server-টি একটি virtual service.

বাজারঘরের নিয়ম (এই পর্বে)

Wallet-এ পেমেন্ট: সবসময় নকল, কখনো আসল wallet নয়। Timeout হলে মোট ৩ বার পর্যন্ত চেষ্টা, মাঝে ১ আর ২ সেকেন্ড অপেক্ষা; wallet প্রত্যাখ্যান করলে (decline) আর চেষ্টা নয়। প্রতিটি চেষ্টায় একই Idempotency-Key, যাতে একই অর্ডারে দুবার টাকা না কাটে। দাম: ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০, পূর্ণ টাকায়; ঢাকায় delivery ৬০, ছাড়ের আগের অঙ্ক ২০০০ বা বেশি হলে ফ্রি; বাইরে ১২০, Plus সদস্যের ৬০. মিতুর তেল আর আলুর অর্ডার: ১০০১ − ১০০ + ৬০ = ৯৬১ টাকা।

২ · Stub, mock, fake, virtual service আর sandbox

সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৯-এ Meszaros-এর পাঁচ double-এর সংজ্ঞা আছে, আর পর্ব ২৪-এ সেগুলো Python-এর unittest.mock-এ হাতে-কলমে। মূল পার্থক্য এক লাইনে মনে করিয়ে দিই: stub শুধু আগে থেকে ঠিক করা উত্তর দেয়; mock সাথে যাচাই করে কোন ডাক কীভাবে এল; fake সত্যিই কাজ করে, কিন্তু সহজ পথে। এই তিনটিই সাধারণত একই process-এর ভেতরে, কোডের একটি object-এর জায়গায় বসে।

Virtual service-এর পার্থক্য হলো সে তারের ওপারে (over the wire) বসে। আপনার কোডের HTTP client, JSON-এ রূপান্তর, header, timeout-এর সেটিং, সবই আসল থাকে; নকল শুধু অন্য প্রান্তের server. ফলে যে bug কোনো in-process mock ধরতে পারে না (ভুল header, timeout-এর সেটিং না থাকা, connection ভেঙে গেলে exception না ধরা), সেগুলো এখানে ধরা পড়ে।

রূপকোথায় চলেকে বানায়সবচেয়ে ভালো কাজ
Stub / mock (unittest.mock)একই process, একটি object-এর জায়গায়Test নিজেUnit test: যুক্তির শাখা, ডাকের সংখ্যা
Fake (in-memory wallet)একই processনিজের দলদ্রুত, অবস্থা মনে রাখা নকল; component test
Virtual service / mock serverআলাদা process, network-এনিজের দল (WireMock, Prism…)HTTP client, timeout, retry, error পথ; integration test
App-এর ভেতরের নকল gatewayApp-এর ভেতরে, test-mode-এApp-এর দলপুরো app চালিয়ে পেমেন্টের পথ; E2E আর demo
Provider-এর sandboxProvider-এর server-এProviderআসল API-র সাথে মাঝে মাঝে মিলিয়ে দেখা

Virtual service কোথায় বসে

The test drives the SUT and controls the virtual wallet through its admin API; the real provider is not called

Test, SUT, virtual wallet আর আসল provider-এর সম্পর্ক admin API ✕ pytest test stub বসায়, charge() ডাকে, যাচাই করে SUT: checkout কোড WalletClient, আসল httpx timeout ০.৫ s, ৩ বার চেষ্টা POST /v1/charges Virtual wallet (WireMock) 127.0.0.1:8797 stub mapping, delay, fault request journal আসল wallet provider sandbox বা production এই test-এ ডাকা হয় না
ছবি ৩৪.১ — SUT-এর কাছে virtual wallet আর আসল wallet দেখতে একই: একটি base URL. Test দুই দিক থেকে কাজ করে: SUT-কে ডাকে, আর পাশের দরজা (admin API) দিয়ে নকলকে বলে দেয় পরের request-এ কী ঘটবে, পরে জিজ্ঞেস করে কী এসেছিল।

বাজারঘর app-এর ভেতরে যে নকল gateway আছে (সারণির চতুর্থ সারি), সেটিও একই ধারণার আরেক রূপ: BAZARGHAR_WALLET_MODE আর test-mode-এর PUT /api/test/wallet দিয়ে তার আচরণ বদলানো যায়। পর্ব ২৯-এ আপনি তার timeout_once দিয়ে idempotent retry দেখেছেন। এখানে বাকি মোডের একটি ছোট সত্যিকারের run, কোর্সের shared app-এ (localhost, port 8787):

$ curl -X PUT $B/api/test/wallet -d '{"mode":"decline"}'
{"mode":"decline","charges":[ …seed-এর ৪টি লেনদেন… ]}
$ curl -X POST $B/api/orders/8/pay -H "Idempotency-Key: pay-8-k1"
{"detail":{"code":"payment_declined","message":"পেমেন্ট প্রত্যাখ্যাত হয়েছে (fake gateway)"}}  [402]
$ curl -X PUT $B/api/test/wallet -d '{"mode":"success"}'
$ curl -X POST $B/api/orders/8/pay -H "Idempotency-Key: pay-8-k2"
  [200]
$ curl $B/api/test/wallet
{'id': 5, 'txn_id': 'FAKE-B48DEBBF0279', 'ref': 'pay-8-k2', 'order_id': 8,
 'method': 'mobile-wallet', 'amount': 961, 'status': 'charged', …}

Decline-এ ledger-এ কিছু যোগ হয়নি, অর্ডার placed থেকে গেল; মোড বদলাতেই একই অর্ডার paid, ৯৬১ টাকার একটি লেনদেন (token আর login-এর লাইন বাদ দেওয়া)। এই নকল খুব কাজের, তবে একটি সীমা আছে: এটি app-এর ভেতরে, তাই app-এর wallet-adapter কোড, তার HTTP client আর timeout-এর সেটিং এখানে পরীক্ষিত হয় না। বাইরের virtual service ঠিক সেই ফাঁক ভরায়।

৩ · Mock server কীভাবে request মেলায়

প্রতিটি mock server-এর হৃদয় একটি তালিকা: “এমন request এলে এমন উত্তর।” WireMock-এ তালিকার প্রতিটি সারির নাম stub mapping. একটি mapping-এর দুই অংশ: request (কোন method, path, header, body মিললে) আর response (status, header, body, delay বা fault). Request এলে server mapping-গুলো ক্রমে পরীক্ষা করে, আর প্রথম যেটির সব শর্ত মেলে, তার উত্তর দেয়। এই প্রক্রিয়ার নাম request matching.

  • Priority: ছোট সংখ্যা আগে। নির্দিষ্ট নিয়ম (৫০০০ টাকার বেশি হলে decline) ছোট সংখ্যায়, সাধারণ নিয়ম (বাকি সবাই সফল) বড় সংখ্যায়। সমান priority-তে WireMock সবশেষে যোগ করা mapping আগে দেখে।
  • Matcher: হুবহু (equalTo), regex (matches), JSON body-র ভেতরের শর্ত (matchesJsonPath, JSONPath দিয়ে), body-র অংশবিশেষ (equalToJson). যত কড়া matcher, তত বেশি ভুল request ধরা পড়ে।
  • কিছুই না মিললে: 404 আর একটি near-miss বিবরণ: সবচেয়ে কাছের mapping কোনটি, আর কোন অংশে অমিল। এটি client-এর bug খোঁজার সেরা সূত্র।

নিচের block-এ WireMock-এর মতো একটি খুদে matcher: তিনটি mapping আর পাঁচটি request. কোনটি কোন উত্তর পাবে, আগে অনুমান করে তারপর “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

import re
KEY = r"BG-\d+-[0-9a-f]{8}"
STUBS = [   # like WireMock mappings: lower priority number is tried first
    {"name": "decline-big", "priority": 1, "method": "POST", "path": "/v1/charges",
     "key": KEY, "body": lambda b: b.get("amount", 0) > 5000, "status": 402},
    {"name": "charge-ok", "priority": 5, "method": "POST", "path": "/v1/charges",
     "key": KEY, "body": lambda b: True, "status": 201},
    {"name": "sms-ok", "priority": 5, "method": "POST", "path": "/sms/send",
     "key": None, "body": lambda b: b.get("to", "").startswith("01"), "status": 202},
]
def problems(stub, req):
    p = [f for f in ("method", "path") if stub[f] != req[f]]
    if stub["key"] and not re.fullmatch(stub["key"], req["headers"].get("Idempotency-Key", "")):
        p.append("Idempotency-Key")
    if not stub["body"](req["body"]):
        p.append("body")
    return p
def match(req):
    for s in sorted(STUBS, key=lambda s: s["priority"]):
        if not problems(s, req):
            return f"{s['status']} via {s['name']}"
    near = min(STUBS, key=lambda s: len(problems(s, req)))
    return f"404 no match; closest {near['name']}, differs in: {', '.join(problems(near, req))}"
H = {"Idempotency-Key": "BG-8-a1b2c3d4"}
REQS = {"charge 961": ("POST", "/v1/charges", H, {"amount": 961}),
        "charge 5200": ("POST", "/v1/charges", H, {"amount": 5200}),
        "key '8'": ("POST", "/v1/charges", {"Idempotency-Key": "8"}, {"amount": 961}),
        "GET charges": ("GET", "/v1/charges", H, {}),
        "sms 017…": ("POST", "/sms/send", {}, {"to": "01712345678"})}
for name, (m, p, h, b) in REQS.items():
    print(f"{name:12} -> {match({'method': m, 'path': p, 'headers': h, 'body': b})}")

আসল আউটপুট (ব্রাউজারের Python):

charge 961   -> 201 via charge-ok
charge 5200  -> 402 via decline-big
key '8'      -> 404 no match; closest charge-ok, differs in: Idempotency-Key
GET charges  -> 404 no match; closest charge-ok, differs in: method
sms 017…     -> 202 via sms-ok

৫২০০ টাকার request দুটি mapping-এর সাথেই মেলে, কিন্তু decline-big-এর priority ১, তাই সে জেতে। ৯৬১ টাকার request decline-big-এর body-শর্তে আটকে যায় আর charge-ok পায়। "8" key-টি regex-এ মেলে না: client ভুল key পাঠাচ্ছে, আর near-miss ঠিক সেই অংশের নাম বলছে। ভাবুন, charge-ok যদি key না দেখে যেকোনো request মেনে নিত, তাহলে এই bug test-এ কখনো ধরা পড়ত না। Matcher যত ঢিলা, virtual service তত কম যাচাই করে।

WireMock · ৩টি mapping, priority অনুযায়ী
Request
পরীক্ষা
উত্তর
  1. সাজানো। Request আসার আগেই mapping-গুলো priority অনুযায়ী সাজানো: decline-big (১) আগে, charge-ok আর sms-ok (৫) পরে। প্রথম request: ৫২০০ টাকা, ঠিক key.
  2. প্রথম mapping-এই মিল। decline-big-এর চারটি শর্তই মেলে, তাই উত্তর 402. charge-ok-ও মিলত, কিন্তু তাকে আর দেখাই হয় না।
  3. দ্বিতীয় request, ৯৬১ টাকা। decline-big-এর শর্ত “amount ৫০০০-এর বেশি” মেলে না। একটি শর্ত না মিললেই পুরো mapping বাদ; matching চলে পরেরটিতে।
  4. charge-ok মিলল। Method, path আর key-এর regex ঠিক; body-র শর্ত নেই। উত্তর 201, আর response template body-তে reference বসায়।
  5. তৃতীয় request: key “8”. কোনো mapping-এর সব শর্ত মেলে না। sms-ok-এর key-শর্ত নেই, কিন্তু path আর body মেলে না।
  6. Near-miss. সবচেয়ে কম অমিল charge-ok-এর, শুধু একটি header. WireMock 404-এর সাথে ঠিক সেই লাইনে চিহ্ন দেয়; নিচের লেখাটি §৪-এর সত্যিকারের run থেকে।

৪ · ডেস্কটপে সত্যিকারের run (১) — WireMock-এ virtual wallet

WireMock HTTP mock server-এর জগতে সবচেয়ে পরিচিত open-source tool (Apache 2.0 লাইসেন্স)। Java-তে লেখা, ২০১১ সালের দিকে Tom Akehurst শুরু করেছিলেন বলে জানা যায়। একটি standalone JAR হিসেবে চলে, তাই যেকোনো ভাষার test এটি ব্যবহার করতে পারে; নিয়ন্ত্রণ হয় JSON ফাইল বা /__admin API দিয়ে। এই কোর্সের লেখার সময়ের run: WireMock 3.13.2, একটি portable Java 21 runtime-এ (Eclipse Temurin, GPLv2 + Classpath Exception), Windows ডেস্কটপে; client দিকে Python 3.12.13, pytest 9.2.0, httpx 0.28.1. Path নিরপেক্ষ করা।

cd ~/bazarghar-qa
java -jar wiremock-standalone-3.13.2.jar --port 8797 --bind-address 127.0.0.1
…
version:                      3.13.2
port:                         8797
extensions:                   response-template,webhook

SUT হলো বাজারঘরের দিকের WalletClient: একটি কাল্পনিক বাইরের wallet provider-এর POST /v1/charges ডাকে, §১-এর retry-নীতি মেনে। Timeout আর sleep বাইরে থেকে দেওয়া যায় (পর্ব ২৫-এর dependency injection), তাই test দ্রুত চলে:

class WalletClient:
    def __init__(self, base_url, timeout=2.0, waits=(1, 2), sleep=time.sleep):
        self.http = httpx.Client(base_url=base_url, timeout=timeout,
                                 headers={"Authorization": "Bearer test_sk_FAKE_0000"})
        self.waits, self.sleep = waits, sleep

    def charge(self, reference, amount):
        key = f"{reference}-{uuid.uuid4().hex[:8]}"   # one key for all attempts
        body = {"reference": reference, "amount": amount, "currency": "BDT"}
        for attempt in range(len(self.waits) + 1):
            try:
                r = self.http.post("/v1/charges", json=body,
                                   headers={"Idempotency-Key": key})
            except httpx.TransportError:          # timeout, connection reset
                r = None
            if r is not None and r.status_code == 201:
                return r.json()
            if r is not None and r.status_code == 402:
                raise PaymentDeclined(r.json()["error"]["code"])
            if attempt < len(self.waits):
                self.sleep(self.waits[attempt])
        raise WalletUnavailable(reference)

Test-এর fixture প্রতিটি test-এর আগে POST /__admin/reset ডাকে: সব mapping, journal আর scenario মুছে যায়, তাই test-গুলো একে অপরের ওপর নির্ভর করে না। প্রতিটি test নিজের mapping বসায়, SUT চালায়, তারপর request journal (WireMock-এর রাখা সব request-এর খাতা) থেকে গুনে দেখে কতবার কী এসেছিল:

WM = "http://127.0.0.1:8797"          # WireMock: the virtual wallet provider
CHARGE = {"method": "POST", "urlPath": "/v1/charges",
          "headers": {"Idempotency-Key": {"matches": "BG-[0-9]+-[0-9a-f]{8}"}}}
OK = {"status": 201, "headers": {"Content-Type": "application/json"},
      "body": '{"id": "ch_{{jsonPath request.body \'$.reference\'}}", '
              '"status": "captured", "amount": {{jsonPath request.body \'$.amount\'}} }',
      "transformers": ["response-template"]}

@pytest.fixture
def wm():
    admin = httpx.Client(base_url=f"{WM}/__admin")
    admin.post("/reset").raise_for_status()      # stubs, journal, scenarios
    yield admin

def test_charge_success(wm, client):
    stub(wm, CHARGE, OK)
    assert client.charge("BG-8", 961) == {"id": "ch_BG-8", "status": "captured", "amount": 961}
    assert len(charges(wm)) == 1

def test_large_amount_declined_without_retry(wm, client):
    stub(wm, CHARGE, OK, priority=5)
    stub(wm, {**CHARGE, "bodyPatterns": [{"matchesJsonPath": "$[?(@.amount > 5000)]"}]},
         {"status": 402, "jsonBody": {"error": {"code": "insufficient_balance"}}}, priority=1)
    with pytest.raises(PaymentDeclined, match="insufficient_balance"):
        client.charge("BG-9", 5200)
    assert len(charges(wm)) == 1                  # a decline is never retried

def test_connection_reset_gives_up_after_three(wm, client, slept):
    stub(wm, CHARGE, {"fault": "CONNECTION_RESET_BY_PEER"})
    with pytest.raises(WalletUnavailable):
        client.charge("BG-8", 961)
    assert len(charges(wm)) == 3 and slept == [1, 2]

stub() আর charges() দুটি ছোট helper: প্রথমটি POST /__admin/mappings-এ mapping পাঠায়, দ্বিতীয়টি POST /__admin/requests/find দিয়ে journal থেকে charge-এর request-গুলো আনে। client fixture timeout ০.৫ সেকেন্ড দেয়, আর sleep-এর জায়গায় একটি তালিকার append, অর্থাৎ একটি spy. OK-এর body-তে response templating: request-এর reference আর amount উত্তরে ফিরে আসে, তাই একটি mapping সব অর্ডারের কাজ চালায়। Timeout-এর চতুর্থ test §৫-এ। চারটি test, সত্যিকারের run:

$ uv run pytest -v
platform win32 -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0
plugins: anyio-4.16.0, recording-0.15.0
collected 4 items

tests/test_wallet_virtual.py::test_charge_success PASSED                 [ 25%]
tests/test_wallet_virtual.py::test_large_amount_declined_without_retry PASSED [ 50%]
tests/test_wallet_virtual.py::test_timeout_then_success_same_key PASSED  [ 75%]
tests/test_wallet_virtual.py::test_connection_reset_gives_up_after_three PASSED [100%]

============================== 4 passed in 0.72s ==============================

লক্ষ করুন, connection reset আর ১.৫ সেকেন্ডের delay থাকা সত্ত্বেও পুরো suite এক সেকেন্ডের কম: অপেক্ষাগুলো spy-তে লেখা হয়, সত্যি ঘুমানো হয় না। আর client যদি ভুল key পাঠায়? curl দিয়ে key “8” পাঠালে WireMock-এর সত্যিকারের উত্তর:

HTTP/1.1 404 Not Found
                         Request was not matched
                         =======================
-----------------------------------------------------------
| Closest stub                | Request                   |
-----------------------------------------------------------
POST                          | POST
[path] /v1/charges            | /v1/charges
Idempotency-Key [matches] :   | Idempotency-Key: 8   <<<<< Header does not match
  BG-[0-9]+-[0-9a-f]{8}       |
-----------------------------------------------------------

(চওড়া টেবিলটি ফোনের জন্য সরু করা, বিষয়বস্তু অপরিবর্তিত।) এই বার্তা পড়েই বোঝা যায়, দোষ client-এর header-এ, mock-এর mapping-এ নয়।

৫ · Latency, error আর timeout ঢোকানো

Virtual service-এর সবচেয়ে বড় শক্তি হলো ইচ্ছামতো বিপদ ঘটানো: fault injection. WireMock-এর response-এ তিন ধরনের বিপদ বসানো যায়:

  • ধীর উত্তর: fixedDelayMilliseconds (বা এলোমেলো delay-এর বিতরণ)। Client-এর timeout-এর চেয়ে বেশি দিলে client-এর দিকে timeout ঘটে।
  • ভাঙা connection: "fault": "CONNECTION_RESET_BY_PEER", খালি উত্তর, বা অর্থহীন byte. Client এখানে HTTP status-ই পায় না, পায় exception.
  • ভুল উত্তর: 500, 503, 429-এর মতো status, বা ভাঙা JSON.

কিন্তু retry পরীক্ষা করতে একটি জিনিস লাগে যা সাধারণ stub পারে না: “প্রথমবার ধীর, দ্বিতীয়বার ঠিক”। WireMock-এর scenario এই কাজ করে: প্রতিটি mapping একটি অবস্থায় (state) সক্রিয়, আর মিললে অবস্থা বদলে দিতে পারে, ঠিক পর্ব ১০-এর state machine-এর মতো। চতুর্থ test:

def test_timeout_then_success_same_key(wm, client, slept):
    s = {"scenarioName": "slow-wallet"}
    stub(wm, CHARGE, {**OK, "fixedDelayMilliseconds": 1500}, **s,
         requiredScenarioState="Started", newScenarioState="answered-late")
    stub(wm, CHARGE, OK, **s, requiredScenarioState="answered-late")
    assert client.charge("BG-8", 961)["status"] == "captured"
    keys = [r["headers"]["Idempotency-Key"] for r in charges(wm)]
    assert slept == [1]
    assert len(keys) == 2 and keys[0] == keys[1], keys
Client (timeout 0.5 s) আর WireMock scenario
সময়
Scenario
Client
Journal
  1. Mapping বসানো। Test দুটি mapping বসাল, দুটিই scenario “slow-wallet”-এর। শুরুর অবস্থা Started; তখন শুধু প্রথম mapping (১৫০০ ms delay) সক্রিয়। তারপর SUT-এর charge("BG-8", 961).
  2. প্রথম চেষ্টা। Request প্রথম mapping-এ মিলল, আর মেলার মুহূর্তেই scenario-র অবস্থা হলো answered-late. Journal-এ ১টি request. WireMock উত্তর আটকে রাখল।
  3. Client-এর timeout. ৫০০ ms পরেও উত্তর নেই; httpx ReadTimeout তুলল, যা TransportError-এর একটি রূপ। Client একে “উত্তর পাইনি” ধরল। মনে রাখুন: wallet টাকা কেটেছে কি না, client জানে না।
  4. অপেক্ষা। নীতি অনুযায়ী ১ সেকেন্ড অপেক্ষা। Test-এ sleep একটি spy, তাই সত্যি ঘুম নেই; তালিকায় শুধু [1] লেখা হলো।
  5. দ্বিতীয় চেষ্টা। অবস্থা এখন answered-late, তাই দ্বিতীয় mapping মিলল, সাথে সাথে 201. গুরুত্বপূর্ণ: key আগের চেষ্টার সমান, যাতে আসল wallet এটিকে একই লেনদেন চেনে।
  6. যাচাই। Journal-এ ২টি request, দুটির key সমান, spy-তে [1]: test পাস। Client-এর একটি bug (প্রতি চেষ্টায় নতুন key) চালু করলে এই শেষ assertion-ই ভাঙে, নিচের run দেখুন।

এবার client-এ একটি সাধারণ bug বসানো হলো: key বানানোর লাইনটি for loop-এর ভেতরে সরে গেছে, ফলে প্রতিটি চেষ্টায় নতুন key (run-এ পরিবেশ-চলক SEED_BUG=new_key_per_attempt দিয়ে চালু)। সত্যিকারের ফল:

$ SEED_BUG=new_key_per_attempt uv run pytest -q --tb=short
..F.                                                                     [100%]
_____________________ test_timeout_then_success_same_key ______________________
tests\test_wallet_virtual.py:53: in test_timeout_then_success_same_key
    assert len(keys) == 2 and keys[0] == keys[1], keys
E   AssertionError: ['BG-8-7376f7ae', 'BG-8-a1291926']
FAILED tests/test_wallet_virtual.py::test_timeout_then_success_same_key - Ass...
1 failed, 3 passed in 0.80s

বাকি তিনটি test সবুজ, কারণ সেগুলোতে retry নেই বা key-এর তুলনা নেই। আসল wallet-এ এই bug-এর ফল: প্রথম চেষ্টায় টাকা কেটেছিল, দ্বিতীয় চেষ্টা নতুন key নিয়ে নতুন লেনদেন, মিতুর ৯৬১ টাকা দুবার। এই পথটি আসল wallet-এর sandbox-এ ইচ্ছামতো ঘটানো প্রায় অসম্ভব; virtual service-এ লাগল দুটি mapping.

আপনার ব্রাউজারে — নকল wallet-এর চার মোড

একই ধারণা in-process রূপে, pytest দিয়ে (Pyodide-এ pytest আছে; ব্যবহার পর্ব ২১-এ)। FakeWallet বাজারঘর app-এর নকল gateway-এর চার মোড অনুকরণ করে, আর একটি ledger রাখে যেখানে একই key-তে একবারই টাকা কাটে। checkout-এ একটি bug বসানো আছে; কোন মোডে ধরা পড়বে?

import os, sys, pytest
os.makedirs("/tmp/p34", exist_ok=True); os.chdir("/tmp/p34")
sys.path.insert(0, os.getcwd()); sys.modules.pop("test_wallet34", None)
open("test_wallet34.py", "w").write('''
import pytest
class Timeout(Exception): pass
class FakeWallet:                   # in-memory virtual wallet with failure modes
    def __init__(self, mode): self.mode, self.ledger, self.calls = mode, {}, 0
    def charge(self, key, amount):
        self.calls += 1
        if self.mode == "decline": return 402        # refused, nothing charged
        self.ledger.setdefault(key, amount)          # one charge per key
        if self.mode == "timeout" or (self.mode == "timeout_once" and self.calls == 1):
            raise Timeout()                          # money moved, answer lost
        return 201
def checkout(wallet, order_id, amount, sleep):       # code under test
    key = f"pay-{order_id}"
    for wait in (1, 2, None):                        # 3 tries, waits 1 s and 2 s
        try:
            code = wallet.charge(key, amount)
        except Timeout:
            code = None
        if code == 201: return "paid"
        if code == 402: return "declined"            # never retry a decline
        if wait: sleep(wait)
    return "failed"                                  # seeded bug
@pytest.mark.parametrize("mode, status, calls, charged, waits", [
    ("success", "paid", 1, 1, []), ("decline", "declined", 1, 0, []),
    ("timeout_once", "paid", 2, 1, [1]), ("timeout", "unknown", 3, 1, [1, 2])])
def test_checkout(mode, status, calls, charged, waits):
    w, slept = FakeWallet(mode), []
    assert checkout(w, 8, 961, slept.append) == status
    assert (w.calls, len(w.ledger), slept) == (calls, charged, waits)
''')
pytest.main(["-q", "--no-header", "--tb=line", "-p", "no:cacheprovider", "test_wallet34.py"])

আসল আউটপুট:

...F                                                                     [100%]
=================================== FAILURES ===================================
E   AssertionError: assert 'failed' == 'unknown'

      - unknown
      + failed
/tmp/p34/test_wallet34.py:29: AssertionError: assert 'failed' == 'unknown'
=========================== short test summary info ============================
FAILED test_wallet34.py::test_checkout[timeout-unknown-3-1-waits3] - Assertio...
1 failed, 3 passed in 0.02s

প্রথম তিন মোড সবুজ: success-এ একবারে paid, decline-এ একবার চেষ্টা আর কোনো টাকা নয়, timeout_once-এ দুই চেষ্টা আর ledger-এ একটি লেনদেন। শুধু timeout মোডে লাল। কেন এটি সত্যিকারের bug? তিনবার timeout মানে wallet-এর উত্তর আসেনি, কিন্তু ledger-এ ৯৬১ টাকা কাটা (charged = 1). Checkout অর্ডারকে “failed” বললে গ্রাহক আবার অর্ডার করবেন, আর টাকা কাটবে দুবার। সঠিক অবস্থা “unknown”: অর্ডার আটকে রেখে পরে wallet-এর হিসাবের সাথে মিলিয়ে দেখা (reconciliation). শেষ লাইনটি return "unknown" করে আবার চালান; চারটিই পাস করবে। ভাবুন: আসল wallet দিয়ে “তিনবার পরপর timeout অথচ টাকা কাটা” কি কখনো ইচ্ছামতো ঘটানো যেত?

নকলের সীমা। এখানে FakeWallet-এর ledger key দিয়ে লেনদেন মেলায়, কারণ আমরা ধরে নিয়েছি আসল wallet তা-ই করে। আসল provider-এর নথি যদি বলে key ২৪ ঘণ্টা পরে মুছে যায়, বা key-এর সাথে amount-ও মিলতে হয়, তাহলে নকল আর আসল আলাদা; সবুজ test তখন মিথ্যা আশ্বাস। নকলের প্রতিটি আচরণ provider-এর নথি বা sandbox-এর একটি পর্যবেক্ষণের সাথে লিখিতভাবে মিলিয়ে রাখুন। ঠিক এই সমস্যা নিয়েই পরের অংশ।

৬ · OpenAPI থেকে mock — আর mock যখন মিথ্যা বলে

হাতে mapping লেখার বদলে API-র নথি থেকে নিজে নিজে mock বানানো যায়। OpenAPI নথিতে প্রতিটি endpoint-এর parameter আর উত্তরের schema থাকে (পর্ব ৩১-এ এই schema দিয়েই response যাচাই করেছেন)। Prism (Stoplight-এর, Apache 2.0) সেই নথি পড়ে একটি mock server চালায়: request নথির নিয়মে বৈধ কি না যাচাই করে, তারপর schema-র উদাহরণ বা schema থেকে বানানো মান দিয়ে উত্তর দেয়। নতুন provider-এর API তৈরি হওয়ার আগেই, শুধু নথি হাতে পেয়ে, consumer দল কাজ শুরু করতে পারে।

সত্যিকারের run: বাজারঘর app-এর /openapi.json নামিয়ে Prism 5.16.0 (Node 24, স্থানীয় npm প্রকল্পে) চালানো হলো port 8798-এ। তারপর একই দুটি request আসল app (8787) আর mock (8798)-এ:

$ npx prism mock openapi.json -p 8798 -h 127.0.0.1
… Prism is listening on http://127.0.0.1:8798

== আসল app (8787)
GET /api/pricing/quote?subtotal=1001&district=Dhaka
{"subtotal":1001,"discount":100,"delivery":60,"total":961,"district":"Dhaka","plus":false}  [200]
GET /api/pricing/quote?subtotal=abc
{"detail":[{"type":"int_parsing","loc":["query","subtotal"],"msg":"Input should be a valid integer, unable to parse string as an integer","input":"abc"}]}  [422]

== Prism mock (8798)
GET /api/pricing/quote?subtotal=1001&district=Dhaka
{"subtotal":0,"discount":0,"delivery":0,"total":0,"district":"string","plus":true}  [200]
GET /api/pricing/quote?subtotal=abc
{"detail":{"code":"invalid_transition","message":"string"}}  [422]
[VALIDATOR] ×  error     Request query parameter subtotal must be integer

দুটি শিক্ষা। প্রথমত, mock-এর উত্তর গঠনে ঠিক কিন্তু অর্থে ফাঁকা: সব সংখ্যা ০, জেলা “string”. ব্যবসার নিয়ম mock জানে না; ৯৬১ টাকার হিসাব যাচাই করতে আসল app লাগে। দ্বিতীয় শিক্ষাটি বেশি বিপজ্জনক। ভুল request-এ mock দিল detail একটি object, আসল app দেয় তালিকা. পর্ব ৩১-এ schemathesis এই অমিল ধরেছিল: app-এর নথি 422-এর জন্য ErrorResponse বলে, অথচ FastAPI-র গঠনগত 422 তালিকা-আকারের। Mobile দল যদি এই mock-এর বিরুদ্ধে লেখে r.json()["detail"]["code"], mock-এ সব test সবুজ, আসল app-এ সেই লাইন crash করবে (তালিকায় string দিয়ে index করা যায় না)। Mock আর আসল সেবার এই ফারাকের নাম contract drift; পর্ব ২৪-এর mock drift-এর network-রূপ।

Drift ধরার একটি সরাসরি উপায় Prism নিজেই দেয়: validation proxy. Prism আসল app-এর সামনে বসে, প্রতিটি request আসল app-এ পাঠায়, আর আসল উত্তর নথির সাথে মেলায়:

$ npx prism proxy openapi.json http://127.0.0.1:8787 -p 8799 -h 127.0.0.1
$ curl -i "http://127.0.0.1:8799/api/pricing/quote?subtotal=abc"
HTTP/1.1 422 Unprocessable Entity
sl-violations: [{"location":["request","query","subtotal"],"severity":"Error","code":"type","message":"Request query parameter subtotal must be integer"},{"location":["response","body","detail"],"severity":"Error","code":"type","message":"Response body property detail must be object"}]
…
[VALIDATOR] ×  error     Violation: response.body.detail Response body property detail must be object

দ্বিতীয় violation-টিই drift: “Response body property detail must be object”. Request-এর violation প্রত্যাশিত, কারণ আমরা ইচ্ছা করে “abc” পাঠিয়েছি। Integration বা E2E test-এর সময় traffic এই proxy-র ভেতর দিয়ে চালালে নথি আর আসল আচরণের প্রতিটি অমিল header-এ আর log-এ উঠে আসে। Consumer-এর দিক থেকে আরও শক্ত পাহারা হলো পর্ব ৩২-এর consumer-driven contract test: সেখানে mock আর চুক্তি একই উৎস থেকে আসে, আর provider সেই চুক্তি আসল কোডে যাচাই করে।

৭ · Record আর replay — আসল উত্তরকে cassette-এ ধরে রাখা

তৃতীয় পথ: নকল হাতে না লিখে আসল সেবার উত্তর একবার রেকর্ড করা, পরে সেটিই বাজানো। পুরোনো দিনের ভিসিআর-এর মতো, তাই Ruby-র জনপ্রিয় library-টির নাম VCR, আর তার Python রূপ VCR.py (MIT লাইসেন্স)। প্রথম run-এ request আসল সেবায় যায়, আর request-উত্তরের জোড়া একটি YAML ফাইলে লেখা হয়, যার নাম cassette. পরের run-গুলোতে একই request এলে network-এ না গিয়ে cassette থেকে উত্তর আসে। এই কৌশলটি record and replay.

সত্যিকারের run: vcrpy 9.4.2 আর তার pytest plugin pytest-recording 0.15.0 (MIT), বাজারঘর app-এর quote-এর বিরুদ্ধে। vcr_config-এ authorization header ছেঁটে ফেলা হয়েছে, যাতে কোনো token cassette-এ না যায়:

APP = "http://127.0.0.1:8787"
SUBTOTAL = int(os.environ.get("SUBTOTAL", "2000"))

@pytest.fixture(scope="module")
def vcr_config():
    return {"filter_headers": ["authorization"], "decode_compressed_response": True}

@pytest.mark.vcr
def test_quote_2000_dhaka_free_delivery():
    r = httpx.get(f"{APP}/api/pricing/quote",
                  params={"subtotal": SUBTOTAL, "district": "Dhaka"})
    assert r.status_code == 200
    assert (r.json()["delivery"], r.json()["total"]) == (0, 1800)
$ uv run pytest tests/test_quote_vcr.py --record-mode=once -q
1 passed in 0.21s
$ cat tests/cassettes/test_quote_vcr/test_quote_2000_dhaka_free_delivery.yaml
interactions:
- request:
    method: GET
    uri: http://127.0.0.1:8787/api/pricing/quote?subtotal=2000&district=Dhaka
  response:
    body:
      string: '{"subtotal":2000,"discount":200,"delivery":0,"total":1800,"district":"Dhaka","plus":false}'
    status:
      code: 200
…
$ uv run pytest tests/test_quote_vcr.py --record-mode=none --block-network -q
1 passed in 0.10s
$ SUBTOTAL=2001 uv run pytest tests/test_quote_vcr.py --record-mode=none --block-network -q --tb=line
E   vcr.errors.CannotOverwriteExistingCassetteException: Can't play back this request: no recorded interaction matches it (the closest differ in query).
      GET http://127.0.0.1:8787/api/pricing/quote?subtotal=2001&district=Dhaka
    Closest recorded requests:
      1. GET http://127.0.0.1:8787/api/pricing/quote?subtotal=2000&district=Dhaka
         query differs: [('district', 'Dhaka'), ('subtotal', '2001')] != [('district', 'Dhaka'), ('subtotal', '2000')]
1 failed in 0.10s

তারপর app আবার চালু হলো seeded bug delivery_after_discount সহ (free-delivery-র সীমা ছাড়ের পরের অঙ্কে, ফলে ঢাকায় ২০০০ টাকায় ৬০ টাকা delivery). একই test দুইভাবে:

$ uv run pytest tests/test_quote_vcr.py --record-mode=none --block-network -q
1 passed in 0.11s
$ uv run pytest tests/test_quote_vcr.py --disable-recording -q --tb=line
tests/test_quote_vcr.py:16: assert (60, 1860) == (0, 1800)
1 failed in 0.07s
  1. Record--record-mode=onceআসল app
  2. Replay--block-networkcassette থেকে
  3. নতুন requestsubtotal=2001মিল নেই
  4. Stalebug চালুreplay সবুজ, live লাল
প্রথম runcassette নেই
GET …/quote?subtotal=2000&district=Dhaka
→ আসল app 8787: 200
  delivery 0, total 1800
cassette লেখা: ১টি interaction
1 passed in 0.21s
দ্বিতীয় runnetwork বন্ধ
একই request → cassette-এ মিল
উত্তর YAML থেকে, app লাগেনি
1 passed in 0.10s
request বদলালrecord-mode=none
subtotal=2001 → কোনো রেকর্ড নেই
CannotOverwriteExistingCassette…
closest differ in query
1 failed in 0.10s
app-এ bugdelivery_after_discount
replay: (0, 1800) → 1 passed
cassette পুরোনো, bug লুকানো
live run--disable-recording
assert (60, 1860) == (0, 1800)
1 failed in 0.07s
→ bug ধরা পড়ল
  1. Record. Cassette নেই, তাই request আসল app-এ গেল। উত্তর (delivery ০, মোট ১৮০০) আর request দুটিই YAML-এ লেখা হলো। Test আসল উত্তরে পাস।
  2. Replay. --block-network দিয়ে network বন্ধ; app না চললেও চলে। Request-এর method, host, port, path আর query মিলল, উত্তর এল cassette থেকে, আগের অর্ধেক সময়ে।
  3. Request বদলালে। ২০০১ টাকার request-এর কোনো রেকর্ড নেই, আর record-mode=none নতুন রেকর্ড নিষেধ করে। VCR.py সবচেয়ে কাছের রেকর্ড আর অমিলের অংশ (query) দেখাল: আবার রেকর্ড করুন, নয়তো matching ঢিলা করুন।
  4. পুরোনো cassette. আসল app-এ এখন bug: ২০০০ টাকায় ঢাকায় ৬০ টাকা delivery. কিন্তু replay আগের দিনের উত্তর বাজায়, তাই test সবুজ। Cassette যেদিন রেকর্ড হয়েছিল, সেদিনের সত্য বলে, আজকের নয়।
  5. Live run. --disable-recording দিয়ে আসল app-এ: (60, 1860), test লাল। শিক্ষা: replay-এর পাশে নির্দিষ্ট সময় পরপর live run আর নতুন রেকর্ড রাখুন, নইলে cassette ধীরে ধীরে একটি পুরোনো mock হয়ে যায়।

নিচের block-এ একই চক্রের খুদে রূপ: Cassette প্রথমবার রেকর্ড করে, পরে বাজায়, অচেনা request-এ থামে, আর provider বদলে গেলেও পুরোনো উত্তর দেয়। live_quote network নয়, আসল নিয়মের একটি function.

import json
def live_quote(subtotal, district, bug=False):     # stands in for the real API
    discount = min(subtotal // 10, 300) if subtotal > 1000 else 0
    base = subtotal - discount if bug else subtotal  # bug: threshold after coupon
    if district == "Dhaka":
        delivery = 0 if base >= 2000 else 60
    else:
        delivery = 120
    return {"delivery": delivery, "total": subtotal - discount + delivery}

class Cassette:
    def __init__(self, mode):
        self.mode, self.tape, self.live_calls = mode, {}, 0
    def call(self, live, **request):
        key = json.dumps(request, sort_keys=True)    # match on the whole request
        if key in self.tape:
            return self.tape[key]                    # replay, no live call
        if self.mode == "none":
            raise LookupError(f"no recorded interaction for {key}")
        self.live_calls += 1
        self.tape[key] = live(**request)             # record
        return self.tape[key]

c = Cassette("once")
print("record :", c.call(live_quote, subtotal=2000, district="Dhaka"), c.live_calls)
c.mode = "none"
print("replay :", c.call(live_quote, subtotal=2000, district="Dhaka"), c.live_calls)
try:
    c.call(live_quote, subtotal=2001, district="Dhaka")
except LookupError as e:
    print("miss   :", e)
buggy = lambda **r: live_quote(**r, bug=True)
print("replay, provider now buggy:", c.call(buggy, subtotal=2000, district="Dhaka"))
print("live,   provider now buggy:", buggy(subtotal=2000, district="Dhaka"))

আসল আউটপুট:

record : {'delivery': 0, 'total': 1800} 1
replay : {'delivery': 0, 'total': 1800} 1
miss   : no recorded interaction for {"district": "Dhaka", "subtotal": 2001}
replay, provider now buggy: {'delivery': 0, 'total': 1800}
live,   provider now buggy: {'delivery': 60, 'total': 1860}

শেষের সংখ্যাটি দেখুন: replay-এর পরেও live_calls ১-ই, অর্থাৎ দ্বিতীয়বার “আসল” function ডাকা হয়নি। চতুর্থ লাইনে provider-এর নিয়ম বদলে গেছে, তবু replay পুরোনো সঠিক উত্তর দিল; পঞ্চম লাইনে live ডাকে আসল অবস্থা: ৬০ টাকা delivery, মোট ১৮৬০. Desktop run-এর সাথে সংখ্যাগুলো হুবহু মেলে, কারণ দুটিই কোর্সের একই নিয়ম আর একই seeded bug.

Cassette আর গোপনীয়তা। Cassette-এ আসল request আর উত্তর হুবহু লেখা হয়: token, cookie, গ্রাহকের নাম, ফোন নম্বর, ঠিকানা। এগুলো code repository-তে গেলে সবাই দেখতে পায়। তাই রেকর্ডের আগেই filter_headers, filter_query_parameters আর before_record_response দিয়ে সংবেদনশীল অংশ সরান, আর commit-এর আগে YAML নিজে পড়ে দেখুন। শুধু কাল্পনিক test অ্যাকাউন্টের বিরুদ্ধে রেকর্ড করুন।

৮ · Sandbox, স্তরে স্তরে কৌশল আর প্রচলিত ভুল

বেশিরভাগ payment আর SMS provider একটি sandbox দেয়: আলাদা test key, আলাদা ঠিকানা, যেখানে টাকা বা বার্তা সত্যি যায় না। অনেক sandbox-এ নির্দিষ্ট “জাদুর” মান থাকে (একটি বিশেষ কার্ড নম্বর বা amount দিলে প্রত্যাখ্যান)। Sandbox আসল provider-এর কোডের সবচেয়ে কাছে, তাই মূল্যবান; কিন্তু তার সীমাও আছে: সেটিও মাঝে মাঝে বন্ধ বা ধীর, rate limit আছে, timeout বা আধা-সম্পন্ন লেনদেন ইচ্ছামতো ঘটানো যায় না, আর production-এর আচরণের সাথে সবসময় হুবহু মেলে না। কোন provider-এর sandbox কী পারে, তা তার নিজের নথিতে দেখে নিতে হবে।

তাই একটি পদ্ধতি দিয়ে সব হয় না; স্তরে স্তরে সাজাতে হয়:

স্তরWallet-এর জায়গায়কী যাচাই হয়কতবার
UnitMock / fake (পর্ব ২৪)Retry-নীতির যুক্তি, অবস্থার সিদ্ধান্তপ্রতিটি commit
Component / integrationVirtual service (WireMock)HTTP client, header, timeout, fault-এর পথপ্রতিটি commit
ContractPact-এর mock + provider verification (পর্ব ৩২)নকল আর আসল একই চুক্তি মানে কি নাদুই দলের build-এ
Sandbox-এর বিরুদ্ধেProvider-এর sandboxআসল API-র সাথে কয়েকটি সুখী আর অসুখী পথরাতে বা release-এর আগে
Productionআসল wallet, পর্যবেক্ষণসহReconciliation, synthetic monitoringসবসময় (পর্ব ৬৬)

WireMock-ই একমাত্র পথ নয়। একই কাজের আরও কয়েকটি open-source tool আছে: Mountebank (MIT, HTTP ছাড়াও TCP সেবার নকল), Hoverfly (Apache 2.0, proxy হয়ে আসল traffic রেকর্ড করে পরে নকল হিসেবে বাজায়), Mockoon (MIT, desktop app আর CLI). Python-এর দলে অনেক সময় একটি ছোট FastAPI বা http.server-এর stub-ও যথেষ্ট, যদি তাতে delay, fault আর request-এর খাতা রাখা হয়। Tool বাছাইয়ের প্রশ্ন একই থাকে: matcher কতটা কড়া করা যায়, বিপদ কতভাবে ঢোকানো যায়, journal থেকে যাচাই করা যায় কি না, আর CI-তে কত সহজে চালু-বন্ধ করা যায়। এই কোর্সের run-এ Java ছিল না বলে একটি portable Java runtime ব্যবহার করা হয়েছে; Docker থাকলে WireMock-এর অফিসিয়াল container image-ও একই কাজ করে।

Integration test-এ কোনটি আসল আর কোনটি নকল রাখবেন, সেই সিদ্ধান্তের কাঠামো পর্ব ২৮-এ। Test environment-এ এই virtual service-গুলো Docker Compose দিয়ে কীভাবে একসাথে তোলা হয়, তা পর্ব ৬৫-এ (Test environment আর test data); আর ইচ্ছাকৃত গোলমাল পুরো system-এ ছড়িয়ে দেখার কৌশল পর্ব ৬৩-এ (Chaos আর resilience testing). JavaScript-এর দিকে browser আর Node-এ network নকল করার জনপ্রিয় tool MSW, তার আলোচনা Full-Stack কোর্সের পর্ব ৭৭-এ।

প্রচলিত ভুল

  • অতি-ঢিলা matcher: “যেকোনো POST-এ 201”: client ভুল path, ভুল header বা ভুল body পাঠালেও সবুজ।
  • শুধু সুখী পথ: Virtual service বসানো হলো, কিন্তু delay, fault, 402, 429, 503 কোনোটি নেই; তাহলে তার অর্ধেক মূল্যই হারাল।
  • Reset নেই: আগের test-এর mapping বা scenario-র অবস্থা পরের test-এ থেকে যায়, ক্রম বদলালে ফল বদলায়।
  • সত্যি ঘুম: Retry-এর অপেক্ষা time.sleep-এ রেখে দেওয়া; suite মিনিটে গড়ায়। Sleep inject করুন।
  • নকলের সত্য যাচাই না করা: Mock-এর উত্তর কারও স্মৃতি থেকে লেখা, provider-এর নথি বা sandbox-এর সাথে কখনো মেলানো হয়নি; এটিই contract drift-এর জন্মস্থান।

আরও গভীরে। Michael Nygard তাঁর Release It! (২০০৭) বইয়ে বাইরের সেবার সাথে প্রতিটি সংযোগবিন্দুকে (integration point) production-এর ব্যর্থতার প্রধান উৎসগুলোর একটি বলেছেন, আর timeout, circuit breaker-এর মতো ধাঁচের পাশাপাশি “test harness”-এর কথা বলেছেন: এমন একটি নকল server যা ইচ্ছা করে ভুল আচরণ করে (ধীরে উত্তর, অর্ধেক উত্তর, connection বন্ধ না করা)। WireMock-এর fault আর delay সেই ধারণারই সহজলভ্য রূপ। বড় প্রতিষ্ঠানে virtual service-এর সংখ্যা বাড়লে তাদের রক্ষণাবেক্ষণ নিজেই একটি কাজ হয়ে দাঁড়ায়; তখন mapping-গুলো রেকর্ড থেকে তৈরি, contract দিয়ে যাচাই আর version-নিয়ন্ত্রিত রাখা হয়। Resilience-এর নকশার দিক (retry-এর গুণফল, backoff আর jitter, circuit breaker) সিস্টেম ডিজাইন কোর্সের পর্ব ৪৮-এ।

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

  • Stub, mock আর service virtualization-এর পার্থক্য? Stub উত্তর দেয়, mock ডাক যাচাই করে, দুটিই সাধারণত process-এর ভেতরে; virtual service network-এ আলাদা server হিসেবে আসল সেবার আচরণ নকল করে।
  • কখন virtualize করবেন? নির্ভরতা বাইরের, ধীর, খরুচে, অনিশ্চিত, বা এখনো তৈরি হয়নি; আর যখন error ও timeout-এর পথ ইচ্ছামতো ঘটাতে হবে।
  • Mock server-এর near-miss কী? কোনো stub না মিললে সবচেয়ে কাছের stub আর অমিলের অংশের বিবরণ, যা client-এর ভুল খুঁজতে সাহায্য করে।
  • Record-replay-এর প্রধান ঝুঁকি? পুরোনো cassette provider-এর বদল লুকায়, আর cassette-এ গোপন তথ্য থেকে যেতে পারে।
  • Payment-এর timeout-কে কেন “ব্যর্থ” বলা যাবে না? টাকা কেটে থাকতে পারে; অবস্থা অজানা, তাই একই key-তে retry আর reconciliation.

৯ · AI-এর যুগে service virtualization

AI সহকারী WireMock-এর mapping, Prism-এর command আর VCR.py-র config খুব দ্রুত লিখে দেয়; কিন্তু এখানকার ভুলগুলো বিশেষভাবে ক্ষতিকর, কারণ নকল ভুল হলে test সবুজই থাকে। প্রচলিত ভুল: WireMock 2 আর 3-এর API মিশিয়ে ফেলা বা অস্তিত্বহীন JSON field বানানো (যেমন delay-এর জন্য বানানো নাম); provider-এর API-র field নিজে কল্পনা করে stub লেখা; শুধু 200-এর stub, কোনো fault নেই; সব matcher “any”; retry-এর test-এ সত্যি sleep; request journal যাচাই না করে শুধু ফেরত মান দেখা; cassette-এ token রেখে দেওয়া; আর না চালিয়েই “সব test পাস” দাবি।

AI-কে provider-এর নথি আর আপনার retry-নীতি দিয়ে virtual service চাইতে পারেন:

তুমি একজন অভিজ্ঞ QA engineer, WireMock 3 আর pytest-এ দক্ষ। নিচে একটি (কাল্পনিক) wallet provider-এর API নথির অংশ আর আমাদের client-এর retry-নীতি দিলাম। [নথির অংশ আর retry-নীতি পেস্ট করুন] ১. নথিতে যা আছে শুধু তা দিয়ে stub mapping লেখো; কোনো field বা status নিজে বানাবে না। নথিতে নেই এমন কিছু লাগলে আলাদা তালিকায় প্রশ্ন হিসেবে লেখো। ২. প্রতিটি mapping-এ matcher যতটা সম্ভব কড়া রাখো: method, path, Idempotency-Key-এর ধাঁচ, body-র দরকারি field. ৩. সুখী পথের সাথে অন্তত এগুলো দাও: 402 decline, 503, client-এর timeout-এর চেয়ে বেশি delay, connection reset, আর scenario দিয়ে "প্রথমবার timeout, পরে সফল"। ৪. pytest test লেখো যা প্রতিটি test-এর আগে /__admin/reset ডাকে, sleep inject করে, আর request journal থেকে request-এর সংখ্যা ও key যাচাই করে। ৫. যে WireMock JSON field ব্যবহার করবে তার তালিকা দাও; আমি আমার version-এর নথিতে মিলিয়ে নেব। নিজে test চালানোর দাবি করবে না।

AI-এর লেখা virtual service হাতে পেলে — চেকলিস্ট

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

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

প্র ০১বাইরের সেবার সাথে সংযোগবিন্দু কেন production-এর এত ব্যর্থতার উৎস, আর virtual service এখানে কী শেখায়?

Michael Nygard ২০০৭ সালে Release It! বইয়ে বাস্তব production-এর ঘটনা থেকে একটি পর্যবেক্ষণ সামনে আনেন: বড় সিস্টেম ভেঙে পড়ার পেছনে প্রায়ই থাকে কোনো বাইরের সেবার সাথে সংযোগ, যাকে তিনি integration point বলেন। কারণটি সরল। নিজের কোডের ভুল আপনার test-এ ধরা পড়তে পারে, কিন্তু বাইরের সেবা কীভাবে খারাপ আচরণ করবে, তা আপনি জানেন না: সে ধীরে উত্তর দিতে পারে, connection খুলে রেখে চুপ থাকতে পারে, অর্ধেক উত্তর দিয়ে থেমে যেতে পারে। Client-এ timeout না থাকলে একটি ধীর সেবা আপনার সব thread আটকে দেয়, আর আপনার app নিজেও ধীর হয়ে পড়ে; ব্যর্থতা এভাবে শিকলের মতো ছড়ায়।

সাধারণ test এই পথগুলো খুব কমই পরীক্ষা করে, কারণ আসল সেবায় এগুলো ইচ্ছামতো ঘটানো যায় না, আর in-process mock HTTP client-এর timeout-এর সেটিংই পরীক্ষা করে না। Nygard এর প্রতিকার হিসেবে এমন একটি test harness-এর কথা বলেছিলেন, যা ইচ্ছা করে খারাপ আচরণ করে। আজ WireMock-এর fixedDelayMilliseconds আর fault ঠিক সেই কাজ করে। এই পর্বের run-এ client-এর timeout ছিল ০.৫ সেকেন্ড; যদি কেউ timeout সেটিং মুছে ফেলত, httpx-এর নিজস্ব সীমা পর্যন্ত test আটকে থাকত, অথবা delay বাড়ালে test-এর সময় চোখে পড়ার মতো বাড়ত, আর আমরা সমস্যাটি দেখতে পেতাম।

আরেকটি দিক হলো tester-এর মানসিকতা। সুখী পথের প্রশ্ন “কাজ করে কি?”, আর integration point-এর প্রশ্ন “ওপাশের সেবা খারাপ আচরণ করলে আমার সিস্টেম কী করে?”। প্রতিটি বাইরের সংযোগের জন্য অন্তত চারটি পরিস্থিতি virtual service-এ লিখে রাখা ভালো অভ্যাস: ধীর, প্রত্যাখ্যান, ভাঙা connection, আর অর্থহীন উত্তর।

মূল উপলব্ধি: বাইরের সেবার খারাপ আচরণই সবচেয়ে বিপজ্জনক, আর সেটি নিয়মিত অনুশীলনের একমাত্র বাস্তব উপায় হলো নিজের নিয়ন্ত্রণে থাকা একটি খারাপ-আচরণকারী নকল।

প্র ০২Payment-এর timeout-কে “ব্যর্থ” না বলে “অজানা” বলা কেন জরুরি, আর এটি test করবেন কীভাবে?

Timeout মানে শুধু এটুকু: নির্দিষ্ট সময়ের মধ্যে উত্তর আসেনি। এর পেছনে তিনটি সম্ভাবনা: request wallet-এ পৌঁছায়ইনি; পৌঁছেছে, কিন্তু wallet কাজ শেষ করেনি; বা wallet টাকা কেটেছে, কিন্তু উত্তরটি পথে হারিয়েছে। Client-এর পক্ষে এদের আলাদা করা অসম্ভব। দূরবর্তী দুই পক্ষের মধ্যে নিশ্চিত ঐকমত্যের এই সমস্যাটি কম্পিউটার বিজ্ঞানে “দুই সেনাপতির সমস্যা” নামে পরিচিত, যার আলোচনা পর্ব ২৯-এর ভাবনার প্রশ্নে আছে।

তাই “failed” বলা একটি দাবি, যা সত্য না-ও হতে পারে। দাবিটি ভুল হলে ক্ষতি সরাসরি গ্রাহকের: অর্ডার ব্যর্থ দেখে তিনি আবার কেনেন, আর টাকা কাটে দুবার। সঠিক নকশায় তিনটি অংশ: প্রথমত, একই Idempotency-Key-তে retry, যাতে wallet একই লেনদেন চেনে; দ্বিতীয়ত, সব চেষ্টা শেষেও উত্তর না এলে অবস্থা “unknown” বা “pending”, যেখানে অর্ডার আটকে থাকে; তৃতীয়ত, পরে wallet-এর লেনদেনের তালিকার সাথে মিলিয়ে দেখা, অর্থাৎ reconciliation. অনেক provider লেনদেনের অবস্থা জানার আলাদা endpoint দেয়, যাতে client reference দিয়ে খোঁজ নিতে পারে। বাজারঘরের HTML pay form-এ প্রথম অংশটিই ভাঙা, যা পর্ব ৩৭-এর সত্যিকারের run-এ ধরা পড়ে: প্রতিবার পাতা দেখালে নতুন idempotency key তৈরি হয়, তাই timeout-এর পরে আবার চাপলে ledger-এ একই অর্ডারের দুটি charge.

Test করার জন্য দরকার এমন একটি নকল, যা “টাকা কেটেছে কিন্তু উত্তর দেয়নি” অবস্থা তৈরি করতে পারে, আর নিজের ledger দেখাতে পারে। এই পর্বের Pyodide block-এর FakeWallet এবং বাজারঘর app-এর timeout মোড ঠিক তা-ই: ledger-এ লেনদেন লেখে, তারপর timeout ছোড়ে। Test তখন দুটি জিনিস একসাথে যাচাই করে: অর্ডারের অবস্থা, আর ledger-এ লেনদেনের সংখ্যা। শুধু অবস্থা দেখলে “failed” আর “unknown” দুটিই যুক্তিসঙ্গত মনে হতে পারে; ledger-এর ১টি লেনদেন দেখলেই বোঝা যায় “failed” মিথ্যা।

মূল উপলব্ধি: Timeout-এর পরে সত্য অজানা; test-এর কাজ নিশ্চিত করা যে কোড অজানাকে অজানা হিসেবেই রাখে, আর নকলের ledger দিয়ে সেটি প্রমাণ করা।

প্র ০৩Virtual service ধীরে ধীরে আসল সেবা থেকে আলাদা হয়ে যায় কেন, আর তাকে সৎ রাখার উপায় কী?

একটি virtual service জন্মের দিন আসলের মতো ছিল, কারণ কেউ নথি বা sandbox দেখে সেটি লিখেছিলেন। তারপর আসল সেবা বদলায়: নতুন field, বদলানো error-এর আকার, নতুন rate limit. নকলকে কেউ জানায় না। কয়েক মাস পরে test-গুলো এমন একটি সেবার বিরুদ্ধে সবুজ, যার অস্তিত্বই আর নেই। এই পর্বে আমরা একটি ছোট নমুনা দেখেছি, আর সেখানে দোষ নথির: Prism-এর mock নথি থেকে তৈরি, নথি বলে 422-এর detail একটি object, আসল app দেয় তালিকা। নথি থেকে বানানো mock নথির ভুলও উত্তরাধিকারসূত্রে পায়।

সৎ রাখার কয়েকটি পরিপূরক উপায় আছে। প্রথমত, validation proxy: integration বা sandbox run-এর traffic Prism proxy-র ভেতর দিয়ে চালালে আসল উত্তর নথির সাথে মেলানো হয়, আর অমিল সাথে সাথে চোখে পড়ে; আমাদের run-এ “Response body property detail must be object”. দ্বিতীয়ত, contract test (পর্ব ৩২): consumer-এর mock আর চুক্তি একই উৎস থেকে আসে, আর provider নিজের build-এ সেই চুক্তি যাচাই করে; ফলে mock আর আসলের মধ্যে একটি যান্ত্রিক সেতু তৈরি হয়। তৃতীয়ত, নিয়মিত আবার রেকর্ড করা: virtual service-এর উত্তর মাঝে মাঝে sandbox থেকে নতুন করে নেওয়া, আর পুরোনোটির সাথে পার্থক্য দেখা। চতুর্থত, sandbox-এর বিরুদ্ধে কয়েকটি ছোট test রাতে চালানো।

এর সাথে আছে মালিকানার প্রশ্ন। যে virtual service-এর কোনো মালিক নেই, সেটিই সবার আগে পুরোনো হয়। অনেক দল তাই প্রতিটি নকলের পাশে লিখে রাখে: কোন নথির কোন version থেকে, কবে শেষবার আসলের সাথে মেলানো হয়েছে।

মূল উপলব্ধি: নকলের বয়স বাড়ে; তাকে নিয়মিত আসল সেবা বা চুক্তির সাথে মেলানোর একটি যান্ত্রিক পথ না থাকলে সে একদিন মিথ্যা বলবেই।

প্র ০৪Record-replay-এর সুবিধা আর ফাঁদগুলো কী, আর কখন এটি ভালো পছন্দ?

Ruby-র জগতে VCR library ২০১০ সালের দিকে জনপ্রিয় হয়, আর পরে Python-এ VCR.py, অন্য ভাষাতেও একই ধারণা আসে। সুবিধা স্পষ্ট: হাতে নকল লিখতে হয় না, উত্তর হুবহু আসল সেবার, আর replay দ্রুত ও network ছাড়া। এই পর্বের run-এ replay-এর test চলেছে app বন্ধ রেখেও, --block-network দিয়ে। বাইরের read-only API, যেমন একটি মানচিত্র বা ঠিকানা খোঁজার সেবা, যার উত্তর খুব কম বদলায়, সেখানে record-replay চমৎকার।

ফাঁদ চারটি। প্রথমত, পুরোনো হয়ে যাওয়া: cassette রেকর্ডের দিনের সত্য বলে। আমাদের run-এ app-এ delivery-র bug চালু থাকলেও replay সবুজ ছিল, শুধু live run লাল হয়েছে। দ্বিতীয়ত, matching-এর ভঙ্গুরতা: request-এ timestamp বা random id থাকলে প্রতিটি run-এ request আলাদা, cassette মেলে না; তখন matching ঢিলা করতে হয়, আর ঢিলা matching ভুল request-ও মেনে নিতে পারে। তৃতীয়ত, গোপনীয়তা: cassette-এ token, cookie আর ব্যক্তিগত তথ্য হুবহু লেখা হয়, যা ছেঁকে না দিলে repository-তে চলে যায়। চতুর্থত, শুধু যা ঘটেছে তা-ই: record-replay timeout বা 503 তৈরি করতে পারে না, যদি না রেকর্ডের দিন সেটি সত্যি ঘটে থাকে; error-এর পথের জন্য তাই হাতে লেখা stub লাগে।

ভালো চর্চা হলো দুটি মিশিয়ে ব্যবহার: সাধারণ উত্তরের জন্য রেকর্ড, বিপদের জন্য হাতে লেখা mapping; প্রতিটি cassette-এর বয়সের একটি সীমা; নির্দিষ্ট সময় পরপর live run (--disable-recording) আর ব্যর্থ হলে নতুন রেকর্ড; আর commit-এর আগে YAML নিজে পড়া।

মূল উপলব্ধি: Record-replay আসল উত্তরের একটি ছবি; ছবি যত পুরোনো, তত অবিশ্বস্ত, আর ছবিতে যা ঘটেনি তা সে কখনো দেখাতে পারে না।

প্র ০৫Provider-এর sandbox থাকলে নিজের virtual service কেন দরকার? দুটির ভাগাভাগি কীভাবে করবেন?

প্রশ্নটি যুক্তিসঙ্গত: provider নিজেই একটি নিরাপদ পরীক্ষার জায়গা দিচ্ছে, তার আচরণ আসল কোড থেকে আসে, আর সে ইতিমধ্যে আছে। তবু শুধু sandbox-এ ভর করলে কয়েকটি সমস্যা দেখা দেয়। প্রথমত, sandbox আপনার নিয়ন্ত্রণে নেই: সে রক্ষণাবেক্ষণে বন্ধ থাকতে পারে, ধীর হতে পারে, rate limit-এ আটকাতে পারে; তখন আপনার CI লাল, অথচ আপনার কোড ঠিক। দ্বিতীয়ত, বিপদ ঘটানোর ক্ষমতা সীমিত: কিছু “জাদুর” মান দিয়ে প্রত্যাখ্যান হয়তো ঘটানো যায়, কিন্তু “টাকা কেটে timeout”, connection reset, বা দ্বিতীয় চেষ্টায় সফল হওয়ার মতো ক্রম সাধারণত যায় না। তৃতীয়ত, ভাগ করা অবস্থা: একই test অ্যাকাউন্ট অনেকে ব্যবহার করলে data-র সংঘর্ষ। চতুর্থত, sandbox আর production সবসময় হুবহু এক নয়।

অন্যদিকে শুধু নিজের virtual service-এ ভর করলে প্রশ্ন ৩-এর drift-এর ঝুঁকি। তাই প্রচলিত ভাগাভাগি এমন: প্রতিটি commit-এর দ্রুত test virtual service-এর বিরুদ্ধে, যেখানে সব বিপদের পথ নিয়ন্ত্রিতভাবে পরীক্ষা হয়; আর অল্প কয়েকটি গুরুত্বপূর্ণ পথ (সফল charge, একটি প্রত্যাখ্যান, refund) রাতে বা release-এর আগে sandbox-এর বিরুদ্ধে, যাতে নকলের অনুমানগুলো আসল আচরণের সাথে মেলে কি না দেখা যায়। Sandbox-এর এই test ব্যর্থ হলে প্রথম প্রশ্ন: নকল পুরোনো হয়েছে, নাকি আমাদের কোড ভাঙছে?

আরেকটি সূক্ষ্ম কথা: sandbox-এর test flaky হলে তা মূল pipeline আটকাবে না, আলাদা সতর্কবার্তা দেবে। নইলে দল লাল আলো উপেক্ষা করতে শেখে। Flaky test-এর ব্যবস্থাপনা নিয়ে বিস্তারিত পর্ব ৪০-এ (Flaky test — কারণ, খোঁজা, quarantine আর স্থায়ী সমাধান)।

মূল উপলব্ধি: Virtual service দেয় নিয়ন্ত্রণ আর গতি, sandbox দেয় আসলের সাথে মিল; দুটির কাজ আলাদা, আর একটি অন্যটিকে পাহারা দেয়।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন। সংখ্যাগুলো scratch-এ চালিয়ে মেলানো।

  1. Spec থেকে test case: বাজারঘর একটি কাল্পনিক SMS gateway-তে POST /sms/send পাঠায়। Gateway-এর নথি: সফল হলে 202; অবৈধ নম্বরে 400; অতিরিক্ত অনুরোধে 429 আর Retry-After header (সেকেন্ডে); সাময়িক সমস্যায় 503. বাজারঘরের নীতি: 400-এ আর চেষ্টা নয়; 429-এ Retry-After যত সেকেন্ড বলে তত অপেক্ষা করে একবার আবার চেষ্টা; 503-এ ১ সেকেন্ড অপেক্ষা করে আরও সর্বোচ্চ ২ বার (মোট ৩ চেষ্টা)। প্রতিটি নিয়মের জন্য virtual service-এর আচরণ, প্রত্যাশিত ফল, মোট request আর অপেক্ষার তালিকাসহ একটি test case-এর ছক বানান।
    IDVirtual serviceপ্রত্যাশিত ফলRequestঅপেক্ষা
    SMS-1202sent১[]
    SMS-2400invalid_number, retry নেই১[]
    SMS-3scenario: 429 (Retry-After: 5), তারপর 202sent২[5]
    SMS-4সবসময় 429 (Retry-After: 5)rate_limited২[5]
    SMS-5scenario: 503, 503, তারপর 202sent৩[1, 1]
    SMS-6সবসময় 503unavailable৩[1, 1]
    SMS-7connection resetনীতিতে লেখা নেই: প্রশ্ন তুলুন??

    SMS-3 আর SMS-5 scenario (stateful stub) ছাড়া লেখা যায় না। প্রতিটি test-এ request journal থেকে সংখ্যা গুনুন আর sleep spy-তে অপেক্ষা দেখুন। SMS-7 সবচেয়ে মূল্যবান সারি: নীতিতে connection ভাঙার কথা নেই; virtual service এই ফাঁকটি চোখে আনে, আর উত্তর আসে product owner-এর কাছ থেকে (পর্ব ১৫)। আরেকটি প্রশ্নও তোলা উচিত: Retry-After খুব বড় হলে (যেমন ৩৬০০) client কি সত্যিই এক ঘণ্টা অপেক্ষা করবে? একটি উচ্চসীমা দরকার।

  2. আউটপুট অনুমান করুন: একটি mock server-এ তিনটি mapping, ছোট priority আগে: (A) priority 1: POST /v1/charges, body-তে currency “USD” → 422; (B) priority 3: POST /v1/charges, amount ৫০০০-এর বেশি → 402; (C) priority 5: POST /v1/charges, যেকোনো body → 201. চারটি request: (১) amount 961, currency BDT; (২) amount 7000, currency USD; (৩) amount 7000, currency BDT; (৪) POST /v1/charge (শেষে s নেই), amount 961. প্রতিটির উত্তর কী?

    (১) A-তে currency মেলে না, B-তে amount মেলে না, C মেলে: 201. (২) A-ই প্রথমে মেলে, কারণ priority 1: 422; B-ও মিলত, কিন্তু দেখা হয় না। (৩) A মেলে না, B মেলে: 402. (৪) কোনো mapping-এর path মেলে না: 404 আর near-miss, যেখানে সবচেয়ে কাছের mapping C (শুধু path-এ অমিল)। §৩-এর block-এর STUBS-এ এই তিনটি mapping বসিয়ে চালিয়ে মেলানো হয়েছে। শিক্ষা: priority-র ক্রম বদলালে (২)-এর উত্তর বদলে 402 হতো; তাই কোন নিয়ম কোনটির আগে, সেটিও test-এর নকশার অংশ।

  3. Test-এ ভুল খুঁজুন: একজন সহকর্মী wallet client-এর retry-এর জন্য নিচের test লিখেছেন। কয়টি সমস্যা দেখছেন?
    def test_retry():
        httpx.post(f"{WM}/__admin/mappings", json={
            "request": {"method": "ANY", "urlPattern": ".*"},
            "response": {"status": 503}})
        client = WalletClient(WM)
        with pytest.raises(WalletUnavailable):
            client.charge("BG-8", 961)
        time.sleep(3)

    অন্তত পাঁচটি। (১) Reset নেই: আগের test-এর mapping আর journal থেকে যায়, ফল ক্রম-নির্ভর। (২) Matcher “ANY” আর .*: client ভুল method, ভুল path বা key ছাড়া request পাঠালেও 503 পায়, তাই client-এর request-এর কিছুই যাচাই হলো না। (৩) Request-এর সংখ্যা আর key-এর তুলনা নেই: client তিনবারের বদলে একবার বা দশবার চেষ্টা করলেও, বা প্রতিবার নতুন key পাঠালেও test পাস। (৪) sleep inject করা হয়নি, তাই client সত্যি ১ + ২ = ৩ সেকেন্ড ঘুমায়; শেষের time.sleep(3) একেবারে অর্থহীন, আরও ৩ সেকেন্ড নষ্ট। (৫) শুধু 503 পরীক্ষা: decline-এ retry না হওয়া, timeout, আর “প্রথমবার ব্যর্থ, পরে সফল” পথ নেই। ঠিক রূপ §৪-এর test-গুলো: fixture-এ reset, কড়া CHARGE matcher, spy-sleep, আর journal থেকে সংখ্যা ও key.

  4. ব্যর্থতা পড়ুন: CI-তে এই ফল এল: AssertionError: ['BG-8-7376f7ae', 'BG-8-a1291926'], test test_timeout_then_success_same_key-এ, বাকি তিনটি সবুজ। আগের দিন সব সবুজ ছিল, আর virtual service-এর mapping বদলায়নি। (ক) সম্ভাব্য bug কী? (খ) আসল wallet-এ এর ফল কী হতো? (গ) Bug report-এর শিরোনাম লিখুন।

    (ক) Journal-এ দুটি request, দুটির Idempotency-Key আলাদা: client প্রতিটি চেষ্টায় নতুন key বানাচ্ছে। সম্ভবত key তৈরির লাইনটি retry loop-এর ভেতরে চলে গেছে (গতকালের কোনো পরিবর্তনে)। Mapping না বদলানোয় দোষ client-এর দিকে; বাকি তিনটি test সবুজ, কারণ সেগুলোতে key-এর তুলনা হয় না। (খ) প্রথম চেষ্টায় wallet টাকা কেটে ধীরে উত্তর দিলে, দ্বিতীয় চেষ্টা নতুন key নিয়ে নতুন লেনদেন: গ্রাহকের ৯৬১ টাকা দুবার কাটা। (গ) “Wallet charge-এর retry প্রতি চেষ্টায় নতুন Idempotency-Key পাঠায়, timeout-এর পরে দুবার টাকা কাটার ঝুঁকি”। Report-এ test-এর নাম, ব্যর্থ assertion, দুটি key, আর গতকালের সবুজ commit-এর উল্লেখ রাখুন (পর্ব ১৮)।

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

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

ক্রমএকটি virtual service দিয়ে retry-এর test-এর ধাপগুলো ক্রমে সাজান (▲▼ চেপে সরান)

  1. Admin API দিয়ে আগের সব mapping, journal আর scenario মুছে ফেলা
  2. Delay বা fault-সহ mapping বসানো, দরকারে scenario-র অবস্থাসহ
  3. SUT-কে virtual service-এর base URL আর spy-sleep দিয়ে চালানো
  4. SUT-এর ফেরত মান বা exception যাচাই করা
  5. Request journal থেকে request-এর সংখ্যা আর key যাচাই করা

একটি checkout কোড বাইরের wallet-কে HTTP-তে ডাকে। কোন bug একটি in-process mock (কোডের wallet object-এর জায়গায় বসানো) ধরতে পারবে না, কিন্তু network-এ চলা virtual service ধরতে পারবে?

  • Decline-এর পরে আবার চেষ্টা করা
  • Timeout-এর পরে মোট কতবার চেষ্টা হলো
  • HTTP client-এ timeout সেট করতে ভুলে যাওয়া
  • Timeout-এর পরে অবস্থা “failed” লেখা

WireMock-এ দুটি mapping: priority 1-এ “amount > 5000 হলে 402”, priority 5-এ “যেকোনো charge-এ 201”. amount 7000-এর একটি সঠিক request এলে কী হয়?

  • 201, কারণ সাধারণ mapping সব request ধরে
  • 402
  • 500, কারণ দুটি mapping একসাথে মেলে
  • 404 আর near-miss

একটি API-র OpenAPI নথি বলে 422-এর body {"detail": {"code", "message"}}, কিন্তু আসল server গঠনগত ভুলে দেয় {"detail": [ … ]}. নথি থেকে Prism দিয়ে বানানো mock-এর বিরুদ্ধে লেখা client test সম্পর্কে কোনটি সঠিক?

  • Mock নিজেই অমিল ধরে test লাল করবে
  • Prism-এর request validation অমিলটি ধরবে
  • Status code আলাদা হওয়ায় test লাল হবে
  • Test সবুজ থাকবে; আসল server-এ client ভাঙবে, আর এটি ধরতে validation proxy বা contract test দরকার

VCR.py-র cassette দিয়ে একটি test মাসের পর মাস সবুজ, অথচ provider এর মধ্যে উত্তরের একটি নিয়ম বদলেছে। এর সবচেয়ে সঠিক ব্যাখ্যা কোনটি?

  • Replay পুরোনো রেকর্ড বাজায়, তাই provider-এর বদল test-এ পৌঁছায় না
  • VCR.py provider-এর নতুন নিয়ম নিজে হিসাব করে মিলিয়েছে
  • Matching ঢিলা, তাই ভুল interaction মিলেছে
  • Authorization header ছেঁটে ফেলায় উত্তর বদলায়নি

একটি checkout wallet-এ ৯৬১ টাকা কাটতে তিনবার চেষ্টা করল, প্রতিবার timeout. নকল wallet-এর ledger-এ সেই key-তে একটি লেনদেন আছে। Checkout অর্ডারের অবস্থা কী রাখা উচিত?

  • failed, কারণ তিনবারই উত্তর আসেনি
  • paid, কারণ ledger-এ লেনদেন আছে
  • unknown বা pending, পরে reconciliation-এর জন্য
  • নতুন Idempotency-Key দিয়ে আবার তিনবার চেষ্টা

“প্রথম request-এ ধীর উত্তর, দ্বিতীয়টিতে সাথে সাথে সফল” — এমন আচরণ একটি mock server-এ বসাতে কোন সুবিধা সবচেয়ে সরাসরি কাজে লাগে?

  • Response templating
  • Stateful scenario (অবস্থাভিত্তিক stub)
  • Near-miss রিপোর্ট
  • Mapping-এর priority

একটি দল সব test শুধু wallet provider-এর sandbox-এর বিরুদ্ধে চালায়। কোন সমস্যাটি এই পদ্ধতিতে সবচেয়ে স্বাভাবিকভাবে দেখা দেয়?

  • Timeout-এর মতো বিপদ ইচ্ছামতো ঘটানো যায় না, আর sandbox-এর সমস্যায় test অকারণে লাল হয়
  • Contract drift বেশি হয়, কারণ sandbox নথি থেকে তৈরি
  • প্রতিটি test-এ আসল টাকা কাটে
  • HTTP client-এর কোড পরীক্ষা হয় না

শব্দকোষ

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

মনে রাখুন

  1. বাইরের, ধীর, খরুচে, অনিশ্চিত বা এখনো তৈরি না হওয়া নির্ভরতাকে virtualize করুন; virtual service network-এ আলাদা server, তাই আপনার HTTP client, header আর timeout আসলই পরীক্ষিত হয়।
  2. Mock server mapping-গুলো priority অনুযায়ী মেলায়, প্রথম মিলেই থামে; কিছু না মিললে near-miss. Matcher কড়া রাখুন, নইলে client-এর ভুল request-ও সবুজ।
  3. Delay, fault আর scenario দিয়ে timeout, connection reset আর “প্রথমে ব্যর্থ, পরে সফল” ঘটান; sleep inject করুন, আর journal থেকে request-এর সংখ্যা ও key যাচাই করুন।
  4. নথি থেকে বানানো mock নথির ভুলও পায়: Prism-এর mock 422-এ object দিল, আসল app তালিকা। Validation proxy আর contract test দিয়ে drift ধরুন।
  5. Record-replay দ্রুত আর সহজ, কিন্তু cassette পুরোনো হয় আর গোপন তথ্য ধরে রাখে; নিয়মিত live run, নতুন রেকর্ড আর ছাঁকনি রাখুন। Sandbox মাঝে মাঝে আসলের সাথে মেলানোর জন্য।

পরের পর্বে: পর্ব ৩৫ (Automation-এর জন্য web — DOM, CSS selector, XPath আর ভালো locator). মডিউল ৬ শুরু: API-র নিচ থেকে এবার browser-এর পর্দায়। UI automation-এর প্রথম শর্ত, page-এর উপাদান নির্ভরযোগ্যভাবে খুঁজে পাওয়া।

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

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