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

Test-এর স্তর আর ধরন — unit থেকে acceptance, functional বনাম non-functional

Test Levels and Test Types — Component to Acceptance, Functional vs Non-functional, Retest vs Regression

Taught in Bangla, this lesson separates test levels (component, component integration, system, system integration and acceptance) from test types (functional, non-functional, black-box and white-box) using the Bazarghar delivery charge. It lists six forms of acceptance testing, including UAT, OAT, alpha and beta. In-page Python places test ideas on a level by type grid and shows a real regression caught after a fix, then explains smoke, sanity, maintenance testing and a first look at the test pyramid.

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

  • পাঁচটি test level-এর প্রতিটির লক্ষ্য, test basis, test object আর সাধারণ defect চেনা
  • Acceptance testing-এর ছয় রকম রূপ আলাদা করে বলতে পারা
  • ISO/IEC 25010-এর গুণ ধরে non-functional test-এর ধারণা বানানো
  • একটি test idea-কে level × type ছকে বসানো আর ছকের ফাঁক খোঁজা
  • Retest আর regression নিজের চোখে চালিয়ে দেখা; smoke, sanity আর maintenance testing-এর জায়গা বোঝা

১ · স্তর আর ধরন — একটি test-কে দুই প্রশ্নে চেনা

বিয়েবাড়ির বাবুর্চির কথা ভাবুন। রান্না শুরুর আগে তিনি মসলা আর চাল আলাদা করে দেখেন — ভেজাল নেই তো? তারপর মাংস আর মসলা একসাথে কষানোর সময় চেখে দেখেন — মিশেছে ঠিকমতো? তারপর পুরো খাবার সাজিয়ে দেখেন — পোলাও, রোস্ট, বোরহানি একসাথে পরিবেশন করা যায় তো? শেষে কনের বাবা আর কয়েকজন মুরুব্বি খেয়ে বলেন — “হ্যাঁ, এটাই চেয়েছিলাম।”

চারটি পরীক্ষার পরিসর আলাদা — এগুলোই test level-এর ধারণা। আবার প্রতিটিতে বাবুর্চি আলাদা গুণও দেখেন: স্বাদ ঠিক কি না, কত দ্রুত পাঁচশো প্লেট বাড়া যায়, খাবার নিরাপদ কি না। এগুলো test type.

মূল ধারণা

Test level হলো test-এর একটি দল, যাকে একসাথে সংগঠিত করা হয় একটি নির্দিষ্ট পরিসরের জিনিস যাচাই করতে — একটি component থেকে পুরো system আর তার বাইরের জগৎ পর্যন্ত। Test type হলো test-এর একটি দল, যা জিনিসটির একটি নির্দিষ্ট গুণ বা বৈশিষ্ট্য যাচাই করে। একটি test সবসময় একটি level-এর এবং একটি type-এর — যেমন “system level-এ performance test”, বা “component level-এ functional test”.

সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৫-এ চারটি level আর প্রধান ধরনগুলোর সংক্ষিপ্ত পরিচয় আছে। এই পর্বে আমরা আরও গভীরে যাব: প্রতিটি level কিসের সাথে মিলিয়ে দেখে, কী ধরনের ভুল ধরে, কে চালান, কোন পরিবেশে চালান — আর এগুলো সবই চলমান উদাহরণ বাজারঘর অনলাইন দোকানে।

বাজারঘরের নিয়মগুলো আবার মনে করে নিন, কারণ পুরো মডিউলে এগুলোই ব্যবহার হবে:

  • Coupon: ১০০০ টাকার বেশি অর্ডারে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায়, ভগ্নাংশ বাদ।
  • Delivery charge: ঢাকার ভেতরে ৬০ টাকা (অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি), বাইরে ১২০ টাকা।
  • Phone number ঘর, আর অর্ডারের অবস্থা (order status). মোবাইল-ওয়ালেটে টাকা দেওয়ার ধাপটি এই কোর্সে সবসময় একটি নকল (mock) — আসল টাকা কোথাও যায় না।

প্রতিটি level চেনা যায় পাঁচটি প্রশ্নে: লক্ষ্য কী, কিসের সাথে মিলিয়ে test বানানো হয় (test basis), কোন জিনিসটি test হচ্ছে (test object), কী ধরনের defect ধরা পড়ে, আর কে কোন পরিবেশে চালান। ISTQB-এর Foundation syllabus-এর বর্তমান সংস্করণে (v4.0, ২০২৩ সালে প্রকাশিত) level পাঁচটি ধরা হয়েছে: component, component integration, system, system integration আর acceptance. অনেক বইয়ে integration একটিই স্তর, তাই চারটি level-এর কথাও পাবেন।

বাজারঘরে পাঁচটি test level

Each level widens the scope: component → component integration → system → system integration → acceptance

Five test levels of the Bazarghar shop as nested boxes Acceptance · ব্যবহারকারী, মালিক, ops System integration System · পুরো বাজারঘর Component integration cart component discount() component Courier API বাইরের system Wallet (mock) নকল payment
ছবি ৫.১ — প্রতিটি বাক্স আগেরটিকে ঘিরে রাখে: ভেতরে একা একা component, তারপর তাদের জোড় (ড্যাশ দাগ), তারপর পুরো বাজারঘর, তারপর বাইরের system-এর সাথে জোড় (courier, wallet), আর সবার বাইরে মানুষ — যাঁদের জন্য system বানানো।

২ · Component testing — সবচেয়ে ছোট টুকরো, একা

Component testing (অনেকে বলেন unit testing; এই কোর্সে দুটি নাম একই অর্থে চলবে) মানে একটি ছোট অংশকে বাকি system থেকে আলাদা করে দেখা — একটি function, একটি class, বা একটি ছোট module. বাজারঘরে discount(subtotal) একটি component; delivery(district) আরেকটি।

লক্ষ্য

অংশটির নিজের যুক্তি ঠিক কি না — হিসাব, শর্ত, সীমা, ভুল ইনপুটে আচরণ। দ্রুত feedback: কোড বদলের কয়েক সেকেন্ডের মধ্যে ফল।

Test basis

Component-এর নকশা বা বিবরণ, কোড নিজে, আর বিস্তারিত requirement — যেমন “১০০০-এর বেশি হলে ১০%, সর্বোচ্চ ৩০০”।

সাধারণ defect

ভুল হিসাব, > আর >=-এর গোলমাল, সীমা ভুলে যাওয়া (৩০০-এর cap নেই), ভুল ইনপুটে crash, ভুল data flow.

কে, কোথায়

সাধারণত developer নিজে, নিজের কম্পিউটারে আর CI-তে। SDET বা tester-রাও লেখেন বা পর্যালোচনা করেন।

Component আলাদা করতে দুটি সহায়ক লাগে। যে অংশটি component-কে ডাকে, সেটি যদি এখনো তৈরি না হয়ে থাকে, তার বদলে একটি test driver বসে — ছোট একটি কোড যা component-কে ইনপুট দিয়ে ডাকে আর ফল মিলিয়ে দেখে। Python-এর unittest বা pytest আসলে এই driver-এর কাজটাই করে। আর component নিজে যাকে ডাকে (যেমন database বা SMS service), তার বদলে বসে একটি stub — আগে থেকে ঠিক করা উত্তর দেয় এমন নকল। এমন নকলের সাধারণ নাম test double; বিস্তারিত পর্ব ২৪-এ (Test double গভীরে)।

গার্মেন্টস কারখানায় নতুন বোতাম-সেলাই মেশিন এলে পুরো লাইন চালানো হয় না; একটি কাপড়ের টুকরো আর হাতে রাখা কয়েকটি বোতাম দিয়ে শুধু মেশিনটি চালিয়ে দেখা হয়। কাপড়ের টুকরো driver-এর মতো, হাতের বোতাম stub-এর মতো।

Component test-এর পরিবেশে আসল database বা network নেই, তাই এটি সবুজ হলেও দুটি component একসাথে কাজ করবে, এমন নিশ্চয়তা নেই — সেটি দেখে পরের level. কীভাবে component test লিখতে হয়, তা মডিউল ৪-এ (পর্ব ২১ থেকে) pytest দিয়ে হাতে-কলমে শিখবেন; Python কোর্সের পর্ব ৪২-এ pytest-এর একটি ছোট শুরু আছে।

৩ · Integration testing — জোড়ার জায়গায় ভুল

অনেক ভুল কোনো একক অংশের ভেতরে নয়, দুটি অংশের মাঝখানে থাকে: একজন পাঠায় পয়সায়, আরেকজন পড়ে টাকায়; একজন লেখে "Dhaka", আরেকজন খোঁজে "DHK". Integration testing ঠিক এই জোড়ার জায়গাগুলো দেখে। এর দুটি রূপ আছে।

Component integration testing — দোকানের ভেতরের জোড়

Component integration testing দেখে বাজারঘরের নিজের অংশগুলো একে অপরের সাথে ঠিকমতো কথা বলে কি না: cart module কি coupon module-কে সঠিক subtotal পাঠায়? Address form যে district পাঠায়, delivery module কি সেটা বোঝে? Order তৈরি হলে কি stock module-এ সংখ্যা কমে?

  • Test basis: software-এর নকশা আর architecture, module-এর interface-এর বিবরণ, sequence diagram, data format-এর চুক্তি।
  • সাধারণ defect: ভুল data format বা একক (পয়সা বনাম টাকা), ভুল ক্রমে ডাকা, অনুপস্থিত বা বাড়তি field, বড়-ছোট হাতের অক্ষর বা ফাঁকা জায়গার অমিল ("dhaka "), ত্রুটি হলে একজন আরেকজনকে না জানানো।
  • কে: সাধারণত developer, বা developer আর SDET মিলে।

System integration testing — বাইরের জগতের সাথে জোড়

