এই পর্বে যা শিখবেন
- একটি use case পড়ে main success scenario, extension আর guarantee আলাদা করা
- নিয়মমাফিক ধাপে use case থেকে test scenario আর test case বের করা, আর সেগুলো গোনা
- Scenario test-এ শুধু শেষ ফল নয়, পুরো যাত্রার পরের অবস্থা (stock, টাকা, অর্ডারের অবস্থা) যাচাই করা
- User story-র acceptance criteria আর end-to-end mapping থেকে scenario বাছাই
- CRUD matrix দিয়ে requirement-এর ফাঁক খোঁজা, আর AI-এর বানানো scenario যাচাই
১ · অংশগুলো ঠিক, যাত্রাটা ভাঙা
পর্ব ০৭ থেকে ১১ পর্যন্ত কৌশলগুলো ছোট ছোট অংশ দেখে। পর্ব ০৭-এ একটি input-এর দল, পর্ব ০৮-এ দলের সীমা, পর্ব ০৯-এ কয়েকটি শর্তের মিশ্রণ। কিন্তু ব্যবহারকারী একটি ঘর পূরণ করে চলে যান না। তিনি একটি লক্ষ্য নিয়ে আসেন, যেমন “অর্ডার দেব”, আর সেই লক্ষ্যে পৌঁছাতে পাঁচ-সাতটি ধাপ পার হন। প্রতিটি ধাপ আলাদাভাবে ঠিক থাকলেও এক ধাপের রেখে যাওয়া অবস্থা পরের ধাপে ভুল ফল দিতে পারে।
ট্রেনের টিকিট কাটার কথা ভাবুন। স্টেশন বাছাই ঠিক কাজ করে, আসন বাছাই ঠিক কাজ করে, মোবাইল ওয়ালেটে টাকা দেওয়াও ঠিক কাজ করে। কিন্তু টাকা দিতে গিয়ে প্রথমবার ব্যর্থ হলো, আপনি আবার চেষ্টা করলেন, আর এর মধ্যে আসনটি অন্য কেউ নিয়ে নিল। এখন টাকা কাটা গেছে, আসন নেই। কোনো একক অংশে ভুল নেই; ভুল তাদের জোড়ায়, একটি নির্দিষ্ট ক্রমে। Scenario testing ঠিক এই ক্রমগুলো খুঁজে বের করে চালায়।
এই কাজের মূল উপকরণ use case: একজন actor কোনো লক্ষ্যে system-এর সাথে ধাপে ধাপে কী করেন, সব ঠিক চললে কী হয়, আর কোন ধাপে কী ভিন্ন হতে পারে, তার লিখিত বিবরণ। Use case লেখা (Cockburn-এর ছাঁচ, level, scope) সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ২২-এ আছে, আর সেই কোর্সের পর্ব ৪৭-এ use case থেকে test-এর একটি ছোট উদাহরণ আছে। এখানে আমরা tester-এর দিক থেকে পুরো পদ্ধতি দেখব: scenario বের করার নিয়মমাফিক ধাপ, scenario গোনা, coverage, প্রতিটি scenario-র test data আর প্রত্যাশিত ফল, চালানো test, আর যে defect শুধু পথের মিশ্রণে ধরা পড়ে।
Coupon: পণ্যের দাম ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায়, ভগ্নাংশ বাদ; ছাড় শুধু পণ্যের দামে। Delivery charge: ঢাকার ভেতরে ৬০ টাকা, বাইরে ১২০ টাকা; পণ্যের দাম ২০০০ টাকা বা বেশি হলে ঢাকার ভেতরে ফ্রি। Phone: ১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3 থেকে 9. Payment: cash on delivery, mobile wallet বা card; wallet এই কোর্সে সবসময় একটি নকল (mock), আসল টাকা নয়।
Use case-এর ধারণা আসে Ivar Jacobson-এর কাছ থেকে। ১৯৮০-এর দশকে Ericsson-এ টেলিফোন system-এর নকশার কাজে তিনি এটি গড়ে তোলেন, ১৯৮৭ সালে OOPSLA সম্মেলনে উপস্থাপন করেন, আর ১৯৯২ সালের “Object-Oriented Software Engineering: A Use Case Driven Approach” বইয়ে বিস্তারিত লেখেন। ১৯৯৭ সালে UML-এ use case diagram জায়গা পায়। লেখার ব্যবহারিক ছাঁচটি জনপ্রিয় করেন Alistair Cockburn, তাঁর “Writing Effective Use Cases” (২০০০ সালের শেষে প্রকাশিত; অনেকে ২০০১ লেখেন) বইয়ে। Testing-এ “scenario testing” নামটি নিয়ে Cem Kaner ২০০৩ সালের দিকে একটি প্রভাবশালী প্রবন্ধ লেখেন, যেখানে ভালো scenario-কে একটি বিশ্বাসযোগ্য, জটিল আর সহজে মূল্যায়ন করা যায় এমন গল্প হিসেবে বর্ণনা করা হয়েছে।
২ · Use case-এর অংশ — বাজারঘরের checkout
Tester-এর কাছে use case একটি test basis, অর্থাৎ যে নথি থেকে test বের হয়। নিচে বাজারঘরের checkout-এর use case, Cockburn-ধাঁচের সংক্ষিপ্ত রূপে। প্রতিটি অংশ test-এ কী কাজে লাগে, তা পরে দেখব।
UC-05 অর্ডার দেওয়া (checkout)
Primary actor: ক্রেতা
Supporting: mobile wallet (MOCK), SMS সেবা
Precondition: ক্রেতা লগইন করা; cart-এ অন্তত ১টি পণ্য
Trigger: ক্রেতা cart থেকে "checkout" চাপেন
Main success scenario
1. ক্রেতা checkout শুরু করেন
2. System cart-এর প্রতিটি পণ্যের stock যাচাই করে
3. ক্রেতা district, phone আর delivery slot দেন
4. System ছাড় আর delivery charge হিসাব করে বিল দেখায়
5. ক্রেতা payment method বেছে নিশ্চিত করেন
6. System wallet-কে মোট টাকা চায়; wallet টাকা দেয়
7. System অর্ডার "paid" করে, stock কমায়, রসিদ আর SMS দেয়
Extensions
2a. কোনো পণ্যের stock শেষ: System জানায়, পণ্যটি বাদ দেয়
→ ধাপ 2-এ ফেরে (cart খালি হলে use case ব্যর্থ শেষ)
3a. Phone নিয়ম মানে না: System ভুল দেখায় → ধাপ 3-এ ফেরে
4a. ক্রেতা coupon দেন: System ছাড় যোগ করে → ধাপ 4-এ ফেরে
5a. ক্রেতা cash on delivery বাছেন: অর্ডার "placed",
stock কমে, রসিদ → সফল শেষ
6a. Wallet টাকা দেয়নি: System জানায়, কিছু কাটা হয়নি;
ক্রেতা আবার চেষ্টা করেন → ধাপ 5-এ ফেরে
6b. Wallet টাকা দেয়নি, ক্রেতা বাতিল করেন:
অর্ডার "cancelled" → ব্যর্থ শেষ
Minimal guarantee: টাকা কাটা হলে অর্ডার paid; টাকা কাটা না
হলে অর্ডার paid নয়; অর্ডার না হলে stock আগের মতো
Success guarantee: অর্ডার paid বা placed; বিল = পণ্যের দাম
− ছাড় + delivery charge
প্রতিটি অংশ tester-এর কাছে একটি নির্দিষ্ট প্রশ্নের উত্তর:
- Primary actor আর supporting actor: কার চোখে test, আর কোন বাইরের system-কে নকল (test double) দিয়ে বদলাতে হবে। এখানে wallet.
- Precondition: test শুরুর আগে কী সাজাতে হবে (লগইন করা ক্রেতা, cart-এ পণ্য)। Precondition-এর বাইরের অবস্থা (খালি cart) এই use case-এর test নয়; সেটি অন্য use case বা negative test.
- Main success scenario: সবকিছু ঠিক চললে কী হয়; এর থেকেই প্রথম scenario. একে basic flow বা happy path-ও বলে।
- Extension: কোন ধাপে কোন শর্তে পথ বদলায়, আর পথটি কোথায় যায়: মূল পথে ফেরে, সফলভাবে শেষ হয়, নাকি ব্যর্থভাবে। প্রতিটি extension কমপক্ষে একটি আলাদা scenario.
- Guarantee (postcondition): এটিই test-এর সবচেয়ে মূল্যবান অংশ। Minimal guarantee প্রতিটি পথের শেষে সত্য থাকতে হবে, ব্যর্থ পথেও। তাই প্রতিটি scenario test-এ শুধু “কী দেখাল” নয়, “কোথায় কী বদলাল” যাচাই করতে হয়।
Extension-এর দুই রকম নাম প্রচলিত। যে পথ লক্ষ্য পূরণ করে (coupon, cash on delivery), তাকে অনেকে alternate flow বলেন; যে পথ লক্ষ্য পূরণ না করে শেষ হয় (6b), তাকে exception flow. Cockburn দুটিকেই “extension” বলেন। Test-এর জন্য নামের চেয়ে জরুরি হলো পথটি কোথায় শেষ হয়, কারণ সেটিই প্রত্যাশিত ফল ঠিক করে। নিচের ছবিতে পুরো use case এক নজরে:
UC-05 checkout — মূল পথ আর extension
বাঁয়ে মূল পথের ৭টি ধাপ, ডানে কোন ধাপ থেকে কোন বিকল্প পথ বের হয় আর কোথায় যায়
এবার মূল পথ ধরে একবার হাঁটি। ক্রেতা ঢাকার ভেতরে চাল (১২০০ টাকা) আর তেল (৯০০ টাকা) কিনছেন, wallet-এ পরিশোধ করবেন। প্রতিটি ধাপে system-এর ভেতরের অবস্থা কী, খেয়াল করুন; scenario test ঠিক এই অবস্থাগুলোই যাচাই করবে।
- ১ শুরুক্রেতা
- ২ stockSystem
- ৩ ঠিকানাক্রেতা
- ৪ বিলSystem
- ৫ paymentক্রেতা
- ৬ walletMOCK
- ৭ paidSystem
| cart | |
| বিল | |
| অর্ডার | |
| কাটা টাকা | |
| chal stock |
- শুরু। ক্রেতা লগইন করা, cart-এ দুটি পণ্য। এটি precondition, তাই test-এর setup-এ এই অবস্থা সাজাতে হয়; use case নিজে এটি আবার যাচাই করে না।
- Stock যাচাই। দুটি পণ্যেরই stock আছে (চাল ৫টি), তাই কিছু বাদ পড়ল না। এখানে কোনো পণ্যের stock ০ হলে পথ 2a-তে যেত।
- ঠিকানা আর phone. ক্রেতা ঢাকা, 01712345678 আর সন্ধ্যার slot দিলেন। Phone নিয়ম মানে (১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 7). নিয়ম না মানলে পথ 3a-তে যেত। এই ঘরের ভেতরের দল আর সীমা পর্ব ০৭ আর ০৮-এর কাজ।
- বিল। পণ্যের দাম ১২০০ + ৯০০ = ২১০০. Coupon নেই, তাই ছাড় ০. ঢাকার ভেতরে ২০০০ বা বেশি, তাই delivery ফ্রি। মোট ২১০০. এই হিসাবের নিয়ম পর্ব ০৯-এর decision table-এর বিষয়; scenario test শুধু দেখে, যাত্রার মাঝে হিসাবটি ঠিক জায়গায় ঠিক মান পেল কি না।
- Payment বাছাই। ক্রেতা mobile wallet বেছে নিশ্চিত করলেন। অর্ডার তৈরি হলো “placed” অবস্থায়, কিন্তু এখনো কোনো টাকা কাটা হয়নি আর stock-ও কমেনি।
- Wallet. System নকল wallet-কে ২১০০ টাকা চাইল, wallet রাজি হলো। Test-এ wallet একটি fake object, যাকে আগে থেকে বলে রাখা যায় রাজি হবে কি না। আসল টাকা কখনো নয়।
- Paid. অর্ডার “paid”, কাটা টাকা ২১০০, চালের stock ৫ থেকে ৪, cart খালি। Success guarantee-র প্রতিটি অংশ এখন যাচাই করা যায়। একটি ভালো scenario test এই পাঁচটি সারির সবগুলো দেখে, শুধু “paid” লেখাটি নয়।
৩ · Extension-এর ভেতরে — wallet টাকা দিল না
মূল পথ প্রায় সবাই test করেন। Defect জমে extension-এ, বিশেষ করে যেখানে পথ মূল পথে ফেরে। ফেরার সময় আগের চেষ্টার কিছু অবস্থা থেকে যায়: একটি হিসাব, একটি কমানো stock, একটি “চেষ্টা চলছে” চিহ্ন। নিচের stepper-এ একজন ক্রেতা coupon দিয়েছেন (বিল ২১০০ − ২১০ = ১৮৯০), আর wallet দুবার টাকা দিতে রাজি হয়নি। বাঁয়ে use case-এর লাইন, ডানে system-এর অবস্থা।
5ক্রেতা wallet বেছে নিশ্চিত6System wallet-কে টাকা চায়6awallet রাজি নয়6a1জানায়, কিছু কাটা হয়নি6a2আবার চেষ্টা → ধাপ 56bআবার ব্যর্থ, ক্রেতা বাতিল6b1cancelled, ব্যর্থ শেষ
| চেষ্টা | |
| চাওয়া টাকা | |
| কাটা টাকা | |
| অর্ডার | |
| chal stock |
- ধাপ ৫। বিল ১৮৯০ (২১০০ − ২১০ ছাড় + ০ delivery). ক্রেতা wallet বেছে নিশ্চিত করলেন। অর্ডার placed, কিছু কাটা হয়নি, stock ৫।
- প্রথম চেষ্টা। System wallet-কে ১৮৯০ টাকা চাইল। Test-এ আমাদের নকল wallet-কে আগে থেকে বলা আছে: প্রথমবার “না”।
- 6a — wallet রাজি নয়। এখানে পথ মূল পথ ছেড়ে extension-এ ঢুকল। কাটা টাকা এখনো ০, আর তা-ই থাকা উচিত।
- 6a1 — minimal guarantee যাচাই। “টাকা কাটা না হলে অর্ডার paid নয়; অর্ডার না হলে stock আগের মতো।” এই মুহূর্তে test তিনটি জিনিস দেখে: কাটা ০, অর্ডার paid নয়, stock ৫। কোড যদি পরিশোধের আগেই stock কমিয়ে ফেলে, এখানে stock ৪ দেখাবে।
- 6a2 — ধাপ ৫-এ ফেরা। ক্রেতা আবার চেষ্টা করলেন। প্রশ্ন: দ্বিতীয়বার system কত টাকা চাইবে? নিয়ম অনুযায়ী আবারও ১৮৯০. ফেরার পথে ছাড় আবার বাদ দিলে চাইবে ১৬৮০। এই ভুল শুধু “coupon + ব্যর্থ চেষ্টা” মিশ্রণে দেখা যায়; coupon ছাড়া ছাড় ০, তাই দুবার বাদ দিলেও কিছু বদলায় না।
- 6b — আবার ব্যর্থ, বাতিল। Wallet আবার “না” বলল, ক্রেতা আর চেষ্টা না করে বাতিল করলেন। এটি একটি ব্যর্থ শেষ, কিন্তু ব্যর্থ শেষেরও প্রত্যাশিত ফল আছে।
- 6b1 — শেষ অবস্থা। অর্ডার cancelled, কাটা টাকা ০, chal stock ৫. Minimal guarantee পূরণ। ব্যর্থতার পথের test-এ এই শেষ অবস্থাটিই আসল প্রত্যাশিত ফল; শুধু “বাতিল হয়েছে” বার্তা দেখে test পাস করানো দুর্বল test.
Extension-এর test-এ সবচেয়ে সাধারণ ভুল হলো শুধু বার্তা যাচাই করা (“Payment failed” দেখা গেছে, তাই পাস)। Use case-এর guarantee বলে ব্যর্থ পথেও কী সত্য থাকবে: টাকা, stock, অর্ডারের অবস্থা। বাস্তবে সবচেয়ে ক্ষতিকর defect-গুলো এখানেই থাকে: টাকা কাটা গেল অথচ অর্ডার নেই, বা অর্ডার বাতিল অথচ stock আটকে রইল।
৪ · Use case থেকে scenario — নিয়মমাফিক ধাপ আর গোনা
একটি test scenario হলো use case-এর ভেতর দিয়ে একটি নির্দিষ্ট পথ: শুরু থেকে কোন কোন extension নিয়ে কোন শেষে পৌঁছায়। প্রতিটি scenario থেকে এক বা একাধিক test case হয়, যেখানে নির্দিষ্ট test data আর প্রত্যাশিত ফল লেখা থাকে। পদ্ধতিটি এমন:
- Use case পড়ে পথের মানচিত্র আঁকুন। প্রতিটি extension কোন ধাপে শুরু, আর কোথায় যায় (কোন ধাপে ফেরে, সফল শেষ, না ব্যর্থ শেষ)। যে extension-এর গন্তব্য লেখা নেই, সেটি requirement-এর ফাঁক; প্রশ্ন তুলুন।
- মূল পথের scenario লিখুন। এটি S1.
- প্রতিটি extension-এর জন্য একটি scenario. মূল পথ ধরে চলুন, শুধু ওই একটি extension নিন। এতে প্রতিটি নতুন scenario শুধু একটি জিনিসে মূল পথ থেকে আলাদা, তাই ব্যর্থ হলে কারণ খোঁজা সহজ।
- লুপের সীমা ঠিক করুন। যে extension মূল পথে ফেরে, সেটি তাত্ত্বিকভাবে অসীমবার ঘটতে পারে। সাধারণ নিয়ম: একবার ঘটা আর দুবার ঘটা (দ্বিতীয়বার ফেরার পর আগের চেষ্টার অবস্থা থেকে যায় কি না)। “তিনবার ভুল PIN হলে আটকে যাবে” ধরনের সংখ্যা থাকলে সেটি সীমা, তাই BVA লাগে।
- ঝুঁকি ধরে মিশ্রণ বাছুন। যে extension-গুলো একই অবস্থা (টাকা, stock) ছোঁয়, তাদের জোড়া আলাদা scenario হিসেবে নিন। সব মিশ্রণ সাধারণত অবাস্তব।
- প্রতিটি scenario-তে test data আর প্রত্যাশিত ফল দিন। ধাপের ভেতরের input-এর মান বাছুন পর্ব ০৭–০৯-এর কৌশলে। প্রত্যাশিত ফলে শেষ অবস্থা আর guarantee লিখুন।
- Coverage মাপুন (নিচে), আর কোন পথ ইচ্ছা করে বাদ দিয়েছেন তা লিখে রাখুন।
| এই ধাপে | |
| তালিকা |
- মূল পথ। ১ থেকে ৭ পর্যন্ত, কোনো extension নেই, সফল শেষ। এটি S1, সবচেয়ে বেশি ব্যবহৃত পথ, তাই সবচেয়ে আগে চালানো হয়।
- 2a. ধাপ ২-এ একটি পণ্যের stock ০, পণ্যটি বাদ পড়ে, পথ আবার ধাপ ২-এ ফেরে, তারপর মূল পথে শেষ পর্যন্ত। S2.
- 3a. ধাপ ৩-এ ভুল phone, ভুল দেখানো, আবার লেখা, তারপর মূল পথ। S3. এই scenario-র ভেতরে কোন ভুল নম্বর দেবেন, তা পর্ব ০৭-এর invalid দল থেকে আসে।
- 4a. Coupon দিলে ছাড় যোগ হয়ে বিল আবার দেখানো হয়, তারপর মূল পথ। S4. ছাড়ের মান বাছবেন পর্ব ০৮-এর সীমা থেকে (যেমন ঠিক ৩০০০, যেখানে ছাড় ৩০০)।
- 5a. Cash on delivery বাছলে wallet ধাপটিই আসে না, অর্ডার placed অবস্থায় সফল শেষ। S5. এটি দ্বিতীয় সফল শেষ, তাই প্রত্যাশিত ফল আলাদা: অর্ডার placed, কাটা ০।
- 6a. Wallet প্রথমবার রাজি নয়, ক্রেতা আবার চেষ্টা করেন, পথ ধাপ ৫-এ ফেরে, দ্বিতীয়বার রাজি। S6. লুপটি এখানে ঠিক একবার।
- 6b. Wallet রাজি নয়, ক্রেতা বাতিল করেন, ব্যর্থ শেষ। S7. এখন মূল পথ ১টি আর extension ৬টি, মোট ৭টি scenario; প্রতিটি extension অন্তত একবার চলেছে।
- মিশ্রণ গোনা। 2a, 3a, 4a প্রতিটি নেওয়া বা না-নেওয়া যায় (2 × 2 × 2 = ৮), আর ধাপ ৫ থেকে শেষ পর্যন্ত ৬টি আলাদা পথ, তাই প্রতিটি extension সর্বোচ্চ একবার ধরলেও মোট ৪৮টি পথ। সব চালানো লাভজনক নয়; ঝুঁকির কারণে বাড়তি নেওয়া হলো S8: coupon, তারপর ব্যর্থ চেষ্টা আর আবার চেষ্টা (§৩-এর প্রশ্ন)।
গোনাটা হাতে না করে যন্ত্রে করা ভালো, কারণ লুপ আর একাধিক শেষ থাকলে ভুল হওয়া সহজ। নিচের program-এ use case-টি শুধু data: প্রতিটি extension কোন ধাপে শুরু আর কোথায় যায়। একটি ছোট recursive function সব পথ তৈরি করে, শর্ত একটাই: প্রতিটি extension এক পথে সর্বোচ্চ একবার। তারপর একক scenario-গুলো আলাদা করে, আর খোঁজে সবচেয়ে কম কয়টি পথ সব extension ঢাকতে পারে।
from itertools import combinations
# UC-05 checkout: main flow is steps 1..7, step 7 = success end
# extension id -> (step where it branches, condition, where it goes)
EXT = {"2a": (2, "item out of stock, removed", 2),
"3a": (3, "phone invalid, re-entered", 3),
"4a": (4, "coupon applied", 4),
"5a": (5, "cash on delivery", "OK"),
"6a": (6, "wallet declined, retry", 5),
"6b": (6, "wallet declined, cancel", "FAIL")}
def paths(step=1, used=(), trail=()):
if step == 7: # main flow reached its end
yield trail + ("OK",); return
yield from paths(step + 1, used, trail) # stay on the main flow
for e, (at, _, goto) in EXT.items():
if at == step and e not in used: # each extension at most once
if goto in ("OK", "FAIL"):
yield trail + (e, goto)
else:
yield from paths(goto, used + (e,), trail + (e,))
allp = list(paths())
single = sorted((p for p in allp if len(p) <= 2), key=lambda p: (len(p), p))
print("basic + one extension each:", len(single))
for p in single:
print(" ", " -> ".join(p) if len(p) > 1 else "basic flow -> OK")
print("all paths, each extension at most once:", len(allp))
for k in range(1, 4): # fewest paths that touch every extension
hit = [c for c in combinations(allp, k)
if set(EXT) <= {x for p in c for x in p}]
if hit:
print("fewest paths covering all 6 extensions:", k)
print(" e.g.", [" ".join(p) for p in hit[0]]); breakআসল আউটপুট (ব্রাউজারের Python):
basic + one extension each: 7
basic flow -> OK
2a -> OK
3a -> OK
4a -> OK
5a -> OK
6a -> OK
6b -> FAIL
all paths, each extension at most once: 48
fewest paths covering all 6 extensions: 2
e.g. ['6a 6b FAIL', '2a 3a 4a 6a 5a OK']
তিনটি সংখ্যা তিনটি আলাদা প্রশ্নের উত্তর। ৭: মূল পথ আর প্রতিটি extension আলাদাভাবে, প্রচলিত ন্যূনতম suite. ৪৮: প্রতিটি extension সর্বোচ্চ একবার ধরে সব সম্ভাব্য পথ, stepper-এর 2 × 2 × 2 × 6. ২: শুধু “প্রতিটি extension অন্তত একবার” চাইলে মাত্র ২টি লম্বা পথই যথেষ্ট, যেমন একটিতে 6a তারপর 6b, অন্যটিতে 2a, 3a, 4a, 6a আর 5a একসাথে। কম test, কিন্তু একটি ব্যর্থ হলে বোঝা কঠিন কোন extension দায়ী, আর একটি ধাপে আটকে গেলে পরের extension-গুলো আর চলেই না। তাই সাধারণ চর্চা হলো ৭টি ছোট scenario, তারপর ঝুঁকির কয়েকটি মিশ্রণ।
ন্যূনতম scenario = ১ (মূল পথ) + E (extension-এর সংখ্যা; একই শর্তের দুটি ভিন্ন শেষ থাকলে দুটি গুনুন)। UC-05-এ ১ + ৬ = ৭। Coverage: ISTQB-এর ২০১৮ সালের Foundation syllabus-এ use case testing-এর coverage ছিল মোটামুটি “যতগুলো use case আচরণ (মূল পথ আর extension) test হয়েছে, তা মোট আচরণের কত শতাংশ”। উদাহরণ: suite চালিয়েছে S1, S4, S6, তাহলে ৩ ÷ ৭ ≈ ৪২.৯%.
৭টি scenario এবার test case টেবিলে। প্রতিটি সারির প্রত্যাশিত ফলে শেষ অবস্থা আছে, কারণ guarantee যাচাই না করলে extension-এর test অর্ধেক।
| ID | পথ | Test data | প্রত্যাশিত ফল |
|---|---|---|---|
| S1 | মূল পথ | chal 1200 + tel 900, Dhaka, wallet হ্যাঁ | paid, কাটা 2100, chal stock 4 |
| S2 | 2a | chal 1200 + dal 300 (dal stock 0), Dhaka | dal বাদ, paid, কাটা 1260 |
| S3 | 3a | phone 01212345678 (তৃতীয় অঙ্ক 2) | phone-এর ভুল, কাটা 0, stock 5 |
| S4 | 4a | 2100, coupon, Dhaka | ছাড় 210, কাটা 1890 |
| S5 | 5a | 2100, Rajshahi, cash on delivery | placed, বিল 2220, কাটা 0 |
| S6 | 6a | 2100, wallet: না, তারপর হ্যাঁ | paid, কাটা ঠিক একবার 2100 |
| S7 | 6b | 2100, wallet: না, না | cancelled, কাটা 0, stock 5 |
| S8 | 4a + 6a | 2100, coupon, wallet: না, তারপর হ্যাঁ | paid, কাটা ঠিক একবার 1890 |
৫ · টেবিল থেকে চালানো scenario test
এবার টেবিলটিকে আসল test বানাই। নিচের প্রথম block-এ ছোট একটি code under test: checkout() function আর একটি নকল wallet. এতে ইচ্ছা করে দুটি defect রাখা আছে (seeded defect), যেমন বাস্তবে প্রায়ই দেখা যায়। A: পরিশোধের আগেই stock কমানো। B: আবার চেষ্টার সময় ছাড় আবার বাদ দেওয়া। দ্বিতীয় block একই namespace-এ চলে (data-shared), তাই প্রথমটি চালানো না থাকলে নিজে থেকে আগে চলবে।
import math
class FakeWallet: # MOCK mobile wallet: no real money moves
def __init__(self, replies):
self.replies, self.charged = list(replies), []
def pay(self, amount): # True = approved, False = declined
ok = self.replies.pop(0)
if ok:
self.charged.append(amount)
return ok
def checkout(cart, stock, district, phone, coupon, method, wallet):
items = {p: tk for p, tk in cart.items() if stock.get(p, 0) > 0} # 2a
if not items:
return {"status": "failed"}
if not (len(phone) == 11 and phone.isdigit() # 3a
and phone[:2] == "01" and phone[2] in "3456789"):
return {"status": "error", "field": "phone"}
sub = sum(items.values())
disc = min(math.floor(sub * 0.10), 300) if coupon and sub > 1000 else 0
fee = (0 if sub >= 2000 else 60) if district == "Dhaka" else 120
total = sub - disc + fee
for p in items:
stock[p] -= 1 # seeded defect A: stock taken before payment
if method == "cod": # 5a
return {"status": "placed", "total": total}
while wallet.replies: # 6a / 6b
if wallet.pay(total):
return {"status": "paid", "total": total}
total -= disc # seeded defect B: discount again on retry
return {"status": "cancelled", "total": total}
print("checkout() ready; run the scenario tests below")আসল আউটপুট: checkout() ready; run the scenario tests below. FakeWallet-কে আগে থেকে উত্তরের তালিকা দেওয়া হয় (True মানে রাজি), আর সে যত টাকা কেটেছে তা charged-এ লিখে রাখে। ক্রেতার আচরণও এই তালিকায়: ব্যর্থ হওয়ার পর তালিকায় আরও উত্তর থাকলে ক্রেতা আবার চেষ্টা করেন, না থাকলে বাতিল করেন। প্রতিটি extension কোডের কোন লাইনে, মন্তব্যে লেখা আছে।
এখন টেবিলের ৮টি সারি ৮টি test method. প্রতিটি test শুধু ফেরত আসা অবস্থা নয়, যাত্রার পরের পার্শ্বফল-ও দেখে: wallet আসলে কত কেটেছে আর stock কত। প্রতিটি test-এ নতুন stock আর নতুন wallet তৈরি হয়, যাতে এক scenario-র অবস্থা অন্যটিতে না গড়ায়।
import sys, unittest
def run(cart=None, district="Dhaka", phone="01712345678",
coupon=False, method="wallet", replies=(True,)):
stock = {"chal": 5, "tel": 5, "dal": 0}
w = FakeWallet(replies)
out = checkout(cart or {"chal": 1200, "tel": 900}, stock,
district, phone, coupon, method, w)
return out, stock, w.charged
class CheckoutScenarios(unittest.TestCase):
def test_s1_basic(self):
out, _, paid = run()
self.assertEqual((out["status"], paid), ("paid", [2100]))
def test_s2_2a_out_of_stock(self):
out, _, paid = run(cart={"chal": 1200, "dal": 300})
self.assertEqual((out["status"], paid), ("paid", [1260]))
def test_s3_3a_bad_phone(self):
out, stock, paid = run(phone="01212345678")
self.assertEqual((out["status"], stock["chal"], paid), ("error", 5, []))
def test_s4_4a_coupon(self):
self.assertEqual(run(coupon=True)[2], [1890])
def test_s5_5a_cash(self):
out, _, paid = run(district="Rajshahi", method="cod")
self.assertEqual((out["status"], out["total"], paid), ("placed", 2220, []))
def test_s6_6a_retry(self):
self.assertEqual(run(replies=(False, True))[2], [2100])
def test_s7_6b_cancel(self): # minimal guarantee: no charge, stock back
out, stock, paid = run(replies=(False, False))
self.assertEqual((out["status"], paid, stock["chal"]), ("cancelled", [], 5))
def test_s8_4a_6a(self): # combined path: coupon, then a retry
self.assertEqual(run(coupon=True, replies=(False, True))[2], [1890])
suite = unittest.defaultTestLoader.loadTestsFromTestCase(CheckoutScenarios)
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)আসল আউটপুট (ব্রাউজারের Python, traceback-এর কিছু লাইন “…” দিয়ে ছোট করা):
test_s1_basic (__main__.CheckoutScenarios.test_s1_basic) ... ok
test_s2_2a_out_of_stock (__main__.CheckoutScenarios.test_s2_2a_out_of_stock) ... ok
test_s3_3a_bad_phone (__main__.CheckoutScenarios.test_s3_3a_bad_phone) ... ok
test_s4_4a_coupon (__main__.CheckoutScenarios.test_s4_4a_coupon) ... ok
test_s5_5a_cash (__main__.CheckoutScenarios.test_s5_5a_cash) ... ok
test_s6_6a_retry (__main__.CheckoutScenarios.test_s6_6a_retry) ... ok
test_s7_6b_cancel (__main__.CheckoutScenarios.test_s7_6b_cancel) ... FAIL
test_s8_4a_6a (__main__.CheckoutScenarios.test_s8_4a_6a) ... FAIL
======================================================================
FAIL: test_s7_6b_cancel (__main__.CheckoutScenarios.test_s7_6b_cancel)
----------------------------------------------------------------------
Traceback (most recent call last):
File "main.py", line 30, in test_s7_6b_cancel
…
AssertionError: Tuples differ: ('cancelled', [], 4) != ('cancelled', [], 5)
…
======================================================================
FAIL: test_s8_4a_6a (__main__.CheckoutScenarios.test_s8_4a_6a)
----------------------------------------------------------------------
Traceback (most recent call last):
…
AssertionError: Lists differ: [1680] != [1890]
…
----------------------------------------------------------------------
Ran 8 tests in …
FAILED (failures=2)
৮টির ৬টি পাস, ২টি ফেল, আর দুটি ফেল দুটি আলাদা শিক্ষা দেয়। S7 (6b) ধরেছে defect A: বাতিল অর্ডারেও চালের stock ৫ থেকে ৪ হয়ে আছে, কারণ কোড পরিশোধের আগেই stock কমিয়েছে। লক্ষ করুন, মূল পথের S1 এটি ধরতে পারেনি, কারণ সফল পথে stock কমারই কথা; ভুলটি শুধু ব্যর্থ শেষে দেখা যায়, আর ধরা পড়েছে শুধু এই কারণে যে test minimal guarantee যাচাই করেছে। S8 (4a + 6a) ধরেছে defect B: wallet দ্বিতীয়বার ১৬৮০ কেটেছে, ১৮৯০ নয়। S4 (শুধু coupon) আর S6 (শুধু আবার চেষ্টা) দুটোই পাস করেছে। অর্থাৎ ৭টি একক scenario দিয়ে use case coverage ১০০% হলেও defect B রয়ে যেত; এটি ধরা পড়েছে ঝুঁকির কারণে বেছে নেওয়া মিশ্রণে।
Assertion-এর ক্রম খেয়াল করুন: assertEqual(actual, expected), তাই [1680] != [1890]-এ বাঁয়েরটি কোড যা করেছে, ডানেরটি নিয়ম যা বলে। প্রত্যাশিত মান ১৮৯০ এসেছে নিয়ম থেকে হিসাব করে (২১০০ − ২১০ + ০), কোড চালিয়ে নয়। কোড চালিয়ে যা আসে তা-ই প্রত্যাশিত ফল হিসেবে বসালে test ভুল কোডেও পাস করত।
৬ · User story, acceptance criteria আর scenario
অনেক agile দল use case লেখে না; requirement আসে user story হিসেবে: “একজন ক্রেতা হিসেবে, আমি wallet ব্যর্থ হলে আবার চেষ্টা করতে চাই, যাতে অর্ডারটি হারাতে না হয়।” Story নিজে ছোট আর অস্পষ্ট; তার সাথে থাকে acceptance criteria, অর্থাৎ যে শর্তগুলো পূরণ হলে story “শেষ” বলে মানা হবে। এগুলো প্রায়ই Given-When-Then রূপে লেখা হয়, আর প্রতিটি criterion প্রায় সরাসরি একটি scenario:
Story: wallet ব্যর্থ হলে আবার চেষ্টা
AC1 Given coupon-সহ 1890 টাকার বিল
When wallet প্রথমবার রাজি নয় আর ক্রেতা আবার চেষ্টা করেন
Then wallet-কে আবারও 1890 চাওয়া হয়
And মোট কাটা টাকা ঠিক একবার 1890
AC2 Given wallet দুবার রাজি নয়
When ক্রেতা বাতিল করেন
Then অর্ডার cancelled, কাটা 0, stock আগের মতো
লক্ষ করুন, AC1 হুবহু S8, আর AC2 হুবহু S7. Story-ভিত্তিক দলে tester-এর কাজ তাই দুটি। প্রথম, acceptance criteria-কে scenario হিসেবে পড়া আর test বানানো। দ্বিতীয়, এবং বেশি মূল্যবান: যে criteria লেখা হয়নি, তা খোঁজা। Story-গুলো আলাদা আলাদা লেখা হয়, তাই কয়েকটি story মিলে যে যাত্রা হয় (coupon story + retry story), তার মিশ্রণ প্রায়ই কারও criteria-তে থাকে না। Use case-এর মতো একটি পুরো যাত্রার মানচিত্র (বা story map) পাশে রাখলে এই ফাঁক চোখে পড়ে। Story আর acceptance criteria থেকে testable requirement লেখা পর্ব ১৫ (Requirement থেকে test — acceptance criteria আর testability)-এর বিষয়, আর Given-When-Then-কে চালানো test বানানো পর্ব ৪৩ (BDD আর Gherkin — Given-When-Then আর pytest-bdd)-এ।
| দিক | Use case | User story + AC |
|---|---|---|
| আকার | একটি লক্ষ্যের পুরো যাত্রা | যাত্রার একটি ছোট অংশ |
| বিকল্প পথ | extension হিসেবে এক জায়গায় | আলাদা story বা AC-তে ছড়ানো |
| Test-এর উৎস | মূল পথ + প্রতিটি extension | প্রতিটি AC একটি scenario |
| সাধারণ ফাঁক | extension-এর গন্তব্য না লেখা | story-র মিশ্রণ কারও AC-তে নেই |
“Scenario testing” শব্দটির একটি দ্বিতীয়, আরও মুক্ত অর্থও আছে। Cem Kaner-এর ধারায় scenario হলো একটি বিশ্বাসযোগ্য, জটিল গল্প, যা use case-এর বাইরেও যায়: যেমন “ঈদের আগের রাতে একজন ক্রেতা ধীর মোবাইল নেটওয়ার্কে তিনটি ট্যাবে একই cart খুলে checkout করছেন”। Hans Buwalda ২০০৪ সালের দিকে এরই একটি চরম রূপকে “soap opera testing” নাম দেন: বাস্তব জীবনের ঘটনাকে নাটকের মতো ঘনীভূত করে এক scenario-তে অনেক অস্বাভাবিক ঘটনা ঢোকানো। এ ধরনের scenario নিয়মমাফিক গোনা যায় না; এর শক্তি কল্পনায়, আর এটি পর্ব ১৪-এর অভিজ্ঞতাভিত্তিক testing-এর কাছাকাছি। Use case থেকে বের করা scenario আর গল্প-scenario একে অপরের পরিপূরক: প্রথমটি পূর্ণতা দেয়, দ্বিতীয়টি বাস্তবতা।
৭ · End-to-end mapping — কোন scenario কোন স্তরে
একটি scenario পুরো যাত্রা, কিন্তু তার test সবসময় browser খুলে পুরো system-এ চালাতে হবে, এমন নয়। Checkout-এর পেছনে কয়েকটি অংশ কাজ করে: cart, দামের হিসাব, অর্ডার, payment আর stock. প্রতিটি scenario কোন অংশ ছোঁয়, তা টেবিলে লিখলে (end-to-end mapping) দুটি জিনিস পরিষ্কার হয়: কোন অংশের defect কোন scenario ধরতে পারে, আর কোন scenario কোন test level-এ চালানো সস্তা।
| Scenario | Cart | হিসাব | অর্ডার | Payment | Stock | কোথায় চালানো সস্তা |
|---|---|---|---|---|---|---|
| S1 মূল পথ | ✓ | ✓ | ✓ | ✓ | ✓ | একটি UI end-to-end + API |
| S2 stock শেষ | ✓ | ✓ | ✓ | ✓ | ✓ | API (stock সাজানো সহজ) |
| S3 phone ভুল | unit বা component (form) | |||||
| S4 coupon | ✓ | ✓ | ✓ | unit (হিসাব) + API | ||
| S5 cash on delivery | ✓ | ✓ | ✓ | ✓ | API | |
| S6, S7, S8 wallet | ✓ | ✓ | ✓ | ✓ | integration, নকল wallet দিয়ে |
এখানে একটি গুরুত্বপূর্ণ নীতি: scenario হলো নকশার একক, চালানোর স্তর নয়। S3-এর পুরো যাত্রা browser-এ চালানো যায়, কিন্তু phone-এর নিয়ম একটি ছোট unit test-এ মিনিটের ভগ্নাংশে যাচাই হয়। পুরো UI-এর end-to-end test ধীর আর ভঙ্গুর, তাই সাধারণত শুধু মূল পথ আর সবচেয়ে ঝুঁকির এক-দুটি পথ সেখানে রাখা হয়, বাকি scenario নিচের স্তরে। এটিই test pyramid-এর যুক্তি, যা পর্ব ০৫-এ দেখেছেন। Wallet-এর scenario-গুলোতে আসল payment সেবা কখনো নয়; নকল wallet বা mock server দিয়ে “রাজি নয়”, “সাড়া নেই” ইত্যাদি সহজে সাজানো যায় (পর্ব ৩৪, Service virtualization — mock server আর নির্ভরতা আলাদা করা)।
Mapping-এ আরেকটি জিনিস চোখে পড়ে: একটি scenario যে অংশ ছোঁয় না, সেই অংশের defect সে ধরতে পারে না। S3-এর কলামগুলো প্রায় খালি, তাই S3 পাস করা মানে payment বা stock সম্পর্কে কিছুই প্রমাণিত নয়। প্রতিটি কলামে অন্তত কয়েকটি ✓ আছে কি না দেখে নিন; সম্পূর্ণ খালি কলাম মানে সেই অংশ কোনো scenario-তেই নেই।
৮ · CRUD matrix — হারিয়ে যাওয়া use case খোঁজা
Scenario testing একটি use case-এর ভেতরের পথ ঢাকে। কিন্তু পুরো একটি use case-ই যদি লেখা না হয়? এটি ধরার একটি পুরোনো, সহজ হাতিয়ার CRUD matrix: সারিতে use case, কলামে data-র entity (পণ্য, cart, অর্ডার, payment), আর প্রতিটি ঘরে লেখা হয় সেই use case entity-টিকে তৈরি (C), পড়া (R), বদলানো (U) না মোছা (D) করে। তারপর প্রতিটি কলামে চারটি অক্ষর খোঁজা হয়। কোনো অক্ষর কোথাও না থাকলে প্রশ্ন: এই কাজটি কি সত্যিই কখনো লাগে না, নাকি এর use case লেখা বাকি? সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ২৩-এ matrix-টি model যাচাইয়ের দিক থেকে আছে; এখানে tester-এর ব্যবহার।
# CRUD matrix: use case -> {entity: C/R/U/D letters}
UC = {
"UC-01 search": {"Prod": "R"},
"UC-02 cart": {"Cart": "CRUD", "Prod": "R"},
"UC-05 checkout": {"Cart": "RD", "Prod": "RU",
"Order": "C", "Pay": "C"},
"UC-07 track": {"Order": "R"},
"UC-08 cancel": {"Order": "U", "Prod": "U"},
"UC-09 stock": {"Prod": "CRU"},
}
ENT = ["Prod", "Cart", "Order", "Pay"]
print(f"{'use case':15}" + "".join(f"{e:>6}" for e in ENT))
for uc, row in UC.items():
print(f"{uc:15}" + "".join(f"{row.get(e, '-'):>6}" for e in ENT))
print("\ngaps (letters no use case performs):")
for e in ENT:
done = set("".join(row.get(e, "") for row in UC.values()))
missing = "".join(c for c in "CRUD" if c not in done)
print(f" {e:6} missing {missing or 'none'}")
print("\nUC-08 cancel touches Pay:", "Pay" in UC["UC-08 cancel"])আসল আউটপুট (ব্রাউজারের Python):
use case Prod Cart Order Pay
UC-01 search R - - -
UC-02 cart R CRUD - -
UC-05 checkout RU RD C C
UC-07 track - - R -
UC-08 cancel U - U -
UC-09 stock CRU - - -
gaps (letters no use case performs):
Prod missing D
Cart missing none
Order missing D
Pay missing RUD
UC-08 cancel touches Pay: False
প্রতিটি ফাঁক একটি প্রশ্ন, সরাসরি defect নয়। Order-এ D নেই: সম্ভবত ঠিক, কারণ অর্ডারের হিসাব রেখে দিতে হয়; বাতিল মানে অবস্থা বদলানো (U), মোছা নয়। Prod-এ D নেই: বিক্রি বন্ধ পণ্য কী হবে, মুছবে না লুকাবে? Product owner-কে জিজ্ঞেস করার মতো। সবচেয়ে বড় খবর Pay-এ U নেই, আর শেষ লাইন বলছে অর্ডার বাতিলের use case payment-কে ছোঁয়ই না। অর্থাৎ paid অর্ডার বাতিল হলে টাকা ফেরতের (refund) কোনো use case নেই। এই ফাঁক কোনো scenario test খুঁজে পেত না, কারণ scenario শুধু লেখা use case-এর ভেতরে হাঁটে।
যে ফাঁদগুলো বারবার দেখা যায়
- শুধু মূল পথ। Demo-র মতো test: সব ঠিক চললে কী হয়। Defect-এর বড় অংশ extension-এ।
- ব্যর্থ পথে শুধু বার্তা দেখা। Minimal guarantee (টাকা, stock, অবস্থা) যাচাই ছাড়া S7-এর মতো test defect A ছেড়ে দিত।
- ফেরার লুপ একবারও না চালানো, বা মাত্র একবার চালিয়ে দ্বিতীয়বারের অবস্থা না দেখা।
- Scenario-গুলো একে অপরের ওপর নির্ভরশীল: S1 যে stock কমায়, S2 তার ওপর চলে। ক্রম বদলালে ফল বদলায়। প্রতিটি scenario নিজের অবস্থা নিজে সাজাবে।
- একটি লম্বা “সব একসাথে” scenario. Coverage দ্রুত বাড়ে, কিন্তু ব্যর্থ হলে কারণ খোঁজা কঠিন, আর প্রথম ব্যর্থতার পরের অংশ চলেই না।
- ধাপের ভেতরের input ভুলে যাওয়া। Scenario পথ ঠিক করে; প্রতিটি ধাপে কোন মান দেবেন, তা EP, BVA আর decision table ঠিক করে।
আরও গভীরে: Use case-এর পথগুলো আসলে একটি directed graph-এর পথ, তাই scenario বের করা একটি graph-traversal সমস্যা: লুপ থাকলে পথ অসীম, তাই “প্রতিটি লুপ সর্বোচ্চ k বার” ধরনের সীমা লাগে, ঠিক যেমন code-এর path coverage-এ (পর্ব ১৩)। ISO/IEC/IEEE 29119-4 test কৌশলের মান, আর তাতে scenario testing একটি specification-based কৌশল হিসেবে আছে, যার coverage মাপা হয় মূল আর বিকল্প পথ ধরে। ISTQB-এর Foundation syllabus-এর ২০১৮ সংস্করণে use case testing আলাদা black-box কৌশল ছিল; আমাদের জানামতে ২০২৩ সালের v4.0-তে সেটি মূল তালিকা থেকে সরে গেছে, আর user story ও acceptance criteria-ভিত্তিক collaboration বেশি জায়গা পেয়েছে। Model-based testing tool-গুলো activity diagram বা state machine থেকে স্বয়ংক্রিয়ভাবে পথ তৈরি করে, যা §৪-এর program-এর বড় রূপ।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন চেনা:
- একটি use case-এ মূল পথ আর ৪টি extension. ন্যূনতম কয়টি scenario? — ১ + ৪ = ৫.
- ৭টি use case আচরণের ৩টি test হয়েছে। Coverage? — ৩ ÷ ৭ ≈ ৪২.৯%.
- Main success scenario আর extension-এর পার্থক্য? — প্রথমটি সব ঠিক চললে লক্ষ্য পূরণের ধাপ; দ্বিতীয়টি কোনো ধাপে শর্ত ভিন্ন হলে বিকল্প বা ব্যর্থতার পথ, যা মূল পথে ফেরে বা শেষ হয়।
- Use case testing কোন level-এ সবচেয়ে কাজের? — system আর acceptance testing-এ, যেখানে পুরো যাত্রা দেখা হয়; তবে প্রতিটি scenario সবচেয়ে সস্তা level-এ চালানো যায়।
- CRUD matrix কী খোঁজে? — কোনো entity-র তৈরি, পড়া, বদলানো বা মোছার কাজ কোনো use case-এ নেই কি না, অর্থাৎ হারিয়ে যাওয়া use case.
৯ · AI-এর যুগে use case আর scenario testing
AI assistant-কে একটি feature-এর বর্ণনা দিয়ে “test scenario লিখে দিন” বললে দ্রুত একটি পরিচ্ছন্ন তালিকা আসে। পরীক্ষা করে দেখলে কিছু ধরন বারবার চোখে পড়ে। তালিকার বেশিরভাগ মূল পথের সামান্য রূপভেদ: বিভিন্ন পণ্য দিয়ে সফল অর্ডার। Extension এলেও প্রত্যাশিত ফল হয় শুধু একটি বার্তা (“error message দেখাবে”), guarantee নেই। ফেরার লুপের দ্বিতীয় চক্র, বা দুটি extension-এর মিশ্রণ প্রায় আসে না, অথচ defect B ঠিক সেখানে। কোড দেওয়া থাকলে AI প্রায়ই কোডের আচরণ পড়ে প্রত্যাশিত ফল বসায়, ফলে ১৬৮০-কেই “সঠিক” ধরে test লিখে ফেলতে পারে। Use case-এ নেই এমন ধাপ বা API field বানিয়ে ফেলে, UI test-এ অপেক্ষার জন্য নির্দিষ্ট সময়ের sleep বসায়, wallet-কে এমনভাবে mock করে যে আসল কিছুই test হয় না, আর চালানো ছাড়াই বলে “সব test পাস”।
AI-কে use case দিন, কোড নয়, আর প্রতিটি পথের শেষ অবস্থা চান:
AI-এর বানানো scenario আর test হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Use case এসেছিল ১৯৮০-এর দশকে, user story ১৯৯০-এর শেষে। Agile দলগুলো use case ছেড়ে story-তে গেল কেন, আর tester-এর জন্য use case-এর চিন্তা কি এখনো দরকারি?
Ivar Jacobson Ericsson-এ টেলিফোন switch-এর মতো বড় system নকশা করতে গিয়ে use case গড়ে তোলেন: system-কে ভেতরের অংশ দিয়ে নয়, বাইরের ব্যবহারকারীর লক্ষ্য দিয়ে বর্ণনা করা। ১৯৮৭ সালে OOPSLA-তে উপস্থাপন আর ১৯৯২ সালের বইয়ের পরে ধারণাটি দ্রুত ছড়ায়, ১৯৯৭ সালে UML-এ use case diagram আসে, আর Rational Unified Process-এর মতো পদ্ধতিতে use case হয়ে ওঠে পুরো প্রকল্পের মেরুদণ্ড। সমস্যা দেখা দিল ভারী নথিতে: শত শত পাতার fully dressed use case, যা লিখতে মাস লাগে আর লেখা শেষ হওয়ার আগেই পুরোনো হয়ে যায়।
Kent Beck-এর Extreme Programming (তাঁর বই ১৯৯৯) ছোট “story” কার্ড নিয়ে আসে। Ron Jeffries পরে এর তিনটি অংশের কথা বলেন: Card, Conversation, Confirmation. অর্থাৎ কার্ডে অল্প লেখা, বিস্তারিত আসে আলাপে, আর নিশ্চিতকরণ আসে acceptance test থেকে। Mike Cohn-এর ২০০৪ সালের বই “User Stories Applied” এটিকে মূলধারায় আনে। Story ছোট, অগ্রাধিকার দেওয়া সহজ, এক sprint-এ শেষ করা যায়; তাই agile দলের কাজের ছন্দের সাথে মেলে।
কিন্তু ছোট হওয়ার একটি দাম আছে: পুরো যাত্রা আর তার বিকল্প পথ কারও মাথায় একসাথে থাকে না। §৬-এর উদাহরণে coupon আর retry দুটি আলাদা story, আর তাদের মিশ্রণে defect B. এজন্যই পরে story map (Jeff Patton) এসেছে, যা story-গুলোকে ব্যবহারকারীর যাত্রার ক্রমে সাজায়; আর Jacobson নিজেও ২০১১ সালের দিকে “Use-Case 2.0” প্রস্তাব করেন, যেখানে use case-কে ছোট slice-এ ভেঙে story-র মতো কাজ করা যায়।
Tester-এর জন্য তাই উত্তর হলো: নথির রূপ যা-ই হোক, use case-এর চিন্তা দরকারি। কোন actor, কোন লক্ষ্য, মূল পথ কী, কোন ধাপে কী ভিন্ন হতে পারে, আর ব্যর্থ হলেও কী সত্য থাকবে। Story-ভিত্তিক দলে এই প্রশ্নগুলো tester নিজেই তোলেন, প্রায়ই একটি হালকা যাত্রার মানচিত্র এঁকে।
মূল উপলব্ধি: Use case থেকে story-তে যাওয়া নথির ভার কমিয়েছে, কিন্তু পুরো যাত্রা দেখার প্রয়োজন কমায়নি। সেই দেখার দায়িত্ব এখন প্রায়ই tester-এর।
প্র ০২Checkout-এ ৪৮টি পথ, অথচ চালালাম ৮টি। কোন মিশ্রণ বাছব, তা কি শুধু অনুমান? আর scenario কতটা “বাস্তব” হওয়া উচিত?
অনুমান নয়, তবে বিচার। তিনটি প্রশ্ন বাছাইকে পদ্ধতিগত করে। প্রথম, কোন extension একই অবস্থা ছোঁয়? 4a ছাড় বদলায়, 6a সেই বিলেই আবার টাকা চায়; দুটি একই সংখ্যা ছোঁয়, তাই জোড়াটি ঝুঁকিপূর্ণ। 3a (phone) আর 5a (cash) কোনো সাধারণ অবস্থা ছোঁয় না, তাই তাদের জোড়ায় নতুন defect-এর সম্ভাবনা কম। দ্বিতীয়, কোন পথে ক্ষতি বেশি? টাকা আর stock-এর পথ phone-এর ভুলের চেয়ে বেশি গুরুত্বপূর্ণ, তাই সেখানে বেশি মিশ্রণ। তৃতীয়, ব্যবহারকারী কোন পথ বেশি নেন? বাস্তব ব্যবহারের তথ্য (কতজন coupon দেন, কতবার wallet ব্যর্থ হয়) থাকলে সেটি অগ্রাধিকার ঠিক করে; একে কখনো operational profile বলা হয়।
যদি মিশ্রণের সংখ্যা তবু বড় থাকে, combinatorial কৌশল কাজে আসে: extension-গুলোকে “নেওয়া বা না-নেওয়া” factor ধরে প্রতিটি জোড়া অন্তত একবার ঢাকা (পর্ব ১১)। NIST-এর গবেষকরা (D. Richard Kuhn ও সহকর্মীরা) কয়েকটি ক্ষেত্রের ব্যর্থতা বিশ্লেষণ করে দেখিয়েছেন যে বেশিরভাগ ব্যর্থতা এক বা দুটি factor-এর মিশ্রণে ঘটে; এটি নির্দিষ্ট data-র পর্যবেক্ষণ, সব software-এর প্রমাণ নয়, কিন্তু “জোড়া ঢাকা” কৌশলের একটি যুক্তি।
“বাস্তবতা” নিয়ে Cem Kaner-এর ২০০৩ সালের দিকের লেখা একটি ভালো মাপকাঠি দেয়: ভালো scenario একটি গল্প, যা বিশ্বাসযোগ্য (stakeholder মানবেন যে এমন ঘটতে পারে), প্রেরণাদায়ক (ব্যর্থ হলে কেউ ঠিক করতে চাইবেন), জটিল (কয়েকটি বৈশিষ্ট্য একসাথে), আর যার ফল সহজে বিচার করা যায়। শেষ শর্তটি গুরুত্বপূর্ণ: অতিরিক্ত জটিল scenario-তে প্রত্যাশিত ফল কেউ নিশ্চিতভাবে জানেন না, তখন test-এর oracle দুর্বল হয়ে যায়।
তাই দুই ধরনের scenario মিশিয়ে নেওয়াই ভালো: use case থেকে নিয়মমাফিক বের করা ছোট scenario, যাদের গোনা আর coverage মাপা যায়; আর কয়েকটি গল্প-scenario, যা বাস্তব জীবনের জটিলতা আনে।
মূল উপলব্ধি: সব পথ চালানো অসম্ভব হলে বাছাই করুন অবস্থা-ভাগাভাগি, ক্ষতি আর ব্যবহারের হার ধরে, আর বাছাইয়ের কারণ লিখে রাখুন।
প্র ০৩Defect A আর B দুটোই “ফেরার পথ”-এর ভুল। আবার চেষ্টা, back বোতাম, দুবার চাপ — এই জায়গাগুলো এত বিপজ্জনক কেন, আর system কীভাবে নিজেকে রক্ষা করে?
Use case-এর মূল পথ সরলরেখা: প্রতিটি ধাপ একবার, ক্রমমতো। Developer প্রায়ই এই সরলরেখা মাথায় রেখে কোড লেখেন: “ধাপ ৪-এ ছাড় বাদ, ধাপ ৬-এ টাকা চাওয়া।” Extension যখন পথকে আগের ধাপে ফিরিয়ে আনে, তখন কোনো ধাপ দ্বিতীয়বার চলে, অথচ প্রথমবারের রেখে যাওয়া অবস্থা মুছে যায়নি। Defect B ঠিক এটি: “ছাড় বাদ দেওয়া”-র লাইনটি দ্বিতীয়বার চলল। Defect A তার উল্টো: একটি কাজ (stock কমানো) ভুল ধাপে আগে হয়ে গেছে, আর ব্যর্থ শেষে তা ফেরানো হয়নি।
Web-এ এই সমস্যা আরও সাধারণ, কারণ ব্যবহারকারী নিজেই পথ ফেরাতে পারেন: browser-এর back বোতাম, পাতা reload, বা ধীর নেটওয়ার্কে “Pay” দুবার চাপা। প্রতিটি একটি অলিখিত extension. Payment-এর ক্ষেত্রে সবচেয়ে ভয়ের ফল দুবার টাকা কাটা।
এর বিরুদ্ধে প্রচলিত প্রতিরক্ষা idempotency key: client প্রতিটি পরিশোধ-অনুরোধের সাথে একটি অনন্য চাবি পাঠায়, আর server একই চাবির দ্বিতীয় অনুরোধে নতুন করে টাকা না কেটে আগের ফলটিই ফেরত দেয়। অনেক payment API এই ধরনের চাবি সমর্থন করে। HTTP-র মান (RFC 9110, ২০২২) কোন method-গুলো idempotent, তা সংজ্ঞায়িত করে: একই অনুরোধ একাধিকবার পাঠালে ফল একবার পাঠানোর মতোই। আরেকটি প্রতিরক্ষা হলো ধাপের ক্রম ঠিক রাখা: stock “আটকে রাখা” (reserve) আর টাকা নিশ্চিত হলে তবেই চূড়ান্ত কমানো, ব্যর্থ হলে আটকানো ছেড়ে দেওয়া।
Tester-এর জন্য এর মানে একটি তালিকা: প্রতিটি ফেরার পথ দুবার চালান; প্রতিটি টাকা বা stock-এর ধাপে “দুবার চাপ” আর “মাঝপথে reload” চেষ্টা করুন; আর প্রতিটি ব্যর্থ শেষে minimal guarantee যাচাই করুন। State-এর এই ধরনের পথ আরও নিয়মমাফিক দেখা হয় পর্ব ১০-এর state transition testing-এ, যেখানে অর্ডারের অবস্থাগুলো আর অবৈধ পথ test হয়।
মূল উপলব্ধি: যেখানে পথ ফেরে, সেখানে অবস্থা জমে। ফেরার প্রতিটি পথ অন্তত দুবার চালান, আর শেষ অবস্থা মেলান।
প্র ০৪Scenario মানেই কি browser-এ পুরো end-to-end test? সব scenario UI দিয়ে automate করলে কী সমস্যা হয়?
না। Scenario হলো নকশার একক: কোন পথ, কোন data, কোন প্রত্যাশিত ফল। কোথায় চালাবেন, সেটি আলাদা সিদ্ধান্ত। সব scenario browser দিয়ে চালালে কয়েকটি পরিচিত সমস্যা আসে। প্রথম, গতি: প্রতিটি UI test পাতা খোলা, লগইন, cart সাজানো দিয়ে শুরু হয়, তাই কয়েক সেকেন্ড থেকে মিনিট লাগে, আর শত শত scenario-তে suite ঘণ্টা ছাড়ায়। দ্বিতীয়, ভঙ্গুরতা: একটি বোতামের জায়গা বা নাম বদলালে অনেক test একসাথে ভাঙে, যদিও আচরণ ঠিক আছে। তৃতীয়, কারণ খোঁজা: পুরো যাত্রার test ফেল করলে defect cart-এ, হিসাবে, না payment-এ, তা আলাদা করে খুঁজতে হয়। চতুর্থ, অবস্থা সাজানো: “wallet প্রথমবার রাজি নয়” browser থেকে ঘটানো কঠিন; নিচের স্তরে নকল wallet দিয়ে সহজ।
Mike Cohn ২০০৯ সালের “Succeeding with Agile” বইয়ে test pyramid-এর ছবি জনপ্রিয় করেন: নিচে অনেক দ্রুত unit test, মাঝে service বা API test, ওপরে অল্প কিছু UI test. উল্টো আকারটিকে (অনেক UI test, অল্প unit test) পরে অনেকে “ice-cream cone” বলে সতর্ক করেছেন। §৭-এর mapping এই নীতির একটি প্রয়োগ: S3-এর phone নিয়ম unit test-এ, wallet-এর scenario নকল wallet দিয়ে integration test-এ, আর UI-তে শুধু মূল পথ ও এক-দুটি সবচেয়ে ঝুঁকির পথ।
তবু একটি পুরো UI end-to-end test-এর মূল্য আছে, কারণ নিচের স্তরের test-গুলো আলাদাভাবে পাস করলেও অংশগুলোর জোড়া (frontend যে field পাঠায়, backend যা আশা করে) শুধু পুরো পথেই দেখা যায়। এজন্যই মূল পথটি ওপরে থাকে। Full-Stack Web Frameworks কোর্সে Playwright দিয়ে এমন test-এর প্রয়োগ আছে, আর এই কোর্সে পর্ব ৩৬ (Playwright-এর মূল — locator, auto-wait আর assertion)-এ বিস্তারিত।
মূল উপলব্ধি: Scenario নকশা করুন পুরো যাত্রা ধরে, কিন্তু প্রতিটি scenario চালান সবচেয়ে নিচের যে স্তরে তার ঝুঁকি ধরা পড়ে।
প্র ০৫Given-When-Then-এ লেখা acceptance criteria কি নিজেই test? Specification by example-এর ধারণা scenario testing-কে কীভাবে বদলেছে?
Given-When-Then রূপটি জনপ্রিয় হয় Dan North-এর behaviour-driven development (BDD) থেকে; তাঁর পরিচিত প্রবন্ধ “Introducing BDD” ২০০৬ সালের দিকে প্রকাশিত। ধারণাটি ছিল test-কে আচরণের উদাহরণ হিসেবে লেখা, এমন ভাষায় যা ব্যবসার লোকও পড়তে পারেন। পরে Cucumber-এর মতো tool এই লেখাকে (Gherkin ভাষায়) সরাসরি চালানো যায় এমন test-এর সাথে জুড়ে দেয়। Gojko Adzic-এর ২০১১ সালের বই “Specification by Example” একই চিন্তাকে বড় পরিসরে দেখায়: requirement লেখা হবে নির্দিষ্ট উদাহরণে, আর সেই উদাহরণগুলোই হবে স্বয়ংক্রিয় test আর জীবন্ত নথি।
এতে scenario testing-এর সময়রেখা বদলেছে। আগে tester requirement পাওয়ার পরে scenario বানাতেন। এখন প্রায়ই product owner, developer আর tester একসাথে বসে (“three amigos”) story-র উদাহরণ ঠিক করেন, আর tester-এর প্রশ্ন (“wallet দুবার ব্যর্থ হলে?”) কোড লেখার আগেই নতুন criterion হয়ে যায়। এটি shift-left-এর একটি বাস্তব রূপ।
তবে Given-When-Then লেখা থাকলেই তা ভালো test নয়। তিনটি সাধারণ দুর্বলতা আছে। প্রথম, criteria শুধু মূল পথ বলে; extension আর guarantee প্রায়ই অনুপস্থিত। দ্বিতীয়, “Then” অংশ অস্পষ্ট (“সফল বার্তা দেখাবে”), যাচাইযোগ্য অবস্থা নেই। তৃতীয়, একটি story-র criteria অন্য story-র সাথে মিশ্রণ দেখে না। তাই tester use case-এর যন্ত্রপাতি (extension তালিকা, guarantee, মিশ্রণ বাছাই) ব্যবহার করে criteria-গুলো সম্পূর্ণ করেন। কোন উদাহরণ test হলো আর কোনটি হলো না, তার হিসাব রাখে traceability, যা পর্ব ১৯-এ আছে।
মূল উপলব্ধি: Given-When-Then একটি ভালো ভাষা, কিন্তু কোন উদাহরণ লিখবেন তা ঠিক করে test design. Use case-এর চিন্তা সেই বাছাইকে সম্পূর্ণ করে।
অনুশীলন
কাগজ-কলমে করুন, তারপর উত্তর মিলিয়ে নিন। চাইলে উপরের program-গুলো বদলে নিজের উত্তর যাচাই করতে পারেন।
-
Use case থেকে scenario আর test case (test design): বাজারঘরের “UC-08 অর্ডার বাতিল”-এর মূল পথ: ১. ক্রেতা অর্ডার খোলেন; ২. বাতিল চাপেন; ৩. System দেখে অর্ডার paid; ৪. System অর্ডার cancelled করে, stock ফেরত দেয়; ৫. System wallet-এ টাকা ফেরত (refund) শুরু করে; ৬. System SMS পাঠায়। Extension: 3a. অর্ডার placed (টাকা দেওয়া হয়নি) → ধাপ ৪, তারপর ধাপ ৫ বাদ দিয়ে ধাপ ৬; 3b. অর্ডার shipped বা delivered → বাতিল নিষেধের বার্তা, ব্যর্থ শেষ; 5a. Refund ব্যর্থ → System refund আবার চেষ্টার তালিকায় রাখে, admin-কে জানায় → ধাপ ৬। ন্যূনতম scenario কয়টি? প্রতিটির test data আর প্রত্যাশিত ফল দিন। কোন মিশ্রণ অসম্ভব?
ন্যূনতম ১ + ৩ = ৪টি। U1 মূল পথ: paid অর্ডার, ২১০০ টাকা → cancelled, stock ফেরত, refund ২১০০ শুরু, SMS. U2 3a: placed (cash on delivery) অর্ডার → cancelled, stock ফেরত, কোনো refund নয়। U3 3b: shipped অর্ডার → নিষেধের বার্তা, অবস্থা shipped-ই থাকে, stock আর টাকা অপরিবর্তিত। U4 5a: paid অর্ডার, নকল wallet refund-এ রাজি নয় → cancelled, stock ফেরত, refund আবার চেষ্টার তালিকায়, admin-কে বার্তা, টাকা “হারায়নি”।
§৪-এর মতো একটি script দিয়ে সব পথ গুনলে (প্রতিটি extension সর্বোচ্চ একবার) ৫টি আসে: মূল, 5a, 3a, 3a + 5a, 3b. কিন্তু 3a + 5a অসম্ভব, কারণ 3a-তে ধাপ ৫ (refund) বাদ পড়ে, তাই refund ব্যর্থ হওয়ার সুযোগই নেই। যান্ত্রিক গোনা পথের গঠন দেখে, শর্তের অর্থ নয়; অসম্ভব পথ মানুষকে বাদ দিতে হয়। আরও দুটি সীমা মনে রাখুন: packed (বাতিল চলে) আর shipped (চলে না)-এর মাঝের সীমা, যা পর্ব ১০-এর state transition-এর বিষয়; আর U1-এ refund-এর টাকা ঠিক কাটা টাকার সমান কি না। এই use case যোগ হলে CRUD matrix-এ Pay-এর U-ও আর ফাঁকা থাকে না।
-
Failure পড়ুন (read the failure): একটি scenario test-এর ইনপুট: পণ্য ২১০০ টাকা, ঢাকার ভেতরে, coupon দেওয়া, wallet প্রথমবার রাজি নয়, দ্বিতীয়বার রাজি। Runner লিখল
AssertionError: Lists differ: [1680] != [1890]. কোনটি actual, কোনটি expected? Expected মানটি নিয়ম থেকে হিসাব করে দেখান। ভুলটি কোথায় হতে পারে, আর শুধু coupon-এর test বা শুধু retry-এর test কেন এটি ধরেনি?assertEqual(actual, expected)ক্রমে বাঁয়ে actual[1680], ডানে expected[1890]. নিয়ম: ছাড় ২১০০-এর ১০% = ২১০ (৩০০-এর কম); ঢাকার ভেতরে ২০০০ বা বেশি, তাই delivery ০; মোট ২১০০ − ২১০ + ০ = ১৮৯০. কাটা গেছে ১৬৮০ = ১৮৯০ − ২১০, অর্থাৎ দ্বিতীয় চেষ্টার আগে ছাড় আবার বাদ দেওয়া হয়েছে। Wallet একবারই টাকা কেটেছে (তালিকায় একটি মান), তাই সমস্যা দুবার কাটা নয়, ভুল অঙ্ক। শুধু coupon-এর test-এ retry নেই, তাই দ্বিতীয়বার বাদ দেওয়ার লাইন চলেই না। শুধু retry-এর test-এ ছাড় ০, তাই ০ দুবার বাদ দিলেও অঙ্ক বদলায় না। Defect-টি দেখা যায় শুধু দুটি extension-এর মিশ্রণে। -
Test-এর ভুল খুঁজুন (find the bug in this test): একজন সহকর্মী S7-এর জন্য এই test লিখেছেন, আর §৫-এর ভুলওয়ালা
checkout()-এ এটি পাস করছে। Test-এ কী দুর্বলতা, আর কীভাবে ঠিক করবেন?def test_cancel(self): out, stock, paid = run(replies=(False, False)) self.assertEqual(out["status"], "cancelled")Test শুধু ফেরত আসা অবস্থার লেখা (“cancelled”) দেখে। Use case-এর minimal guarantee বলে বাতিল পথেও টাকা কাটা ০ আর stock আগের মতো থাকবে, কিন্তু test
paidআরstockপেয়েও যাচাই করে না। তাই defect A (পরিশোধের আগেই stock কমানো) নিয়েও পাস করে। ঠিক রূপ:self.assertEqual((out["status"], paid, stock["chal"]), ("cancelled", [], 5)), অথবা তিনটি আলাদা assertion. যাচাই করতে কোডে stock কমানোর লাইনটি পরিশোধের পরে সরিয়ে দেখুন: পুরোনো test দুই কোডেই পাস করে, নতুন test শুধু ঠিক কোডে। -
Scenario গোনা আর coverage: “লগইন” use case: মূল পথ ১. ক্রেতা phone আর password দেন; ২. System মিলিয়ে দেখে; ৩. System OTP পাঠায়, ক্রেতা দেন; ৪. লগইন সফল। Extension: 2a ভুল password → ধাপ ১-এ ফেরে; 2b পরপর তিনবার ভুল → অ্যাকাউন্ট সাময়িক আটকে, ব্যর্থ শেষ; 3a OTP আসেনি → আবার পাঠানো, ধাপ ৩-এ ফেরে; 3b OTP মেয়াদোত্তীর্ণ → ব্যর্থ শেষ। (ক) ন্যূনতম scenario কয়টি? (খ) প্রতিটি extension সর্বোচ্চ একবার ধরলে মোট কয়টি পথ? (গ) একটি suite চালিয়েছে মূল পথ, 2a আর 3a. Coverage কত? (ঘ) 2b-তে কোন সীমার test লাগবে?
(ক) ১ + ৪ = ৫. (খ) §৪-এর program-এর মতো একটি script-এ গুনলে ১০টি পথ: মূল; 3a; 3a + 3b; 3b; 2a; 2a + 3a; 2a + 3a + 3b; 2a + 3b; 2a + 2b; 2b. (গ) ৫টি আচরণের ৩টি: ৩ ÷ ৫ = ৬০%; বাদ পড়েছে দুটি ব্যর্থ শেষ, 2b আর 3b, যেখানে নিরাপত্তার ঝুঁকি সবচেয়ে বেশি। (ঘ) “তিনবার” একটি সীমা: দুবার ভুলের পর তৃতীয়বার ঠিক password দিলে লগইন হবে (আটকাবে না), আর তিনবার ভুলে আটকাবে; সাথে “পরপর” শব্দটির অর্থ (মাঝে একবার সঠিক লগইন হলে গোনা কি শূন্য থেকে শুরু?) product owner-কে জিজ্ঞেস করার মতো প্রশ্ন। লক্ষ করুন, এখানে লুপ ১ বারের বেশি ঘুরতে পারে, তাই “সর্বোচ্চ একবার” নিয়মে গোনা ১০টি পথের বাইরে 2a-র দ্বিতীয় চক্রও ঝুঁকির কারণে আলাদা test পাওয়ার যোগ্য।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমUse case থেকে scenario test বানানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Use case পড়ে প্রতিটি extension কোথায় শুরু আর কোথায় যায়, তার মানচিত্র আঁকা
- মূল পথের scenario লেখা
- প্রতিটি extension-এর জন্য একটি করে scenario লেখা
- ঝুঁকি ধরে লুপের দ্বিতীয় চক্র আর extension-এর মিশ্রণ বাছা
- প্রতিটি scenario-তে test data আর শেষ অবস্থাসহ প্রত্যাশিত ফল দেওয়া
- Test চালিয়ে coverage মাপা আর বাদ দেওয়া পথ লিখে রাখা
একটি use case-এ মূল পথ ১টি আর extension ৫টি (প্রতিটির একটি করে শেষ)। প্রচলিত নিয়মে ন্যূনতম কয়টি test scenario লাগে?
- ৫টি
- ৬টি
- ৩২টি
- ১টি, সব extension একসাথে
Checkout use case-এর minimal guarantee: “টাকা কাটা না হলে অর্ডার paid নয়; অর্ডার না হলে stock আগের মতো।” Wallet দুবার ব্যর্থ হওয়ার পর ক্রেতা বাতিল করলেন। Test-এ কী যাচাই করা সবচেয়ে জরুরি?
- “Payment failed” বার্তা দেখা গেছে কি না
- আবার চেষ্টার বোতাম দেখা যায় কি না
- অর্ডার cancelled, কাটা টাকা ০ আর stock আগের মতো আছে কি না
- মোট বিল ঠিকভাবে দেখানো হয়েছে কি না
একটি use case-এ ৭টি আচরণ (মূল পথ আর ৬টি extension). একটি suite চালিয়েছে মূল পথ, একটি coupon-এর extension আর একটি retry-এর extension. Use case coverage কত?
- ৫০%
- প্রায় ১৪.৩%
- প্রায় ২৮.৬%
- প্রায় ৪২.৯%
“Coupon দেওয়া” scenario পাস করে, “wallet একবার ব্যর্থ, তারপর সফল” scenario-ও পাস করে, কিন্তু দুটি একসাথে ঘটলে wallet ভুল টাকা কাটে। এ থেকে কী শিক্ষা?
- একই অবস্থা ছোঁয়া extension-এর মিশ্রণ ঝুঁকি ধরে আলাদা scenario হিসেবে নিতে হয়
- দুটি scenario-র test ভুলভাবে লেখা হয়েছে
- সবসময় use case-এর সব পথ চালাতে হবে
- Coverage ১০০% হলে defect থাকতে পারে না
একটি CRUD matrix-এ “Payment” কলামে শুধু C আছে (checkout payment তৈরি করে), কোনো use case payment পড়ে, বদলায় বা মোছে না। Tester-এর সবচেয়ে উপযুক্ত পদক্ষেপ কোনটি?
- সঙ্গে সঙ্গে “payment মোছার” use case যোগ করতে বলা
- ফাঁকগুলোকে প্রশ্ন হিসেবে তোলা, বিশেষ করে refund (U) কোথায় হয়
- উপেক্ষা করা, কারণ checkout-এর scenario test সব পাস করছে
- Checkout use case-এ আরও extension-এর test লেখা
দলের সব use case scenario এখন browser-এ পুরো UI end-to-end test হিসেবে চলে, আর suite শেষ হতে দুই ঘণ্টা লাগে। কোন পরিবর্তন সবচেয়ে যুক্তিসংগত?
- অর্ধেক scenario মুছে ফেলা
- প্রতিটি test-এর sleep কমিয়ে দেওয়া
- Scenario-গুলো unit, API আর integration স্তরে সরিয়ে UI-তে শুধু মূল পথ আর ঝুঁকির কয়েকটি পথ রাখা
- Suite শুধু রাতে একবার চালানো, দিনে কখনো নয়
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন, অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Use case = actor-এর লক্ষ্যে মূল পথ + extension + guarantee; tester-এর কাছে এটি পথের মানচিত্র আর oracle.
- ন্যূনতম suite: ১ + E scenario; coverage = test হওয়া আচরণ ÷ মোট আচরণ।
- প্রতিটি scenario-তে শেষ অবস্থা যাচাই করুন, বিশেষ করে ব্যর্থ পথে minimal guarantee.
- ফেরার লুপ দুবার চালান, আর একই অবস্থা ছোঁয়া extension-এর মিশ্রণ ঝুঁকি ধরে বাছুন।
- Scenario নকশার একক, চালানোর স্তর নয়; acceptance criteria থেকে scenario, আর CRUD matrix দিয়ে হারানো use case খুঁজুন।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ১৩ · White-box testing — statement, branch, condition আর MC/DC coverageপরবর্তী পর্বকোডের ভেতর দেখে statement থেকে MC/DC পর্যন্ত coverage মাপার কৌশল।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্ব১৪টি মডিউলের পুরো রোডম্যাপ।
- পর্ব ০৯ · Decision table আর cause-effectআগের কৌশলScenario-র প্রতিটি ধাপের ভেতরের নিয়মের মিশ্রণ।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ২২পাশের ট্র্যাকUse case আর user story লেখা: ছাঁচ, INVEST আর Given-When-Then.
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ২৩গভীরে যানUse case diagram, activity diagram আর CRUD matrix দিয়ে model যাচাই।