এই পর্বে যা শিখবেন
- Tester-এর দৃষ্টিতে CI: কোন test কোন stage-এ, প্রতি পরিবর্তনে না রাতে, আর কোনটি merge আটকাবে
- খরচ আর ভুল ধরার সম্ভাবনা দেখে stage সাজানো, আর fail fast-এর সত্যিকারের লাভ মাপা
- Parallel worker, critical path, sharding-এর প্রথম ধারণা, matrix build আর dependency cache
- Artifact (JUnit XML, coverage, trace, screenshot) আর quality gate নকশা: coverage, mutation, performance আর security
- GitHub Actions-এর workflow উদাহরণ actionlint দিয়ে যাচাই, secret-এর নিয়ম, pipeline-এর flakiness আর feedback-এর সময়
১ · CI কী, আর tester-এর কাছে এর মানে কী
একটি garments কারখানার লাইনের কথা ভাবুন। প্রতিটি শার্ট কয়েকটি টেবিল পেরিয়ে যায়। প্রথম টেবিলে এক নজরে দেখা হয় সেলাই ছুটে আছে কি না: কয়েক সেকেন্ডের কাজ, আর বেশিরভাগ ভুল এখানেই ধরা পড়ে। ধোয়ার পর রং ওঠে কি না, সেই দীর্ঘ পরীক্ষা হয় শেষে; কেউ চায় না সেটি শেষ হওয়ার পর জানা যাক, বোতামই লাগানো হয়নি। আর যে টেবিলে আটকায়, শার্ট সেখান থেকে আর সামনে যায় না।
Continuous integration (CI) মানে দলের সবাই দিনে অনেকবার নিজের পরিবর্তন মূল কোডে মেলান, আর প্রতিবার একটি স্বয়ংক্রিয় ব্যবস্থা কোড build করে test চালায়। ধাপগুলোর সারিকে বলে pipeline, প্রতিটি ধাপকে stage. ইতিহাস আর প্রকৌশলের দিক সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫৮-এ আছে; runner, cache আর DAG-এর অবকাঠামো ক্লাউড ও DevOps কোর্সের পর্ব ৫৭-এ; আর একটি full-stack app-এর পুরো workflow ফুল-স্ট্যাক ওয়েব ফ্রেমওয়ার্ক কোর্সের পর্ব ৮১-এ। এই পর্বে প্রশ্নটি আলাদা: একজন tester বা SDET pipeline-কে কীভাবে নকশা করবেন, যাতে সেটি দ্রুত, বিশ্বাসযোগ্য আর অর্থবহ সিদ্ধান্ত দেয়?
Tester-এর চোখে pipeline আসলে একটি জীবন্ত test plan. পর্ব ১৭-এর plan-এ যা কাগজে লেখা থাকে, pipeline তা কোডে লিখে প্রতিটি পরিবর্তনে চালায়; পর্ব ০৪ (SDLC আর STLC-তে testing)-এ দেখেছেন, CI-এর gate আসলে যন্ত্রে যাচাই করা exit criteria. আর পর্ব ০৫ (Test-এর স্তর আর ধরন)-এর test pyramid এখানে সময়ের রেখায় বিছিয়ে দেওয়া হয়: নিচের চওড়া স্তর (unit) আগে, ওপরের সরু স্তর (UI) পরে।
সস্তা আর দ্রুত আগে · দামি আর ধীর পরে · প্রথম লাল-এ থামা · প্রমাণ (artifact) রেখে যাওয়া
এই পর্বের সব run বাজারঘরের shared app-এর একটি কপিতে, নিজের কম্পিউটারে (§৩)। নিচের stepper-এর সংখ্যাগুলো সেই সবুজ run-এর। “পরে” চাপুন:
- পরিবর্তন
PRtrigger - lint
ruff0.06 s - unit
494.93 s - integration
10110.28 s - api
61.04 s - ui-smoke
13.40 s - gate
PASS0.06 s
pull_request → pipeline শুরু
লক্ষ্য: merge-এর আগে উত্তর
=== stage lint All checks passed!
=== stage unit 49 passed in 3.65s
=== stage integration bringing up nodes... Coverage XML written to file reports/coverage.xml 101 passed in 8.93s
bazarghar on http://127.0.0.1:8851 … === stage api 6 passed in 0.70s
=== stage ui-smoke 1 passed in 3.06s
PASS junit-unit: 49 tests, 0 failed
PASS line coverage 84.1% (baseline …)
PASS search p95 3.0 ms (budget …)
GREEN after 20.34 s
- Trigger. একজন developer বাজারঘরের কোডে পরিবর্তন করে pull request খুললেন। CI সেবা একটি পরিষ্কার পরিবেশে pipeline শুরু করে। প্রতিটি stage-এর একটাই প্রশ্ন: “এই পরিবর্তন কি কিছু ভাঙল?”
- lint, ০.০৬ সেকেন্ড। ruff কোড না চালিয়ে পড়ে: অব্যবহৃত import, অসংজ্ঞায়িত নাম, সন্দেহজনক গঠন। পর্ব ০৬-এর static analysis এখানে যন্ত্রে বসেছে। সবচেয়ে সস্তা, তাই সবার আগে।
- unit, ৪.৯৩ সেকেন্ড। Coupon, delivery আর phone-এর নিয়মের ৪৯টি test. ব্যর্থ হলে বার্তা নির্দিষ্ট function আর মান দেখায়।
- integration, ১০.২৮ সেকেন্ড। বাকি ১০১টি test: API, database, order-এর অবস্থা, review, payment. ধীর বলে pytest-xdist-এর তিনটি worker-এ ভাগ করে চলে, আর coverage মাপে।
- api, ১.০৪ সেকেন্ড। এবার app সত্যিই চালু হয় port 8851-এ, নিজের database নিয়ে: একটি ছোট test environment. ছয়টি test আসল HTTP দিয়ে কথা বলে: health, তিনটি coupon মান, order আর একবারই টাকা কাটা, আর search-এর p95.
- ui-smoke, ৩.৪০ সেকেন্ড। একটিমাত্র UI যাত্রা headless Edge-এ: login, দুটি পণ্য cart-এ, checkout-এ মোট ১০৬০ টাকা। এটি smoke test: সব UI নয়, শুধু “প্রধান পথ খোলা আছে কি না”।
- gate, ০.০৬ সেকেন্ড। কোনো test চালায় না; আগের stage-গুলোর রেখে যাওয়া প্রমাণ (JUnit XML, coverage, p95) পড়ে নিয়ম মিলিয়ে সিদ্ধান্ত দেয়। সব PASS: merge-এর অনুমতি। মোট ২০.৩৪ সেকেন্ড, যার মধ্যে app চালু হতে প্রায় ০.৬ সেকেন্ড।
Pipeline শুধু test চালানোর যন্ত্র নয়; এটি দলের চুক্তি: “এই প্রশ্নগুলোর উত্তর হ্যাঁ না হলে কোড main-এ যাবে না।”
২ · Stage-এর মানচিত্র — কোন test কোথায়, কখন
একটি পূর্ণ test pipeline-এ সাধারণত নিচের stage-গুলো থাকে। সব প্রকল্পে সবগুলো লাগে না, আর নাম দল ভেদে আলাদা; কিন্তু ক্রমের যুক্তি প্রায় সব জায়গায় এক। ডান দিকের কলাম বলে, এই কোর্সের কোন পর্বে বিষয়টি গভীরে আছে।
| Stage | কী প্রশ্ন | কখন চলে | আটকায়? | গভীরে |
|---|---|---|---|---|
| lint, format, type check | কোড কি পড়ার মতো আর স্পষ্ট ভুলমুক্ত? | প্রতি PR | হ্যাঁ | পর্ব ০৬ |
| unit | প্রতিটি নিয়ম কি ঠিক হিসাব করে? | প্রতি PR | হ্যাঁ | পর্ব ২১, ২২ |
| integration / API | অংশগুলো একসাথে, DB-সহ ঠিক চলে? | প্রতি PR | হ্যাঁ | পর্ব ২৮–৩৩ |
| contract | অন্য service-এর সাথে চুক্তি কি ভাঙল? | প্রতি PR, deploy-এর আগে | হ্যাঁ | পর্ব ৩২ |
| UI smoke | প্রধান যাত্রা কি খোলা? | প্রতি PR | হ্যাঁ | পর্ব ৩৬–৩৭ |
| পূর্ণ E2E, cross-browser | সব যাত্রা, সব browser-এ? | রাতে বা merge-এর পরে | সাধারণত না, ticket খোলে | পর্ব ৪২ |
| performance | ধীর হলো কি? | PR-এ ছোট smoke, রাতে load | smoke: হ্যাঁ | পর্ব ৪৮, ৫০, ৫১ |
| security | নতুন ঝুঁকি এল কি? | PR-এ baseline, রাতে active scan | high alert: হ্যাঁ | পর্ব ৫৩ |
| mutation, fuzz | Test কতটা শক্ত? অদ্ভুত input-এ crash? | বদলানো লাইনে PR-এ, পুরোটা রাতে | সাধারণত না | পর্ব ৫৯, ৬০ |
| deploy + post-deploy smoke | নতুন পরিবেশে কি উঠল? | merge-এর পরে | লাল হলে rollback | পর্ব ৬৫, ৬৬ |
তিনটি নীতি এই টেবিলের পেছনে। এক, খরচ আর মূল্য। প্রতিটি PR-এ যা চলে তা দ্রুত হতে হবে, কারণ developer অপেক্ষা করছেন; দামি কিন্তু কম ঘন ঘন দরকারি পরীক্ষা যায় nightly build-এ। দুই, আটকানো বনাম জানানো। যে check নির্ভরযোগ্য আর নির্দিষ্ট (unit, contract), সে merge আটকাতে পারে; যে check শব্দময় (দীর্ঘ E2E, পুরো mutation run), সে ticket খোলে বা সতর্ক করে। শব্দময় check দিয়ে merge আটকালে দল gate-কে উপেক্ষা করতে শেখে। তিন, পরিবেশ। api আর UI-এর জন্য app কোথাও চালু করতে হয়, নিজের database আর config নিয়ে (পর্ব ৬৫)।
নিচের ছবি বাজারঘরের pipeline-কে নির্ভরতার গ্রাফ হিসেবে দেখায়: কোন stage কার শেষ হওয়ার অপেক্ষা করে, আর কোনগুলো পাশাপাশি চলতে পারে। এমন গ্রাফকে বলে DAG.
বাজারঘরের test pipeline — নির্ভরতা, সময় আর artifact
Stages as a DAG with measured seconds; thick orange arrows = critical path
৩ · সত্যিকারের run — নিজের কম্পিউটারে বাজারঘরের pipeline
এবার আসল কাজ। এই কম্পিউটারে কোনো CI সেবা নেই, Docker নেই, আর কোথাও কিছু push করা হয়নি। তাই একই stage-গুলো চালিয়েছে একটি ছোট Python script, ci_local.py: প্রতিটি stage একটি আলাদা process, সময় মাপা হয়, exit code দেখা হয়, প্রথম লাল stage-এর পরে বাকিগুলো বাদ, আর শেষে artifact-এর তালিকা। CI সেবা মূলত এটাই করে, শুধু job-গুলো আলাদা যন্ত্রে। এমন local runner দিয়ে developer push-এর আগেই pipeline চালিয়ে দেখতে পারেন; nox (Apache 2.0) বা tox (MIT)-এর মতো তৈরি tool-ও একই কাজ করে।
পরিবেশ: Python 3.12.13, uv 0.11.28 (MIT বা Apache 2.0), pytest 9.2.0 (MIT), pytest-xdist 3.8.0 (MIT), pytest-cov 7.1.0 (MIT) আর coverage 7.17.3 (Apache 2.0), ruff 0.17.5 (MIT), httpx 0.28.1 (BSD 3-Clause), Playwright for Python 1.65.2 (Apache 2.0) আর কম্পিউটারে আগে থেকে থাকা Microsoft Edge. সব run-এ DO_NOT_TRACK=1 রাখা ছিল; এই tool-গুলোর কোনোটি usage তথ্য পাঠায় বলে জানা নেই, তবু অভ্যাসটি ভালো। Path নিরপেক্ষ করা।
"""Run the CI stages locally, in order, fail-fast. uv run python ci_local.py"""
import json, os, subprocess, sys, time, urllib.request
from pathlib import Path
PY, PORT = sys.executable, os.environ.get("CI_PORT", "8851")
os.environ["BASE_URL"] = f"http://127.0.0.1:{PORT}"
R = Path("reports"); R.mkdir(exist_ok=True)
Path(".coverage").unlink(missing_ok=True) # fresh coverage data per run
PT = [PY, "-m", "pytest", "-q", "-p", "no:cacheprovider"]
UNIT = ["tests/test_pricing.py", "tests/test_phone.py"]
COV = ["--cov=bazarghar", "--cov-append"]
STAGES = {
"lint": [PY, "-m", "ruff", "check", "src", "tests", "scripts"],
"unit": PT + UNIT + COV + ["--cov-report=", f"--junitxml={R}/junit-unit.xml"],
"integration": PT + ["tests", *[f"--deselect={u}" for u in UNIT], "-n", "3", *COV,
f"--cov-report=xml:{R}/coverage.xml", f"--junitxml={R}/junit-integration.xml"],
"api": PT + ["ci_tests/test_api_smoke.py", f"--junitxml={R}/junit-api.xml"],
"ui-smoke": PT + ["ci_tests/test_ui_smoke.py", f"--junitxml={R}/junit-ui.xml"],
"gate": [PY, "gate.py"],
}
NEEDS_APP = {"api", "ui-smoke"}
def start_app():
p = subprocess.Popen([PY, "-m", "bazarghar.cli", "--port", PORT, "--test-mode", "--reset",
"--db", str(R / "ci.db"), "--log-level", "warning"])
for _ in range(50): # bounded wait, no endless loop
try: urllib.request.urlopen(os.environ["BASE_URL"] + "/api/health", timeout=1); return p
except OSError: time.sleep(0.2)
p.terminate(); sys.exit("app did not start")
order = sys.argv[1].split(",") if len(sys.argv) > 1 else list(STAGES)
app, results, t0 = None, [], time.perf_counter()
for name in order:
if results and results[-1][1] != 0:
results.append((name, None, 0.0)); continue # fail fast: skip the rest
if name in NEEDS_APP and app is None: app = start_app()
print(f"\n=== stage {name}", flush=True)
s = time.perf_counter(); code = subprocess.run(STAGES[name]).returncode
results.append((name, code, time.perf_counter() - s))
if app: app.terminate(); app.wait() # stop our own server by PID
# … then: print the summary table, write reports/pipeline.json, list artifacts, exit 1 if redকয়েকটি নকশার সিদ্ধান্ত লক্ষ করুন। প্রতিটি stage নিজের JUnit XML লেখে (পর্ব ২৬, বিভিন্ন ভাষায় unit test-এ এর গঠন দেখেছেন), কারণ gate আর মানুষ দুজনেই পরে সেটি পড়বে। App চালু হয় শুধু যখন কোনো stage-এর দরকার, নিজের ci.db নিয়ে, আর শেষে নিজের PID ধরে বন্ধ হয়। অপেক্ষা সীমিত (৫০টি health check), যাতে আটকে থাকা app pipeline ঝুলিয়ে না রাখে। সব stage এক ফাইলে, কোডের পাশে: pipeline as code-এর ছোট রূপ।
api stage-এর ছয়টি test আসল HTTP পাঠায় (পর্ব ৩১, Code দিয়ে API testing-এর ধাঁচে): health; coupon-এর তিনটি মান (১০০০ → ০, ১০০১ → ১০০, ৩০১০ → ৩০০); একটি পুরো order যার Idempotency-Key দিয়ে দুবার pay করলেও wallet-এ একটিই charge; আর search-এর ৩০টি request থেকে p95, সীমা ৫০০ ms, যা reports/perf.json-এ লেখা হয়। ui-smoke একটি Playwright test (পর্ব ৩৭, Playwright গভীরে): ব্যর্থ হলে screenshot আর trace ফাইল রেখে যায়।
প্রথম run — পরিষ্কার কোড, তবু লাল
প্রথম সংস্করণের gate-এ একটি নিয়ম ছিল যা অনেক দলেই দেখা যায়: “line coverage অন্তত ৯০%”. কোডে কোনো seeded bug চালু নেই। সত্যিকারের ফল:
$ uv run python ci_local.py
…
=== stage gate
PASS junit-api: 6 tests, 0 failed
PASS junit-integration: 101 tests, 0 failed
PASS junit-ui: 1 tests, 0 failed
PASS junit-unit: 49 tests, 0 failed
FAIL line coverage 84.1% (floor 90%)
PASS search p95 3.6 ms (budget 500 ms)
--- pipeline summary
lint exit 0 0.06 s
unit exit 0 5.88 s
integration exit 0 9.50 s
api exit 0 1.00 s
ui-smoke exit 0 3.31 s
gate exit 1 0.05 s
RED at gate after 20.35 s
artifacts: coverage.xml junit-api.xml junit-integration.xml junit-ui.xml junit-unit.xml perf.json pipeline.json
১৫৭টি test সবুজ, app ঠিক, অথচ pipeline লাল। ৯০ কোথাও থেকে আনা একটি গোল সংখ্যা, এই কোড দেখে ঠিক করা নয়। এমন gate দুটি খারাপ পথ খোলে: হয় gate বন্ধ করে দেওয়া, নয়তো দ্রুত coverage বাড়াতে assertion-হীন test লেখা (পর্ব ৫৯, Mutation testing-এ দেখেছেন, coverage ১০০% হয়েও test অন্ধ থাকতে পারে)। এটি Goodhart's law-এর CI রূপ: মাপকে লক্ষ্য বানালে মাপ বিকৃত হয়।
দ্বিতীয় run — ratchet, আর দশমিকের একটি ফাঁদ
যুক্তিসঙ্গত বিকল্প হলো coverage ratchet: স্থির লক্ষ্যের বদলে শেষ সবুজ build-এর মান কোডের পাশে একটি ফাইলে (coverage-baseline.json, মান ৮৪.১) রাখা, আর নিয়ম “coverage কমতে পারবে না”। নতুন কোডের সাথে test না এলে মান কমে আর gate লাল হয়; test যোগ হলে baseline-ও ওঠে। কিন্তু প্রথম চেষ্টায় পরিষ্কার কোডে আবার লাল এল, এবার এই বার্তায়:
FAIL line coverage 84.1% (baseline 84.1%, may not drop)
৮৪.১ কি ৮৪.১-এর চেয়ে কম? আসল মান ছিল ৯৪৯ ÷ ১১২৯ লাইন = ৮৪.০৬%, ছাপার সময় গোল হয়ে ৮৪.১, কিন্তু তুলনা হচ্ছিল গোল না করা ৮৪.০৬-এর সাথে। দুই পাশ একই নিয়মে (এক দশমিকে) গোল করার পর:
=== stage gate
PASS junit-api: 6 tests, 0 failed
PASS junit-integration: 101 tests, 0 failed
PASS junit-ui: 1 tests, 0 failed
PASS junit-unit: 49 tests, 0 failed
PASS line coverage 84.1% (baseline 84.1%, may not drop)
PASS search p95 3.0 ms (budget 500 ms)
--- pipeline summary
lint exit 0 0.06 s
unit exit 0 4.93 s
integration exit 0 10.28 s
api exit 0 1.04 s
ui-smoke exit 0 3.40 s
gate exit 0 0.06 s
GREEN after 20.34 s
Gate-ও কোড, তারও bug হয়। দশমিকের এই ভুল কোনো test-এ ধরা পড়েনি; ধরা পড়ল কারণ প্রথম দিনেই পরিষ্কার কোডে gate চালানো হয়েছিল। নতুন gate চালু করার আগে জানা সবুজ build আর জানা লাল build দুটোতেই চালিয়ে দেখুন, ঠিক যেমন একটি test-কে প্রথমে লাল হতে দেখতে হয়। §৬-এর ব্রাউজার-ভিত্তিক gate-এ এই ফাঁদ আবার দেখবেন।
৪ · Fail fast আর stage-এর ক্রম — কার আগে কে
এবার একটি bug. বাজারঘরের coupon_ge switch চালু করলে ঠিক ১০০০ টাকার অর্ডারেও ১০০ টাকা ছাড় হয় (নিয়ম বলে “১০০০-এর বেশি”)। একই pipeline, একই ক্রম:
$ BAZARGHAR_BUGS=coupon_ge uv run python ci_local.py
=== stage lint
All checks passed!
=== stage unit
...F...................F......................... [100%]
E AssertionError: assert 100 == 0
E + where 100 = <function coupon_discount at 0x…>(1000, frozenset({'coupon_ge'}))
…
FAILED tests/test_pricing.py::test_coupon_rule[coupon-1000] - AssertionError:...
FAILED tests/test_pricing.py::test_quote_endpoint[1000-Dhaka-False-expected0]
2 failed, 47 passed in 4.38s
--- pipeline summary
lint exit 0 0.06 s
unit exit 1 5.67 s
integration skipped 0.00 s
api skipped 0.00 s
ui-smoke skipped 0.00 s
gate skipped 0.00 s
RED at unit after 5.74 s
artifacts: junit-unit.xml pipeline.json
৫.৭৪ সেকেন্ডে লাল, আর বার্তা প্রায় নিজেই bug report: coupon_discount(1000) দিল ১০০, expected ০. বাকি চারটি stage চলেইনি: ভাঙা কোডে আরও ১৫ সেকেন্ড খরচ করে নতুন কিছু জানা যেত না। এটাই fail fast, আর এর ভাষা exit code: যেকোনো tool শূন্য ছাড়া কিছু দিলে pipeline থামে।
এবার একটি পরীক্ষা: একই bug, কিন্তু ক্রম উল্টে UI আগে (ui-smoke,api,integration,unit,lint,gate). অনেক দলে “ব্যবহারকারী যা দেখেন সেটাই আগে দেখি” যুক্তিতে এমন হয়:
$ BAZARGHAR_BUGS=coupon_ge uv run python ci_local.py ui-smoke,api,integration,unit,lint,gate
=== stage ui-smoke
F [100%]
> expect(page.get_by_test_id("quote-discount")).to_have_text("0")
E AssertionError: Locator expected to have text '0'
E Actual value: 100
E Call log:
E - Expect "to_have_text" get_by_test_id("quote-discount") with timeout 5000ms
E 14 × locator resolved to <dd data-testid="quote-discount">100</dd>
E - unexpected value "100"
…
1 failed in 8.08s
--- pipeline summary
ui-smoke exit 1 8.41 s
api skipped 0.00 s
…
RED at ui-smoke after 8.98 s
artifacts: junit-ui.xml pipeline.json ui-smoke-failure.png ui-smoke-trace.zip
UI test-ও bug ধরল, কিন্তু তিনটি দাম দিয়ে। সময়: সবুজ অবস্থায় যে stage ৩.৪০ সেকেন্ডের, লাল অবস্থায় তা ৮.৪১, কারণ Playwright-এর expect ঠিক মানের জন্য পুরো ৫ সেকেন্ডের সময়সীমা পর্যন্ত বারবার দেখে (১৪ বার), তারপর হাল ছাড়ে। পর্ব ৩৬-এর auto-wait সবুজ পথে বন্ধু, লাল পথে খরচ। বার্তা: “checkout পাতায় ছাড় ১০০ দেখাচ্ছে” জানা গেল, কিন্তু কোন হিসাব, কোন subtotal-এ, তা খুঁজতে আরও কাজ লাগবে; unit test সরাসরি function আর input দেখিয়েছিল। প্রমাণ: লাভও আছে, screenshot আর trace ফাইল (প্রায় ৩২০ KB) এখন artifact-এ, যা খুলে পুরো যাত্রা আবার দেখা যায়।
ক্রমের হিসাব — খরচ ভাগ সম্ভাবনা
একটি নির্দিষ্ট bug-এ কোন ক্রম দ্রুত, তা দেখা সহজ। কিন্তু pipeline প্রতিদিন শত শত পরিবর্তনে চলে, আর আগে থেকে জানা থাকে না কোথায় ভাঙবে। তাই প্রশ্নটি হলো: গড়ে developer কত সেকেন্ডে উত্তর পান? এই time to feedback নির্ভর করে প্রতিটি stage-এর সময় আর সেটি লাল হওয়ার সম্ভাবনার ওপর। নিচের প্রোগ্রাম মাপা সময় নেয় (সবুজ আর লাল অবস্থার আলাদা), সম্ভাবনাগুলো অনুমান (আপনার দলের ইতিহাস থেকে আসা উচিত), তারপর পাঁচটি stage-এর সব ১২০টি ক্রম যাচাই করে:
from itertools import permutations
# (seconds when green, seconds when red) measured locally; p = ASSUMED chance of red
STAGE = {"lint": (0.06, 0.06, 0.10), "unit": (4.93, 5.67, 0.20),
"integration": (10.28, 10.28, 0.15), "api": (1.04, 1.04, 0.05),
"ui-smoke": (3.40, 8.41, 0.05)} # a red UI test waits for its timeout
def expected_feedback(order):
"""Average seconds until the developer hears the answer (red or green)."""
t, alive, total = 0.0, 1.0, 0.0 # alive = chance that all earlier stages passed
for s in order:
green, red, p = STAGE[s]
total += alive * p * (t + red) # the run stops here, red
t += green
alive *= 1 - p
return total + alive * t # all green: the full time
def first_red(order, catches): # one known bug: when does the run turn red?
t = 0.0
for s in order:
if s in catches: return f"red at {s} after {t + STAGE[s][1]:.2f} s"
t += STAGE[s][0]
return "green"
as_written = ["lint", "unit", "integration", "api", "ui-smoke"]
ui_first = ["ui-smoke", "api", "integration", "unit", "lint"]
ratio = sorted(STAGE, key=lambda s: STAGE[s][0] / STAGE[s][2]) # cost / chance
best = min(permutations(STAGE), key=expected_feedback)
for name, order in [("as written", as_written), ("ui first", ui_first),
("cost/chance", ratio), ("best of 120", list(best))]:
print(f"{name:11} {expected_feedback(order):5.2f} s {' > '.join(order)}")
catches = {"unit", "api", "ui-smoke"} # stages whose tests fail with coupon_ge
print("coupon_ge, as written:", first_red(as_written, catches))
print("coupon_ge, ui first: ", first_red(ui_first, catches))আসল আউটপুট (ব্রাউজারের Python):
as written 14.79 s lint > unit > integration > api > ui-smoke
ui first 17.85 s ui-smoke > api > integration > unit > lint
cost/chance 14.51 s lint > api > unit > ui-smoke > integration
best of 120 14.49 s lint > api > unit > integration > ui-smoke
coupon_ge, as written: red at unit after 5.73 s
coupon_ge, ui first: red at ui-smoke after 8.41 s
শেষ দুই লাইন সত্যিকারের run-এর সাথে মেলে: ৫.৭৩ বনাম মাপা ৫.৭৪, আর ৮.৪১ বনাম মাপা ৮.৯৮; পার্থক্যের প্রায় ০.৬ সেকেন্ড হলো app চালু হওয়া, যা এই মডেলে নেই। coupon_ge integration stage-এ ধরা পড়ে না, কারণ app-এর নিজের দুটি ব্যর্থ test-ই unit-এর ফাইলে; তাই catches-এ integration নেই।
গড় হিসাবে UI-আগের ক্রম সবচেয়ে খারাপ, ১৭.৮৫ সেকেন্ড। সহজ নিয়ম “সময় ÷ লাল হওয়ার সম্ভাবনা, ছোট থেকে বড়” দেয় ১৪.৫১, আর ১২০টি ক্রমের সেরাটি ১৪.৪৯; ছোট পার্থক্যটি আসে কারণ নিয়মটি লাল অবস্থার বাড়তি সময় (UI-এর timeout) দেখে না।
আসল শিক্ষা সংখ্যায় নয়: সস্তা আর প্রায়ই-লাল stage আগে; ধীর, দামি আর লাল হলে আরও ধীর stage পরে। সম্ভাবনাগুলো বদলে দেখুন, যেমন ui-smoke-এর 0.05-কে 0.4 করুন: তখন সেটি সামনে উঠে আসবে কি না?
| ক্রম | |
| লাল হলো | |
| বার্তা | |
| গড় সময় |
- লিখিত ক্রম। lint ০.০৬ সেকেন্ডে সবুজ, তারপর unit ৫.৬৭ সেকেন্ডে লাল। মোট ৫.৭৪ সেকেন্ডে উত্তর, আর বার্তা সরাসরি function আর input দেখায়:
coupon_discount(1000)দিল ১০০, expected ০. - UI আগে। একই bug, কিন্তু প্রথমে app চালু, browser খোলা, login, cart, checkout. লাল হলো ৮.৯৮ সেকেন্ডে, প্রায় ৫৬% বেশি সময়ে।
- কেন ধীর। লাল UI test সঙ্গে সঙ্গে থামে না:
to_have_text("0")৫ সেকেন্ডের সময়সীমা পর্যন্ত ১৪ বার locator মিলিয়ে দেখে। সবুজ পথে এই অপেক্ষা flaky হওয়া আটকায়, লাল পথে feedback-এ সময় যোগ করে। বার্তাও কম নির্দিষ্ট। - গড়ের প্রশ্ন। আগে থেকে bug-এর জায়গা জানা থাকে না, তাই প্রতিটি stage লাল হওয়ার সম্ভাবনা ধরে গড় করতে হয়। অনুমিত সম্ভাবনায় লিখিত ক্রম গড়ে ১৪.৭৯ সেকেন্ড, UI-আগে ১৭.৮৫.
- সেরা ক্রম আর নিয়ম। “সময় ÷ সম্ভাবনা ছোট থেকে বড়” নিয়মে ১৪.৫১, সব ক্রমের সেরা ১৪.৪৯: lint, api, unit, integration, ui-smoke. বাস্তবে api-এর জন্য চলন্ত app লাগে, তাই ক্রমের সাথে parallel-এর যুক্তিও মেলাতে হয় (§৫)।
৫ · Parallel, critical path, matrix আর cache
ক্রম সাজানো একটি হাতিয়ার; দ্বিতীয়টি হলো একসাথে চালানো। দুটি স্তরে parallel হয়: এক stage-এর ভেতরে test-গুলো কয়েকটি process-এ ভাগ করা (pytest-xdist-এর -n), আর একাধিক stage বা job আলাদা runner-এ পাশাপাশি চালানো।
এক stage-এর ভেতরে: ১৫০টি test, ১, ২ আর ৩ worker
App-এর পুরো ১৫০টি test, প্রতিটি সংখ্যার worker-এ তিনবার করে, মাপা সময় (process শুরু থেকে শেষ, সেকেন্ডে):
serial [17.87, 16.5, 13.56] median 16.5
-n 2 [14.31, 9.28, 9.36] median 9.36
-n 3 [9.46, 7.87, 8.04] median 8.04
তিন worker-এ মধ্যমা ১৬.৫ থেকে ৮.০৪ সেকেন্ড, প্রায় ২.০৫ গুণ দ্রুত, তিন গুণ নয়। কারণ প্রতিটি worker-কে নিজে Python চালু করে test খুঁজে নিতে হয়, আর সব test সমান লম্বা নয়। Run থেকে run-এ ৪ সেকেন্ডের বেশি পার্থক্যও লক্ষ করুন (একই সময়ে কম্পিউটারে অন্য কাজ চলছিল); CI runner-ও প্রায়ই ভাগ করা যন্ত্র, তাই একটি মাপ নয়, কয়েকটির মধ্যমা দেখুন (পর্ব ৫০)। xdist নিরাপদে চলে কারণ প্রতিটি test নিজের database ফাইল পায় (tmp_path); test-গুলো একটি shared অবস্থা বদলালে parallel তাদের ভেঙে দেয় (পর্ব ৩৭)।
Stage-এর মধ্যে: DAG আর critical path
কোন stage কার পরে চলবে, তা “needs” দিয়ে লেখা হয়। নিচের প্রোগ্রাম মাপা সময়গুলো দিয়ে হিসাব করে: সব পরপর চালালে কত, ১, ২ বা ৩টি runner-এ কত, আর critical path কোনটি। শেষ লাইনে integration-কে দুই ভাগে ভাগ করলে কী হয়, তা-ও দেখে:
# Stage durations (seconds) from the local GREEN run; "needs" = must finish first
STAGES = { # name: (seconds, needs)
"lint": (0.06, []),
"unit": (4.93, ["lint"]),
"integration": (10.28, ["unit"]),
"deploy-test": (0.60, ["unit"]),
"api": (1.04, ["deploy-test"]),
"ui-smoke": (3.40, ["deploy-test"]),
"gate": (0.06, ["integration", "api", "ui-smoke"]),
}
def schedule(stages, runners): # start a ready stage when a runner is free
finish, free = {}, [0.0] * runners
while len(finish) < len(stages):
ready = [s for s, (d, needs) in stages.items()
if s not in finish and all(n in finish for n in needs)]
for s in sorted(ready, key=lambda s: -stages[s][0]): # longest first
i = free.index(min(free))
start = max([free[i]] + [finish[n] for n in stages[s][1]])
free[i] = finish[s] = start + stages[s][0]
return max(finish.values())
def critical_path(stages): # longest chain of "needs"
best = {}
for s, (d, needs) in stages.items(): # already in dependency order
prev = max(needs, key=lambda n: best[n][0], default=None)
best[s] = (d + (best[prev][0] if prev else 0), (best[prev][1] if prev else []) + [s])
return best["gate"]
print(f"serial sum: {sum(d for d, _ in STAGES.values()):.2f} s")
for r in (1, 2, 3):
print(f"{r} runner(s): {schedule(STAGES, r):.2f} s")
length, path = critical_path(STAGES)
print(f"critical path {length:.2f} s:", " -> ".join(path))
SPLIT = {**STAGES, "integration": (10.28 / 2, ["unit"]), "integration-2": (10.28 / 2, ["unit"]),
"gate": (0.06, ["integration", "integration-2", "api", "ui-smoke"])}
print(f"integration in 2 shards, 3 runners: {schedule(SPLIT, 3):.2f} s")আসল আউটপুট:
serial sum: 20.37 s
1 runner(s): 20.37 s
2 runner(s): 15.33 s
3 runner(s): 15.33 s
critical path 15.33 s: lint -> unit -> integration -> gate
integration in 2 shards, 3 runners: 10.19 s
পরপর চালালে ২০.৩৭ সেকেন্ড, যা সত্যিকারের সবুজ run-এর ২০.৩৪-এর খুব কাছে। দ্বিতীয় runner যোগ করলে ১৫.৩৩: ডানের শাখা (deploy, api, ui-smoke, মোট ৫.০৪) integration চলার সময়েই শেষ হয়। কিন্তু তৃতীয় runner কিছুই দেয় না, কারণ সময় এখন critical path দিয়ে বাঁধা: lint, unit, integration, gate. এই পথ ছোট না করলে আরও runner অর্থহীন।
পথ ছোট করার উপায় হলো লম্বা stage ভাঙা: integration-কে দুটি সমান shard-এ ভাগ করলে তিন runner-এ ১০.১৯ সেকেন্ড। এটি আদর্শ হিসাব: বাস্তবে প্রতিটি shard-এর নিজের শুরুর খরচ আছে, আর test-গুলো কখনো একদম সমান ভাগ হয় না। Test-এর সময়ের ইতিহাস ধরে ভারসাম্যপূর্ণ shard বানানো পর্ব ৬৮-এর বিষয়।
Matrix — একই test, কয়েকটি পরিবেশ
বাজারঘর লেখা Python 3.12-এর জন্য, কিন্তু server-এ কাল 3.13 বা 3.14 আসতে পারে। Matrix build একই job-কে কয়েকটি পরিবেশে চালায়। এই কম্পিউটারে তিনটি Python আগে থেকে ছিল; unit stage প্রতিটিতে সত্যিকারভাবে চালানো:
== python 3.12.13
49 passed in 3.38s
== python 3.13.5
49 passed in 3.81s
== python 3.14.4
49 passed in 3.14s
তিনটিতেই সবুজ। Matrix-এর খরচ গুণে বাড়ে: ৩টি Python × ৩টি OS = ৯টি job, browser-এর matrix (পর্ব ৪২) যোগ হলে আরও। তাই PR-এ ছোট matrix, রাতে পূর্ণটি; সমন্বয় কমাতে পর্ব ১১ (Pairwise testing)-এর যুক্তিও খাটে।
Dependency cache — প্রতিবার সব নামানো নয়
প্রতিটি CI job একটি খালি যন্ত্রে শুরু হয়, তাই প্রতিবার সব package নামাতে হয়, যদি না আগের run-এর নামানো package রেখে দেওয়া হয়: dependency cache. এই প্রকল্পের uv.lock-এর ৩৪টি package (প্রকল্পসহ) দিয়ে একটি নতুন পরিবেশ বানানো, একবার cache ছাড়া আর একবার cache থেকে (একই lockfile থেকে):
no cache 57.56 s exit 0
warm cache 0.39 s exit 0
পার্থক্য বিশাল, তবে CI-তে cache নিজেও নামাতে হয়, তাই লাভ এর চেয়ে কম। আর cache key হওয়া উচিত lockfile-এর hash: lockfile বদলালে নতুন cache, নয়তো পুরোনো package দিয়ে test চলে আর সবুজ ফল মিথ্যা হয়। “আমার কম্পিউটারে চলে, CI-তে চলে না”-র একটি প্রচলিত কারণ পুরোনো cache; cache poisoning-এর ঝুঁকি ক্লাউড ও DevOps কোর্সের পর্ব ৫৭-এ।
৬ · Artifact আর quality gate — প্রমাণ রাখা, নিয়মে সিদ্ধান্ত
Pipeline লাল হলে প্রথম প্রশ্ন: কেন? CI-এর যন্ত্র job শেষে মুছে যায়; যে ফাইল রেখে যাওয়া হয়, তাকে বলে artifact. বাজারঘরের run যা রেখে গেছে:
| Artifact | কে লেখে | কে পড়ে | কখন রাখা |
|---|---|---|---|
junit-*.xml | প্রতিটি test stage | gate, CI-এর রিপোর্ট পাতা, পর্ব ৬৭-এর trend | সবসময় |
coverage.xml | integration (pytest-cov) | gate-এর ratchet, review | সবসময় |
perf.json | api stage | gate-এর p95 নিয়ম | সবসময় |
ui-smoke-trace.zip, .png | ui-smoke fixture | মানুষ, Playwright trace viewer-এ | শুধু লাল হলে |
pipeline.json | runner script | pipeline-এর গতির মাপ | সবসময় |
সবচেয়ে প্রচলিত ভুল: artifact upload-এর ধাপ শুধু সফল run-এ চলে। Test লাল হলে pipeline সেখানেই থামে, আর রিপোর্ট আপলোড হয় না, ঠিক যখন সবচেয়ে দরকার (পর্ব ৩০-এ Newman-এর প্রসঙ্গে if: always() দেখেছেন)। উল্টো দিকে, trace আর video বড় ফাইল; সব সবুজ run-এ রাখলে জায়গা আর সময় যায়, তাই সেগুলো শুধু ব্যর্থতায়, সীমিত দিনের জন্য।
Gate-এর নকশা — আটকানো, সতর্ক করা, না জানানো
Quality gate হলো artifact পড়ে নিয়ম অনুযায়ী এগোনো বা থামার সিদ্ধান্ত। প্রতিটি নিয়মের জন্য তিনটি প্রশ্ন: মাপটি কি নির্ভরযোগ্য? সত্যিই ঝুঁকির সাথে যুক্ত? ভাঙলে merge বন্ধ, না শুধু সতর্কবার্তা? আগের পর্বগুলোর gate একসাথে:
- Test-এর ফল: কোনো ব্যর্থ test নয়, আর test-এর সংখ্যা শূন্য নয় (ভুল path দিলে pytest কোনো test না পেয়েও শেষ হতে পারে; সংখ্যা যাচাই সেই ফাঁক বন্ধ করে)। আটকায়।
- Coverage: স্থির লক্ষ্যের বদলে ratchet, আর বদলানো লাইনের coverage দেখা (পর্ব ১৩-এর
--fail-under-এর বিকল্প)। Coverage শুধু বলে কোন লাইন চলেছে, assertion আছে কি না বলে না। - Mutation: mutation score PR-এ শুধু বদলানো লাইনে আর মন্তব্য হিসেবে, পুরো run রাতে; সাধারণত আটকায় না, প্রবণতা দেখা হয় (পর্ব ৫৯)।
- Performance: PR-এ ছোট smoke (এখানে search-এর p95 < ৫০০ ms), রাতে পূর্ণ load test; k6-এর threshold ভাঙলে exit code 99 (পর্ব ৪৮), SLO থেকে gate আর noise (পর্ব ৫০), Lighthouse-এর gate (পর্ব ৫১)।
- Security: Security gate: PR-এ ZAP baseline, high alert-এ আটকানো, medium নতুন এলে সতর্ক; রাতে active scan (পর্ব ৫৩)। Contract-এর gate (পর্ব ৩২) deploy-এর আগে।
Performance gate সত্যিই কাজ করে কি না, দেখতে slow_search bug চালু করে শুধু api stage চালানো হলো (এই bug search-কে প্রতি request-এ ১৫০০ ms ধীর করে):
$ BAZARGHAR_BUGS=slow_search uv run python ci_local.py api
=== stage api
.....F [100%]
E AssertionError: p95 1505 ms over the 500 ms budget
…
1 failed, 5 passed in 45.86s
--- pipeline summary
api exit 1 46.21 s
RED at api after 47.49 s
Gate ধরল, কিন্তু ৪৬ সেকেন্ডে: ৩০টি ধীর request-এর প্রতিটি ১.৫ সেকেন্ড। ধীরতার test নিজেই ধীর, তাই এমন check-এ request-এর সংখ্যা আর সময়সীমা হিসাব করে রাখতে হয়। এবার একই gate-কে নিয়মের তালিকা হিসেবে লিখে পাঁচটি build-এ চালান। প্রথম তিনটির মান এই পর্বের সত্যিকারের run থেকে; শেষ দুটি আর ZAP ও mutation-এর ঘর নমুনা মান:
# A quality gate as data: (check, rule, blocking?)
RULES = [
("failed tests", lambda b: b["failed"] == 0, True),
("coverage ratchet", lambda b: round(b["cov"], 1) >= b["cov_base"], True),
("search p95 ms", lambda b: b["p95"] < 500, True),
("ZAP high alerts", lambda b: b["zap_high"] == 0, True),
("ZAP medium", lambda b: b["zap_medium"] <= b["zap_medium_base"], False),
("mutation score", lambda b: b["mutation"] >= b["mutation_base"] - 2, False),
]
def gate(build):
fails = [(name, block) for name, rule, block in RULES if not rule(build)]
verdict = "BLOCK" if any(b for _, b in fails) else "WARN" if fails else "PASS"
return verdict, [("must " if b else "warn ") + n for n, b in fails]
BASE = {"cov_base": 84.1, "zap_medium_base": 2, "mutation_base": 85.1}
BUILDS = {
"clean": dict(failed=0, cov=84.06, p95=3.0, zap_high=0, zap_medium=2, mutation=85.1),
"coupon_ge": dict(failed=2, cov=84.06, p95=3.0, zap_high=0, zap_medium=2, mutation=85.1),
"slow_search": dict(failed=0, cov=84.06, p95=1505.4, zap_high=0, zap_medium=2, mutation=85.1),
"less tests": dict(failed=0, cov=82.30, p95=3.1, zap_high=0, zap_medium=2, mutation=80.0),
"new CSP alert": dict(failed=0, cov=84.20, p95=2.9, zap_high=0, zap_medium=3, mutation=86.0),
}
for name, b in BUILDS.items():
verdict, why = gate({**BASE, **b})
print(f"{name:13} {verdict:5} {', '.join(why)}")
raw = 84.06 >= 84.1
print("trap: comparing the raw 84.06 with 84.1 ->", "pass" if raw else "BLOCK (rounding only)")আসল আউটপুট:
clean PASS
coupon_ge BLOCK must failed tests
slow_search BLOCK must search p95 ms
less tests BLOCK must coverage ratchet, warn mutation score
new CSP alert WARN warn ZAP medium
trap: comparing the raw 84.06 with 84.1 -> BLOCK (rounding only)
নিয়মগুলো একটি তালিকায়, প্রতিটির পাশে লেখা সেটি আটকায় কি না; দলের আলোচনা হয় তালিকা নিয়ে, আর gate review করা যায়। “less tests” build-এ একসাথে দুটি সংকেত: coverage কমেছে (আটকায়) আর mutation score নেমেছে (শুধু সতর্ক); দুটো মিলে বলে নতুন কোডের সাথে test আসেনি। “new CSP alert” merge আটকায় না, কিন্তু চোখে পড়ে। আর শেষ লাইন §৩-এর ফাঁদ: গোল না করা ৮৪.০৬ সরাসরি ৮৪.১-এর সাথে তুললে পরিষ্কার build আটকে যায়।
লাল pipeline থেকে মেরামত পর্যন্ত tester-এর কাজের ধারা এবার ধাপে ধাপে। সব আউটপুট সত্যিকারের run-এর:
lint exit 0 0.06 s unit exit 1 5.67 s integration skipped 0.00 s … RED at unit after 5.74 s
FAILED test_coupon_rule[coupon-1000] FAILED test_quote_endpoint[1000-Dhaka-False-expected0] 2 failed, 47 passed
assert 100 == 0
where 100 = coupon_discount(1000, …)
{'discount': 100} != {'discount': 0}
{'total': 960} != {'total': 1060}
$ BAZARGHAR_BUGS=coupon_ge pytest tests/test_pricing.py \
-k "coupon-1000 or 1000-Dhaka" --tb=line
FF
2 failed, 30 deselected in 0.13s
2 passed, 30 deselected in 0.11s
…
gate exit 0 0.06 s
GREEN after 20.34 s
- কোথায় থামল। সারাংশ বলে unit stage-এ
exit 1, বাকি সব skipped. তাই integration, api বা UI-এর ফল নিয়ে কিছু বলা যাবে না; সেগুলো চলেইনি, “পাস” ধরে নেওয়া ভুল। - কোন test. JUnit XML বা log থেকে দুটি নাম: coupon-এর নিয়ম ১০০০-এ, আর quote endpoint ১০০০ টাকা ঢাকায়। দুটিই একই সীমার মান, পর্ব ০৮-এর BVA-এর on point. একই কারণের দুই প্রকাশ, দুটি আলাদা bug নয়।
- কী ভুল। ১০০০ টাকায় ছাড় ১০০, expected ০; মোট ৯৬০, expected ১০৬০. নিয়ম বলে “১০০০-এর বেশি হলে”, তাই কোডে
>-এর জায়গায়>=সন্দেহ। Expected মান এসেছে requirement থেকে, কোড থেকে নয়। - পুনরুৎপাদন। পুরো pipeline আবার না চালিয়ে শুধু ব্যর্থ দুটি test নিজের কম্পিউটারে,
-kদিয়ে বেছে (পর্ব ২১): ০.১৩ সেকেন্ডে একই দুটি লাল। CI-এর লাল এখন হাতের মুঠোয়; এখান থেকে defect report বা মেরামত। - মেরামত আর যাচাই। শর্ত ঠিক করার পরে একই দুটি সবুজ (০.১১ সেকেন্ড), তারপর পুরো pipeline: সবুজ, ২০.৩৪ সেকেন্ডে, gate-এর সব নিয়ম PASS. এখানে মেরামত মানে bug switch বন্ধ করা; বাস্তবে কোডের লাইন বদল।
৭ · Pipeline as code — workflow, actionlint, required check আর secret
বাস্তবে এই stage-গুলো একটি CI সেবার ফাইলে লেখা হয়। নিচে বাজারঘরের জন্য একটি GitHub Actions workflow, YAML-এ। এটি উদাহরণ — GitHub-এ চালানো হয়নি। ফাইলটি শুধু static check করা হয়েছে (নিচে)। Action-গুলোর version নম্বর লেখার সময়ের সর্বশেষ প্রধান সংস্করণ; ব্যবহারের আগে মিলিয়ে নিন।
name: bazarghar-ci
on:
pull_request:
push:
branches: [main]
permissions:
contents: read
concurrency:
group: ci-${{ github.ref }}
cancel-in-progress: true
env:
DO_NOT_TRACK: "1"
jobs:
lint:
runs-on: ubuntu-latest
timeout-minutes: 5
steps:
- uses: actions/checkout@v7
- uses: astral-sh/setup-uv@v10
with:
enable-cache: true
- run: uv run ruff check src tests scripts
unit:
needs: lint
runs-on: ubuntu-latest
timeout-minutes: 10
strategy:
fail-fast: false
matrix:
python: ["3.12", "3.13", "3.14"]
steps:
- uses: actions/checkout@v7
- uses: astral-sh/setup-uv@v10
with:
enable-cache: true
python-version: ${{ matrix.python }}
- run: uv run pytest tests/test_pricing.py tests/test_phone.py --junitxml=reports/junit-unit-py${{ matrix.python }}.xml
- uses: actions/upload-artifact@v7
if: always()
with:
name: junit-unit-py${{ matrix.python }}
path: reports/
integration:
needs: unit
runs-on: ubuntu-latest
timeout-minutes: 15
steps:
- uses: actions/checkout@v7
- uses: astral-sh/setup-uv@v10
with:
enable-cache: true
- run: >-
uv run pytest tests -n 3
--deselect tests/test_pricing.py --deselect tests/test_phone.py
--cov=bazarghar --cov-report=xml:reports/coverage.xml
--junitxml=reports/junit-integration.xml
- uses: actions/upload-artifact@v7
if: always()
with:
name: integration-reports
path: reports/
e2e-smoke:
needs: integration
runs-on: ubuntu-latest
timeout-minutes: 15
env:
BASE_URL: http://127.0.0.1:8851
PW_CHANNEL: "" # bundled Chromium on Linux; msedge on the local PC
steps:
- uses: actions/checkout@v7
- uses: astral-sh/setup-uv@v10
with:
enable-cache: true
- run: uv run playwright install --with-deps chromium
- run: uv run bazarghar --port 8851 --test-mode --reset --db ci.db &
- run: curl --retry 10 --retry-connrefused --retry-delay 1 -s "$BASE_URL/api/health"
- run: uv run pytest ci_tests --junitxml=reports/junit-e2e.xml
- uses: actions/upload-artifact@v7
if: always()
with:
name: e2e-reports
path: reports/
retention-days: 7
gate:
needs: [integration, e2e-smoke]
runs-on: ubuntu-latest
timeout-minutes: 5
steps:
- uses: actions/checkout@v7
- uses: actions/download-artifact@v8
with:
path: reports/
merge-multiple: true
- run: python gate.pyTester-এর চোখে কয়েকটি লাইন বিশেষ জরুরি। needs হলো DAG; timeout-minutes আটকে থাকা job-কে অসীম অপেক্ষা থেকে বাঁচায়; if: always() লাল run-এও রিপোর্ট রাখে; matrix-এ fail-fast: false একটি Python-এ ভাঙলেও বাকিগুলো চালায়, যাতে জানা যায় ঠিক কোনগুলোতে ভাঙল; concurrency একই branch-এ নতুন push এলে পুরোনো run বাতিল করে। এখানে api আর UI এক job-এ (app একবার চালু করে), আর gate আলাদা job যা সব artifact নামিয়ে পড়ে।
YAML-এরও test — actionlint
Workflow ফাইলে একটি বানান ভুল সাধারণত push করার পরে CI-তেই প্রথম ধরা পড়ে। actionlint 1.7.12 (MIT লাইসেন্স, একটি স্বতন্ত্র binary) ফাইলটি না চালিয়ে পড়ে। ওপরের ফাইলে সত্যিকারের run কিছু না লিখে exit 0 দিল। এরপর একটি কপিতে তিনটি ভুল ইচ্ছা করে বসানো হলো: needs: unti, matrix.pyhton আর timeout-minutes: "five". সত্যিকারের আউটপুট (shellcheck এই কম্পিউটারে নেই, তাই সেই অংশ বন্ধ):
$ actionlint -no-color -shellcheck= -pyflakes= ci.yml
ci.yml:17:22: expecting a single ${{...}} expression or float number literal, but found plain text node [syntax-check]
ci.yml:38:31: property "pyhton" is not defined in object type {python: number} [expression]
ci.yml:46:3: job "integration" needs job "unti" which does not exist in this workflow [job-needs]
ci.yml:92:22: expecting a single ${{...}} expression or float number literal, but found plain text node [syntax-check]
$ echo $?
1
চারটি বার্তা (সময়সীমার ভুলটি দুটি job-এ বসেছিল), প্রতিটিতে লাইন আর কলাম। এমন বানান ভুল push-এর পরে নীরবে ভুল আচরণ দিতে পারত। Pipeline নিজেও কোড, তার জন্য lint-ই প্রথম test; check-jsonschema দিয়ে workflow-এর JSON Schema মেলানো আরেকটি পথ।
Required check আর branch protection
Pipeline লাল হলেও কেউ merge করে ফেললে gate অর্থহীন। তাই Git hosting সেবাগুলোতে branch protection-এর নিয়ম থাকে: main-এ সরাসরি push নয়, review বাধ্যতামূলক, আর নির্দিষ্ট check সবুজ না হলে merge বোতাম বন্ধ। সেই check-গুলোকে বলে required check. শুধু নির্ভরযোগ্য check-ই required হওয়া উচিত; flaky check required হলে মানুষ “আবার চালান” বোতামে অভ্যস্ত হয়। আরেকটি সূক্ষ্ম ফাঁক: দুটি PR আলাদাভাবে সবুজ, কিন্তু একসাথে মেলালে ভাঙে। Merge queue প্রতিটি PR-কে সর্বশেষ main-এর সাথে মিলিয়ে আবার test করে এই ফাঁক বন্ধ করে (ভাবনার প্রশ্ন ০৫)। বিস্তারিত সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫৮-এ।
Secret — CI-এর log সবচেয়ে বেশি মানুষ পড়েন
Staging-এ smoke test চালাতে token লাগে, load test-এ admin-এর পাসওয়ার্ড। পর্ব ৪৫ (Automation framework)-এর নিয়ম এখানেও: secret কোডে নয়, CI সেবার secret store-এ, আর job-এ পৌঁছায় environment variable হয়ে। CI সেবা registered secret-এর হুবহু মান log-এ ছাপা হলে *** দিয়ে ঢেকে দেয়: masked variable. কিন্তু “হুবহু” শব্দটি জরুরি। নিচের প্রোগ্রাম একটি সাধারণ masker-এর মতো আচরণ করে, একটি স্পষ্টত নকল token নিয়ে:
import base64, json, urllib.parse
SECRET = "fake+STAGING/tok=7Qx9" # an obviously fake value
def mask(line, secrets):
"""What a CI runner does: replace every registered secret value with ***."""
for s in secrets:
line = line.replace(s, "***")
return line
b64 = base64.b64encode(SECRET.encode()).decode()
log = [
f"login with token {SECRET}", # printed as is
"header: " + json.dumps({"Authorization": f"Bearer {SECRET}"}),
"debug b64: " + b64, # transformed
"url: /api?t=" + urllib.parse.quote(SECRET, safe=""), # URL-encoded
"split: " + SECRET[:9] + " ... " + SECRET[9:], # printed in parts
]
print("== only the raw value registered")
for line in log:
print(mask(line, [SECRET]))
print("== derived forms registered too")
derived = [SECRET, b64, urllib.parse.quote(SECRET, safe="")]
for line in log:
print(mask(line, derived))
leaks = [line for line in log if any(p in mask(line, derived) for p in (SECRET[:9], SECRET[9:]))]
print("still leaking:", len(leaks), "line(s)")আসল আউটপুট:
== only the raw value registered
login with token ***
header: {"Authorization": "Bearer ***"}
debug b64: ZmFrZStTVEFHSU5HL3Rvaz03UXg5
url: /api?t=fake%2BSTAGING%2Ftok%3D7Qx9
split: fake+STAG ... ING/tok=7Qx9
== derived forms registered too
login with token ***
header: {"Authorization": "Bearer ***"}
debug b64: ***
url: /api?t=***
split: fake+STAG ... ING/tok=7Qx9
still leaking: 1 line(s)
হুবহু মান দুই জায়গাতেই ঢাকা পড়ল। কিন্তু base64 করা, URL-encode করা আর টুকরো করে ছাপা রূপ বেরিয়ে গেল; base64 উল্টে আসল token পাওয়া এক লাইনের কাজ। রূপান্তরিত মানগুলোকেও secret হিসেবে register করলে (GitHub Actions-এর docs অনুযায়ী ::add-mask:: দিয়ে এটি করা যায়) দুটি বন্ধ হলো, কিন্তু টুকরো করা রূপ তখনও খোলা। শিক্ষা: masking শেষ প্রতিরক্ষা, প্রথম নয়। Secret কখনো ছাপবেন না, debug-এর জন্যও না; test-এর log-এ request header লেখার আগে সেগুলো ছেঁটে নিন।
আরও দুটি নিয়ম: fork থেকে আসা PR-এ secret দেওয়া হয় না, তাই সেখানে secret-নির্ভর test চলে না; আর test-এ শুধু test account আর সীমিত অনুমতির token. অবকাঠামো ক্লাউড ও DevOps কোর্সের পর্ব ৩৩ আর ৬১-এ।
৮ · Pipeline-এর flakiness আর feedback-এর সময়
একটি pipeline শুধু তখনই কাজের, যখন দল তার লাল-কে বিশ্বাস করে। Pipeline লাল হওয়ার তিন রকম কারণ, আর প্রতিটির আলাদা চিকিৎসা:
আসল bug
কোডের ভুল, যেমন coupon_ge. চিকিৎসা: মেরামত, দরকারে নতুন regression test.
Flaky test
একই কোডে কখনো লাল, কখনো সবুজ। চিকিৎসা পর্ব ৪০ (Flaky test)-এ: খোঁজা, quarantine, স্থায়ী সমাধান।
অবকাঠামো
Network ব্যর্থ, জায়গা শেষ, app সময়মতো ওঠেনি। চিকিৎসা: শুধু এই ধাপে সীমিত retry আর timeout.
Gate-এর ভুল
নিয়ম নিজেই ভুল, যেমন §৩-এর দশমিক। চিকিৎসা: জানা সবুজ আর জানা লাল build-এ gate যাচাই।
সবচেয়ে বিপজ্জনক অভ্যাস হলো পুরো pipeline-এ ঢালাও retry: “লাল হলে তিনবার চালানো, একবার সবুজ হলেই যথেষ্ট।” এতে flaky test লুকায়, আর মাঝে মাঝে ঘটে এমন আসল bug-ও (যেমন race condition, পর্ব ৬২) সবুজের নিচে চাপা পড়ে। Retry রাখতেই হলে (পর্ব ৪০-এর test retry) প্রতিটি retry রিপোর্টে আলাদা দেখান আর flake rate মাপুন। এই পর্বের কোনো run-এ retry ছিল না।
Feedback কত দ্রুত হওয়া উচিত?
কোনো সর্বজনীন সংখ্যা নেই, আর এই পর্ব কোনো শিল্প-গড় দাবি করে না। একটি পুরোনো নির্দেশিকা হলো Extreme Programming-এর “ten-minute build”: Kent Beck-এর বই (দ্বিতীয় সংস্করণ, ২০০৪)-এ build আর test মোটামুটি দশ মিনিটের মধ্যে শেষ রাখার পরামর্শ আছে বলে উদ্ধৃত হয়। যুক্তিটা মানুষের: অপেক্ষা লম্বা হলে developer অন্য কাজে চলে যান, আর লাল ফল এলে পুরো প্রসঙ্গ আবার মাথায় আনতে হয়। ব্যবহারিক উপায়:
- মাপুন: প্রতিটি stage-এর সময় আর গড় time to feedback, যেমন
pipeline.json; ধীর হওয়া চোখে পড়ুক। - স্তর ভাগ করুন: PR-এ দ্রুত, merge-এর পরে আরও, রাতে সব। প্রতিটি স্তরের সময়সীমা দল নিজে ঠিক করুক।
- সবচেয়ে লম্বা পথ ছোট করুন: critical path-এর stage ভাঙা, sharding, শুধু প্রাসঙ্গিক test বাছা (পর্ব ৬৮)।
- পুরোনো run বাতিল করুন: একই branch-এ নতুন push এলে আগেরটির ফল আর কারও দরকার নেই।
আরও গভীরে: Stage-এর ক্রম আসলে একটি পুরোনো optimisation সমস্যা: স্বাধীন পরীক্ষাগুলো পরপর চালিয়ে প্রথম ব্যর্থতায় থামলে গড় খরচ সবচেয়ে কম হয় খরচ ÷ ব্যর্থতার সম্ভাবনা ছোট থেকে বড় সাজালে (§৪-এর নিয়ম); কিন্তু বাস্তবে পরীক্ষাগুলো স্বাধীন নয় (একই bug কয়েকটি stage ধরে) আর লাল অবস্থার খরচ আলাদা, তাই নিয়মটি শুরু, শেষ কথা নয়। বড় প্রতিষ্ঠানে আরও এক ধাপ: test-এর ইতিহাস থেকে প্রতিটি পরিবর্তনের জন্য কোন test-এর লাল হওয়ার সম্ভাবনা বেশি তা আন্দাজ করে সেগুলো আগে চালানো (predictive test selection, পর্ব ৬৮)। আর Google-এর মতো প্রতিষ্ঠানের প্রকাশিত অভিজ্ঞতা বলে, বিশাল codebase-এ প্রতিটি পরিবর্তনে সব test চালানোই অসম্ভব হয়ে পড়ে; তখন pipeline-এর নকশা মানে test বাছাইয়ের নকশা।
পরীক্ষা ও ইন্টারভিউতে:
- CI pipeline-এ test-এর stage কোন ক্রমে রাখবেন? সস্তা আর প্রায়ই ভুল ধরে এমন আগে (lint, unit), ধীর আর দামি পরে (integration, UI, performance, security); প্রথম লাল-এ থামা।
- Fail fast কী? প্রথম ব্যর্থ stage-এর পরে বাকিগুলো না চালিয়ে সঙ্গে সঙ্গে ফল জানানো, যাতে সময় আর যন্ত্র বাঁচে।
- CI-তে কোন artifact রাখবেন? JUnit XML, coverage রিপোর্ট, আর ব্যর্থতায় screenshot, trace, log; upload ধাপ লাল run-এও চলবে।
- Coverage gate কেন বিপজ্জনক হতে পারে? মাপ লক্ষ্য হলে assertion-হীন test দিয়ে coverage বাড়ানো যায়; ratchet বা বদলানো লাইনের coverage আর mutation-এর সাথে মিলিয়ে দেখা ভালো।
- তিনটি runner যোগ করলেও pipeline কেন দ্রুত হলো না? সময় critical path দিয়ে বাঁধা; সবচেয়ে লম্বা নির্ভরতার পথের stage ভাঙতে বা ছোট করতে হবে।
৯ · AI-এর যুগে CI pipeline
AI সহকারীকে “বাজারঘরের জন্য একটি CI workflow লেখো” বললে এক মিনিটে সুন্দর YAML আসে। এই পর্বের অভিজ্ঞতা দিয়ে সেটি যাচাই করুন। AI-এর লেখা pipeline আর test-এ প্রচলিত দুর্বলতা: এমন action-এর input বা version বানানো যা নেই; test ধাপে || true বা continue-on-error দিয়ে লাল-কে সবুজ বানানো; artifact upload শুধু সফল run-এ; সব stage এক job-এ, কোনো ক্রম বা fail fast নেই; ঢালাও retry; ঢালাও coverage-এর লক্ষ্য; secret echo করে “debug”; app চালু হওয়ার অপেক্ষায় sleep 30; আর test-এর দিকে শুধু happy path, requirement-এর বদলে কোডের বর্তমান আচরণ assert করা, এত mock যে আসল কিছুই চলে না, সীমার মান বাদ। আর সবচেয়ে বড়টি: না চালিয়ে “pipeline সবুজ হবে” দাবি।
AI-কে কাজ দিন এমন প্রশ্নে, যার উত্তর আপনি যাচাই করতে পারবেন:
AI-এর pipeline হাতে পেলে — চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।
প্র ০১“Daily build আর smoke test” থেকে প্রতিটি commit-এ pipeline: testing-এর সময় কীভাবে বদলাল?
“Continuous integration” শব্দটি সাধারণত Grady Booch-এর ১৯৯১ সালের object-oriented design-এর বইয়ের সাথে যুক্ত করা হয়, তবে সেখানে ধারণাটি আজকের মতো দিনে বহুবার মেলানো নয়। ১৯৯০-এর দশকের মাঝামাঝি বড় প্রতিষ্ঠানে প্রচলিত চর্চা ছিল daily build: প্রতিদিন একবার পুরো product build করে একটি ছোট smoke test চালানো। Microsoft-এর এই চর্চা Michael Cusumano আর Richard Selby-র ১৯৯৫ সালের বই “Microsoft Secrets”-এ বর্ণিত হয়, আর Steve McConnell ১৯৯৬ সালে IEEE Software-এ “Daily Build and Smoke Test” নামে একটি পরিচিত লেখায় একে সুপারিশ করেন বলে উদ্ধৃত হয়। দিনে একবার মানে একটি ভাঙা পরিবর্তন পরের দিন সকালে ধরা পড়ত, আর ততক্ষণে তার ওপর আরও কয়েকজনের কাজ জমত।
১৯৯০-এর দশকের শেষে Kent Beck-দের Extreme Programming দিনে বহুবার মেলানো আর প্রতিবার সব test চালানোকে মূল চর্চা বানায়, আর Martin Fowler-এর “Continuous Integration” প্রবন্ধ (প্রথম প্রকাশ ২০০০ সালে, পরে কয়েকবার হালনাগাদ) চর্চাটিকে ব্যাপক পরিচিতি দেয়। এর জন্য দুটি জিনিস লাগল: স্বয়ংক্রিয় test-এর বড় ভাণ্ডার, আর build যন্ত্র যা প্রতিটি পরিবর্তনে নিজে চলে। পরের দুই দশকে hosted CI সেবা যন্ত্রের ঝামেলা প্রায় তুলে দিল।
Tester-এর ভূমিকায় এর প্রভাব গভীর। আগে regression testing ছিল release-এর আগের একটি পর্যায়; এখন তা প্রতিটি পরিবর্তনের অংশ, আর এর মান নির্ভর করে suite-এর নকশার ওপর: কোন test কোন স্তরে, কত দ্রুত, কত নির্ভরযোগ্য। Manual tester-এর কাজও বদলায়: যা বারবার একই রকম, তা pipeline-এ যায়; মানুষের সময় যায় exploratory testing, ঝুঁকি বিচার আর নতুন feature-এর নকশায় (পর্ব ২০)।
মূল উপলব্ধি: CI testing-কে একটি পর্যায় থেকে একটি অবিরাম প্রক্রিয়ায় বদলেছে। তাই tester-এর দক্ষতার একটি বড় অংশ এখন test লেখা নয়, test-এর ব্যবস্থা নকশা করা।
প্র ০২UI test ব্যবহারকারীর সবচেয়ে কাছে। তাহলে pipeline-এ সেটিকে শুরুতে, আর বেশি সংখ্যায় রাখলে সমস্যা কোথায়?
যুক্তিটি আকর্ষণীয়: ব্যবহারকারী যা দেখেন, তা-ই পরীক্ষা করুন। কিন্তু এই পর্বের সত্যিকারের run তিনটি খরচ দেখিয়েছে। প্রথমত সময়: একই coupon_ge bug-এ UI-আগের ক্রম লাল হলো ৮.৯৮ সেকেন্ডে, লিখিত ক্রম ৫.৭৪ সেকেন্ডে, কারণ লাল UI assertion ৫ সেকেন্ডের সময়সীমা পর্যন্ত অপেক্ষা করে। দ্বিতীয়ত বার্তা: UI বলল “checkout পাতায় ছাড় ১০০”, unit বলল “coupon_discount(1000) দিল ১০০”; দ্বিতীয়টি থেকে মেরামত মিনিটের কাজ। তৃতীয়ত নির্ভরযোগ্যতা: UI test-এ browser, network, সময় আর অনেক চলমান অংশ, তাই flaky হওয়ার সুযোগ বেশি (পর্ব ৪০)।
এই অভিজ্ঞতার সারাংশই test pyramid. Mike Cohn ২০০৯ সালের “Succeeding with Agile” বইয়ে ধারণাটি জনপ্রিয় করেন: অনেক দ্রুত unit test, মাঝারি সংখ্যক service স্তরের test, অল্প UI test. উল্টো আকৃতিকে অনেকে “ice-cream cone” বলেন: অল্প unit, বিশাল UI suite আর ওপরে হাতে-করা test; এমন suite ধীর আর ভঙ্গুর, তাই দল pipeline-কে কম বিশ্বাস করে। পরে কেউ কেউ “testing trophy”-র মতো বিকল্প আকৃতি প্রস্তাব করেছেন, যেখানে integration test-এর ভাগ বেশি; সব আকৃতিরই মূল কথা একই: প্রতিটি ঝুঁকি সবচেয়ে সস্তা স্তরে ধরুন, যেখানে তা নির্ভরযোগ্যভাবে ধরা যায়।
তার মানে UI test বাদ নয়। কিছু ঝুঁকি শুধু ওপরের স্তরেই দেখা যায়: বোতাম আছে কিন্তু কাজ করে না, JavaScript-এর একটি ভুল, পাতার ভেতরে দুটি অংশের ভুল সংযোগ। তাই UI-এর জন্য দুটি স্তর: প্রতিটি PR-এ একটি বা কয়েকটি smoke যাত্রা, শেষের দিকে; আর পূর্ণ E2E আর cross-browser রাতে বা merge-এর পরে। লাল হলে trace আর screenshot রাখুন, যাতে UI-এর দুর্বল বার্তার ক্ষতি পূরণ হয়।
মূল উপলব্ধি: প্রশ্ন “কোন test গুরুত্বপূর্ণ” নয়, বরং “এই ঝুঁকি সবচেয়ে সস্তায় আর নির্ভরযোগ্যভাবে কোথায় ধরা যায়?” UI test অপরিহার্য, কিন্তু শুরুর পাহারাদার হিসেবে নয়।
প্র ০৩CI-এর secret কেন বিশেষ ঝুঁকি, আর বাস্তবে কী ঘটেছে?
একটি CI job-এর কাছে প্রায়ই অনেক ক্ষমতা জমা থাকে: package publish করার token, staging-এর database-এর পাসওয়ার্ড, cloud-এ deploy করার অনুমতি। আর job চালায় এমন অনেক কোড যা আপনার দল লেখেনি: তৃতীয় পক্ষের action, script, package. এর যেকোনো একটি দুষ্ট হলে সে environment variable পড়ে বাইরে পাঠাতে বা log-এ ছাপতে পারে।
দুটি বহুল আলোচিত ঘটনা এর বাস্তবতা দেখায়। ২০২১ সালের এপ্রিলে Codecov জানায়, তাদের Bash Uploader script (যা অনেক দল CI-তে coverage পাঠাতে চালাত) কয়েক মাস ধরে আক্রমণকারীদের হাতে বদলানো ছিল, আর বদলানো script CI-এর environment variable, অর্থাৎ secret, বাইরে পাঠাত বলে প্রকাশিত হয়। ২০২৫ সালের মার্চে GitHub Actions-এর একটি জনপ্রিয় তৃতীয় পক্ষের action (tj-actions/changed-files)-এর বিভিন্ন version tag একটি দুষ্ট commit-এ সরিয়ে দেওয়া হয়, যা runner-এর memory থেকে secret পড়ে workflow-এর log-এ ছাপত; public repository-তে সেই log যে কেউ পড়তে পারত। দুই ক্ষেত্রেই মূল শিক্ষা: CI-তে চলা প্রতিটি বাইরের কোড আপনার secret দেখতে পারে।
প্রতিরক্ষা কয়েক স্তরে। Secret-এর ক্ষমতা যতটা সম্ভব ছোট আর মেয়াদ কম; test-এর জন্য আলাদা account. তৃতীয় পক্ষের action পুরো commit SHA দিয়ে আটকে রাখা (tag সরানো যায়, SHA নয়)। Workflow-এর permissions সবচেয়ে কম। Fork-এর PR-এ secret নয়। দীর্ঘমেয়াদি key-এর বদলে স্বল্পমেয়াদি পরিচয় (OIDC), যা ক্লাউড ও DevOps কোর্সের পর্ব ৬১-এ আছে। আর masking শেষ প্রতিরক্ষা, §৭-এর প্রোগ্রাম দেখিয়েছে রূপ বদলালে তা কাজ করে না। Tester-এর দিক থেকে: test-এর log-এ header আর body লেখার আগে ছাঁটুন, আর artifact-এ secret বা আসল গ্রাহকের তথ্য যায় কি না নিয়মিত দেখুন।
মূল উপলব্ধি: CI-এর log আর artifact অনেক মানুষ আর যন্ত্র পড়ে। Secret সেখানে পৌঁছানোর প্রতিটি পথ বন্ধ করুন, আর ধরে নিন যে CI-তে চলা যেকোনো বাইরের কোড secret দেখতে পায়।
প্র ০৪দলের pipeline প্রায়ই লাল হয়, আর সবাই “আবার চালান” চাপেন। Tester হিসেবে আপনি কোথা থেকে শুরু করবেন?
প্রথম কাজ মাপা, অনুমান নয়। গত কয়েক সপ্তাহের run-এর তালিকা (JUnit XML আর pipeline.json-এর মতো artifact) থেকে প্রতিটি লাল run-কে §৮-এর চার দলে ভাগ করুন: আসল bug, flaky test, অবকাঠামো, gate-এর ভুল। একই commit-এ “আবার চালান”-এ সবুজ হয়ে যাওয়া লাল প্রায় নিশ্চিতভাবে প্রথম দলের নয়। Google Testing Blog-এ ২০১৬ সালে John Micco-র একটি লেখা জানিয়েছিল, তাঁদের বিশাল test ভাণ্ডারে flaky ফল একটি স্থায়ী সমস্যা, আর তাঁরা flaky test আলাদা করে চিহ্নিত ও পরিচালনা করেন; বিস্তারিত সংখ্যা মূল লেখায় দেখুন। ছোট দলেও ছবি প্রায়ই একই: কয়েকটি test বেশিরভাগ ঝামেলার উৎস।
দ্বিতীয় কাজ বিশ্বাস ফেরানো। সবচেয়ে বেশি লাল-করা flaky test-গুলো quarantine-এ নিন (পর্ব ৪০): তারা চলবে, ফল দেখা যাবে, কিন্তু merge আটকাবে না, আর প্রতিটির একজন মালিক ও মেরামতের তারিখ থাকবে। অবকাঠামোর ধাপে (package নামানো, app চালু) সীমিত retry আর স্পষ্ট বার্তা দিন, যাতে “network ব্যর্থ” আর “test ব্যর্থ” আলাদা দেখায়। আর required check-এর তালিকা ছাঁটুন: শুধু নির্ভরযোগ্য check merge আটকাবে।
তৃতীয় কাজ অভ্যাস বদলানো। “আবার চালান” বোতামের ব্যবহারও একটি metric হতে পারে; প্রতিটি পুনরায় চালানো একটি ছোট সংকেত যে কোথাও বিশ্বাস ভেঙেছে। নতুন test যোগের সময় পর্ব ৩৭-এর নিয়মে isolation যাচাই, আর gate-এর নিয়ম বদলালে §৩-এর মতো জানা সবুজ আর জানা লাল build-এ পরীক্ষা। আর লাল pipeline-কে সবার কাজ ভাবা: main লাল থাকলে নতুন merge বন্ধ, প্রথম কাজ সবুজ করা।
মূল উপলব্ধি: যে pipeline-এর লাল কেউ বিশ্বাস করেন না, সে আসল bug-ও লুকায়। মাপুন, দলে ভাগ করুন, শব্দময় check-কে আটকানো থেকে সরান, আর নির্ভরযোগ্যতাকে pipeline-এর প্রথম feature ভাবুন।
প্র ০৫দুটি pull request আলাদাভাবে সবুজ, merge-এর পরে main লাল। এমন কেন হয়, আর merge queue কীভাবে বাঁচায়?
প্রতিটি PR-এর pipeline চলে তার নিজের branch-এ, যা main-এর কোনো একটি পুরোনো অবস্থা থেকে শুরু। ধরুন, PR ক কুপনের সীমা ১০০০ থেকে ১৫০০ করল আর সংশ্লিষ্ট test বদলাল; PR খ একই সময়ে একটি নতুন test যোগ করল যা ধরে নেয় ১০০১ টাকায় ছাড় ১০০. দুটি PR আলাদাভাবে সবুজ, কারণ কেউ কারও পরিবর্তন দেখেনি। দুটোই merge হলে main-এ খ-এর test লাল। কোনো file-এ merge conflict হয়নি, তাই Git কিছু বলেনি: এটি অর্থের দ্বন্দ্ব, লেখার নয়।
সমাধানের একটি পুরোনো নীতি আছে, যাকে Graydon Hoare (Rust ভাষার স্রষ্টা) ২০১৪ সালের একটি লেখায় “not rocket science rule” নামে বর্ণনা করেন: এমন একটি repository রাখুন যার main সবসময় সব test পাস করে; আর তা নিশ্চিত করতে প্রতিটি পরিবর্তনকে main-এর সাথে মেলানো অবস্থায় test করে তারপরই main সরান। তিনি এর উৎস আরও পুরোনো চর্চায় দেখিয়েছেন। Rust প্রকল্পের “bors” নামের bot এই নীতিতে কাজ করত, আর পরে বড় hosting সেবাগুলোও merge queue চালু করে (GitHub-এ ২০২৩ সালের দিকে সাধারণভাবে উপলব্ধ হয়, GitLab-এ একই ধারণা merge train নামে)।
Merge queue-এর খরচও আছে: প্রতিটি PR merge-এর আগে আরেকবার pipeline চালায়, তাই pipeline ধীর হলে সারি লম্বা হয়। তাই অনেক সারি একসাথে কয়েকটি PR মিলিয়ে test করে, আর লাল হলে ভাগ করে খোঁজে কোনটি দায়ী। Tester-এর দিক থেকে তিনটি দায়িত্ব: queue-এর pipeline দ্রুত আর নির্ভরযোগ্য রাখা (এখানে flaky test সবার সময় নষ্ট করে), required check-এর তালিকা ঠিক করা, আর main লাল হলে কোন PR-এর সমন্বয়ে ভাঙল তা ইতিহাস থেকে খুঁজে বের করা।
মূল উপলব্ধি: “আমার branch-এ সবুজ” মানে “main-এ সবুজ” নয়। Main-এর সবুজ অবস্থা রক্ষা করতে পরিবর্তনকে main-এর সাথে মেলানো অবস্থায় test করতে হয়, আর সেই ব্যবস্থার গতি নির্ভর করে pipeline-এর গতি আর নির্ভরযোগ্যতার ওপর।
অনুশীলন
উত্তর দেখার আগে কাগজে নিজে করুন। সব সংখ্যা সত্যিকারের run বা scratch script-এ মেলানো।
-
Test নকশা (spec থেকে): বাজারঘরের gate-এর spec: “(ক) কোনো test ব্যর্থ হলে merge আটকানো হবে। (খ) line coverage এক দশমিকে গোল করে baseline ৮৪.১-এর কম হলে আটকানো হবে। (গ) ZAP-এর high alert একটিও থাকলে আটকানো হবে। (ঘ) এর কোনোটি না ঘটলে কিন্তু medium alert baseline ২-এর বেশি হলে শুধু সতর্কবার্তা।” এই gate function-এর জন্য test case নকশা করুন: কোন শর্তে কোন input আর expected ফল (PASS, WARN, BLOCK)? Coverage-এর সীমায় কোন মানগুলো নেবেন?
প্রতিটি শর্ত একবার করে ভাঙা আর একটি সব-ঠিক case (পর্ব ০৯-এর decision table-এর মতো): (১) সব ঠিক: failed 0, cov 84.1, high 0, medium 2 → PASS. (২) failed 1 → BLOCK. (৩) high 1 → BLOCK. (৪) medium 3, বাকি ঠিক → WARN. (৫) medium 3 আর failed 1 একসাথে → BLOCK (আটকানো সতর্কতার ওপরে)। Coverage-এর সীমায় পর্ব ০৮-এর মতো দুই পাশ, আর গোল করার নিয়মের জন্য বাড়তি মান: 84.06 → গোল করে 84.1, PASS; 84.04 → 84.0, BLOCK; আর একটি ফাঁদ: 84.05 → Python-এ
round(84.05, 1)দেয় 84.0, কারণ 84.05 binary-তে ঠিক লেখা যায় না, একটু কম; তাই BLOCK. Scratch-এ মিলিয়ে দেখা। এই case spec-এর একটি অস্পষ্টতা ধরে: “গোল করে” মানে কোন নিয়মে? Product owner-এর সাথে ঠিক করুন, আর test-এ লিখে রাখুন। -
ফল আগে বলুন (predict): বাজারঘরের
cancel_after_shippedbug চালু করলে shipped অবস্থার order-ও cancel হয়ে যায়। App-এর নিজের দুটি test এটি ধরে, দুটিইtests/test_orders.py-এ। ক্রম lint, unit (শুধু pricing আর phone), integration, api, ui-smoke, gate. কোন stage লাল হবে, কোনগুলো skipped, আর কোন artifact থাকবে?Unit-এ order-এর কোনো test নেই, তাই lint আর unit সবুজ; integration লাল; api, ui-smoke আর gate skipped. সত্যিকারের run:
=== stage unit 49 passed in 3.70s === stage integration FAILED tests/test_orders.py::test_invalid_transitions_are_409[5-cancel] - ass... FAILED tests/test_orders.py::test_customer_cannot_cancel_shipped_order - asse... 2 failed, 99 passed in 8.05s … RED at integration after 14.43 s artifacts: coverage.xml junit-integration.xml junit-unit.xml pipeline.jsonদুটি জিনিস খেয়াল করুন। coverage.xml লাল run-এও আছে, কারণ pytest-cov test শেষে রিপোর্ট লেখে; কিন্তু gate চলেনি, তাই coverage-এর বিচারও হয়নি। আর এই bug ধরতে ১৪.৪৩ সেকেন্ড লাগল, coupon-এর ৫.৭৪-এর তুলনায়: order-এর অবস্থার নিয়ম যদি ঘন ঘন বদলায়, তার pure-function test unit stage-এ আনলে feedback দ্রুত হবে।
-
Pipeline-এ ভুল খুঁজুন: একজন সহকর্মীর লেখা workflow-এর একটি job. তিনি বলছেন, “কখনো লাল হয় না, দারুণ stable!” অন্তত চারটি সমস্যা খুঁজুন।
test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 - run: echo "token=$STAGING_TOKEN" | base64 env: STAGING_TOKEN: ${{ secrets.STAGING_TOKEN }} - run: uv run pytest -q || true - run: sleep 30 - uses: actions/upload-artifact@v7 with: name: reports path: reports/(১)
pytest -q || true: test যা-ই হোক ধাপের exit code 0, তাই job কখনো লাল হয় না। “stable” আসলে অন্ধ।|| trueমুছুন। (২) Secret base64 করে ছাপা: হুবহু মান নয় বলে mask হবে না (§৭-এর প্রোগ্রাম), আর log পড়া যে কেউ উল্টে নিতে পারবেন। ধাপটি মুছুন। (৩)sleep 30: কোনো কিছুর জন্য অন্ধ অপেক্ষা; ধীর আর flaky. App-এর অপেক্ষা হলে health endpoint-এ সীমিত retry, আর ধাপটি test-এর আগে। (৪) Artifact upload-এif: always()নেই: ঠিক করার পর test লাল হলে রিপোর্ট আর আসবে না। (৫)timeout-minutesনেই, আর pytest-কে--junitxmlবলা হয়নি, তাইreports/হয়তো খালিই। এর সাথেactionlintচালানো আর একটি seeded bug দিয়ে দেখা job সত্যিই লাল হয় কি না। -
হিসাব (critical path): একটি pipeline-এ build ২ মিনিট; তারপর চারটি job যাদের প্রত্যেকে শুধু build-এর ওপর নির্ভর করে: unit ৩, api ৪, ui ৬, contract ১ মিনিট; সবার শেষে gate ১ মিনিট, যা চারটির ওপর নির্ভর করে। পরপর চালালে কত? ২টি আর ৩টি runner-এ সবচেয়ে কম কত? Critical path কোনটি?
পরপর: ২ + ৩ + ৪ + ৬ + ১ + ১ = ১৭ মিনিট। Critical path: build → ui → gate = ২ + ৬ + ১ = ৯ মিনিট; এর চেয়ে কম অসম্ভব। ২টি runner: build-এর পরে চারটি job-এর মোট কাজ ১৪ মিনিট, দুই runner-এ অন্তত ৭; তাই ২ + ৭ + ১ = ১০ মিনিট, আর তা পাওয়া যায় (runner ক: ui ৬ + contract ১; runner খ: api ৪ + unit ৩)। ৩টি runner: ৯ মিনিট (ক: ui; খ: api; গ: unit + contract = ৪), অর্থাৎ critical path-এ পৌঁছে গেছে; চতুর্থ runner আর কিছু দেয় না। §৫-এর scheduler-এ এই সংখ্যাগুলো বসিয়ে মিলিয়ে নিতে পারেন: 17, 10, 9, 9.
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি সাধারণ PR pipeline-এর stage-গুলো সবচেয়ে যুক্তিসঙ্গত ক্রমে সাজান (▲▼ চেপে সরান)
- Lint আর static check
- Unit test
- Integration আর API test (database-সহ)
- Test environment-এ app চালু করে UI smoke test
- Artifact পড়ে quality gate-এর সিদ্ধান্ত
- সবুজ হলে merge-এর অনুমতি
একটি pipeline-এ lint ১ মিনিট, unit ৪ মিনিট, UI ১২ মিনিট। Unit stage প্রায়ই লাল হয়, UI কদাচিৎ। Fail fast রেখে গড় feedback-এর সময় কমাতে কোন ক্রম সবচেয়ে ভালো?
- UI → unit → lint
- lint → UI → unit
- lint → unit → UI
- ক্রমে কিছু যায় আসে না, মোট সময় একই
Pipeline-এর stage-গুলোর সময়: lint ১, unit ৫, integration ১০, deploy ১, api ১, UI ৩ মিনিট। Integration আর deploy দুটিই শুধু unit-এর পরে চলতে পারে; api আর UI deploy-এর পরে; শেষে gate (প্রায় ০)। অনেক runner থাকলেও pipeline অন্তত কত মিনিট নেবে?
- ২১ মিনিট
- ১৬ মিনিট
- ১০ মিনিট
- ১০ মিনিটের কম, কারণ ডানের শাখা ছোট
একটি UI test লাল হলে সেই job-এর trace আর screenshot পরে পাওয়া যায় না। সবচেয়ে সম্ভাব্য কারণ কোনটি?
- Playwright লাল test-এ trace বানাতে পারে না
- Headless browser-এ screenshot নেওয়া যায় না
- CI runner সব ফাইল সবসময় মুছে দেয়, artifact রাখার উপায় নেই
- Artifact upload ধাপে
if: always()বাif: failure()নেই
একটি gate নিয়ম: “line coverage অন্তত ৯০% না হলে merge বন্ধ।” পরিষ্কার কোডেই coverage ৮৪.১%, তাই প্রথম দিনেই সব PR আটকে গেল। সবচেয়ে যুক্তিসঙ্গত পরিবর্তন কোনটি?
- Coverage ratchet: শেষ সবুজ build-এর মানের নিচে নামলে আটকানো
- দ্রুত ৯০%-এ পৌঁছাতে assertion ছাড়া test যোগ করা
- Coverage মাপাই বন্ধ করা
- Gate লাল হলে তিনবার retry করা
CI-এর secret store-এ API_TOKEN রাখা আছে, আর platform তার হুবহু মান log-এ *** দিয়ে ঢাকে। কোন ক্ষেত্রে token log-এ পড়ার মতো বেরিয়ে যেতে পারে?
- Script-এ
echo $API_TOKENলিখলে - Token-টি একটি JSON header-এর ভেতরে হুবহু ছাপা হলে
- Token-কে base64 করে ছাপালে
- Token-কে environment variable হিসেবে job-এ পাঠালে, কিছু না ছাপিয়ে
১৫০টি test একটি worker-এ মধ্যমা ১৬.৫ সেকেন্ড, তিনটি worker-এ ৮.০৪ সেকেন্ড (pytest-xdist). তিন গুণ দ্রুত না হওয়ার সবচেয়ে সম্ভাব্য কারণ কোনটি?
- তিন worker-এ কিছু test চলেনি
- Worker চালু হওয়ার খরচ আর test-গুলোর অসমান সময়
- Coverage মাপার কারণে সব test দ্বিগুণ ধীর
- Python-এর GIL একসাথে একটির বেশি test চলতে দেয় না
দুটি pull request আলাদাভাবে সব check-এ সবুজ, কোনো merge conflict নেই, কিন্তু দুটো merge হওয়ার পরে main-এর একটি test লাল। কোন ব্যবস্থা এমন ঘটনা আগেই আটকাতে বানানো?
- Dependency cache
- Matrix build
- Secret masking
- Merge queue
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Pipeline হলো প্রতিটি commit-এ নিজে চলা test plan: সস্তা আর প্রায়ই-লাল check আগে, ধীর আর দামি পরে, প্রথম লাল-এ থামা।
- বাজারঘরে
coupon_geলিখিত ক্রমে ৫.৭৪ সেকেন্ডে লাল, UI-আগে ৮.৯৮ সেকেন্ডে আর কম স্পষ্ট বার্তায়; লাল UI test timeout পর্যন্ত অপেক্ষা করে। - Parallel সাহায্য করে (১৬.৫ → ৮.০৪ সেকেন্ড), কিন্তু pipeline critical path-এর চেয়ে দ্রুত হয় না; লম্বা stage ভাঙুন।
- Artifact লাল run-এও রাখুন; gate-এর প্রতিটি নিয়মে লিখুন আটকায় না সতর্ক করে। ঢালাও coverage লক্ষ্যের বদলে ratchet, আর gate-কেও test করুন।
- Workflow-ও কোড: actionlint চালান। Secret কখনো ছাপবেন না; masking শুধু হুবহু মান ঢাকে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৬৫ · Test environment আর test data — Docker Compose, seed আর maskingপরবর্তী পর্বআলাদা test environment সাজানো, seed করা ডেটা আর নিরাপদ masking করা।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্বপুরো কোর্সের রোডম্যাপ।
- পর্ব ৪০ · Flaky testআগের ধারণালাল pipeline-এর সবচেয়ে বিরক্তিকর কারণ।
- ক্লাউড ও DevOps · পর্ব ৫৭পাশের ট্র্যাকRunner, cache আর pipeline-এর অবকাঠামো।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৫৮পাশের ট্র্যাকCI-এর ইতিহাস, চর্চা আর main সবুজ রাখা।