System integration testing দেখে পুরো বাজারঘর বাইরের system-এর সাথে ঠিক কাজ করে কি না: courier কোম্পানির API (ডেলিভারির জন্য), মোবাইল-ওয়ালেটের payment (আমাদের ক্ষেত্রে mock), SMS gateway (অর্ডারের খবর পাঠাতে)। এখানে সমস্যা হলো, বাইরের system আপনার নিয়ন্ত্রণে নেই — তার test পরিবেশ বন্ধ থাকতে পারে, ধীর হতে পারে, বা হঠাৎ নতুন version আসতে পারে।

  • Test basis: বাইরের API-র নথি, দুই পক্ষের চুক্তি (কোন field, কোন format, কোন error code), workflow-এর বিবরণ।
  • সাধারণ defect: চুক্তির অমিল (district নামের বদলে code চাওয়া হয়েছে), timeout সামলাতে না পারা, একই অনুরোধ দুবার গেলে দুবার টাকা কাটা, বাইরের system-এর ভুল উত্তরে নিজের system ভেঙে পড়া।
  • কে: প্রায়ই আলাদা test দল বা SDET, অনেক সময় দুই প্রতিষ্ঠানের মানুষ মিলে।

নামের ফাঁদ: দুটি function-এর জোড়ও integration, দুই প্রতিষ্ঠানের system-এর জোড়ও integration. তাই বলুন কোন জোড় — “cart আর coupon-এর integration test”, বা “courier API-র সাথে system integration test”.

জোড়া লাগানোর কৌশল (big-bang, top-down, bottom-up) আর test database নিয়ে integration test পর্ব ২৮-এ, বাইরের system-এর নকল পর্ব ৩৪-এ (Service virtualization), চুক্তি স্বয়ংক্রিয়ভাবে মেলানো পর্ব ৩২-এ (Contract testing). সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫১-এ integration-এর কৌশলের একটি সংক্ষিপ্ত রূপ আছে।

৪ · System testing আর acceptance testing

System testing — পুরো দোকান, আসলের মতো পরিবেশে

System testing পুরো জোড়া-লাগানো বাজারঘরকে একটি জিনিস হিসেবে দেখে: browser থেকে login, পণ্য খোঁজা, cart, coupon, checkout, নকল payment, order status, SMS — শুরু থেকে শেষ পর্যন্ত। পরিবেশ যতটা সম্ভব production-এর মতো, কিন্তু আলাদা — যাতে আসল গ্রাহকের data-য় হাত না পড়ে। এমন পরিবেশকে বলে test environment.

  • Test basis: system requirement (SRS), use case, user story, ঝুঁকির বিশ্লেষণ, ব্যবহারকারীর নির্দেশিকা।
  • সাধারণ defect: পুরো প্রবাহে ভুল ফল (checkout পাতায় ৬০, invoice-এ ১২০), ভুল business rule, non-functional ঘাটতি (ভিড়ে ধীর, keyboard দিয়ে চালানো যায় না), পরিবেশের configuration-এর ভুল।
  • কে: প্রায়ই স্বাধীন test দল — manual QA আর SDET.

Acceptance testing — “এটা কি গ্রহণ করা যায়?”

আগের সব level মূলত জিজ্ঞেস করে, “ঠিকভাবে বানানো হয়েছে?” Acceptance testing জিজ্ঞেস করে, “এটা কি আমাদের প্রয়োজন মেটায়, আমরা কি চালু করতে প্রস্তুত?” এর লক্ষ্য ভুল খোঁজার চেয়ে বেশি আস্থা তৈরি আর সিদ্ধান্ত নেওয়া। এখানে বড় defect পাওয়া মানে আগের level-এ কিছু ফসকে গেছে, বা requirement-ই ভুল বোঝা হয়েছিল। পর্ব ০২-এর ভাষায়, এটি validation-এর সবচেয়ে কাছের level. Acceptance-এর ছয়টি প্রচলিত রূপ:

রূপকে করেনকিসের সাথে মিলিয়েবাজারঘরে উদাহরণ
UAT (user acceptance)আসল ব্যবহারকারী বা তাঁদের প্রতিনিধিব্যবসার প্রয়োজন, user story-র acceptance criteriaদোকানের মালিক আর কয়েকজন নিয়মিত ক্রেতা আসল-ধাঁচের অর্ডার দিয়ে দেখেন coupon আর delivery-র হিসাব বোঝা যায় কি না
OAT (operational acceptance)চালানোর দল (ops, system admin)চালানো আর রক্ষণাবেক্ষণের প্রয়োজনরাতের backup থেকে order database ফেরানো যায়? Server বদলালে deploy চলে? Monitoring-এ সতর্কবার্তা আসে?
Contractual (চুক্তিভিত্তিক)গ্রাহক প্রতিষ্ঠান, প্রায়ই নির্মাতার সাথে মিলেচুক্তিতে লেখা গ্রহণের শর্তবাজারঘর যদি কোনো বাইরের প্রতিষ্ঠান বানিয়ে দেয়: “চুক্তির ৩৫টি শর্তের সবকটি পূরণ হলে তবেই চূড়ান্ত হস্তান্তর”
Regulatory (নিয়ন্ত্রক)প্রতিষ্ঠান নিজে, কখনো নিয়ন্ত্রক সংস্থার পর্যবেক্ষণেআইন, নীতিমালা, মানদণ্ডগ্রাহকের ব্যক্তিগত তথ্য রাখার নিয়ম মানা হচ্ছে কি না; চিকিৎসা বা ব্যাংকিং software-এ এই রূপ সবচেয়ে কঠোর
Alphaভেতরের মানুষ বা বাছাই করা ব্যবহারকারীপণ্যের লক্ষ্য, ব্যবহারের অভিজ্ঞতাপ্রকাশের আগে বাজারঘরের অফিসের কর্মীরা দুই সপ্তাহ নিজেরা কেনাকাটা করেন, নির্মাতার নিয়ন্ত্রিত পরিবেশে
Betaসীমিত সংখ্যক বাইরের ব্যবহারকারীনিজেদের আসল পরিবেশে ব্যবহারের অভিজ্ঞতারাজশাহী আর সিলেটের কয়েকশো ক্রেতা নিজের পুরোনো ফোন আর ধীর network-এ নতুন app ব্যবহার করে মতামত পাঠান

Alpha নির্মাতার জায়গায় বা নিয়ন্ত্রণে, beta ব্যবহারকারীর নিজের জায়গায় — তাই beta এমন সমস্যা ধরে যা test environment-এ তৈরি করা কঠিন (অদ্ভুত ফোন, দুর্বল network). Acceptance-এর পুরো প্রক্রিয়া, ATDD আর UAT-এর আয়োজন পর্ব ৪৪-এ (Acceptance testing — ATDD, UAT, alpha আর beta).

এক feature, চার level — delivery charge ধরে

এবার একটি নিয়ম ধরে দেখি, প্রতিটি level তার কোন দিকটি দেখে আর কোন ভুল ধরে। নিয়ম: “ঢাকার ভেতরে ডেলিভারি চার্জ ৬০ টাকা, বাইরে ১২০ টাকা।” “পরে” চাপুন; প্রতিটি ধাপে ডানের নোট পড়ুন।

  1. RequirementR-DEL-1৬০ / ১২০
  2. Componentdelivery()একা
  3. Integrationform → cartজোড়
  4. Systemcheckoutপুরো প্রবাহ
  5. AcceptanceUATমালিকের মত
R-DEL-1test basis
inside Dhaka   -> 60 taka
outside Dhaka  -> 120 taka
(spec says nothing about
 empty or misspelt district)
component testdriver: unittest
delivery("Dhaka") == 60 ok
delivery("Rajshahi") == 120 ok
delivery("")   -> ?  ask BA
no DB, no UI, no network
integrationদুটি জোড়
form sends "dhaka " (space)
delivery("dhaka ") -> 120
expected 60          FAIL
courier API wants "DHK",
we send "Dhaka"      FAIL
system testbrowser থেকে
login -> cart -> checkout
page 60, invoice 60, SMS 60
50 users: page < 2 s   ok
keyboard only          ok
UATমালিক আর ক্রেতা
buyer in Savar charged 120
owner: "Savar is Dhaka!"
"Dhaka" = city or district?
-> requirement must change
  1. Requirement — test basis. নিয়মটি এক লাইনের। খেয়াল করুন, ফাঁকা বা ভুল বানানের district হলে কী হবে, তা লেখা নেই। প্রতিটি level-এর test basis শেষ পর্যন্ত এই লাইন থেকেই আসে, তাই এখানকার অস্পষ্টতা ওপরের সব level-এ পৌঁছে যায়।
  2. Component level. শুধু delivery() function, unittest-কে driver হিসেবে নিয়ে। দুটি সাধারণ মান ঠিক আছে। ফাঁকা district-এর আচরণ requirement-এ নেই, তাই tester একটি প্রশ্ন তোলেন — এটিও test-এর ফল। এই level-এ database, UI বা network কিছুই নেই।
  3. Integration level — দুটি জোড়ে দুটি ভুল। Component integration: address form শেষে একটি ফাঁকা জায়গাসহ ছোট হাতের "dhaka " পাঠায়, ফলে ঢাকার ক্রেতার কাছে ১২০ টাকা। System integration: courier API district-এর code চায় ("DHK"), আমরা পাঠাচ্ছি নাম। দুটি component আলাদাভাবে সবুজ ছিল, ভুল ছিল মাঝখানে।
  4. System level. জোড়ের ভুল ঠিক করার পরে browser থেকে পুরো checkout: পাতায়, invoice-এ আর SMS-এ একই ৬০ টাকা। একই level-এ non-functional test-ও চলছে — ৫০ জন একসাথে checkout করলে পাতা ২ সেকেন্ডের কম সময়ে আসে, আর শুধু keyboard দিয়েও কাজ শেষ করা যায়।
  5. Acceptance level — validation. সব test সবুজ, তবু UAT-তে সাভারের এক ক্রেতা ১২০ টাকা দিলেন। মালিক বললেন, সাভার তো ঢাকা! সাভার ঢাকা জেলার ভেতরে, কিন্তু ঢাকা শহরের সিটি কর্পোরেশনের বাইরে। “ঢাকা” মানে শহর না জেলা — requirement-এ লেখা ছিল না। কোড spec মেনেছে, কিন্তু প্রয়োজন মেটেনি; ফল হলো requirement-এর সংশোধন।

শেষ ধাপের শিক্ষা: প্রতিটি level আলাদা প্রশ্নের উত্তর দেয়, তাই একটি level আরেকটির বদলি নয়। হাজারটি component test-ও “ঢাকা মানে কী” বলত না; আবার UAT-তে “dhaka ” আর “Dhaka”-র অমিল খোঁজা হতো ধীর আর ব্যয়বহুল। Requirement-এর এমন অস্পষ্টতা কোড লেখার আগেই ধরার উপায় পর্ব ০৪-এ (shift-left) আর পর্ব ০৬-এ (requirement review).

