এই পর্বে যা শিখবেন
- পাঁচটি 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
২ · 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 তার কোন দিকটি দেখে আর কোন ভুল ধরে। নিয়ম: “ঢাকার ভেতরে ডেলিভারি চার্জ ৬০ টাকা, বাইরে ১২০ টাকা।” “পরে” চাপুন; প্রতিটি ধাপে ডানের নোট পড়ুন।
- Requirement
R-DEL-1৬০ / ১২০ - Component
delivery()একা - Integration
form → cartজোড় - System
checkoutপুরো প্রবাহ - Acceptance
UATমালিকের মত
inside Dhaka -> 60 taka outside Dhaka -> 120 taka (spec says nothing about empty or misspelt district)
delivery("Dhaka") == 60 ok
delivery("Rajshahi") == 120 ok
delivery("") -> ? ask BA
no DB, no UI, no network
form sends "dhaka " (space)
delivery("dhaka ") -> 120
expected 60 FAIL
courier API wants "DHK",
we send "Dhaka" FAIL
login -> cart -> checkout page 60, invoice 60, SMS 60 50 users: page < 2 s ok keyboard only ok
buyer in Savar charged 120
owner: "Savar is Dhaka!"
"Dhaka" = city or district?
-> requirement must change
- Requirement — test basis. নিয়মটি এক লাইনের। খেয়াল করুন, ফাঁকা বা ভুল বানানের district হলে কী হবে, তা লেখা নেই। প্রতিটি level-এর test basis শেষ পর্যন্ত এই লাইন থেকেই আসে, তাই এখানকার অস্পষ্টতা ওপরের সব level-এ পৌঁছে যায়।
- Component level. শুধু
delivery()function, unittest-কে driver হিসেবে নিয়ে। দুটি সাধারণ মান ঠিক আছে। ফাঁকা district-এর আচরণ requirement-এ নেই, তাই tester একটি প্রশ্ন তোলেন — এটিও test-এর ফল। এই level-এ database, UI বা network কিছুই নেই। - Integration level — দুটি জোড়ে দুটি ভুল। Component integration: address form শেষে একটি ফাঁকা জায়গাসহ ছোট হাতের
"dhaka "পাঠায়, ফলে ঢাকার ক্রেতার কাছে ১২০ টাকা। System integration: courier API district-এর code চায় ("DHK"), আমরা পাঠাচ্ছি নাম। দুটি component আলাদাভাবে সবুজ ছিল, ভুল ছিল মাঝখানে। - System level. জোড়ের ভুল ঠিক করার পরে browser থেকে পুরো checkout: পাতায়, invoice-এ আর SMS-এ একই ৬০ টাকা। একই level-এ non-functional test-ও চলছে — ৫০ জন একসাথে checkout করলে পাতা ২ সেকেন্ডের কম সময়ে আসে, আর শুধু keyboard দিয়েও কাজ শেষ করা যায়।
- Acceptance level — validation. সব test সবুজ, তবু UAT-তে সাভারের এক ক্রেতা ১২০ টাকা দিলেন। মালিক বললেন, সাভার তো ঢাকা! সাভার ঢাকা জেলার ভেতরে, কিন্তু ঢাকা শহরের সিটি কর্পোরেশনের বাইরে। “ঢাকা” মানে শহর না জেলা — requirement-এ লেখা ছিল না। কোড spec মেনেছে, কিন্তু প্রয়োজন মেটেনি; ফল হলো requirement-এর সংশোধন।
শেষ ধাপের শিক্ষা: প্রতিটি level আলাদা প্রশ্নের উত্তর দেয়, তাই একটি level আরেকটির বদলি নয়। হাজারটি component test-ও “ঢাকা মানে কী” বলত না; আবার UAT-তে “dhaka ” আর “Dhaka”-র অমিল খোঁজা হতো ধীর আর ব্যয়বহুল। Requirement-এর এমন অস্পষ্টতা কোড লেখার আগেই ধরার উপায় পর্ব ০৪-এ (shift-left) আর পর্ব ০৬-এ (requirement review).
পাঁচ level এক টেবিলে
| Level | Test object | Test basis | সাধারণ defect | সাধারণত কে |
|---|---|---|---|---|
| Component | discount(), delivery() | component-এর নকশা, কোড | ভুল হিসাব, সীমার ভুল | developer |
| Component integration | cart + coupon, form + delivery | architecture, interface | format, একক, ক্রমের অমিল | developer, SDET |
| System | পুরো বাজারঘর | SRS, use case, user story | প্রবাহের ভুল, non-functional ঘাটতি | স্বাধীন test দল |
| System integration | বাজারঘর + courier, wallet mock, SMS | বাইরের API-র চুক্তি | চুক্তির অমিল, timeout | test দল, অন্য পক্ষ |
| 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-এর সামনে দুটি আলাদা প্রশ্ন:
- ঠিক করা ভুলটি কি সত্যিই গেছে? যে test ব্যর্থ হয়েছিল, ঠিক সেটি নতুন কোডে আবার চালানো। এর নাম confirmation testing, প্রচলিত নাম retest.
- এই সংশোধন কি অন্য কিছু ভেঙেছে? আগে যা ঠিক চলত, তা এখনো চলে কি না — আগের সব (বা বাছাই করা) 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.
if subtotal > 1000:
return subtotal*10//100
if subtotal >= 1000:
d = subtotal * 10 // 100
return min(d, 300)
if subtotal > 1000:
d = subtotal * 10 // 100
return min(d, 300)
| cap_300 | |
| delivery_dhaka | |
| delivery_out | |
| no_discount_1000 | |
| above_1000 |
- v1, পুরো suite. পাঁচটির মধ্যে শুধু
cap_300ব্যর্থ: ৫০০০ টাকায় এসেছে ৫০০, চাওয়া হয়েছিল ৩০০. Tester bug B-17 লেখেন — সাথে এই test-এর নাম আর আসল ফল। - Developer v2 দিলেন। Cap যোগ হয়েছে, কিন্তু শর্তে
>=এসে গেছে। নতুন কোডে এখনো কোনো test চলেনি, তাই সব ঘরে প্রশ্নবোধক চিহ্ন — “developer বলেছেন ঠিক হয়েছে” মানে এখনো কিছু যাচাই হয়নি। - Retest (confirmation). শুধু
cap_300চালানো হলো:OK. B-17 বন্ধ করা যায়। বাকি চারটি চালানো হয়নি, তাই ঘরে ড্যাশ। এখানে থামলে নতুন defect-টি release পর্যন্ত চলে যেত। - Regression run. পাঁচটিই আবার চালানো হলো।
cap_300ঠিক আছে, কিন্তুno_discount_1000(পুরো নামtest_no_discount_at_1000) এখন FAIL: ঠিক ১০০০ টাকায় ১০০ টাকা ছাড়। আগে পাস করা test এখন ব্যর্থ — regression ধরা পড়ল, নতুন bug লেখা হলো। - 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-এর সংখ্যা কাল্পনিক, কিন্তু ক্রমটি বাস্তব দলের মতো।
- Build
2.4.0এলো - Smoke
12 checksচওড়া, অগভীর - Sanity
9 checksসরু, গভীর - Regression
240 testsচওড়া, গভীর - Release
2.4.3সিদ্ধান্ত
| সময় | |
| Build | |
| কী চলল | |
| Test | |
| ফল |
- ০৯:০০ — build 2.4.0 এলো। এতে আছে B-17-এর সংশোধন আর অর্ডারের খবর SMS-এ পাঠানোর নতুন feature. দল এখনো কিছু চালায়নি। প্রথম প্রশ্ন: এই build কি আদৌ test করার যোগ্য?
- ০৯:১০ — smoke, ১২টি যাচাই। অ্যাপ খোলা, login, খোঁজা, cart, checkout পাতা, নকল payment, order status… ১১টি ঠিক, কিন্তু login ব্যর্থ। Login ছাড়া প্রায় কিছুই test করা যায় না, তাই build প্রত্যাখ্যাত। খরচ মাত্র দশ মিনিট।
- ১১:০০ — build 2.4.1, আবার smoke. Login-এর সংশোধনসহ নতুন build-এ একই ১২টি যাচাই, সবগুলো ঠিক। Build গ্রহণ করা হলো; এবার গভীর test শুরু।
- ১৪:০০ — build 2.4.2, sanity. দুপুরে coupon-এর হিসাবে ছোট একটি সংশোধন এলো। পুরো suite না চালিয়ে শুধু coupon এলাকার ৯টি গুরুত্বপূর্ণ case — ১০০০-এর দুই পাশ, cap-এর সীমা, coupon ছাড়া অর্ডার। সবগুলো ঠিক।
- ১৫:০০ — regression, ২৪০টি test. Release-এর আগে পুরো automated suite. ২৩৯টি ঠিক, একটি ব্যর্থ: SMS-এ delivery charge ভুল দেখাচ্ছে — নতুন SMS feature পুরোনো হিসাবের সাথে ঠিক জোড়েনি। নতুন bug লেখা হলো।
- ১৮:০০ — build 2.4.3, retest আর regression. SMS-এর সংশোধনের পরে প্রথমে সেই একটি ব্যর্থ test-এর retest, তারপর আবার পুরো ২৪০টির regression. সব ঠিক, release-এর সিদ্ধান্ত।
| Smoke | Sanity | Regression | |
|---|---|---|---|
| প্রশ্ন | 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.
যেমন: ঈদের জন্য নতুন couponMigration (স্থানান্তর)
এক platform বা server থেকে আরেকটিতে সরানো, পুরোনো data নতুন গঠনে রূপান্তর।
যেমন: order database নতুন server-এRetirement (অবসর)
একটি অংশ বা পুরো system বন্ধ করা — data সংরক্ষণ, পরে ফেরানো যায় কি না।
যেমন: পুরোনো cash-on-delivery moduleMigration-এ “নতুন 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
দুটি সতর্কতা। প্রথমত, 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 ছক মানতে বলা হয়েছে আর অনুমান আলাদা করে চিহ্নিত করতে বলা হয়েছে:
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 বা ফোল্ডারের নাম নয়। সীমাটা দল ঠিক করে — শর্ত একটাই, সবাই যেন একই অর্থ বোঝে আর প্রতিটি পরিসর কেউ না কেউ দেখে।
অনুশীলন
খাতা-কলম নিয়ে বসুন। প্রথমে নিজে উত্তর লিখুন, তারপর মিলিয়ে দেখুন।
-
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-এ নেই, তাই এটি একটি খোলা প্রশ্ন।
- Component, functional:
-
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-এর চেহারা: সংশোধনের কাছেই, কিন্তু অন্য একটি আচরণে। -
এই 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 দিয়ে বাছাই করা অংশ) চালাতে হবে।
-
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-কে ছোট পরিসর থেকে বড় পরিসরে সাজান (▲▼ চেপে সরান)
- 🧩 Component testing — একটি function বা module, একা
- 🔗 Component integration testing — দোকানের ভেতরের অংশগুলোর জোড়
- 🖥️ System testing — পুরো system, আসলের মতো পরিবেশে
- 🌐 System integration testing — বাইরের system-এর সাথে জোড়
- 🤝 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)
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Level = পরিসর, type = গুণ। প্রতিটি test-এর দুটিই আছে; যেকোনো type যেকোনো level-এ হতে পারে।
- পাঁচ level: component → component integration → system → system integration → acceptance; প্রতিটির আলাদা test basis আর আলাদা ধরনের defect.
- Acceptance-এর রূপ: UAT, OAT, contractual, regulatory, alpha, beta; লক্ষ্য আস্থা আর সিদ্ধান্ত।
- Retest দেখে ঠিক করা ভুলটি গেছে কি না; regression দেখে বদল অন্য কিছু ভাঙল কি না। দুটিই লাগে।
- Smoke চওড়া-অগভীর, sanity সরু-গভীর; চালু system-এ বদল, স্থানান্তর বা অবসরে maintenance testing, পরিসর ঠিক করে impact analysis.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ০৬ · Static testing — review, walkthrough, inspection আর static analysisপরবর্তী পর্বকোড না চালিয়ে defect ধরা — requirement review থেকে linter পর্যন্ত।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্বপুরো কোর্সের রোডম্যাপ — কোন পর্ব কখন।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৪৫সংক্ষিপ্ত রূপTesting-এর মৌলিক, level আর black-box বনাম white-box — একটি দ্রুত পুনরালোচনা।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৩পাশের ট্র্যাকISO/IEC 25010-এর quality model বিস্তারিতভাবে — non-functional test-এর ভিত্তি।
- ফুল-স্ট্যাক ওয়েব ফ্রেমওয়ার্ক · পর্ব ৭২পাশের ট্র্যাকএকটি আসল web app-এ pyramid, trophy আর কোন level-এ কী test করবেন।