পাঁচ level এক টেবিলে

LevelTest objectTest basisসাধারণ defectসাধারণত কে
Componentdiscount(), delivery()component-এর নকশা, কোডভুল হিসাব, সীমার ভুলdeveloper
Component integrationcart + coupon, form + deliveryarchitecture, interfaceformat, একক, ক্রমের অমিলdeveloper, SDET
Systemপুরো বাজারঘরSRS, use case, user storyপ্রবাহের ভুল, non-functional ঘাটতিস্বাধীন test দল
System integrationবাজারঘর + courier, wallet mock, SMSবাইরের API-র চুক্তিচুক্তির অমিল, timeouttest দল, অন্য পক্ষ
Acceptanceচালু করার উপযুক্ত পুরো systemব্যবসার প্রয়োজন, চুক্তি, আইনভুল বোঝা প্রয়োজন, ব্যবহারে অসুবিধাব্যবহারকারী, মালিক, ops

V-model-এ কোন level কোন নকশার ধাপের সাথে জোড়া, তা পর্ব ০৪-এ (SDLC আর STLC-তে testing). Level-এর ক্রম সময়ের কঠোর ক্রম নয়: agile দলে একই sprint-এ তিন-চার level-এর test একসাথে চলে।

৫ · Test-এর ধরন — functional, non-functional, black-box আর white-box

Level ঠিক করে “কতটুকু”; type ঠিক করে “কোন গুণ”। চার রকম type প্রচলিত: functional, non-functional, black-box আর white-box — আর এদের পাশে বদলের সাথে সম্পর্কিত (change-related) test, যা পরের অংশে।

Functional testing — system কী করে

Functional testing দেখে system তার কাজগুলো ঠিকমতো করে কি না: coupon-এর হিসাব, delivery charge, অর্ডারের অবস্থা বদল, ভুল phone number-এ সতর্কবার্তা। ISO/IEC 25010-এর ভাষায় এটি functional suitability — কাজ সম্পূর্ণ (completeness), সঠিক (correctness) আর উপযুক্ত (appropriateness) কি না। প্রতিটি level-এই functional test হয়।

Non-functional testing — system কতটা ভালোভাবে করে

Non-functional testing দেখে কাজটি কেমনভাবে হয় — দ্রুত? নিরাপদে? সবার জন্য? নানা ফোনে? এর তালিকা আসে quality-র মডেল ISO/IEC 25010 থেকে, যার বিস্তারিত সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৩-এ। নিচের টেবিলে প্রতিটি গুণের জন্য বাজারঘরের একটি test idea, আর এই কোর্সে কোথায় গভীরে যাবেন:

Quality characteristicপ্রশ্নবাজারঘরের test ideaগভীরে
Performance efficiencyকত দ্রুত, কত ভিড় সামলায়?৫০ জন একসাথে checkout করলে ৯৫% অনুরোধ ২ সেকেন্ডের মধ্যে (performance testing)পর্ব ৪৬–৫১
Securityঅনুমতি ছাড়া কেউ কিছু দেখতে বা করতে পারে?URL-এ অন্যের order নম্বর বসালে তাঁর ঠিকানা দেখা যায় কি না (security testing)পর্ব ৫২–৫৩
Usability (২০২৩-এ interaction capability)মানুষ সহজে কাজ সারতে পারেন?নতুন ক্রেতা সাহায্য ছাড়া প্রথম অর্ডার দিতে পারেন কি না (usability testing); screen reader আর keyboard দিয়ে checkout (accessibility)পর্ব ৫৪–৫৬
Compatibilityনানা পরিবেশে চলে, অন্য system-এর সাথে মেলে?পুরোনো Android ফোনের browser আর ছোট পর্দায় cart (compatibility testing)পর্ব ৪২, ৫৭
Reliabilityভুল বা বিপর্যয়েও টেকে, ফিরে আসে?Wallet mock-এর উত্তর না এলে অর্ডার “pending” থাকে, হারিয়ে যায় না (reliability)পর্ব ৫৭, ৬৩
Maintainabilityবদলানো আর test করা সহজ?নতুন coupon নিয়ম যোগ করতে কতগুলো ফাইল বদলাতে হয়; static analysis-এর রিপোর্টপর্ব ০৬, ২৫
Portability (২০২৩-এ flexibility)অন্য পরিবেশে সরানো বা install করা যায়?নতুন cloud server-এ install script একবারে চলে কি নাপর্ব ৬৫

ISO/IEC 25010-এর ২০১১ সংস্করণে product quality-র আটটি characteristic. ২০২৩-এর সংশোধিত সংস্করণে (আমাদের জানামতে) safety নামে নবম characteristic যোগ হয়েছে আর কয়েকটি নাম বদলেছে (usability → interaction capability, portability → flexibility). বেশিরভাগ বই আর পরীক্ষা এখনো ২০১১-র নাম ব্যবহার করে; কাজের সময় কোন সংস্করণ ধরছেন, বলে নিন।

Non-functional test-এর পূর্বশর্ত: requirement মাপা যায় এমনভাবে লেখা। “Checkout দ্রুত হবে” দিয়ে pass-fail ঠিক হয় না; “৯৫% অনুরোধ ২ সেকেন্ডের মধ্যে” দিয়ে হয়। এ ধরনের test-ও যেকোনো level-এ হতে পারে — একটি function দশ হাজারবার ডাকার সময় মাপাও performance test.

Black-box আর white-box — test বানানোর সময় কী দেখছেন

তৃতীয় একটি ভাগ test-এর ভিত্তি নিয়ে। Black-box testing-এ test বানানো হয় শুধু বাইরের বিবরণ দেখে — requirement, spec, user story; ভেতরের কোড না জেনেই। “১০০০-এর ঠিক ওপরে আর ঠিক নিচে দেখি” একটি black-box চিন্তা। White-box testing-এ test বানানো হয় ভেতরের গঠন দেখে — কোডের প্রতিটি শাখা, শর্ত, loop. “এই if-এর দুই দিকই অন্তত একবার চালাই” একটি white-box চিন্তা।

দুটি পরস্পরের পরিপূরক: white-box test কোডে যা নেই (যেমন বাদ পড়া ৩০০ টাকার cap) তা কখনো ধরে না, আর black-box test spec-এ নেই এমন শাখা দেখে না। মডিউল ২ পুরোটাই এই কৌশলগুলো নিয়ে: black-box কৌশল পর্ব ০৭–১২-এ, white-box coverage পর্ব ১৩-এ, আর অভিজ্ঞতাভিত্তিক কৌশল (error guessing, exploratory) পর্ব ১৪-এ।

নিজে চালিয়ে দেখুন — test idea-কে level × type ছকে বসানো

বাজারঘরের ১৩টি test idea নিচে একটি তালিকায় আছে, প্রতিটির সাথে তার level আর type (F = functional, NF = non-functional, CH = change-related). কোডটি একটি dict-এ ছক বানিয়ে ছাপায়, তারপর ছকের ফাঁকা ঘর গোনে। প্রথমবার চালালে ব্রাউজারে Python (Pyodide) নামতে কয়েক সেকেন্ড লাগে।

ideas = [   # (id, level, type, test idea)  F / NF / CH = change-related
    ("T1", "component", "F", "discount(1500) == 150"),
    ("T2", "component", "NF", "10000 discount() calls < 50 ms"),
    ("T3", "comp-integ", "F", "cart -> coupon: taka, not poisha"),
    ("T4", "system", "F", "checkout saves order + charge"),
    ("T5", "system", "NF", "checkout < 2 s with 50 users"),
    ("T6", "system", "NF", "other user's order is hidden"),
    ("T7", "system", "NF", "checkout with keyboard only"),
    ("T8", "sys-integ", "F", "courier API gets district+charge"),
    ("T9", "sys-integ", "NF", "wallet mock timeout -> pending"),
    ("T10", "acceptance", "F", "owner tries coupon on real-like orders"),
    ("T11", "acceptance", "NF", "ops restores order DB from backup"),
    ("T12", "component", "CH", "retest B-17 after the fix"),
    ("T13", "system", "CH", "all checkout tests after the fix"),
]
levels = ["component", "comp-integ", "system", "sys-integ", "acceptance"]
kinds = ["F", "NF", "CH"]
table = {lv: {k: [] for k in kinds} for lv in levels}
for tid, lv, k, idea in ideas:
    table[lv][k].append(tid)

print(f"{'level':<11}" + "".join(f"{k:<10}" for k in kinds))
for lv in levels:
    row = "".join(f"{','.join(table[lv][k]) or '-':<10}" for k in kinds)
    print(f"{lv:<11}{row}")

gaps = [f"{lv}/{k}" for lv in levels for k in kinds if not table[lv][k]]
print("empty cells:", len(gaps))
for g in gaps:
    print("  ", g)

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

level      F         NF        CH        
component  T1        T2        T12       
comp-integ T3        -         -         
system     T4        T5,T6,T7  T13       
sys-integ  T8        T9        -         
acceptance T10       T11       -         
empty cells: 4
   comp-integ/NF
   comp-integ/CH
   sys-integ/CH
   acceptance/CH

প্রথম অংশটি ছক: সারিতে পাঁচ level, কলামে তিন type. table হলো dict-এর ভেতরে dict — table["system"]["NF"] মানে system level-এর non-functional test-এর তালিকা, এখানে T5, T6, T7 (performance, security, accessibility). or '-' ফাঁকা তালিকার বদলে একটি ড্যাশ বসায়। শেষ অংশ ১৫টি ঘরের মধ্যে ৪টি ফাঁকা ঘর দেখায়।

ফাঁকা ঘর মানেই ভুল নয়, এটি একটি প্রশ্ন। “comp-integ/NF”-এ ঝুঁকি সামান্য, বাদ রাখা যায়; কিন্তু “sys-integ/CH” ফাঁকা মানে courier API-র নতুন version এলে regression-এর পরিকল্পনা নেই — সম্ভবত সত্যিকারের ফাঁক। ছক বানিয়ে ফাঁক খোঁজা test plan-এর একটি কাজের অভ্যাস (পর্ব ১৭).

৬ · Retest বনাম regression — বদলের পরে দুই প্রশ্ন

বাজারঘরে একটি bug ধরা পড়েছে, নাম B-17: ৫০০০ টাকার অর্ডারে ৫০০ টাকা ছাড় হচ্ছে, অথচ নিয়মে সর্বোচ্চ ৩০০। Developer কোড ঠিক করলেন। এখন tester-এর সামনে দুটি আলাদা প্রশ্ন:

  1. ঠিক করা ভুলটি কি সত্যিই গেছে? যে test ব্যর্থ হয়েছিল, ঠিক সেটি নতুন কোডে আবার চালানো। এর নাম confirmation testing, প্রচলিত নাম retest.
  2. এই সংশোধন কি অন্য কিছু ভেঙেছে? আগে যা ঠিক চলত, তা এখনো চলে কি না — আগের সব (বা বাছাই করা) test আবার চালানো। এর নাম regression testing.

মোটরসাইকেলের ব্রেক ঠিক করাতে মিস্ত্রির কাছে গেলেন। ফেরত নিয়ে প্রথমে ব্রেক চেপে দেখেন — ঠিক হয়েছে? এটি retest. তারপর একটু চালিয়ে দেখেন — হর্ন বাজে, লাইট জ্বলে, গিয়ার ঠিক পড়ে? কারণ মিস্ত্রি ব্রেকের তার টানতে গিয়ে পাশের লাইটের তারে টান দিয়ে থাকতে পারেন। এটি regression.

এবার নিজে চালিয়ে দেখুন। প্রথম block-এ বাজারঘরের দুটি component (discount আর delivery), B-17-সহ প্রথম version, আর পাঁচটি unittest test. শেষ লাইনে পুরো suite চলে।

import unittest, sys

def discount(subtotal):              # v1: bug B-17, no 300 taka cap
    if subtotal > 1000:
        return subtotal * 10 // 100
    return 0

def delivery(district):
    return 60 if district == "Dhaka" else 120

class ShopTests(unittest.TestCase):
    def test_no_discount_at_1000(self):
        self.assertEqual(discount(1000), 0)
    def test_ten_percent_above_1000(self):
        self.assertEqual(discount(1500), 150)
    def test_cap_300(self):                  # written for B-17
        self.assertEqual(discount(5000), 300)
    def test_delivery_dhaka(self):
        self.assertEqual(delivery("Dhaka"), 60)
    def test_delivery_outside(self):
        self.assertEqual(delivery("Rajshahi"), 120)

def run(*names):
    if names:
        suite = unittest.TestSuite(ShopTests(n) for n in names)
    else:
        suite = unittest.TestLoader().loadTestsFromTestCase(ShopTests)
    unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)

run()

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

test_cap_300 (__main__.ShopTests.test_cap_300) ... FAIL
test_delivery_dhaka (__main__.ShopTests.test_delivery_dhaka) ... ok
test_delivery_outside (__main__.ShopTests.test_delivery_outside) ... ok
test_no_discount_at_1000 (__main__.ShopTests.test_no_discount_at_1000) ... ok
test_ten_percent_above_1000 (__main__.ShopTests.test_ten_percent_above_1000) ... ok

======================================================================
FAIL: test_cap_300 (__main__.ShopTests.test_cap_300)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 17, in test_cap_300
    self.assertEqual(discount(5000), 300)
    ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^
AssertionError: 500 != 300

----------------------------------------------------------------------
Ran 5 tests in 0.001s

FAILED (failures=1)

লাইন ধরে পড়ুন। discount-এ শর্ত > 1000 ঠিক আছে, কিন্তু min(…, 300) নেই — এটাই B-17. ShopTests একটি unittest.TestCase; এর ভেতরের প্রতিটি test_ দিয়ে শুরু হওয়া method একটি test, আর assertEqual(আসল, প্রত্যাশিত) দুটি মান মেলায়। run() কোনো নাম না পেলে TestLoader দিয়ে class-এর সব test নেয় (নামের বর্ণানুক্রমে, তাই test_cap_300 আগে চলে); নাম পেলে শুধু সেগুলো নিয়ে একটি test suite বানায়। verbosity=2 প্রতিটি test-এর নাম আর ফল আলাদা লাইনে দেখায়।

ফল: পাঁচটির মধ্যে একটি FAIL. AssertionError: 500 != 300 মানে function দিয়েছে ৫০০, test চেয়েছিল ৩০০ — B-17 হাতেনাতে ধরা পড়েছে। বাকি চারটি ok; এই চারটিই পরে regression-এর পাহারাদার।

Developer সংশোধন করলেন। সংশোধনের সময় তিনি শর্তটিও “পরিষ্কার” করে নতুন করে লিখলেন — আর ভুলে >-এর বদলে >= লিখে ফেললেন। নিচের block আগেরটির সাথে একই namespace-এ চলে (data-shared), তাই test আর run() আবার লিখতে হয়নি; শুধু discount-এর নতুন version বসেছে। আগের block না চালিয়ে এটি চালালে run পাওয়া যাবে না।

def discount(subtotal):              # v2: fix for B-17
    if subtotal >= 1000:             # condition rewritten during the fix
        return min(subtotal * 10 // 100, 300)
    return 0

print("== retest: only the B-17 test")
run("test_cap_300")
print("== regression run: every test")
run()

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

== retest: only the B-17 test
test_cap_300 (__main__.ShopTests.test_cap_300) ... ok

----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
== regression run: every test
test_cap_300 (__main__.ShopTests.test_cap_300) ... ok
test_delivery_dhaka (__main__.ShopTests.test_delivery_dhaka) ... ok
test_delivery_outside (__main__.ShopTests.test_delivery_outside) ... ok
test_no_discount_at_1000 (__main__.ShopTests.test_no_discount_at_1000) ... FAIL
test_ten_percent_above_1000 (__main__.ShopTests.test_ten_percent_above_1000) ... ok

======================================================================
FAIL: test_no_discount_at_1000 (__main__.ShopTests.test_no_discount_at_1000)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 13, in test_no_discount_at_1000
AssertionError: 100 != 0

----------------------------------------------------------------------
Ran 5 tests in 0.000s

FAILED (failures=1)

Retest অংশে শুধু test_cap_300 চলেছে, ফল OK — B-17 সত্যিই গেছে। এখানে থেমে গেলে দল ভাবত কাজ শেষ। Regression run পাঁচটিই চালায়, আর এবার অন্য একটি test ব্যর্থ: test_no_discount_at_1000, 100 != 0. অর্থাৎ ঠিক ১০০০ টাকার অর্ডারে এখন ১০০ টাকা ছাড় হচ্ছে, অথচ নিয়ম বলে ১০০০-এর বেশি হলে তবেই। এই test আগের run-এ পাস করেছিল; সংশোধন একটি নতুন defect এনেছে — এটাই regression.

দুটি test-ই component level-এর: retest আর regression level নয়, type — যেকোনো level-এ হতে পারে। পার্থক্য উদ্দেশ্যে: ঠিক করা ভুলটি দেখা, নাকি বাকি সব ঠিক আছে কি না।

নিচের stepper একই ঘটনাকে ধাপে ধাপে দেখায়, আর শেষে তৃতীয় version (v3)-ও যোগ করে, যেখানে শর্ত আবার > করা হয়েছে (v3-এর ফল lab-এ আলাদা script-এ যাচাই করা)। টেবিলে test-এর নাম ছোট করে লেখা ; যেমন cap_300 মানে test_cap_300 নামের test.

v1B-17 সহ
if subtotal > 1000:
    return subtotal*10//100
v2B-17-এর সংশোধন
if subtotal >= 1000:
    d = subtotal * 10 // 100
    return min(d, 300)
v3দ্বিতীয় সংশোধন
if subtotal > 1000:
    d = subtotal * 10 // 100
    return min(d, 300)
Test-এর ফল (— = চালানো হয়নি)
cap_300
delivery_dhaka
delivery_out
no_discount_1000
above_1000
  1. v1, পুরো suite. পাঁচটির মধ্যে শুধু cap_300 ব্যর্থ: ৫০০০ টাকায় এসেছে ৫০০, চাওয়া হয়েছিল ৩০০. Tester bug B-17 লেখেন — সাথে এই test-এর নাম আর আসল ফল।
  2. Developer v2 দিলেন। Cap যোগ হয়েছে, কিন্তু শর্তে >= এসে গেছে। নতুন কোডে এখনো কোনো test চলেনি, তাই সব ঘরে প্রশ্নবোধক চিহ্ন — “developer বলেছেন ঠিক হয়েছে” মানে এখনো কিছু যাচাই হয়নি।
  3. Retest (confirmation). শুধু cap_300 চালানো হলো: OK. B-17 বন্ধ করা যায়। বাকি চারটি চালানো হয়নি, তাই ঘরে ড্যাশ। এখানে থামলে নতুন defect-টি release পর্যন্ত চলে যেত।
  4. Regression run. পাঁচটিই আবার চালানো হলো। cap_300 ঠিক আছে, কিন্তু no_discount_1000 (পুরো নাম test_no_discount_at_1000) এখন FAIL: ঠিক ১০০০ টাকায় ১০০ টাকা ছাড়। আগে পাস করা test এখন ব্যর্থ — regression ধরা পড়ল, নতুন bug লেখা হলো।
  5. v3 আর আবার পুরো suite. শর্ত আবার > করা হলো। এবারও আগে নতুন bug-এর retest, তারপর পুরো regression: পাঁচটিই ok. শুধু তখনই বলা যায়, এই বদল নিরাপদ।

বাস্তবে regression suite-এ হাজার হাজার test থাকে; প্রতিটি বদলের পরে সব চালানো সময়সাপেক্ষ, তাই impact analysis করে বাছাই করা হয় কোন অংশ বদলে প্রভাবিত হতে পারে। এই কারণেই regression test সাধারণত সবার আগে automate করা হয়: বারবার চলে, প্রতিবার একই কাজ। বড় suite থেকে test বাছাইয়ের কৌশল পর্ব ৬৮-এ (বড় test suite — selection, sharding).

৭ · Smoke, sanity আর regression — release-এর দিন

নতুন build test environment-এ এলেই কি দুই দিনের পুরো test শুরু? না। আগে দেখা দরকার build আদৌ test করার যোগ্য কি না। এই দ্রুত, চওড়া কিন্তু অগভীর যাচাইয়ের নাম smoke test — অ্যাপ খোলে? login হয়? পণ্য খোঁজা যায়? cart-এ যায়? checkout পাতা খোলে? নকল payment শেষ হয়? প্রতিটি প্রধান পথ একবার করে, খুঁটিনাটিতে না গিয়ে। Smoke-এ ব্যর্থ হলে build ফেরত যায়, আর দলের দুই দিন বাঁচে।

Sanity test সাধারণত বোঝায় একটি ছোট বদলের পরে শুধু সেই এলাকাটি দ্রুত কিন্তু একটু গভীরে দেখা — যেমন coupon-এর হিসাবে ছোট সংশোধনের পরে coupon-এর কয়েকটি গুরুত্বপূর্ণ case. Smoke চওড়া আর অগভীর; sanity সরু আর একটু গভীর। আর regression হলো সবচেয়ে চওড়া আর গভীর — পুরো suite বা ঝুঁকি ধরে বাছাই করা বড় অংশ।

সংজ্ঞায় মতভেদ: smoke আর sanity নিয়ে বই আর দলভেদে মতভেদ অনেক; কেউ দুটিকে সমার্থক ধরেন, কেউ উল্টো সংজ্ঞাও লেখেন। উত্তর দেওয়ার সময় এক লাইনে বলে নিন কোন সংজ্ঞা ধরছেন।

নিচের stepper বাজারঘরের একটি কাল্পনিক release-এর দিন দেখায়। সময়, build নম্বর আর test-এর সংখ্যা কাল্পনিক, কিন্তু ক্রমটি বাস্তব দলের মতো।

  1. Build2.4.0এলো
  2. Smoke12 checksচওড়া, অগভীর
  3. Sanity9 checksসরু, গভীর
  4. Regression240 testsচওড়া, গভীর
  5. Release2.4.3সিদ্ধান্ত
Test lead-এর খাতা
সময়
Build
কী চলল
Test
ফল
  1. ০৯:০০ — build 2.4.0 এলো। এতে আছে B-17-এর সংশোধন আর অর্ডারের খবর SMS-এ পাঠানোর নতুন feature. দল এখনো কিছু চালায়নি। প্রথম প্রশ্ন: এই build কি আদৌ test করার যোগ্য?
  2. ০৯:১০ — smoke, ১২টি যাচাই। অ্যাপ খোলা, login, খোঁজা, cart, checkout পাতা, নকল payment, order status… ১১টি ঠিক, কিন্তু login ব্যর্থ। Login ছাড়া প্রায় কিছুই test করা যায় না, তাই build প্রত্যাখ্যাত। খরচ মাত্র দশ মিনিট।
  3. ১১:০০ — build 2.4.1, আবার smoke. Login-এর সংশোধনসহ নতুন build-এ একই ১২টি যাচাই, সবগুলো ঠিক। Build গ্রহণ করা হলো; এবার গভীর test শুরু।
  4. ১৪:০০ — build 2.4.2, sanity. দুপুরে coupon-এর হিসাবে ছোট একটি সংশোধন এলো। পুরো suite না চালিয়ে শুধু coupon এলাকার ৯টি গুরুত্বপূর্ণ case — ১০০০-এর দুই পাশ, cap-এর সীমা, coupon ছাড়া অর্ডার। সবগুলো ঠিক।
  5. ১৫:০০ — regression, ২৪০টি test. Release-এর আগে পুরো automated suite. ২৩৯টি ঠিক, একটি ব্যর্থ: SMS-এ delivery charge ভুল দেখাচ্ছে — নতুন SMS feature পুরোনো হিসাবের সাথে ঠিক জোড়েনি। নতুন bug লেখা হলো।
  6. ১৮:০০ — build 2.4.3, retest আর regression. SMS-এর সংশোধনের পরে প্রথমে সেই একটি ব্যর্থ test-এর retest, তারপর আবার পুরো ২৪০টির regression. সব ঠিক, release-এর সিদ্ধান্ত।
SmokeSanityRegression
প্রশ্নbuild কি test-এর যোগ্য?বদলানো এলাকা কি যুক্তিসংগত আচরণ করছে?বদলে আগের কিছু ভাঙল?
পরিসরচওড়া, অগভীরসরু, একটু গভীরচওড়া, গভীর
কখনপ্রতিটি নতুন build-এর শুরুতেছোট সংশোধন বা hotfix-এর পরেrelease-এর আগে, নিয়মিত (প্রতি রাতে বা প্রতি merge-এ)
সময়মিনিটমিনিট থেকে ঘণ্টাঘণ্টা (automation-এ কম)

৮ · Maintenance testing — চালু system-এ বদল

বাজারঘর চালু হওয়ার পরেও কাজ শেষ নয়। নতুন coupon নিয়ম আসে, wallet-এর API-র নতুন version আসে, server বদলায়, পুরোনো feature বন্ধ হয়। চালু (production-এ থাকা) system-এ এমন যেকোনো বদলের সময়ের test হলো maintenance testing. এর তিনটি প্রধান কারণ বা trigger:

Modification (বদল)

পরিকল্পিত নতুন feature, জরুরি bug fix, operating system বা database-এর upgrade, নিরাপত্তা patch.

যেমন: ঈদের জন্য নতুন coupon

Migration (স্থানান্তর)

এক platform বা server থেকে আরেকটিতে সরানো, পুরোনো data নতুন গঠনে রূপান্তর।

যেমন: order database নতুন server-এ

Retirement (অবসর)

একটি অংশ বা পুরো system বন্ধ করা — data সংরক্ষণ, পরে ফেরানো যায় কি না।

যেমন: পুরোনো cash-on-delivery module

Migration-এ “নতুন server-এ পাতা খোলে” যথেষ্ট নয়: অর্ডারের সংখ্যা আর মোট টাকা দুই database-এ মেলে কি না, বাংলা নাম-ঠিকানা ভাঙেনি তো — এসবও দেখতে হয়। Retirement-এ প্রশ্ন: বন্ধ module-এর পুরোনো অর্ডার কি যতদিন রাখা দরকার ততদিন খুঁজে পাওয়া যায়?

Maintenance testing-এর দুটি অংশ: বদলানো অংশটি নিজে ঠিক কাজ করছে কি না (প্রায়ই retest আর নতুন test), আর বাকি system-এ বদলের প্রভাব (regression). কতটা regression লাগবে, ঠিক করে impact analysis: কোন module বদলেছে, কে কে তাকে ডাকে, কোন data-র গঠন বদলেছে, কোন ঝুঁকি বেশি।

দুটি নাম গুলিয়ে ফেলবেন না: maintenance testing হলো চালু system-এ বদলের সময়ের test (কখন আর কেন test করছেন)। Maintainability testing হলো একটি non-functional type — system বদলানো কতটা সহজ, সেটি মাপা (কোন গুণ দেখছেন)। প্রথমটি একটি পরিস্থিতি, দ্বিতীয়টি একটি গুণ।

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

  • Test level আর test type-এর পার্থক্য? Level বলে পরিসর (component থেকে acceptance), type বলে কোন গুণ (functional, performance…); যেকোনো type যেকোনো level-এ হতে পারে।
  • Retest আর regression testing-এর পার্থক্য? Retest দেখে ঠিক করা defect সত্যিই গেছে কি না; regression দেখে বদলের ফলে অন্য কিছু ভাঙল কি না।
  • Alpha বনাম beta? Alpha নির্মাতার জায়গায় বা নিয়ন্ত্রণে, ভেতরের বা বাছাই করা মানুষ দিয়ে; beta ব্যবহারকারীর নিজের পরিবেশে, সীমিত বাইরের মানুষ দিয়ে।
  • Smoke বনাম sanity? Smoke চওড়া-অগভীর, build-এর যোগ্যতা দেখে; sanity সরু-গভীর, ছোট বদলের এলাকা দেখে — আর বলে নিন যে সংজ্ঞায় মতভেদ আছে।
  • Maintenance testing কখন হয়? চালু system-এ modification, migration বা retirement-এর সময়; impact analysis দিয়ে regression-এর পরিসর ঠিক হয়।

৯ · Test pyramid — প্রথম দেখা

সব level-এ সমান সংখ্যক test রাখা লাভজনক নয়। Component test দ্রুত (মিলিসেকেন্ড), সস্তা, আর ব্যর্থ হলে ঠিক কোথায় ভুল তা বলে দেয়। Browser-চালিত end-to-end (E2E) test ধীর (সেকেন্ড থেকে মিনিট), পরিবেশের ওপর নির্ভরশীল, আর মাঝে মাঝে কোনো কারণ ছাড়াই ব্যর্থ হয়। এই যুক্তি থেকে test pyramid নামের ছবি: নিচে অনেক component test, মাঝে কম integration বা API test, ওপরে অল্প কয়েকটি UI বা E2E test. ধারণাটি সাধারণত Mike Cohn-এর নামে পরিচিত, যিনি ২০০৯ সালের বই “Succeeding with Agile”-এ এটি জনপ্রিয় করেন।

Test pyramid — কোন স্তরে কতগুলো test

Many fast component tests at the base, fewer slow end-to-end tests at the top

Test pyramid: component at the base, integration in the middle, end-to-end at the top E2E/UI Integration API, জোড় Component অনেক, দ্রুত ধীর দ্রুত
ছবি ৫.২ — ওপরে গেলে প্রতিটি test বেশি অংশ একসাথে চালায়, তাই বাস্তবের কাছাকাছি, কিন্তু ধীর আর ভঙ্গুর। নিচে গেলে উল্টো। Pyramid কোনো কঠোর নিয়ম নয় — একটি অনুপাতের পরামর্শ।

দুটি সতর্কতা। প্রথমত, pyramid-এর স্তর আর test level হুবহু এক জিনিস নয়: pyramid-এর “integration” স্তরে component integration আর system integration দুটিই পড়ে, আর acceptance test অনেক সময় E2E হিসেবে ওপরে বসে। দ্বিতীয়ত, উল্টো আকার — ওপরে অনেক manual আর UI test, নিচে প্রায় কিছু নেই — একটি পরিচিত ভুল, যাকে “ice-cream cone” বলা হয়। Exploratory বা usability-র মতো মানুষের হাতের test pyramid-এর ভেতরে নয়, পাশে থাকে।

Pyramid-এর হিসাব, trophy আর honeycomb-এর মতো বিকল্প আকার আছে সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫১-এ আর ফুল-স্ট্যাক ওয়েব ফ্রেমওয়ার্ক কোর্সের পর্ব ৭২-এ। এই কোর্সে CI pipeline-এ কোন test কখন চলবে তা পর্ব ৬৪-এ, আর বড় suite-এর রক্ষণাবেক্ষণ পর্ব ৬৮-এ।

আরও গভীরে: Level আর type-এর আনুষ্ঠানিক সংজ্ঞা ও প্রক্রিয়া আছে আন্তর্জাতিক মানদণ্ড ISO/IEC/IEEE 29119-এ (প্রথম খণ্ডগুলো ২০১৩ সালে প্রকাশিত, পরে সংশোধিত), যা পুরোনো IEEE 829-এর জায়গা নিয়েছে। কিছু বড় প্রতিষ্ঠান level-এর বদলে test-এর “আকার” (small, medium, large) দিয়ে ভাগ করে — test কতটা সম্পদ ব্যবহার করতে পারে (একটি process, একটি যন্ত্র, নাকি network) — যার বর্ণনা আছে “Software Engineering at Google” (২০২০) বইয়ে। Microservice-এর জগতে “system” কোনটি, তা-ই অস্পষ্ট হয়ে যায়; তাই level-কে একটি চিন্তার কাঠামো হিসেবে নিন, অলঙ্ঘ্য নিয়ম হিসেবে নয়।

১০ · AI-এর যুগে — AI দিয়ে test idea, কিন্তু যাচাই আপনার

AI assistant-এর কাছে checkout-এর test case চাইলে কয়েক সেকেন্ডে পেশাদার-দেখতে তালিকা আসে, কিন্তু তাতে সাধারণত কয়েকটি পরিচিত সমস্যা থাকে:

  • প্রায় সব test সুখী পথের (happy path) — সঠিক ইনপুট, সব ঠিকঠাক; ভুল phone number, ফাঁকা district, ঠিক ১০০০ টাকার সীমা বাদ।
  • প্রায় সব test functional আর system level-এর; non-functional (গতি, accessibility, নিরাপত্তা) আর integration-এর জোড় খুব কম।
  • কোড দেখিয়ে test লিখতে বললে AI প্রায়ই কোড এখন যা করে তা-ই assert করে, requirement যা বলে তা নয়। ওপরের v2 দেখালে সে হয়তো লিখত discount(1000) == 100 — একটি test যা ভুল কোডেও সবুজ।
  • নেই এমন API field বা tool option বানায়, অপেক্ষার জন্য sleep বসায়, আর এত mock বসায় যে আসল কিছুই test হয় না।
  • চালানো ছাড়াই বলে “সব test পাস করবে”।

AI-কে কাজে লাগানোর ভালো উপায়: তাকে ছক বানাতে আর ফাঁক খুঁজতে দিন, কিন্তু requirement নিজে দিন আর উত্তর যাচাই করুন। নিচের prompt-এ দেখুন, AI-কে level × type ছক মানতে বলা হয়েছে আর অনুমান আলাদা করে চিহ্নিত করতে বলা হয়েছে:

তুমি একজন অভিজ্ঞ QA engineer. নিচের requirement-গুলো একটি কাল্পনিক অনলাইন দোকানের: - ১০০০ টাকার বেশি অর্ডারে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা - ঢাকার ভেতরে ডেলিভারি চার্জ ৬০ টাকা, বাইরে ১২০ টাকা - checkout-এ phone number বাধ্যতামূলক ১. প্রতিটি test idea-কে একটি level (component, component integration, system, system integration, acceptance) আর একটি type (functional, non-functional-এর কোন গুণ, change-related) দিয়ে টেবিলে লেখো। ২. প্রতিটি test-এর প্রত্যাশিত ফল requirement থেকে নাও, কোড থেকে নয়। requirement-এ উত্তর না থাকলে "অস্পষ্ট — প্রশ্ন" লেখো, নিজে বানিয়ো না। ৩. সীমার মান (ঠিক ১০০০, ১০০১, যেখানে ছাড় ৩০০ ছোঁয়) আলাদা করে রাখো। ৪. শেষে বলো ছকের কোন ঘর ফাঁকা রইল আর কেন। কোনো tool-এর option বা API field লিখলে তার অফিসিয়াল নথির নাম বলো।

AI-এর দেওয়া test বা test idea হাতে পেলে — চেকলিস্ট

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

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

প্র ০১Ariane 5 রকেটের প্রথম উড্ডয়ন (১৯৯৬) কোন test level-এ ধরা পড়তে পারত?

১৯৯৬ সালের ৪ জুন ইউরোপের Ariane 5 রকেট প্রথম উড্ডয়নের প্রায় ৩৭ সেকেন্ড পরে পথ হারিয়ে ধ্বংস হয়। তদন্ত বোর্ডের (Jacques-Louis Lions-এর নেতৃত্বে) প্রকাশিত প্রতিবেদন অনুযায়ী, দিক নির্ণয়ের যন্ত্রের (inertial reference system) software-টি আগের Ariane 4 থেকে প্রায় অপরিবর্তিত নেওয়া হয়েছিল। একটি গতি-সম্পর্কিত মানকে 64-bit দশমিক সংখ্যা থেকে 16-bit পূর্ণসংখ্যায় রূপান্তরের সময় মানটি সীমা ছাড়িয়ে যায়, আর ব্যতিক্রম (exception) সামলানো হয়নি। Ariane 4-এর পথে মানটি কখনো এত বড় হতো না; Ariane 5 শুরুতেই দ্রুততর ছিল। বিকল্প যন্ত্রটিতে একই software ছিল, তাই সেটিও একইভাবে ব্যর্থ হয়।

Component level: function-টি নিজে Ariane 4-এর জন্য “ঠিক” ছিল। Component test-এর test basis ছিল Ariane 4-এর বিবরণ, তাই সেখানে ভুল ধরার উপায় কম। System level: প্রতিবেদন অনুযায়ী, Ariane 5-এর আসল উড্ডয়ন-পথের data দিয়ে এই যন্ত্রসহ পুরো system-এর বাস্তবসম্মত test হয়নি; কিছু simulation-এ যন্ত্রটির জায়গায় নকল মডেল ব্যবহার হয়েছিল। এই অর্থে, নতুন পরিবেশে পুনর্ব্যবহৃত অংশটির system বা system integration test-এ নতুন পথের data দিলে ব্যর্থতা দেখা যেতে পারত। Test basis-এর প্রশ্ন: সমস্যার মূলে ছিল অনুমান — “Ariane 4-এ কাজ করেছে, তাই এখানেও করবে।” পুনর্ব্যবহারের সময় পুরোনো requirement নতুন প্রেক্ষাপটে আবার পর্যালোচনা হয়নি।

এখানে maintenance testing-এর একটি শিক্ষাও আছে: পুনর্ব্যবহার একরকম migration — পুরোনো component নতুন system-এ। আর যে অংশটি ব্যর্থ হয়, প্রতিবেদন অনুযায়ী উড্ডয়নের পরে Ariane 5-এ তার কোনো কাজই ছিল না; অপ্রয়োজনীয় কোড চালু রাখাও ঝুঁকি। তাই পুনর্ব্যবহৃত component-এর জন্য নতুন system-এর আসল মানের পরিসর ধরে নতুন test basis লেখা উচিত, পুরোনো test-এর সবুজ ফল ধার করা নয়।

মূল উপলব্ধি: প্রতিটি level তার test basis-এর চেয়ে বেশি দেখতে পারে না। পরিবেশ বা প্রেক্ষাপট বদলালে test basis বদলায়, আর তখন component-এর “পাস” ফল পুরোনো প্রশ্নের উত্তর মাত্র।

প্র ০২Mars Climate Orbiter (১৯৯৯) — দুই পক্ষের software আলাদাভাবে ঠিক থাকলেও জোড়ে কেন ভুল হয়?

১৯৯৯ সালের সেপ্টেম্বরে NASA-র Mars Climate Orbiter মঙ্গলের কক্ষপথে ঢোকার সময় হারিয়ে যায়। Mishap Investigation Board-এর প্রতিবেদন অনুযায়ী মূল কারণ ছিল এককের অমিল: মহাকাশযানের ছোট ছোট গতি-সংশোধনের হিসাব যে ground software তৈরি করত, তা ফল দিত ইংরেজি এককে (pound-force second), অথচ navigation দলের software ধরে নিয়েছিল মেট্রিক একক (newton-second) — যা দুই পক্ষের interface-এর নথিতেই চাওয়া হয়েছিল। দুই এককের অনুপাত প্রায় ৪.৪৫, ফলে মাসের পর মাস ছোট ছোট ভুল জমে মহাকাশযান পরিকল্পনার চেয়ে অনেক নিচ দিয়ে মঙ্গলের কাছে পৌঁছায়।

Test level-এর চোখে দেখুন। প্রতিটি পক্ষের component test তার নিজের test basis অনুযায়ী পাস করতে পারত — একটি ঠিকভাবে pound-force second হিসাব করছে, অন্যটি ঠিকভাবে যা পাচ্ছে তা ব্যবহার করছে। ভুলটা কোনো component-এর ভেতরে নয়, জোড়ের চুক্তিতে। এটি ঠিক সেই ধরনের defect যা system integration testing-এর জন্য তৈরি: দুই দলের, দুই প্রতিষ্ঠানের, বা দুই system-এর মাঝখানের data কি চুক্তি মানছে? প্রতিবেদন এছাড়া প্রক্রিয়ার দুর্বলতাও দেখায় — navigation দলের কিছু সদস্য অস্বাভাবিকতা লক্ষ করেছিলেন, কিন্তু সেটি যথেষ্ট জোরালোভাবে তোলা বা সমাধান করা হয়নি।

বাজারঘরের পয়সা বনাম টাকার উদাহরণ এর ছোট রূপ: cart যদি 150000 পাঠায় (পয়সায়) আর coupon ধরে নেয় টাকা, তাহলে দুটি component আলাদাভাবে নিখুঁত হয়েও ক্রেতা ৩০০ টাকার বদলে অদ্ভুত ছাড় পাবেন। এই কারণেই এখন অনেক দল contract test (পর্ব ৩২) দিয়ে interface-এর চুক্তি স্বয়ংক্রিয়ভাবে মিলিয়ে দেখে, আর একক নামের অংশ হিসেবে লেখে (amount_poisha).

মূল উপলব্ধি: দুটি সবুজ component test মিলে একটি সবুজ integration হয় না। জোড়ের প্রতিটি অনুমান — একক, format, ক্রম, ভুলের নিয়ম — আলাদা test দাবি করে।

প্র ০৩HealthCare.gov (২০১৩) — শেষ মুহূর্তের system test আর non-functional test বাদ দিলে কী হয়?

২০১৩ সালের ১ অক্টোবর যুক্তরাষ্ট্রের সরকারি স্বাস্থ্যবিমার ওয়েবসাইট HealthCare.gov চালু হয়, আর প্রথম দিন থেকেই বেশিরভাগ মানুষ account খুলতে বা আবেদন শেষ করতে পারেননি। প্রকাশিত প্রতিবেদন আর মার্কিন কংগ্রেসের শুনানিতে উঠে আসে, বেশ কয়েকটি ঠিকাদার প্রতিষ্ঠান আলাদা আলাদা অংশ বানিয়েছিল, আর পুরো system একসাথে জোড়া লাগিয়ে end-to-end test হয়েছিল উদ্বোধনের মাত্র সপ্তাহ দুয়েক আগে — যেখানে স্বাভাবিকভাবে মাসের পর মাস লাগার কথা। প্রত্যাশিত ভিড়ে system কেমন আচরণ করবে, সেই load test-ও যথেষ্ট আগে ও যথেষ্ট পরিসরে হয়নি বলে জানা যায়।

Test level-এর ভাষায় এখানে তিনটি ফাঁক। প্রথম, component আর component integration level-এ প্রতিটি ঠিকাদারের অংশ হয়তো চলেছিল, কিন্তু system integration — বিভিন্ন সরকারি data উৎস আর অংশগুলোর জোড় — দেরিতে আর তাড়াহুড়োয়। দ্বিতীয়, non-functional গুণ (performance efficiency, reliability) দেখার জন্য যে বাস্তবসম্মত পরিবেশ আর সময় দরকার, তা ছিল না; কার্যকরী test পাস করা system-ও লাখো মানুষের ভিড়ে ভেঙে পড়তে পারে। তৃতীয়, release-এর তারিখ আগে থেকে ঠিক ছিল, তাই test-এর ফল সিদ্ধান্তকে প্রভাবিত করার সুযোগ ছিল সামান্য — acceptance-এর মূল প্রশ্ন “আমরা কি প্রস্তুত?” কার্যত জিজ্ঞেসই হয়নি।

পরে একটি বিশেষ দল কয়েক সপ্তাহ ধরে monitoring যোগ করে, bottleneck খুঁজে, অংশে অংশে system স্থিতিশীল করে। তাদের কাজের বড় অংশই ছিল আসলে দেরিতে করা system আর performance testing — এবার production-এ, আসল মানুষের ওপর। বাজারঘরের মতো ছোট দোকানেও শিক্ষাটি একই: ঈদের আগের ভিড়ের অনেক আগেই পুরো checkout-এর system test আর load test-এর সময় পরিকল্পনায় রাখুন।

মূল উপলব্ধি: System আর non-functional test শেষ মুহূর্তের আনুষ্ঠানিকতা নয়। এগুলোর জন্য সময়, বাস্তবসম্মত পরিবেশ আর release থামানোর অধিকার আগে থেকে পরিকল্পনায় রাখতে হয় — নইলে আপনার ব্যবহারকারীরাই আপনার load test হয়ে যান।

প্র ০৪Y2K সমস্যা — ইতিহাসের সবচেয়ে বড় maintenance testing কি সফল ছিল, নাকি অকারণ ভয়?

১৯৬০ থেকে ৮০-র দশকে স্মৃতি দামি ছিল, তাই অনেক software সালের শুধু শেষ দুই অঙ্ক রাখত — ১৯৮৫ মানে 85. ২০০০ সালে 00 এলে হিসাব ভেঙে পড়ার ভয় ছিল: বয়স ঋণাত্মক, সুদের হিসাব উল্টো, মেয়াদ “একশো বছর আগে” শেষ। ১৯৯০-এর দশকের শেষ ভাগে সারা পৃথিবীর ব্যাংক, বিদ্যুৎ, বিমান, সরকারি দপ্তর পুরোনো কোড খুঁজে খুঁজে বদলায় — আর বিপুল পরিমাণ test চালায়।

এটি maintenance testing-এর পাঠ্যপুস্তকীয় উদাহরণ। Impact analysis: কোথায় কোথায় তারিখ ব্যবহার হয়, কোন হিসাব তার ওপর নির্ভর করে — প্রায়ই নথি ছাড়া, এমন ভাষায় লেখা কোডে যা জানা মানুষ কমে গেছে। Retest: প্রতিটি সংশোধিত তারিখের হিসাব। Regression: সংশোধন অন্য কিছু ভাঙল কি না। System আর system integration test: অনেক প্রতিষ্ঠান কম্পিউটারের ঘড়ি এগিয়ে ২০০০ সালে নিয়ে পুরো system চালিয়ে দেখে, আর অন্য প্রতিষ্ঠানের সাথে data আদান-প্রদান পরীক্ষা করে। একটি সূক্ষ্ম boundary-ও ছিল: ২০০০ সাল অধিবর্ষ (৪০০ দিয়ে বিভাজ্য), অথচ কিছু কোড “১০০ দিয়ে বিভাজ্য হলে অধিবর্ষ নয়” নিয়মের অর্ধেকটা মেনে ২৯ ফেব্রুয়ারিকে বাদ দিত।

১ জানুয়ারি ২০০০-এ বড় কোনো বিপর্যয় ঘটেনি, কিছু ছোট ঘটনা ঘটেছিল। এরপর বিতর্ক শুরু: সব খরচ কি অকারণ ছিল? অনেক প্রকৌশলীর যুক্তি, বিপর্যয় হয়নি ঠিক কারণ আগে থেকে কাজ হয়েছিল — ভালো testing-এর সাফল্য প্রায়ই অদৃশ্য। অন্যদিকে, ঝুঁকির মাত্রা কোথাও কোথাও বাড়িয়ে বলা হয়েছিল, এই সমালোচনাও আছে। দুই পক্ষের দাবিই পুরোপুরি প্রমাণ করা কঠিন।

মূল উপলব্ধি: চালু system-এ একটি ছোট অনুমান (দুই অঙ্কের সাল) বদলাতে হলে বদলের চেয়ে বেশি পরিশ্রম লাগে প্রভাব খুঁজতে আর regression চালাতে। আর testing-এর সাফল্য মাপা কঠিন, কারণ সফল হলে “কিছুই ঘটে না”।

প্র ০৫“Unit” কত বড় — একটি function, একটি class, নাকি একটি আচরণ? Level-এর সীমা কে ঠিক করে?

শুনতে সহজ, কিন্তু এ নিয়ে অভিজ্ঞ মানুষদের মধ্যেও মতভেদ আছে। ISTQB-এর বর্তমান syllabus “component testing” নামটি পছন্দ করে আর বলে component-কে আলাদাভাবে test করা হয়, প্রায়ই test double দিয়ে। কিন্তু component কত বড়, তা প্রকল্পভেদে আলাদা। Martin Fowler-এর মতো লেখকরা দুই ঘরানার কথা বলেন: solitary unit test, যেখানে test-এর বস্তুর প্রতিটি সহযোগী নকল দিয়ে বদলানো হয়; আর sociable unit test, যেখানে আসল সহযোগী (যেমন বাজারঘরের discount আর delivery একসাথে) ব্যবহার করা হয়, শুধু ধীর বা বাইরের জিনিস (database, network) নকল। প্রথম ঘরানা ভুলের জায়গা নিখুঁতভাবে দেখায়; দ্বিতীয়টি কোড বদলালেও কম ভাঙে আর জোড়ের কিছু ভুলও ধরে।

তাহলে একটি test কোন level-এর, তা ঠিক করবেন কীভাবে? Test-টি কোন tool-এ লেখা (unittest, pytest, Playwright) তা দিয়ে নয়। pytest দিয়ে পুরো system-এর API test লেখা যায়, আবার Playwright দিয়ে একটি একক component-ও। প্রশ্ন হলো: test-টি কোন পরিসর যাচাই করছে, আর কোন test basis-এর সাথে মিলিয়ে? “discount function কি requirement-এর হিসাব মানে” — component. “cart কি coupon-কে ঠিক এককে টাকা পাঠায়” — component integration. “ক্রেতা কি browser থেকে ঠিক দামে কিনতে পারেন” — system. কিছু প্রতিষ্ঠান এই বিতর্ক এড়াতে level-এর বদলে test-এর আকার (small/medium/large — কতটা সম্পদ ব্যবহারের অনুমতি) দিয়ে ভাগ করে।

পরীক্ষার খাতায় এবং দলের ভেতরে তাই সংজ্ঞা আগে বলে নেওয়াই নিরাপদ: “এই প্রকল্পে unit মানে একটি module, database ছাড়া।” মডিউল ৪-এ (পর্ব ২২, ২৪) এই সিদ্ধান্তের প্রভাব হাতে-কলমে দেখবেন।

মূল উপলব্ধি: Level হলো পরিসর আর উদ্দেশ্যের নাম, tool বা ফোল্ডারের নাম নয়। সীমাটা দল ঠিক করে — শর্ত একটাই, সবাই যেন একই অর্থ বোঝে আর প্রতিটি পরিসর কেউ না কেউ দেখে।

অনুশীলন

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

  1. Spec থেকে প্রতিটি level-এ test: বাজারঘরের নতুন নিয়ম: “Checkout-এ phone number বাধ্যতামূলক; ১১ অঙ্কের, শুরু হবে 01 দিয়ে। অর্ডার হলে ক্রেতা ওই নম্বরে SMS পাবেন।” প্রতিটি level (component, component integration, system, system integration, acceptance) থেকে অন্তত একটি test idea লিখুন, আর প্রতিটির type বলুন।

    একটি সম্ভাব্য উত্তর (আপনারটি আলাদা হতে পারে):

    • Component, functional: valid_phone("01712345678") সত্য; ১০ অঙ্ক, ১২ অঙ্ক, 02 দিয়ে শুরু, অক্ষর মেশানো — সবগুলো মিথ্যা। (সীমা: ঠিক ১১ অঙ্কের দুই পাশ।)
    • Component integration, functional: checkout form যে নম্বর পাঠায় (সামনে-পেছনে ফাঁকা জায়গা, বা বাংলা অঙ্ক ০১৭…) order module কি তা একই রূপে রাখে?
    • System, functional ও non-functional: browser থেকে নম্বর ছাড়া checkout চাপলে স্পষ্ট বার্তা আসে আর অর্ডার হয় না (functional); বার্তাটি screen reader পড়ে, ঘরটির label আছে (accessibility).
    • System integration, functional ও reliability: SMS gateway-র test পরিবেশে ঠিক নম্বর আর বার্তা পৌঁছায়; gateway উত্তর না দিলে অর্ডার বাতিল হয় না, SMS পরে আবার চেষ্টা হয়।
    • Acceptance (UAT): মালিক আর কয়েকজন ক্রেতা দেখেন বার্তা বোঝা যায় কি না; প্রশ্ন উঠতে পারে — +880 দিয়ে লিখলে কী হবে? Requirement-এ নেই, তাই এটি একটি খোলা প্রশ্ন।
  2. Test failure পড়ুন: একটি দল coupon-এ বদল আনার পরে নিচের ফল পেল (unittest-এর আসল আউটপুটের অংশ)। (ক) কোন test retest আর কোনটি regression হিসেবে চলেছে বোঝা যায়? (খ) প্রত্যাশিত আর আসল মান কোনটি? (গ) Developer সম্ভবত কী বদলেছেন?
    == retest: only the B-17 test
    test_cap_300 (__main__.ShopTests.test_cap_300) ... ok
    == regression run: every test
    test_no_discount_at_1000 (...) ... FAIL
    AssertionError: 100 != 0

    (ক) প্রথম অংশে শুধু test_cap_300 — B-17-এর জন্য লেখা test, তাই এটি retest (confirmation). দ্বিতীয় অংশে সব test, তাই regression run; test_no_discount_at_1000 সেখানে ধরা পড়েছে।

    (খ) assertEqual(discount(1000), 0)-এ প্রথম মান আসল, দ্বিতীয়টি প্রত্যাশিত। তাই 100 != 0 মানে function দিয়েছে ১০০, প্রত্যাশা ছিল ০.

    (গ) ঠিক ১০০০ টাকায় এখন ১০% ছাড় হচ্ছে, অর্থাৎ শর্ত “১০০০-এর বেশি” থেকে “১০০০ বা বেশি” হয়ে গেছে — কোডে >-এর জায়গায় >=. Cap ঠিক হয়েছে (retest পাস), কিন্তু সীমার মান ভেঙেছে। এটাই সাধারণ regression-এর চেহারা: সংশোধনের কাছেই, কিন্তু অন্য একটি আচরণে।

  3. এই test plan-এর অংশে ভুল খুঁজুন: একজন নতুন tester বাজারঘরের জন্য লিখেছেন — “(১) UAT: developer দল নিজের ল্যাপটপে সব user story চালিয়ে দেখবে। (২) Performance test: discount(1500) একবার চালিয়ে দেখা হবে ফল ১৫০ কি না। (৩) Smoke test: release-এর আগের দিন ২৪০টি test দুই দিন ধরে। (৪) B-17 ঠিক হলে শুধু test_cap_300 চালিয়ে release.” চারটি ভুল চিহ্নিত করুন আর সংশোধন লিখুন।
    • (১) UAT করেন আসল ব্যবহারকারী বা তাঁদের প্রতিনিধি (মালিক, কয়েকজন ক্রেতা), production-এর মতো পরিবেশে। Developer-এর নিজের ল্যাপটপে নিজের চালানো test বড়জোর component বা system test.
    • (২) একবার চালিয়ে ফল মেলানো functional test, performance নয়। Performance test-এ মাপা যায় এমন লক্ষ্য লাগে (যেমন “৫০ জন একসাথে থাকলে ৯৫% অনুরোধ ২ সেকেন্ডে”), আর ভিড় তৈরি করতে হয়।
    • (৩) Smoke মানে দ্রুত, চওড়া, অগভীর — মিনিটের ব্যাপার, প্রতিটি নতুন build-এর শুরুতে। ২৪০টি test দুই দিন ধরে চালানো হলো regression.
    • (৪) শুধু retest করে release করলে সংশোধনে ঢোকা নতুন defect ধরা পড়ে না। Retest-এর পরে regression (অন্তত impact analysis দিয়ে বাছাই করা অংশ) চালাতে হবে।
  4. Maintenance testing পরিকল্পনা: বাজারঘরের order database পুরোনো server থেকে নতুন cloud server-এ সরানো হবে (migration), আর একই সাথে পুরোনো “cash on delivery v1” module বন্ধ হবে (retirement). প্রতিটির জন্য তিনটি করে test idea লিখুন, আর বলুন regression-এর পরিসর কীভাবে ঠিক করবেন।

    Migration: (১) পুরোনো আর নতুন database-এ অর্ডারের মোট সংখ্যা আর মোট টাকার যোগফল মেলে; (২) বাংলা নাম-ঠিকানা আর বিশেষ অক্ষর ভাঙেনি — কয়েকটি নমুনা অর্ডার হাতে মিলিয়ে; (৩) প্রতিটি অবস্থার (pending, shipped, delivered) অর্ডার নতুন system-এ খোলে আর অবস্থা বদলানো যায়। সাথে OAT: নতুন server-এ backup নেওয়া আর ফেরানো যায়।

    Retirement: (১) বন্ধ module-এর পুরোনো অর্ডার এখনো খুঁজে দেখা যায় (শুধু পড়ার জন্য); (২) নতুন অর্ডারে cash on delivery v1 আর বেছে নেওয়া যায় না, আর কোনো পাতা ভাঙা link দেখায় না; (৩) archive করা data থেকে একটি অর্ডার ফেরানো যায়।

    Regression-এর পরিসর: impact analysis দিয়ে — database বা cash on delivery ব্যবহার করা module-গুলোর (checkout, order status, রিপোর্ট, SMS) পুরো regression, বাকি অংশে অন্তত smoke.

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

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

ক্রমISTQB-এর পাঁচটি test level-কে ছোট পরিসর থেকে বড় পরিসরে সাজান (▲▼ চেপে সরান)

  1. 🧩 Component testing — একটি function বা module, একা
  2. 🔗 Component integration testing — দোকানের ভেতরের অংশগুলোর জোড়
  3. 🖥️ System testing — পুরো system, আসলের মতো পরিবেশে
  4. 🌐 System integration testing — বাইরের system-এর সাথে জোড়
  5. 🤝 Acceptance testing — ব্যবহারকারী, মালিক বা ops-এর গ্রহণ

একটি অনলাইন দোকান courier কোম্পানির API-তে district-এর নাম পাঠায়, অথচ API চায় district-এর code. এই ধরনের ভুল কোন test level-এ ধরা পড়ার কথা?

  • Component testing
  • Component integration testing
  • User acceptance testing
  • System integration testing

একটি defect ঠিক করার পরে tester ঠিক সেই test আবার চালালেন, যেটি আগে ব্যর্থ হয়েছিল। এর নাম কী?

  • Regression testing
  • Confirmation testing (retest)
  • Smoke testing
  • Maintenance testing

নতুন build test পরিবেশে এসেছে। গভীর test শুরুর আগে দল দশ মিনিটে দেখতে চায় অ্যাপ খোলে কি না, login হয় কি না, cart আর checkout পাতা খোলে কি না। এটি কোন test?

  • Smoke test
  • Sanity test
  • Full regression test
  • User acceptance test

“৫০ জন একসাথে checkout করলে ৯৫% অনুরোধের উত্তর ২ সেকেন্ডের মধ্যে আসবে” — এই requirement যাচাইয়ের test কোন type-এর?

  • Functional testing
  • Usability testing
  • Non-functional testing (performance)
  • White-box testing

একটি চালু দোকানের order database পুরোনো server থেকে নতুন server-এ সরানো হচ্ছে, আর দল অর্ডারের সংখ্যা ও মোট টাকা মিলিয়ে দেখছে। এটি কোন test-এর উদাহরণ?

  • Maintainability testing
  • Maintenance testing (migration)
  • Alpha testing
  • Component testing

একটি দোকানের operations দল দেখছে রাতের backup থেকে order database ফেরানো যায় কি না, আর monitoring-এ সতর্কবার্তা আসে কি না। এটি কোন acceptance testing?

  • Beta testing
  • Regulatory acceptance testing
  • User acceptance testing
  • Operational acceptance testing (OAT)

শব্দকোষ

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

মনে রাখুন

  1. Level = পরিসর, type = গুণ। প্রতিটি test-এর দুটিই আছে; যেকোনো type যেকোনো level-এ হতে পারে।
  2. পাঁচ level: component → component integration → system → system integration → acceptance; প্রতিটির আলাদা test basis আর আলাদা ধরনের defect.
  3. Acceptance-এর রূপ: UAT, OAT, contractual, regulatory, alpha, beta; লক্ষ্য আস্থা আর সিদ্ধান্ত।
  4. Retest দেখে ঠিক করা ভুলটি গেছে কি না; regression দেখে বদল অন্য কিছু ভাঙল কি না। দুটিই লাগে।
  5. Smoke চওড়া-অগভীর, sanity সরু-গভীর; চালু system-এ বদল, স্থানান্তর বা অবসরে maintenance testing, পরিসর ঠিক করে impact analysis.

পরের পর্বে: এ পর্যন্ত সব test-এ কোড চালাতে হয়েছে। কিন্তু অনেক defect কোড না চালিয়েই ধরা যায় — requirement পড়ে, কোড পর্যালোচনা করে, বা static analysis tool দিয়ে। পর্ব ০৬-এ দেখবেন review, walkthrough, inspection আর static analysis.

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

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