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

বিভিন্ন ভাষায় unit test — JUnit, Jest/Vitest আর Go-র testing তুলনা

Unit Testing Across Languages — JUnit, Jest/Vitest and Go testing Compared

Taught in Bangla, this lesson runs the same five-row Bazarghar coupon table in pytest 9.2.0, Vitest 5.1.0, JUnit 6.1.3 and Go 1.27.4, and all four catch the planted rounding bug on the 2999 taka row. It compares the xUnit family, parametrize, it.each, @ParameterizedTest and Go table-driven tests with t.Run, assertion argument order and failure messages. A fake wallet is built with Mock, vi.fn, Mockito and a Go fake, and JUnit XML counts differ: pytest reports 6 tests, Go 7.

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

  • xUnit পরিবারের সাধারণ অংশগুলো চিনে যেকোনো নতুন ভাষার test framework দ্রুত পড়তে পারা
  • একই test design টেবিল pytest, Vitest, JUnit আর Go-তে লেখা, চালানো আর ব্যর্থতার রিপোর্ট পড়া
  • Setup, parametrize, assertion, বাছাই করে চালানো আর mocking-এ চার framework-এর রীতি তুলনা করা
  • Mockito, vi.fn, Python-এর Mock আর Go-র হাতে লেখা fake দিয়ে একই নকল wallet বানানো
  • JUnit XML-এর গঠন পড়া, tool-ভেদে গোনার পার্থক্য বোঝা, আর রিপোর্ট থেকে ব্যক্তিগত তথ্য সরানো

১ · xUnit পরিবার — এক নকশা, অনেক ভাষা

দেশের বিভিন্ন শিক্ষা বোর্ডের পরীক্ষার কথা ভাবুন। প্রশ্ন আলাদা, ছাপা আলাদা, কিন্তু কাঠামো এক: প্রশ্নপত্র, উত্তরপত্র, পরীক্ষক, নম্বর মেলানোর নিয়ম, আর শেষে ফলাফলের তালিকা। একটি বোর্ডের খাতা দেখতে জানলে অন্য বোর্ডের খাতাও আপনি দেখতে পারবেন। Unit test framework-ও তেমন। Python, JavaScript, Java বা Go, যে ভাষাতেই হোক, ভেতরে প্রায় একই পাঁচ-ছয়টি অংশ। এই অংশগুলো চিনে ফেললে নতুন প্রকল্পে অচেনা framework দেখে আর ভয় লাগে না।

পর্ব ২১ (pytest-এর মূল) আর পর্ব ২২ (ভালো unit test-এর গঠন)-এ আপনি Python-এ test লিখেছেন। বাস্তবের দলে প্রায়ই একাধিক ভাষা থাকে: backend Java বা Go-তে, frontend JavaScript-এ, data-র কাজ Python-এ। একজন QA engineer বা SDET-কে তাই সবগুলোর test পড়তে, review করতে, আর CI-র রিপোর্ট বুঝতে হয়। এই পর্বে একটিই নিয়ম আর একটিই test টেবিল চারটি framework-এ চালিয়ে দেখব, প্রতিটি সত্যিকারের run.

Kent Beck Smalltalk-এর জন্য একটি ছোট testing framework-এর নকশা লেখেন, “Simple Smalltalk Testing: With Patterns”; লেখাটির সময় সূত্রভেদে ১৯৮৯ থেকে ১৯৯৪-এর মধ্যে বলা হয়, framework-টি পরে SUnit নামে পরিচিত। ১৯৯৭ সালে Beck আর Erich Gamma Java-র জন্য JUnit লেখেন; প্রচলিত গল্প অনুযায়ী এর বড় অংশ লেখা হয়েছিল একটি সম্মেলনে যাওয়ার বিমানযাত্রায়। এরপর প্রায় প্রতিটি ভাষায় এর অনুকরণ এলো: C++-এ CppUnit, .NET-এ NUnit, Python-এ PyUnit (২০০১ সালে unittest নামে standard library-তে)। পুরো পরিবারকে বলা হয় xUnit. JUnit 5 আসে ২০১৭ সালে নতুন নকশায়, আর JUnit 6 আসে ২০২৫ সালে, Java 17 বা নতুন version লাগে। Go ভাষার testing package Go 1.0 (২০১২) থেকেই আছে, ইচ্ছা করেই assertion ছাড়া। JavaScript-এ Facebook ২০১৪ সালে Jest open source করে; Vitest আসে ২০২১ সালের শেষে, Jest-এর প্রায় একই API নিয়ে।

xUnit পরিবারের গাছ — সরাসরি বংশধর আর নতুন ধরনের উত্তরসূরি

The xUnit family: direct descendants and idea-level successors

xUnit পরিবার: SUnit → JUnit → unittest, NUnit, CppUnit; উত্তরসূরি pytest, Go testing, Jest/Vitest, JUnit 5/6 SUnit · Smalltalk Kent Beck · ১৯৯০-এর আশেপাশে JUnit · Java · ১৯৯৭ Beck ও Gamma unittest Python · ২০০১ NUnit .NET CppUnit C++ সরাসরি বংশধর: class + assertX method ধারণা এক, ধরন নতুন pytest · ২০০৪ থেকে function + সাধারণ assert parametrize, fixture Go testing · ২০১২ TestXxx + if দিয়ে যাচাই table-driven, t.Run Jest ২০১৪ → Vitest describe · it · expect it.each, vi.fn JUnit 5 → JUnit 6 ২০১৭ · ২০২৫ annotation, @CsvSource সবার মধ্যে একই অংশ test case · fixture · assertion runner · রিপোর্ট (JUnit XML)
ছবি ২৬.১ — ওপরের তিনটি “সরাসরি বংশধর” JUnit-এর class আর assertEquals-ধাঁচ প্রায় হুবহু নিয়েছে। নিচের চারটি একই ধারণা নিয়েছে, কিন্তু নিজের ভাষার রীতিতে নতুন রূপ দিয়েছে। সবচেয়ে নিচের অংশগুলো যেকোনো framework-এ খুঁজলে পাবেন।

পাঁচটি অংশ, চারটি framework

নিচের টেবিলটি এই পর্বের মানচিত্র। প্রথম কলামে xUnit-এর সাধারণ ধারণা, বাকি কলামে প্রতিটি framework-এ তার নাম। প্রতিটি ঘর পরের অংশগুলোতে সত্যিকারের কোডে দেখবেন।

ধারণাpytestVitest / JestJUnit 5/6Go testing
Test casedef test_…()it("…", fn)@Test void …()func TestXxx(t *testing.T)
দল (suite)ফাইল, classdescribeclass, @Nestedpackage
Fixture@pytest.fixturebeforeEach@BeforeEachসাধারণ কোড, t.Cleanup
Assertionassert actual == expectedexpect(actual).toBe(expected)assertEquals(expected, actual)if got != want { t.Errorf(…) }
টেবিল (parameterized test)parametrizeit.each@ParameterizedTeststruct-এর slice + t.Run
Runnerpytestvitest runConsole Launcher, Maven, Gradlego test

কোনো অচেনা প্রকল্পে নতুন framework দেখলে এই টেবিলের সারিগুলোকে পাঁচটি প্রশ্ন বানিয়ে নিন: (১) একটি test চেনা যায় কীভাবে, নাম দেখে নাকি annotation দেখে? (২) প্রস্তুতি আর পরিষ্কারের কাজ কোথায় লেখা? (৩) যাচাই কীভাবে, আর ব্যর্থ হলে বার্তায় কোন মান আগে আসে? (৪) একই test অনেক input-এ কীভাবে চলে? (৫) কোন command চালায়, আর কোন ফাইলে রিপোর্ট লেখে? এই পাঁচটির উত্তর জানলে প্রথম দিনেই আপনি test পড়তে, একটি ব্যর্থতার কারণ খুঁজতে আর review-এ প্রশ্ন করতে পারবেন। বাকিটা ধীরে ধীরে শেখা যায়।

এই ধারণাগুলোর প্রথম পরিচয় আছে সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৬-এ। এখানে আমরা যাব আরও গভীরে: একই নিয়মের test চার ভাষায় চালিয়ে বার্তা, গোনা আর রিপোর্টের সূক্ষ্ম পার্থক্য খুঁজব, যা বাস্তবের CI-তে প্রায়ই বিভ্রান্তি তৈরি করে।

২ · একটি নিয়ম, পাঁচটি সারি, একটি বসানো ভুল

বাজারঘরের coupon নিয়ম কোর্স জুড়ে একই: অর্ডার ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায়, ভগ্নাংশ বাদ (floor); ঋণাত্মক টাকা অবৈধ। পর্ব ০৭ (equivalence partitioning) আর পর্ব ০৮ (boundary value analysis)-এর কৌশলে বাছাই করা পাঁচটি সারি, আর একটি exception-এর test:

IDtotalexpectedকেন এই সারি
edge-100010000সীমার ঠিক ওপরে নয়, ছাড় নেই
edge-10011001100সীমা পার হওয়ার প্রথম মান
below-cap2999299cap-এর নিচে; floor না round, এখানেই ধরা পড়ে
cap-30003000300ঠিক ৩০০-তে পৌঁছানো
cap-50005000300cap-এর partition, অনেক ওপরে
negative-5errorঅবৈধ partition

প্রতিটি ভাষার কোডে একই বসানো ভুল রাখা হলো: floor-এর জায়গায় round. ২৯৯৯-এর ১০% হলো ২৯৯.৯; floor করলে ২৯৯, round করলে ৩০০. ১০০১-এর ১০% হলো ১০০.১, যা দুই নিয়মেই ১০০; তাই পাঁচ সারির মধ্যে শুধু below-cap ভুলটি ধরতে পারে। প্রত্যাশা: চারটি framework-এই ঠিক একটি সারি লাল হবে।

সত্যিকারের run-এর পরিবেশ

সব run এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে, একটি আলাদা scratch ফোল্ডারে করা; কোনো tool system-wide install করা হয়নি। JDK আর Go-র portable zip সেই ফোল্ডারেই খোলা হয়েছে, checksum মিলিয়ে। Path আর কম্পিউটার-নির্দিষ্ট অংশ নিরপেক্ষ করা (~/bazarghar-qa).

ভাষাTool ও versionলাইসেন্স
Python 3.12.13pytest 9.2.0MIT
Node.js 24.15.0Vitest 5.1.0MIT
Java (Temurin JDK 25.0.5)JUnit 6.1.3 Console Launcher; মিলিয়ে দেখা JUnit 5.14.4-এ; Mockito 5.24.0JUnit: EPL 2.0; Mockito: MIT; JDK: GPLv2 + Classpath Exception
Go 1.27.4go test; testify v1.12.1; go-junit-report v2.1.0Go: BSD-3-Clause; বাকি দুটি MIT
bazarghar-qa/
├── py/     bazarghar/pricing.py   tests/test_coupon.py
├── js/     src/pricing.js         test/coupon.test.js
├── java/   src/bazarghar/Pricing.java
│           test/bazarghar/PricingTest.java
└── go/     pricing/pricing.go     pricing/pricing_test.go

প্রথমে চারটি test পাশাপাশি দেখুন। প্রতিটি ধাপে একটি framework-এর মূল অংশ; লম্বা লাইন ভেঙে লেখা। “পরে” চাপুন:

  1. pytestassertPython
  2. VitestexpectJavaScript
  3. JUnit@TestJava
  4. Got.RunGo
  5. মিলটেবিলএকই কাঠামো
tests/test_coupon.pyfunction + assert
CASES = [pytest.param(1000, 0,
           id="edge-1000"), …]

@pytest.mark.parametrize(
    ("total", "expected"), CASES)
def test_coupon_discount(
        total, expected):
    assert coupon_discount(
        total) == expected
test/coupon.test.jsdescribe · it · expect
describe("couponDiscount", () => {
  it.each([
    { total: 1000, expected: 0 },
    …
  ])("$total taka -> $expected",
    ({ total, expected }) => {
      expect(couponDiscount(total))
        .toBe(expected);
  });
});
PricingTest.javaannotation
@ParameterizedTest(
    name = "{0} taka -> {1}")
@CsvSource({"1000, 0", "1001, 100",
  "2999, 299", "3000, 300",
  "5000, 300"})
void couponDiscount(int total,
                    int expected) {
  assertEquals(expected,
    Pricing.couponDiscount(total));
}
pricing_test.gotable-driven
tests := []struct{ name string
  total, want int }{
  {"edge-1000", 1000, 0}, … }
for _, tc := range tests {
  t.Run(tc.name, func(t *testing.T) {
    got, err := CouponDiscount(tc.total)
    …
    if got != tc.want {
      t.Errorf("… = %d, want %d", …)
    }
  })
}
চারটির মিলটেবিল · যাচাই · নাম
pytest  parametrize │ assert
Vitest  it.each     │ expect
JUnit   @CsvSource  │ assertEquals
Go      []struct    │ if + Errorf
সারির নাম:
[edge-1000] │ $total taka
{0} taka    │ tc.name
  1. pytest. সাধারণ function আর সাধারণ assert; টেবিল থাকে parametrize-এ, প্রতিটি সারির id pytest.param-এ। বিস্তারিত পর্ব ২১-এ। লক্ষ করুন, এখানে কোনো class বা import করা assertion method নেই।
  2. Vitest. describe দিয়ে দল, it (বা test) দিয়ে একটি test, expect(actual).toBe(expected) দিয়ে যাচাই। it.each object-এর তালিকা নেয়; নামের ভেতরে $total লিখলে প্রতিটি সারির মান বসে যায়। ক্রম: আগে actual, matcher-এ expected.
  3. JUnit. সবকিছু annotation দিয়ে: @ParameterizedTest বলে “এটি টেবিলের test”, @CsvSource-এ সারিগুলো লেখা (লেখা থেকে int-এ রূপান্তর JUnit নিজে করে)। assertEquals-এ আগে expected, পরে actual; Vitest-এর উল্টো।
  4. Go. কোনো বিশেষ টেবিল-সুবিধা নেই; টেবিল একটি সাধারণ struct-এর slice, আর for loop-এ প্রতিটি সারি t.Run দিয়ে আলাদা subtest. যাচাই সাধারণ if, বার্তা নিজে লেখা: got আর want.
  5. যা মিলল। চারটিতেই টেবিল আর যাচাই আলাদা, আর প্রতিটি সারির নিজের নাম। নামের রীতি আলাদা: pytest-এর id, Vitest আর JUnit-এ নামের ছাঁচে মান বসানো, Go-তে টেবিলের name কলাম। ভাষা বদলালেও পর্ব ০৮-এর সীমার মানগুলো হুবহু একই থাকে; test design ভাষা-নিরপেক্ষ।

৩ · pytest থেকে Vitest — একই টেবিল, JavaScript-এ

pytest-এর run পর্ব ২১-এর মতোই। বসানো ভুলসহ সত্যিকারের ফল (uv run pytest -q tests/test_coupon.py):

..F...                                                                   [100%]
================================== FAILURES ===================================
_______________________ test_coupon_discount[below-cap] _______________________

total = 2999, expected = 299

    @pytest.mark.parametrize(("total", "expected"), CASES)
    def test_coupon_discount(total, expected):
>       assert coupon_discount(total) == expected
E       assert 300 == 299
E        +  where 300 = coupon_discount(2999)

tests\test_coupon.py:16: AssertionError
=========================== short test summary info ===========================
FAILED tests/test_coupon.py::test_coupon_discount[below-cap] - assert 300 == 299
1 failed, 5 passed in 0.07s

এবার JavaScript. Vitest হলো Vite-এর জগতের test runner, যার API প্রায় পুরোটাই Jest-এর মতো; তাই এখানে যা শিখবেন, Jest-এও প্রায় হুবহু খাটে। JavaScript কোর্সের পর্ব ৪৮-এ Vitest-এর পরিচয় আর ফুল-স্ট্যাক ওয়েব ফ্রেমওয়ার্ক কোর্সের পর্ব ৭৩-এ mock আর snapshot আছে। এখানে আমাদের লক্ষ্য তুলনা। প্রকল্প বানানো (global install নয়, প্রকল্পের ভেতরে):

mkdir js && cd js
npm init -y
npm pkg set type=module          # import/export ব্যবহারের জন্য
npm install -D vitest            # এখানে 5.1.0
npx vitest run --reporter=verbose
import { describe, it, expect } from "vitest";
import { couponDiscount } from "../src/pricing.js";

describe("couponDiscount", () => {
  it.each([
    { total: 1000, expected: 0 },
    { total: 1001, expected: 100 },
    { total: 2999, expected: 299 },
    { total: 3000, expected: 300 },
    { total: 5000, expected: 300 },
  ])("$total taka -> $expected", ({ total, expected }) => {
    expect(couponDiscount(total)).toBe(expected);
  });

  it("rejects a negative total", () => {
    expect(() => couponDiscount(-5)).toThrow(/negative/);
  });
});

ভুল ঠিক থাকা অবস্থায় (floor) সত্যিকারের run-এ সবুজ; ছোট একটি payment test-ও আছে, যা §৭-এ দেখবেন:

 RUN  v5.1.0 ~/bazarghar-qa/js

 ✓ test/payment.test.js > charges the wallet once 2ms
 ✓ test/coupon.test.js > couponDiscount > 1000 taka -> 0 1ms
 ✓ test/coupon.test.js > couponDiscount > 1001 taka -> 100 0ms
 ✓ test/coupon.test.js > couponDiscount > 2999 taka -> 299 0ms
 ✓ test/coupon.test.js > couponDiscount > 3000 taka -> 300 0ms
 ✓ test/coupon.test.js > couponDiscount > 5000 taka -> 300 0ms
 ✓ test/coupon.test.js > couponDiscount > rejects a negative total 1ms

 Test Files  2 passed (2)
      Tests  7 passed (7)

Math.floor-কে Math.round করে আবার চালানো (সত্যিকারের run, রং বন্ধ রেখে):

 ❯ test/coupon.test.js (6 tests | 1 failed) 7ms
   ❯ couponDiscount (6)
     × 2999 taka -> 299 4ms

⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯

 FAIL  test/coupon.test.js > couponDiscount > 2999 taka -> 299
AssertionError: expected 300 to be 299 // Object.is equality

- Expected
+ Received

- 299
+ 300

 ❯ test/coupon.test.js:12:35
     10|     { total: 5000, expected: 300 },
     11|   ])("$total taka -> $expected", ({ total, expected }) => {
     12|     expect(couponDiscount(total)).toBe(expected);
       |                                   ^

 Test Files  1 failed (1)
      Tests  1 failed | 5 passed (6)
  • নামে মান: $total আর $expected প্রতিটি সারির মান দিয়ে বদলেছে, তাই ব্যর্থ সারির নাম “2999 taka -> 299”. Array-র সারি দিলে %i, %s-এর মতো printf-ধাঁচের চিহ্ন চলে।
  • toBe বনাম toEqual: বার্তার “Object.is equality” মানে toBe একই মান বা একই object খোঁজে। সংখ্যায় ঠিক আছে; কিন্তু দুটি আলাদা object-এর ভেতরের মান মেলাতে toEqual লাগে। বাজারঘরের bill-এর মতো object-এ toBe লিখলে মান মিললেও test ব্যর্থ হয়।
  • Diff আর জায়গা: “- Expected / + Received” অংশে চাওয়া ২৯৯, পাওয়া ৩০০; নিচে কোডের লাইন আর ক্যারেট (^) দিয়ে ঠিক কোথায় ব্যর্থ। pytest-এর where লাইনের মতো function call অবশ্য দেখায় না।
  • Jest থেকে এলে: নকলের function jest.fn()-এর জায়গায় vi.fn(); describe, it আর expect Vitest-এ import করে নিতে হয় (config-এ globals চালু না থাকলে)। বাকি matcher প্রায় হুবহু, তাই পুরোনো Jest suite সাধারণত অল্প বদলেই Vitest-এ চলে।
  • বাছাই করে চালানো: pytest-এর -k-এর মতো Vitest-এ -t "নামের অংশ"; ফাইলের নাম দিয়েও বাছাই করা যায়। Exit code ব্যর্থ হলে 1, যা CI পড়ে।

৪ · JUnit — annotation, assertEquals-এর ক্রম আর @ParameterizedTest

JUnit Java-র সবচেয়ে প্রচলিত test framework. JUnit 5 থেকে এটি তিন ভাগে: JUnit Platform (test খোঁজা আর চালানোর ইঞ্জিন, যার ওপর Maven, Gradle আর IDE চলে), JUnit Jupiter (test লেখার annotation আর assertion), আর Vintage (পুরোনো JUnit 4-এর test চালানোর জন্য)। Java প্রোগ্রামিং কোর্সের পর্ব ৪৭-এ JUnit 5, AssertJ আর Mockito-র পরিচয় আছে; সেখানে Maven দিয়ে চালানো। এখানে build tool ছাড়াই, JUnit-এর একটি jar (Console Launcher) দিয়ে চালাব, যাতে প্রতিটি অংশ চোখে পড়ে।

package bazarghar;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class PricingTest {
    @ParameterizedTest(name = "{0} taka -> {1}")
    @CsvSource({"1000, 0", "1001, 100", "2999, 299", "3000, 300", "5000, 300"})
    void couponDiscount(int total, int expected) {
        assertEquals(expected, Pricing.couponDiscount(total));
    }

    @Test
    void rejectsNegativeTotal() {
        var e = assertThrows(IllegalArgumentException.class,
                () -> Pricing.couponDiscount(-5));
        assertTrue(e.getMessage().contains("negative"));
    }
}

Compile আর চালানো। javac-কে JUnit-এর jar দেখাতে হয়, কারণ annotation-গুলো সেখানে; Mockito-র jar রাখা lib ফোল্ডারে (§৭):

javac -d out -cp "junit-platform-console-standalone-6.1.3.jar;lib/*" \
      src/bazarghar/*.java test/bazarghar/*.java
java -jar junit-platform-console-standalone-6.1.3.jar execute \
      --class-path out --select-class bazarghar.PricingTest

Windows-এ classpath-এর বিভাজক ;, Linux আর Mac-এ :. বসানো ভুলসহ সত্যিকারের ফল (ধন্যবাদ-বার্তার banner আর রং বাদ):

╷
├─ JUnit Platform Suite ✔
├─ JUnit Jupiter ✔
│  └─ PricingTest ✔
│     ├─ rejectsNegativeTotal() ✔
│     └─ couponDiscount(int, int) ✔
│        ├─ "1000" taka -> "0" ✔
│        ├─ "1001" taka -> "100" ✔
│        ├─ "2999" taka -> "299" ✘ expected: <299> but was: <300>
│        ├─ "3000" taka -> "300" ✔
│        └─ "5000" taka -> "300" ✔
└─ JUnit Vintage ✔

Failures (1):
  JUnit Jupiter:PricingTest:couponDiscount(int, int):"2999" taka -> "299"
    MethodSource [className = 'bazarghar.PricingTest', methodName = 'couponDiscount', methodParameterTypes = 'int, int']
    => org.opentest4j.AssertionFailedError: expected: <299> but was: <300>
       org.junit.jupiter.api.Assertions.assertEquals(Assertions.java:569)
       bazarghar.PricingTest.couponDiscount(PricingTest.java:13)

Test run finished after 124 ms
…
[         6 tests found           ]
[         5 tests successful      ]
[         1 tests failed          ]

গাছের মতো রিপোর্ট পড়ুন ওপর থেকে নিচে: Platform-এর নিচে তিনটি engine (Suite, Jupiter, Vintage), Jupiter-এর নিচে class, তার নিচে method, আর parameterized method-এর নিচে প্রতিটি সারি। Failures অংশে stack trace-এর শেষ লাইন বলে দেয় test ফাইলের কোন লাইন: PricingTest.java:13. সারাংশে ৬টি test: পাঁচটি সারি আর exception-এর test.

JUnit 5 আর 6-এর একটি ছোট পার্থক্য: একই কোড JUnit 5.14.4-এর launcher দিয়েও চালানো হয়েছে; ফল হুবহু, শুধু নামে উদ্ধৃতিচিহ্ন নেই: 2999 taka -> 299 ✘. JUnit 6-এ CSV থেকে আসা লেখা-মান display name-এ উদ্ধৃতিসহ দেখায়। পরীক্ষা বা ইন্টারভিউতে “JUnit 5” বলা হলে এই পর্বের annotation আর assertion হুবহু খাটে।

assertEquals-এর ক্রম — ছোট ভুল, বিভ্রান্তিকর বার্তা

JUnit-এর নিয়ম assertEquals(expected, actual). Java-তে দুটোই int, তাই উল্টো লিখলেও compiler কিছু বলে না, আর মান না মিললে test ঠিকই ব্যর্থ হয়। সমস্যা শুধু বার্তায়। একটি ছোট test-এ ইচ্ছা করে ক্রম উল্টানো হলো: assertEquals(Pricing.couponDiscount(2999), 299). সত্যিকারের ফল:

│     └─ belowCap() ✘ expected: <300> but was: <299>
    => org.opentest4j.AssertionFailedError: expected: <300> but was: <299>

বার্তা বলছে “৩০০ চাওয়া হয়েছিল, কোড দিয়েছে ২৯৯”, যা উল্টো। রাত দুটোয় CI-র এই লাইন পড়ে কেউ requirement বদলাতে যেতে পারেন, অথবা ভাবতে পারেন floor ঠিক আছে আর cap-এ ভুল। নিয়ম মুখস্থ রাখুন: JUnit আর unittest-এ আগে expected, Vitest আর AssertJ-এ আগে actual (assertThat(actual).isEqualTo(expected)). AssertJ-এর মতো fluent লাইব্রেরি জনপ্রিয় হওয়ার একটি কারণ এটিই: ক্রম বাক্যের মতো পড়া যায়, ভুল হয় কম।

Lifecycle — প্রতিটি test নতুন object

JUnit Jupiter ডিফল্টে প্রতিটি test method-এর জন্য test class-এর নতুন instance বানায়। ফলে এক test-এ field বদলালে পরের test তা দেখে না; পর্ব ২১-এর function-scope fixture-এর সমতুল্য। এই lifecycle-এ চারটি annotation: @BeforeEach আর @AfterEach প্রতিটি test-এর আগে-পরে, @BeforeAll আর @AfterAll পুরো class-এ একবার (সাধারণত static method). Fixture-এর scope নিয়ে গভীর আলোচনা পর্ব ২৩ (Fixture আর test data — scope, factory আর builder)-এ।

৫ · Go — table-driven test আর t.Run

Go-র নকশাকারীরা ইচ্ছা করে ছোট পথ নিয়েছেন। Test লেখার নিয়ম মাত্র তিনটি: ফাইলের নাম _test.go দিয়ে শেষ, function-এর নাম Test দিয়ে শুরু, আর একমাত্র parameter t *testing.T. কোনো assertion function নেই। Go-র FAQ-এর যুক্তি মোটামুটি এমন: assertion থাকলে মানুষ ভালো error বার্তা লেখা এড়িয়ে যায়, আর প্রথম ব্যর্থতায় থেমে যায়; সাধারণ if আর ভালো বার্তাই যথেষ্ট। এর বদলে Go সম্প্রদায়ের প্রিয় রীতি হলো table-driven test: সারিগুলো একটি struct-এর slice-এ, আর একটি loop.

package pricing

import (
	"errors"
	"testing"
)

func TestCouponDiscount(t *testing.T) {
	tests := []struct {
		name        string
		total, want int
	}{
		{"edge-1000", 1000, 0},
		{"edge-1001", 1001, 100},
		{"below-cap", 2999, 299},
		{"cap-3000", 3000, 300},
		{"cap-5000", 5000, 300},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got, err := CouponDiscount(tc.total)
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}
			if got != tc.want {
				t.Errorf("CouponDiscount(%d) = %d, want %d", tc.total, got, tc.want)
			}
		})
	}
}

func TestNegativeTotalIsRejected(t *testing.T) {
	_, err := CouponDiscount(-5)
	if !errors.Is(err, ErrNegative) {
		t.Errorf("got error %v, want ErrNegative", err)
	}
}

Go-তে error ফেরত আসে দ্বিতীয় মান হিসেবে, exception নয়; তাই ঋণাত্মক টাকার test errors.Is দিয়ে নির্দিষ্ট error খোঁজে। Go module বানিয়ে চালানো (go mod init example.com/bazarghar, তারপর go test). বসানো ভুলসহ সত্যিকারের run, প্রথমে ডিফল্ট আউটপুট, তারপর -v আর -run দিয়ে শুধু cap-এর সারি:

$ go test ./pricing/
--- FAIL: TestCouponDiscount (0.00s)
    --- FAIL: TestCouponDiscount/below-cap (0.00s)
        pricing_test.go:26: CouponDiscount(2999) = 300, want 299
FAIL
FAIL	example.com/bazarghar/pricing	0.009s
FAIL
$ go test -v -run 'TestCouponDiscount/cap' ./pricing/
=== RUN   TestCouponDiscount
=== RUN   TestCouponDiscount/cap-3000
=== RUN   TestCouponDiscount/cap-5000
--- PASS: TestCouponDiscount (0.00s)
    --- PASS: TestCouponDiscount/cap-3000 (0.00s)
    --- PASS: TestCouponDiscount/cap-5000 (0.00s)
PASS
ok  	example.com/bazarghar/pricing	0.007s

ডিফল্ট আউটপুট শুধু ব্যর্থতা দেখায়: পাস করা সারি চুপচাপ। ব্যর্থ subtest-এর নাম TestCouponDiscount/below-cap, অর্থাৎ parent আর সারির নাম / দিয়ে জোড়া; একে বলে subtest. -run একটি regular expression নেয়, /-এর দুই পাশে আলাদা করে মেলায়; “cap” দুটি সারির নামেই আছে। খেয়াল করুন, parent-এর লাইনেও FAIL: একটি সন্তান ব্যর্থ হলে parent-ও ব্যর্থ। এই তথ্য §৮-এ গোনার সময় গুরুত্বপূর্ণ হবে।

দ্বিতীয় run-টি বসানো ভুল থাকা অবস্থাতেই, অথচ সবুজ: বাছাই করা দুটি সারি ভুলটি ধরতে পারে না, আর parent-ও PASS, কারণ ব্যর্থ সারিটি চলেইনি। বাছাই করে চালানো দ্রুত, কিন্তু সবুজ ফলকে পুরো suite-এর ফল ভাববেন না। এবার loop ধাপে ধাপে, বসানো ভুলসহ:

1for _, tc := range tests {2  t.Run(tc.name, func(t *testing.T) {3    got, err := CouponDiscount(tc.total)4    if err != nil { t.Fatalf(…) }5    if got != tc.want {6      t.Errorf("… = %d, want %d")7    }8  })9}
এই মুহূর্তে
tc.name
total
got
want
subtest
  1. টেবিল তৈরি। tests-এ পাঁচটি সারি, প্রতিটিতে name, total আর want. Loop শুরু হবে প্রথম সারি থেকে। টেবিলটি সাধারণ Go data; নতুন সারি যোগ করা মানে এক লাইন।
  2. edge-1000. t.Run একটি নতুন subtest খোলে, নিজের t সহ। CouponDiscount(1000) দেয় ০, যা want-এর সমান; if-এর ভেতরে ঢোকা হয় না। এই subtest পাস।
  3. edge-1001. ১০০১ ÷ ১০ = ১০০.১; round করলেও ১০০, floor করলেও ১০০. তাই বসানো ভুল থাকা সত্ত্বেও এই সারি পাস। সীমার সারি সব ভুল ধরে না; কোন সারি কোন ভুল ধরে, সেটিই test design.
  4. below-cap — Errorf. ২৯৯৯ ÷ ১০ = ২৯৯.৯, round করে ৩০০; want ২৯৯. t.Errorf বার্তা লেখে আর subtest-কে ব্যর্থ চিহ্নিত করে, কিন্তু থামায় না। t.Fatalf হলে এই subtest সেখানেই থামত; তবু loop পরের সারিতে যেত, কারণ প্রতিটি সারি আলাদা subtest.
  5. cap-3000. Loop চলছে: ৩০০০ ÷ ১০ = ৩০০, পাস। একটি সারির ব্যর্থতা বাকি সারিকে আটকায়নি; t.Run ছাড়া সরাসরি loop-এ t.Fatalf লিখলে প্রথম ব্যর্থতাতেই পুরো test থেমে যেত।
  6. cap-5000. ৫০০০ ÷ ১০ = ৫০০, min(500, 300) = ৩০০, পাস। পাঁচটি সারির চারটি পাস, একটি ফেল।
  7. Parent-এর ফল। সব subtest শেষ। একটি সন্তান ব্যর্থ, তাই TestCouponDiscount নিজেও FAIL, আর package-এর ফল FAIL. ফলের লাইনগুলো Go শেষে গাছের মতো একসাথে ছাপে; -v ছাড়া শুধু ব্যর্থগুলো।

Go-র T ভেতরে কীভাবে কাজ করে, তার একটি ছোট শিক্ষণ মডেল JavaScript-এ। আসল Go নয়, কিন্তু নিয়ম একই: Errorf চিহ্ন দেয় আর চলতে দেয়, Fatalf শুধু নিজের subtest থামায়, আর সন্তান ব্যর্থ হলে parent ব্যর্থ। টেবিলে একটি ভুল সারিও আছে: ঋণাত্মক টাকা, কিন্তু error প্রত্যাশার কলাম নেই। “চালান” চাপুন:

// Teaching model of Go's testing.T: Run, Errorf, Fatalf
function makeT(name, log) {
  const t = { name, failed: false, children: [] };
  t.Errorf = (msg) => { t.failed = true; log.push(`    ${t.name}: ${msg}`); };
  t.Fatalf = (msg) => { t.Errorf(msg); throw "stop"; }; // ends this test
  t.Run = (sub, body) => {
    const c = makeT(`${t.name}/${sub}`, log);
    try { body(c); } catch (e) { if (e !== "stop") throw e; }
    t.children.push(c);
    if (c.failed) t.failed = true;          // a failing child fails the parent
  };
  return t;
}
function couponDiscount(total) {            // seeded defect: round
  if (total < 0) return [0, "negative"];
  return [total > 1000 ? Math.min(Math.round(total / 10), 300) : 0, null];
}

const log = [];
const t = makeT("TestCouponDiscount", log);
const tests = [["edge-1000", 1000, 0], ["below-cap", 2999, 299],
               ["negative", -5, 0], ["cap-3000", 3000, 300]];
for (const [name, total, want] of tests) {
  t.Run(name, (t) => {
    const [got, err] = couponDiscount(total);
    if (err) t.Fatalf(`unexpected error: ${err}`);
    if (got !== want) t.Errorf(`CouponDiscount(${total}) = ${got}, want ${want}`);
  });
}
log.forEach((line) => console.log(line));
for (const c of [t, ...t.children])
  console.log(`--- ${c.failed ? "FAIL" : "PASS"}: ${c.name}`);
const all = [t, ...t.children];
console.log(`counted: ${all.length}, failed: ${all.filter((c) => c.failed).length}`);

আসল আউটপুট:

    TestCouponDiscount/below-cap: CouponDiscount(2999) = 300, want 299
    TestCouponDiscount/negative: unexpected error: negative
--- FAIL: TestCouponDiscount
--- PASS: TestCouponDiscount/edge-1000
--- FAIL: TestCouponDiscount/below-cap
--- FAIL: TestCouponDiscount/negative
--- PASS: TestCouponDiscount/cap-3000
counted: 5, failed: 3

negative সারিতে Fatalf সেই subtest থামিয়েছে (got/want-এর লাইনে আর পৌঁছায়নি), কিন্তু পরের cap-3000 চলেছে আর পাস করেছে। একই চার সারির টেবিল আসল Go 1.27.4-এ চালিয়ে মিলিয়ে দেখা হয়েছে: একই দুটি বার্তা (unexpected error: total must not be negative), একই PASS/FAIL. শেষ লাইনটি খেয়াল করুন: ৪টি সারি, কিন্তু গোনায় ৫, কারণ parent নিজেও একটি test; ব্যর্থ ৩টি। টেবিলের আসল ভুল হলো error-এর কলাম না থাকা; Go-তে প্রচলিত সমাধান wantErr bool কলাম। নিজে চেষ্টা করুন: Math.round-কে Math.floor করে চালান; কতটি FAIL থাকে?

testify — যাঁরা assertion চান

Go সম্প্রদায়ের অনেকে তবু assertion লাইব্রেরি ব্যবহার করেন; সবচেয়ে পরিচিত testify (MIT). একই ভুলে assert.Equal(t, 299, got, "coupon for 2999 taka")-এর সত্যিকারের বার্তা (path নিরপেক্ষ করা):

--- FAIL: TestBelowCapWithTestify (0.00s)
    testify_test.go:12:
        	Error Trace:	~/bazarghar-qa/go/pricing/testify_test.go:12
        	Error:      	Not equal:
        	            	expected: 299
        	            	actual  : 300
        	Test:       	TestBelowCapWithTestify
        	Messages:   	coupon for 2999 taka

testify-র assert.Equal-এও JUnit-এর মতো আগে expected. assert ব্যর্থ হলেও test চলতে থাকে (Errorf-এর মতো), আর require package-এর একই function থামিয়ে দেয় (Fatalf-এর মতো)। দলে কোনটি চলবে, একবার ঠিক করে সবাই একই রীতি মানাই ভালো।

৬ · একই ভুল, পাঁচ রকম বার্তা — আর রীতির তুলনা

CI-তে লাল দাগ দেখলে প্রথম কাজ বার্তা পড়া। একই ২৯৯৯ টাকার ভুল পাঁচটি tool কীভাবে বলে, পাশাপাশি দেখুন; প্রতিটি লেখা সত্যিকারের run থেকে, ছোট করা:

  1. pytestassertrewriting
  2. VitesttoBediff
  3. JUnit<299>expected আগে
  4. Gowantনিজের লেখা
  5. testifyEqualলাইব্রেরি
pytest 9.2.0মান আর উৎস
> assert coupon_discount(total)
         == expected
E assert 300 == 299
E  +  where 300 =
      coupon_discount(2999)
tests\test_coupon.py:16
Vitest 5.1.0diff আর ক্যারেট
AssertionError: expected 300
  to be 299 // Object.is equality
- Expected
+ Received
- 299
+ 300
 ❯ test/coupon.test.js:12:35
JUnit 6.1.3expected আগে
"2999" taka -> "299" ✘
AssertionFailedError:
  expected: <299>
  but was: <300>
at PricingTest.java:13
ক্রম উল্টালে:
expected: <300> but was: <299>
Go 1.27.4বার্তা আপনার হাতে
--- FAIL: TestCouponDiscount
  --- FAIL: …/below-cap
    pricing_test.go:26:
    CouponDiscount(2999) = 300,
    want 299
testify v1.12.1expected আগে
Error:  Not equal:
        expected: 299
        actual  : 300
Messages: coupon for 2999 taka
  1. pytest. assert 300 == 299: বাঁ পাশ কোডের ফল, ডান পাশ expected, কারণ আমরা actual == expected লিখি। where লাইন বলে ৩০০ কোন call থেকে এলো। পাঁচটির মধ্যে সবচেয়ে বেশি তথ্য, আর তার জন্য আপনাকে কিছুই লিখতে হয়নি।
  2. Vitest. বাক্যের মতো: “expected 300 to be 299”, অর্থাৎ পাওয়া গেছে ৩০০, হওয়ার কথা ২৯৯. নিচে - Expected আর + Received-এর diff, তারপর ফাইল:লাইন:কলাম। বড় object-এ এই diff খুব কাজের।
  3. JUnit. expected: <299> but was: <300>. এটি সত্য বলছে শুধু তখনই, যখন আপনি assertEquals(expected, actual) ক্রম মেনেছেন। উল্টালে একই ভুলে বার্তা হয় “expected 300, was 299”, যা সত্যিকারের run-এ দেখেছেন।
  4. Go. বার্তা পুরোপুরি আপনার লেখা। রীতি হলো f(x) = got, want y: function-এর নাম, input, পাওয়া মান, চাওয়া মান। ভালো লিখলে সবচেয়ে পরিষ্কার; অলসভাবে t.Error("wrong") লিখলে সবচেয়ে অকেজো। দায়িত্ব test লেখকের।
  5. testify. লাইব্রেরি Go-তে assertion-ধাঁচ ফিরিয়ে আনে: expected আর actual আলাদা লাইনে, সাথে আপনার বার্তা। মাপকাঠি সব tool-এ একই: বার্তা পড়ে কোড না খুলেই বোঝা যায় কি না, কোন input, কী চাওয়া, কী পাওয়া।

এবার এই পাতাতেই একই ব্যর্থ case তিন ধাঁচের assertion-এ চালিয়ে দেখুন। ছোট শিক্ষণ মডেল, আসল লাইব্রেরি নয়, কিন্তু বার্তার ছাঁচ আসল tool-এর মতো:

// One failing case, three assertion styles (teaching model)
const couponDiscount = (total) =>              // seeded defect: round
  total > 1000 ? Math.min(Math.round(total / 10), 300) : 0;

function assertEquals(expected, actual) {      // JUnit style
  if (expected !== actual)
    throw new Error(`expected: <${expected}> but was: <${actual}>`);
}
const expect = (actual) => ({                  // Jest/Vitest style
  toBe(expected) {
    if (!Object.is(actual, expected))
      throw new Error(`expected ${actual} to be ${expected}`);
  },
});
function checkGotWant(got, want) {             // Go style, by hand
  if (got !== want)
    throw new Error(`CouponDiscount(2999) = ${got}, want ${want}`);
}

const checks = {
  "JUnit, right order ": () => assertEquals(299, couponDiscount(2999)),
  "JUnit, swapped     ": () => assertEquals(couponDiscount(2999), 299),
  "Vitest expect      ": () => expect(couponDiscount(2999)).toBe(299),
  "Go got/want        ": () => checkGotWant(couponDiscount(2999), 299),
};
for (const [style, run] of Object.entries(checks)) {
  try { run(); console.log(style, "PASS"); }
  catch (e) { console.log(style, "FAIL ->", e.message); }
}

আসল আউটপুট:

JUnit, right order  FAIL -> expected: <299> but was: <300>
JUnit, swapped      FAIL -> expected: <300> but was: <299>
Vitest expect       FAIL -> expected 300 to be 299
Go got/want         FAIL -> CouponDiscount(2999) = 300, want 299

চারটিই FAIL, অর্থাৎ ক্রম উল্টালেও ভুল ধরা পড়ে; test-এর ফল ঠিক থাকে। পার্থক্য শুধু দ্বিতীয় লাইনের বার্তায়: ৩০০ আর ২৯৯ জায়গা বদলেছে। Assertion function জানে না কোন argument আসলে কী; সে শুধু অবস্থান দেখে। তাই code review-তে JUnit-এর প্রতিটি assertEquals-এ প্রথম argument একটি ধ্রুবক বা expected নামের variable কি না, দেখে নেওয়া একটি সহজ কিন্তু কার্যকর অভ্যাস। নিজে চেষ্টা করুন: Math.round-কে Math.floor করুন; চারটিই PASS হবে।

রীতির তুলনা — প্রতিদিনের কাজ চার framework-এ

কাজpytestVitestJUnit 5/6Go
প্রতিটি test-এর আগে প্রস্তুতিfixture (function scope)beforeEach@BeforeEachtest-এর শুরুতে সাধারণ কোড; পরিষ্কারে t.Cleanup
Exception বা error যাচাইpytest.raisestoThrowassertThrowserrors.Is(err, …)
কয়েকটি যাচাই একসাথে, থামা ছাড়াসরাসরি নেই (plugin আছে)expect.softassertAllt.Errorf নিজেই থামে না
বাদ দেওয়াskip, xfailit.skip, it.todo@Disabled, assumptiont.Skip
নাম দিয়ে বাছাই-k, node id-t, ফাইল--select-method, @Tag-run (regex)
সমান্তরাল চালানোplugin (pytest-xdist)ডিফল্টে ফাইলগুলো আলাদা worker-এconfig দিয়ে চালু করতে হয়t.Parallel(); package-গুলো ডিফল্টে সমান্তরাল
নকল (mock) লাইব্রেরিunittest.mock, pytest-mockvi.fn, vi.mockMockitointerface + হাতে লেখা fake; testify/mock, gomock

দুটি ঘর একটু বিশেষ। “থামা ছাড়া যাচাই”কে বলে soft assertion: একটি test-এ কয়েকটি মান যাচাই করে সব ব্যর্থতা একসাথে জানানো, যেমন একটি bill-এর discount, delivery আর payable. Go-তে এটি ডিফল্ট আচরণ, অন্যগুলোতে আলাদা করে চাইতে হয়। আর সমান্তরাল চালানো দ্রুত, কিন্তু test-গুলো একে অপরের ওপর নির্ভর করলে (একই ফাইল বা global অবস্থা) এলোমেলো ব্যর্থতা আসে; সে আলোচনা পর্ব ৪০ (Flaky test)-এ।

৭ · নকল wallet, চার রূপে — Mock, vi.fn, Mockito আর Go-র fake

বাজারঘরের payment ধাপ একটি mobile-wallet client ডাকে; এই কোর্সে সেটি সবসময় নকল। Test double-এর ধরন (dummy, stub, spy, mock, fake) সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৯-এ আছে, আর unittest.mock-এর গভীর আলোচনা পর্ব ২৪ (Test double গভীরে)-এ। এখানে একটিই ছোট নিয়ম: pay(wallet, orderId, amount) wallet-এর charge একবার ডাকে, উত্তর “ok” হলে ফল “paid”. Test যাচাই করবে: ফল ঠিক, আর charge ঠিক একবার, ঠিক argument দিয়ে ডাকা হয়েছে। এই ধরনের নকলকে বলে spy বা mock.

from unittest.mock import Mock

from bazarghar.payment import pay


def test_pay_charges_wallet_once():
    wallet = Mock()
    wallet.charge.return_value = "ok"
    assert pay(wallet, "BG-1001", 1890) == "paid"
    wallet.charge.assert_called_once_with("BG-1001", 1890)
import { it, expect, vi } from "vitest";
import { pay } from "../src/payment.js";

it("charges the wallet once", () => {
  const wallet = { charge: vi.fn().mockReturnValue("ok") };
  expect(pay(wallet, "BG-1001", 1890)).toBe("paid");
  expect(wallet.charge).toHaveBeenCalledTimes(1);
  expect(wallet.charge).toHaveBeenCalledWith("BG-1001", 1890);
});
import static org.mockito.Mockito.*;
// … JUnit imports …

class PaymentTest {
    @Test
    void chargesWalletOnce() {
        Wallet wallet = mock(Wallet.class);
        when(wallet.charge("BG-1001", 1890)).thenReturn("ok");
        assertEquals("paid", Payment.pay(wallet, "BG-1001", 1890));
        verify(wallet, times(1)).charge("BG-1001", 1890);
    }
}
type fakeWallet struct{ calls []string }

func (f *fakeWallet) Charge(orderID string, amount int) string {
	f.calls = append(f.calls, orderID)
	return "ok"
}

func TestPayChargesWalletOnce(t *testing.T) {
	w := &fakeWallet{}
	got, err := Pay(w, "BG-1001", 1890)
	if err != nil || got != "paid" {
		t.Fatalf("Pay() = %q, %v; want \"paid\", nil", got, err)
	}
	if len(w.calls) != 1 || w.calls[0] != "BG-1001" {
		t.Errorf("Charge calls = %v, want [BG-1001]", w.calls)
	}
}

চারটিই সত্যিকারের run-এ পাস করেছে। কিন্তু চারটির পেছনের কৌশল ভাষার স্বভাব থেকে এসেছে:

  • Python: ভাষা পুরোপুরি dynamic, তাই Mock() যেকোনো attribute আর যেকোনো call মেনে নেয়। সুবিধা: এক লাইনে নকল। ঝুঁকি: wallet.chrage-এর মতো বানান ভুলও চুপচাপ চলে; প্রতিকার autospec, পর্ব ২৪-এ।
  • JavaScript: function নিজেই মান, তাই vi.fn() একটি function বানায় যা প্রতিটি call মনে রাখে। Object-এর একটি ঘরে বসালেই নকল তৈরি।
  • Java: Mockito চলার সময় Wallet interface-এর একটি নতুন class তৈরি করে (bytecode বানিয়ে); when(…).thenReturn(…) দিয়ে উত্তর ঠিক, verify দিয়ে call যাচাই। Type-নিরাপদ: ভুল method-এর নাম compile-ই হবে না।
  • Go: interface নিজে থেকে মেলে (কোনো implements লিখতে হয় না), তাই একটি ছোট struct-ই fake. কোনো লাইব্রেরি ছাড়া, পুরো আচরণ চোখের সামনে। বড় interface-এ হাতে লেখা কষ্টকর হলে gomock বা testify/mock-এর মতো tool আছে।

JDK 21 থেকে Mockito-র একটি বাস্তব সতর্কবার্তা দেখা দেয়। Mockito JVM-এ নিজেকে agent হিসেবে জুড়ে দেয়, আর নতুন JDK এটি নিয়ে সাবধান করে। JDK 25-এ সত্যিকারের run-এর শুরুতে (path নিরপেক্ষ):

Mockito is currently self-attaching to enable the inline-mock-maker. This will no longer work in future releases of the JDK. Please add Mockito as an agent to your build as described in Mockito's documentation: https://javadoc.io/doc/org.mockito/mockito-core/latest/org.mockito/org/mockito/Mockito.html#0.3
WARNING: A Java agent has been loaded dynamically (~azarghar-qa\java\libyte-buddy-agent-1.17.7.jar)
…
WARNING: Dynamic loading of agents will be disallowed by default in a future release

Test পাস করেছে, তবু এই warning উপেক্ষা করবেন না: ভবিষ্যতের JDK-তে এটিই ব্যর্থতা হবে। সমাধান Mockito-র docs-এ: -javaagent:mockito-core.jar দিয়ে JVM চালানো, Maven বা Gradle-এর test config-এ। এখানে java -jar-এর সাথে শুধু -javaagent যোগ করায় নতুন error এলো (NoClassDefFoundError: net/bytebuddy/…), কারণ agent আর test আলাদা classpath থেকে load হচ্ছিল; সব jar একই -cp-তে দিয়ে Console Launcher-এর main class চালালে Mockito-র সতর্কবার্তা আর আসেনি, test পাস। শিক্ষা: পরিবেশের warning-ও tester-এর খবর, আর তার সমাধান একবার চালিয়ে যাচাই করতে হয়।

সব ভাষাতেই একই ফাঁদ: নকল যত সহজ, অতিরিক্ত নকলের ঝুঁকি তত বেশি। চারটি test-এর কোনোটিই আসল wallet-এর আচরণ জানে না: আসল API যদি “ok”-এর বদলে “OK” ফেরায়, চারটিই সবুজ থাকবে আর production ভাঙবে। নকল আর আসলের মিল রক্ষার উপায় contract testing, পর্ব ৩২-এ।

৮ · JUnit XML — সব tool-এর সাধারণ রিপোর্ট

চারটি ভাষার test একটি CI pipeline-এ চললে (সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫৮), dashboard-কে চারটি আলাদা আউটপুট পড়তে হয় না। প্রায় সব tool একটি সাধারণ ফরম্যাটে ফল লিখতে পারে: JUnit XML. নাম JUnit হলেও এটি কোনো আনুষ্ঠানিক মানদণ্ড নয়; Java-র Ant build tool-এর JUnit রিপোর্ট থেকে শুরু হয়ে ধীরে ধীরে সবার “সাধারণ ভাষা” হয়েছে, প্রতিটি tool-এর নিজস্ব সামান্য ভিন্ন রূপসহ। চারটি tool-এ যেভাবে লেখানো হলো:

uv run pytest --junitxml=report.xml
npx vitest run --reporter=junit --outputFile=report.xml
java -jar junit-platform-console-standalone-6.1.3.jar execute \
     --class-path out --select-class bazarghar.PricingTest --reports-dir=reports
go test -v ./pricing/ | go-junit-report -set-exit-code > report.xml

Go নিজে JUnit XML লেখে না; go test -json দিয়ে প্রতিটি ঘটনার JSON দেয়, আর go-junit-report-এর মতো আলাদা tool (MIT) -v-এর আউটপুট XML-এ রূপান্তর করে। pytest-এর XML (সুন্দর করে সাজানো, hostname নিরপেক্ষ) ধাপে ধাপে পড়ুন:

1<testsuites name="pytest tests">2 <testsuite name="pytest"3   tests="6" failures="1"4   errors="0" skipped="0"5   time="0.044" hostname="…">6  <testcase classname=7    "tests.test_coupon"8    name="…[edge-1000]"/>9  <testcase … name="…[below-cap]">10   <failure message=11    "assert 300 == 299 …">12    …পুরো traceback…13   </failure>14  </testcase> …15 </testsuite>16</testsuites>
এই অংশের অর্থ
element
অর্থ
CI যা করে
  1. মূল element. <testsuites> পুরো run-কে ধরে রাখে; ভেতরে এক বা একাধিক <testsuite>. একাধিক ফাইল বা package-এর ফল একই ফাইলে আসতে পারে।
  2. testsuite-এর গুনতি। tests="6", failures="1", errors="0", skipped="0". Failure মানে assertion ব্যর্থ; error মানে test-এর বাইরে অপ্রত্যাশিত সমস্যা (যেমন fixture ভেঙে যাওয়া)। hostname-এ ছিল আসল কম্পিউটারের নাম; এখানে সরানো।
  3. পাস করা testcase. ভেতরে কিছু নেই, শুধু classname আর name. এই দুটি মিলে test-এর পরিচয়: pytest-এর node id-র মতো, tests.test_coupon আর test_coupon_discount[edge-1000]. খালি testcase মানেই পাস।
  4. ব্যর্থ testcase. ভেতরে একটি <failure>, যার message-এ ছোট বার্তা: assert 300 == 299 আর where লাইন। CI-র তালিকায় সাধারণত এটুকুই দেখায়, তাই ভালো assertion বার্তা এখানেও কাজে লাগে।
  5. failure-এর ভেতরের লেখা। পুরো traceback, terminal-এ যা দেখেছেন প্রায় তাই। Skip হলে <skipped>, error হলে <error> element আসে একই জায়গায়।
  6. শেষ। ছয়টি testcase-এর পরে element বন্ধ। CI প্রতিটি ফাইলের গুনতি যোগ করে dashboard-এ দেখায়। কিন্তু build লাল না সবুজ, তা ঠিক হয় সাধারণত tool-এর exit code দেখে, XML দেখে নয়; দুটি আলাদা সংকেত।

একই ভুল, ভিন্ন গুনতি

চারটি tool-এর XML-এর শুরুর গুনতি (সত্যিকারের ফাইল থেকে, শুধু coupon-এর test):

Tooltestsfailuresকেন
pytest61প্রতিটি parametrize সারি একটি testcase
Vitest61it.each-এর প্রতিটি সারি একটি testcase; name-এ couponDiscount > 2999 taka -> 299
JUnit61Jupiter-এর ফাইল আলাদা (TEST-junit-jupiter.xml); name-এ couponDiscount(int, int)[3]
Go + go-junit-report72Parent TestCouponDiscount-ও একটি testcase, আর সন্তান ব্যর্থ বলে সেটিও failure

একই কোড, একই ভুল, অথচ dashboard-এ Go-র দলের “ব্যর্থ test” দ্বিগুণ। কয়েকটি ভাষার দল একসাথে metric দেখালে এমন পার্থক্য ভুল সিদ্ধান্তে নিয়ে যেতে পারে। JUnit-এর XML-এ সারির নাম [3], অর্থাৎ ক্রমিক নম্বর; সুন্দর display name আছে ভেতরের লেখায়। Test report আর metric নিয়ে বিস্তারিত পর্ব ৬৭ (Test report আর metric)-এ।

রিপোর্টে ব্যক্তিগত তথ্য: pytest, Vitest আর go-junit-report তিনটিই hostname-এ কম্পিউটারের আসল নাম লিখেছে। JUnit Console Launcher-এর XML-এ আরও বেশি: একটি <properties> অংশে ষাটটির বেশি system property, যার মধ্যে user.name, user.home, পুরো PATH আর কাজের ফোল্ডার। CI-তে এগুলো সাধারণত build server-এর তথ্য, কিন্তু নিজের ল্যাপটপের রিপোর্ট কোনো ticket, forum বা প্রকাশ্য জায়গায় দেওয়ার আগে এই অংশ মুছে ফেলুন। এই পর্বের সব XML-এ সেগুলো সরানো হয়েছে।

এবার এই পাতাতেই একটি JUnit XML তৈরি করে পড়ুন। Pyodide-এ pytest আছে; কোড একটি test ফাইল লিখে --junitxml দিয়ে চালায়, তারপর Python-এর xml.etree দিয়ে ফাইলটি পড়ে, যেমন একটি CI tool পড়ে:

import os, sys, pytest
import xml.etree.ElementTree as ET
os.makedirs("/home/pyodide/p26", exist_ok=True); os.chdir("/home/pyodide/p26")
sys.path.insert(0, os.getcwd())
for m in ("pricing26", "test_coupon26"):
    sys.modules.pop(m, None)             # re-run after you edit the code

open("pricing26.py", "w").write('''
def coupon_discount(total):              # seeded defect: round, not floor
    if total > 1000:
        return min(round(total / 10), 300)
    return 0
''')
open("test_coupon26.py", "w").write('''
import pytest
from pricing26 import coupon_discount

@pytest.mark.parametrize(("total", "expected"),
    [(1000, 0), (1001, 100), (2999, 299), (3000, 300)],
    ids=["edge-1000", "edge-1001", "below-cap", "cap-3000"])
def test_coupon_discount(total, expected):
    assert coupon_discount(total) == expected
''')
code = pytest.main(["-q", "--tb=no", "-p", "no:cacheprovider",
                    "--junitxml=report.xml", "test_coupon26.py"])
print("exit code:", int(code))
suite = ET.parse("report.xml").getroot().find("testsuite")
print({k: suite.get(k) for k in ("tests", "failures", "errors", "skipped")})
for case in suite.iter("testcase"):
    fail = case.find("failure")
    note = "pass" if fail is None else "FAIL: " + fail.get("message").splitlines()[0]
    print(case.get("name"), "->", note)

আসল আউটপুট:

..F.                                                                     [100%]
=========================== short test summary info ============================
FAILED test_coupon26.py::test_coupon_discount[below-cap] - assert 300 == 299
1 failed, 3 passed in 0.02s
exit code: 1
{'tests': '4', 'failures': '1', 'errors': '0', 'skipped': '0'}
test_coupon_discount[edge-1000] -> pass
test_coupon_discount[edge-1001] -> pass
test_coupon_discount[below-cap] -> FAIL: assert 300 == 299
test_coupon_discount[cap-3000] -> pass

প্রথম চার লাইন pytest-এর নিজের আউটপুট (--tb=no দেওয়ায় traceback নেই)। তারপর দুটি আলাদা সংকেত: exit code 1, যা দেখে CI build লাল করে; আর XML-এর গুনতি, ৪টি test, ১টি failure, যা dashboard-এ যায়। শেষের চার লাইন আমাদের ছোট “CI”-র কাজ: প্রতিটি <testcase> খুঁজে দেখা ভেতরে <failure> আছে কি না, থাকলে তার message-এর প্রথম লাইন। বড় CI tool ঠিক এভাবেই, আরও অনেক বিস্তারে, রিপোর্ট পড়ে। খেয়াল করুন, ব্যর্থ সারির পরিচয় এসেছে name থেকে, যেখানে parametrize-এর id আছে; অর্থবহ id না দিলে dashboard-এ থাকত test_coupon_discount[2999-299]. নিজে চেষ্টা করুন: round(total / 10)-কে total // 10 করে চালান; exit code আর failures দুটোই 0 হবে। আরেকবার, "tests"-এর পাশে "hostname" যোগ করে দেখুন ব্রাউজারের ভেতরের Python কী নাম লেখে।

আরও গভীরে: JUnit XML-এর একক আনুষ্ঠানিক schema নেই; Ant, Maven Surefire, Jenkins আর বিভিন্ন CI নিজেদের রূপ মেনে চলে, তাই কোনো tool skipped-কে attribute হিসেবে লেখে, কেউ শুধু element হিসেবে। এই সমস্যা মেটাতে JUnit দল “Open Test Reporting” নামে একটি নতুন, ঘটনাভিত্তিক XML ফরম্যাট এনেছে, যা JUnit Platform লিখতে পারে। আরেকটি পুরোনো সাধারণ ভাষা হলো TAP (Test Anything Protocol), Perl-এর জগতে ১৯৮০-এর দশকের শেষে শুরু, লাইনভিত্তিক সাধারণ লেখা (ok 1, not ok 2); Node-এর নিজস্ব test runner এখনো TAP লিখতে পারে। বড় দলে নিয়ম একটাই: যে ফরম্যাটই হোক, dashboard কীভাবে গোনে, তা লিখে রাখুন।

পরীক্ষা ও ইন্টারভিউতে:

  • xUnit পরিবারের সাধারণ অংশ কী কী? Test case, fixture (setup/teardown), assertion, test suite, test runner আর ফলের রিপোর্ট; SUnit আর JUnit থেকে প্রায় সব ভাষায় ছড়ানো।
  • JUnit 5-এ table-ভিত্তিক test কীভাবে লেখেন? @ParameterizedTest আর একটি উৎস, যেমন @CsvSource, @ValueSource বা @MethodSource; প্রতিটি সারি আলাদা invocation.
  • Go-তে t.Errorf আর t.Fatalf-এর পার্থক্য? Errorf ব্যর্থ চিহ্নিত করে চলতে দেয়; Fatalf চিহ্নিত করে বর্তমান test বা subtest থামায়।
  • JUnit-এ assertEquals-এর argument-এর ক্রম? আগে expected, পরে actual; উল্টালে ফল ঠিক থাকে কিন্তু বার্তা উল্টো বলে।
  • JUnit XML কেন দরকার? ভিন্ন ভাষার test-এর ফল একই ফরম্যাটে CI আর dashboard-এ দেখাতে; তবে গোনার নিয়ম tool-ভেদে আলাদা হতে পারে।

৯ · AI-এর যুগে — এক framework থেকে আরেকটিতে test অনুবাদ

“এই pytest ফাইলটি JUnit-এ লিখে দাও” ধরনের কাজে AI সহকারী খুব দ্রুত। কিন্তু অনুবাদে চেনা ভুল আসে: assertEquals-এর argument উল্টো; JUnit 4-এর org.junit.Test আর JUnit 5-এর org.junit.jupiter.api.Test মেশানো, যাতে কিছু test Jupiter engine-এ খুঁজেই পাওয়া যায় না আর চুপচাপ বাদ পড়ে; Vitest ফাইলে jest.fn(); Go-তে না-থাকা function, যেমন standard library-তে assert.Equal আছে ধরে নেওয়া; শুধু happy path অনুবাদ করে সীমার সারি বাদ; কোডের বর্তমান আচরণকে expected বানানো, ফলে round-এর ভুলে ২৯৯৯-এর expected ৩০০; সব নির্ভরতা mock; আর না চালিয়েই “সব test পাস” দাবি।

AI-কে requirement আর টেবিল দিন, অনুবাদের নিয়ম বেঁধে দিন:

তুমি একজন অভিজ্ঞ SDET. নিচে বাজারঘরের coupon নিয়ম আর একটি pytest ফাইল দিলাম। এটিকে JUnit 5 (Jupiter) আর Go-র table-driven test-এ অনুবাদ করো। নিয়ম: অর্ডার ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০, ভগ্নাংশ বাদ (floor); ঋণাত্মক টাকা অবৈধ। শর্ত: ১. প্রতিটি সারি হুবহু রাখবে, একটিও বাদ দেবে না; expected মান নিয়ম থেকে, কোড থেকে নয়। ২. JUnit-এ শুধু org.junit.jupiter.* import; assertEquals(expected, actual) ক্রম মানবে; টেবিলে @ParameterizedTest আর @CsvSource. ৩. Go-তে শুধু standard library-র testing package; প্রতিটি সারি t.Run দিয়ে, বার্তা "f(x) = got, want y" ধাঁচে; error-এর জন্য wantErr কলাম। ৪. কোনো mock নয়। ৫. তুমি কোড চালাওনি, তাই "সব পাস" লিখবে না; বরং বলো floor-এর জায়গায় round হলে কোন সারি ব্যর্থ হওয়ার কথা।

অনুবাদ করা test হাতে পেলে — চেকলিস্ট

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

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

প্র ০১Go কেন standard library-তে assertion রাখেনি? সিদ্ধান্তটি কি ঠিক ছিল?

Go-র FAQ-এ একটি প্রশ্ন আছে, মোটামুটি “testing-এর জন্য আমার প্রিয় helper function কোথায়?” উত্তরের সারকথা: assertion লাইব্রেরি থাকলে মানুষ সঠিক error handling আর অর্থবহ বার্তা লেখা নিয়ে ভাবা বন্ধ করে দেয়; প্রথম ব্যর্থতায় test থেমে যায়, ফলে একসাথে সব সমস্যা দেখা যায় না; আর assertion-এর জন্য একটি ছোট আলাদা ভাষা শিখতে হয়। Go-র দর্শন হলো, test-ও সাধারণ Go কোড, একই if, একই loop, একই error.

পক্ষের যুক্তি শক্ত। Table-driven test আর t.Errorf মিলে ডিফল্টেই soft assertion: পাঁচ সারির তিনটি ভুল হলে তিনটিই একবারে দেখা যায়। বার্তার মান লেখকের হাতে, তাই ভালো দলে বার্তা হয় নিখুঁত: CouponDiscount(2999) = 300, want 299. বাইরের লাইব্রেরি নেই বলে নির্ভরতা কম, আর নতুন কেউ এলে আলাদা API শিখতে হয় না।

বিপক্ষের যুক্তিও বাস্তব। বড় struct বা slice তুলনায় হাতে লেখা কোড লম্বা হয়; তাই Google-এর প্রকৌশলীরাই go-cmp নামের তুলনার লাইব্রেরি এনেছেন, যা দুটি মানের পার্থক্য সুন্দর করে দেখায়। আর testify-র ব্যাপক জনপ্রিয়তা দেখায় যে অনেক developer assertion-এর সুবিধা চান। অলস লেখক হাতে t.Error("wrong") লিখলে বার্তা pytest-এর চেয়ে অনেক খারাপ হয়; অর্থাৎ নকশাটি শৃঙ্খলা ধরে নেয়।

Tester-এর দৃষ্টিতে প্রশ্নটি “কোনটি ভালো” নয়, “দলে কোন রীতি, আর সেটি review-তে কীভাবে রক্ষা হবে”। Go প্রকল্পে review checklist-এ থাকা উচিত: প্রতিটি বার্তায় input, got আর want আছে কি না, আর table-এ সারির নাম অর্থবহ কি না।

মূল উপলব্ধি: Assertion লাইব্রেরি না থাকা মানে ভালো বার্তার দায়িত্ব test লেখকের। নকশাটি শৃঙ্খলাবদ্ধ দলে চমৎকার কাজ করে, অলস দলে দুর্বল রিপোর্ট দেয়।

প্র ০২JUnit 4 থেকে 5-এ যাওয়ার সময় কিছু test “চুপচাপ” চলা বন্ধ করে দেয় কেন? এখান থেকে migration-এর কী শিক্ষা?

JUnit 4 ছিল একটি একক jar; @Test annotation থাকত org.junit package-এ। ২০১৭ সালের JUnit 5 পুরো নকশা বদলায়: Platform নামের একটি সাধারণ চালানোর স্তর, তার ওপর আলাদা আলাদা “engine”. নতুন test লেখার engine Jupiter, যার @Test থাকে org.junit.jupiter.api-তে; পুরোনো JUnit 4-এর test চালাতে আলাদা Vintage engine লাগে। লক্ষ্য ছিল ভালো: IDE আর build tool একটি Platform-এর সাথে কথা বলবে, আর যেকোনো নতুন test framework নিজের engine দিয়ে যোগ হতে পারবে। Cucumber বা Spock-এর মতো tool-ও এভাবে Platform-এ চলে।

সমস্যা হয় মিশ্র অবস্থায়। একটি ফাইলে কেউ (বা AI) ভুল করে import org.junit.Test লিখল, অথচ প্রকল্পে Vintage engine নেই। কোড ঠিকই compile হয়, কারণ JUnit 4-এর jar অন্য কোনো নির্ভরতার সাথে classpath-এ চলে এসেছে; কিন্তু Jupiter সেই annotation চেনে না, তাই test খুঁজে পায় না। কোনো লাল দাগ নেই, শুধু “tests found” সংখ্যা এক কম। ঠিক এই ধরনের নীরব বাদ পড়া পর্ব ২১-এ pytest-এর নামের নিয়মেও দেখেছেন।

Migration-এর শিক্ষা কয়েকটি। প্রথমত, আগে আর পরে test-এর গুনতি মেলানো বাধ্যতামূলক; কমে গেলে কারণ খুঁজুন। দ্বিতীয়ত, ধাপে ধাপে যান: Vintage দিয়ে পুরোনো test চালু রেখে নতুন test Jupiter-এ, তারপর ফাইল ধরে রূপান্তর। তৃতীয়ত, static analysis বা build-এর নিয়ম দিয়ে পুরোনো import নিষিদ্ধ করুন, যাতে ভুল ফিরে না আসে। JUnit 6 (২০২৫)-এ পুরোনো অনেক deprecated অংশ সরানো হয়েছে; একই সতর্কতা সেখানেও খাটে।

মূল উপলব্ধি: Test framework বদলানোর সবচেয়ে বড় ঝুঁকি ব্যর্থ test নয়, যে test আর চলছেই না। গুনতি মেলানোই প্রথম প্রতিরক্ষা।

প্র ০৩JUnit XML-এর কোনো আনুষ্ঠানিক মানদণ্ড নেই, তবু সবাই এটি ব্যবহার করে। এই “অলিখিত মানদণ্ড”-এর লাভ আর ঝুঁকি কী?

JUnit XML-এর জন্ম Java-র Ant build tool-এর JUnit task থেকে: test চালিয়ে ফল একটি XML ফাইলে লেখা, যাতে পরে HTML রিপোর্ট বানানো যায়। Jenkins-এর মতো CI সার্ভার সেই ফাইল পড়তে শিখল, তারপর অন্য ভাষার tool ভাবল, “আমরাও এই ফরম্যাট লিখলে CI-তে বিনা খরচে সুন্দর রিপোর্ট পাব।” এভাবে কোনো কমিটি ছাড়াই এটি সাধারণ ভাষা হয়ে গেল: pytest, Vitest, Jest, JUnit, NUnit, আর Go-তে রূপান্তরের tool দিয়ে।

লাভ স্পষ্ট। একটি CI pipeline চার ভাষার test-এর ফল একই dashboard-এ দেখাতে পারে; flaky test খোঁজার tool, test-এর সময়ের প্রবণতা, ব্যর্থতার ইতিহাস সব একই ফাইল থেকে আসে। নতুন tool বানালে শুধু এই ফরম্যাট লিখতে জানলেই চলে।

ঝুঁকিগুলো সূক্ষ্ম। প্রথমত, গোনার নিয়ম আলাদা: এই পর্বের সত্যিকারের run-এ একই ভুল pytest-এ ১টি failure, Go-র রূপান্তরে ২টি, কারণ parent test-ও গোনা হয়েছে। দুই দলের “ব্যর্থতার হার” তুলনা করলে ভুল সিদ্ধান্ত আসবে। দ্বিতীয়ত, নামের ধরন আলাদা: JUnit-এর XML-এ সারির নাম [3], ফলে ইতিহাসে কোন সারি বারবার ব্যর্থ হয় তা খুঁজতে অসুবিধা। তৃতীয়ত, অতিরিক্ত তথ্য: hostname, আর কোনো কোনো tool-এ পুরো system property, যা রিপোর্ট শেয়ার করলে ব্যক্তিগত তথ্য ফাঁস করে। চতুর্থত, কোনো tool নতুন বৈশিষ্ট্য যোগ করলে (যেমন একটি test-এর ভেতরে কয়েকটি ধাপ) পুরোনো ফরম্যাটে তা প্রকাশের জায়গা নেই; এজন্যই JUnit দল নতুন Open Test Reporting ফরম্যাট এনেছে।

মূল উপলব্ধি: অলিখিত মানদণ্ড যোগাযোগ সহজ করে, কিন্তু প্রতিটি tool-এর উপভাষা জানতে হয়। Dashboard-এর সংখ্যা বিশ্বাস করার আগে জানুন কে, কীভাবে গুনেছে।

প্র ০৪কয়েকটি ভাষার দলে সব test একই ধাঁচে লেখা উচিত, নাকি প্রতিটি ভাষার নিজস্ব রীতিতে?

ধরুন বাজারঘরের backend Go-তে, admin panel Java-তে, আর frontend TypeScript-এ। QA lead চাইলেন সব জায়গায় একই নিয়ম: প্রতিটি test-এর নাম “should…” দিয়ে শুরু, সব জায়গায় assertion লাইব্রেরি, সব জায়গায় mock লাইব্রেরি। শুনতে গোছানো, কিন্তু ফল প্রায়ই উল্টো। Go-তে testify আর mock লাইব্রেরি চাপালে Go-র অভিজ্ঞ developer-রা অস্বস্তিতে পড়েন, কারণ সেই ভাষার সম্প্রদায়, বই আর open source কোড অন্য রীতি মানে। নতুন কেউ এলে দুটি রীতিই শিখতে হয়।

অন্যদিকে পুরো স্বাধীনতাও বিপজ্জনক। একই coupon নিয়ম তিনটি service-এ আলাদা টেবিলে test হলে কোনো একটি থেকে below-cap-এর মতো গুরুত্বপূর্ণ সারি বাদ পড়তে পারে; আর রিপোর্ট আলাদা হলে কেউ পুরো ছবি দেখেন না।

একটি যুক্তিসঙ্গত মাঝামাঝি পথ: কী test করা হবে সেটি ভাষা-নিরপেক্ষ আর অভিন্ন রাখা, কীভাবে লেখা হবে সেটি ভাষার রীতিতে। অভিন্ন অংশে থাকে test design (partition, সীমা, সারির নাম যেমন edge-1001, below-cap), প্রয়োজনে একটি ভাগ করা টেবিল ফাইল (CSV বা JSON) যা প্রতিটি ভাষার test পড়ে; একই রিপোর্ট ফরম্যাট (JUnit XML) আর গোনার নিয়ম লিখিত; আর review checklist-এর সাধারণ প্রশ্ন: সীমার সারি আছে কি না, বার্তায় input-got-want আছে কি না। ভাষার রীতিতে থাকে framework, assertion-এর ধাঁচ আর নকলের কৌশল। এই পর্বে ঠিক এটাই করা হয়েছে: একটি টেবিল, চারটি স্বাভাবিক রূপ।

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

প্র ০৫Mockito, vi.fn, Python-এর Mock আর Go-র হাতে লেখা fake কেন এত আলাদা? এটি code-এর নকশা নিয়ে কী বলে?

প্রতিটি নকলের কৌশল ভাষার একটি মৌলিক বৈশিষ্ট্যের প্রতিফলন। Python-এ object-এর attribute চলার সময় যোগ করা যায়, তাই Mock() যেকোনো নাম আর যেকোনো call মেনে নেয়; শক্তি নমনীয়তা, দুর্বলতা হলো বানান ভুলও ধরা পড়ে না। JavaScript-এ function সাধারণ মান, তাই নকল function বানানো এক লাইনের কাজ, আর module বদলানোর জন্য vi.mock-এর মতো কৌশল লাগে। Java-তে type কঠোর আর class চলার সময় সহজে বদলানো যায় না, তাই Mockito bytecode তৈরি করে নতুন class বানায়; এর জন্যই JDK-র agent-সংক্রান্ত সতর্কবার্তা, যা এই পর্বের সত্যিকারের run-এ দেখেছেন। Go-তে interface নিজে থেকে মেলে, তাই ছোট interface-এর একটি fake struct লেখা এত সহজ যে লাইব্রেরির প্রয়োজনই কম পড়ে।

এর থেকে নকশার একটি গভীর শিক্ষা আসে। যে কোডের নির্ভরতা একটি ছোট interface বা parameter হিসেবে বাইরে থেকে আসে (dependency injection), সেটি যেকোনো ভাষায় সহজে test করা যায়, এমনকি লাইব্রেরি ছাড়াও। বাজারঘরের pay function wallet-কে parameter হিসেবে নেয়, তাই চারটি ভাষাতেই নকল বসানো সহজ হয়েছে। যদি function-এর ভেতরে সরাসরি আসল wallet client তৈরি হতো, Python-এ patch, Java-তে static mock, Go-তে package-স্তরের variable বদলানোর মতো জটিল কৌশল লাগত। “Mock লাইব্রেরি ছাড়া test লেখা কঠিন” মনে হলে প্রায়ই সমস্যা লাইব্রেরিতে নয়, কোডের নকশায়। এই বিষয় নিয়েই পর্ব ২৫ (Testable code — dependency injection, seam আর legacy code).

আরেকটি দিক: শক্তিশালী mock লাইব্রেরি অতিরিক্ত নকলের লোভ বাড়ায়। Go-র হাতে লেখা fake-এ প্রতিটি নকল আচরণ চোখে পড়ে, তাই মানুষ কম নকল করে।

মূল উপলব্ধি: নকলের কৌশল ভাষা ঠিক করে, কিন্তু নকল কতটা সহজ হবে তা ঠিক করে কোডের নকশা। ছোট interface আর বাইরে থেকে দেওয়া নির্ভরতা সব ভাষায় test সহজ করে।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন। সব সংখ্যা আর আউটপুট সত্যিকারের run থেকে।

  1. Spec থেকে Go-র table-driven test: বাজারঘরের delivery charge: ঢাকার ভেতরে ৬০ টাকা, অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি; বাইরে ১২০ টাকা, Plus সদস্যের ৬০ টাকা। Charge(district string, total int, member bool) int-এর জন্য পাঁচ সারির একটি table-driven test লিখুন, অর্থবহ নামসহ। কোন সারি কোন partition বা সীমা থেকে, বলুন। কোডে >= 2000-এর জায়গায় > 2000 থাকলে কোন সারি কী বার্তা দেবে?
    tests := []struct {
    	name     string
    	district string
    	total    int
    	member   bool
    	want     int
    }{
    	{"dhaka-1999", "Dhaka", 1999, false, 60},
    	{"dhaka-2000-free", "Dhaka", 2000, false, 0},
    	{"dhaka-plus-no-effect", "Dhaka", 1999, true, 60},
    	{"outside-never-free", "Khulna", 5000, false, 120},
    	{"outside-plus", "Khulna", 500, true, 60},
    }
    for _, tc := range tests {
    	t.Run(tc.name, func(t *testing.T) {
    		got := Charge(tc.district, tc.total, tc.member)
    		if got != tc.want {
    			t.Errorf("Charge(%q, %d, %v) = %d, want %d",
    				tc.district, tc.total, tc.member, got, tc.want)
    		}
    	})
    }

    প্রথম দুটি সারি ঢাকার ২০০০-এর সীমার দুই পাশ; তৃতীয়টি দেখায় ঢাকায় Plus সদস্য হলেও নিয়ম একই; চতুর্থটি ধরে “বাইরেও বড় অর্ডারে ফ্রি” ধরনের ভুল; পঞ্চমটি বাইরের Plus partition. সত্যিকারের run-এ পাঁচটিই PASS. > 2000 বসালে সত্যিকারের ফল:

    --- FAIL: TestCharge (0.00s)
        --- FAIL: TestCharge/dhaka-2000-free (0.00s)
            delivery_test.go:23: Charge("Dhaka", 2000, false) = 60, want 0
  2. বার্তা পড়ে আগে বলুন: (ক) একটি JUnit test-এ লেখা assertEquals(Pricing.couponDiscount(2999), 299), আর CI-র বার্তা expected: <300> but was: <299>. কোড আসলে কত ফেরত দিয়েছে? (খ) Vitest-এ expect(couponDiscount(1001)).toBe(100) ব্যর্থ হয়ে বলল expected 101 to be 100. কোড কত দিয়েছে? (গ) Go-র একটি test function-এ ৫টি সারি t.Run দিয়ে চলে, আর একই package-এ আরেকটি সাধারণ test আছে। একটি সারি ব্যর্থ। go-junit-report-এর XML-এ tests আর failures কত হবে?

    (ক) ৩০০. Argument উল্টো বলে বার্তাও উল্টো: JUnit প্রথম argument-কে expected ধরে, যেটি আসলে কোডের ফল। সত্যিকারের run-এ ঠিক এই বার্তা এসেছিল, যখন কোড round দিয়ে ৩০০ দিচ্ছিল। (খ) ১০১; Vitest-এর বাক্যে expected X-এর X হলো expect()-এর ভেতরের মান, অর্থাৎ actual. (গ) ৭টি test (parent ১, সারি ৫, সাধারণ test ১), ২টি failure (ব্যর্থ সারি আর তার parent). এই পর্বের coupon package-এ ঠিক এই গঠনে সত্যিকারের XML: tests="7" failures="2".

  3. Test-এ ভুল খুঁজুন: একজন সহকর্মী নিচের Vitest ফাইল লিখে বললেন, “তিনটি test, সব সবুজ।” সত্যিকারের run-এ সত্যিই Tests 3 passed (3), অথচ couponDiscount ইচ্ছা করে ভাঙা: সবসময় 9999 দেয়। তিনটি সমস্যা খুঁজে বের করুন।
    const couponDiscount = (total) => 9999;   // badly broken on purpose
    
    it("caps the discount at 300", () => {
      [3000, 5000].forEach((t) => expect(couponDiscount(t) <= 300));
    });
    it.each([[1001, 100], [2999, 299]])("coupon", (total, expected) => {
      expect(couponDiscount(total)).not.toBe(expected + 1);
    });

    (১) প্রথম test-এ expect(…) আছে কিন্তু কোনো matcher (.toBe(true)) নেই; expect একা কিছুই যাচাই করে না, তাই test সবসময় পাস। লিখুন expect(couponDiscount(t)).toBe(300). (২) it.each-এর নামে কোনো %i বা $ চিহ্ন নেই, তাই দুটি সারিরই নাম “coupon”; সত্যিকারের run-এ রিপোর্টে দুটি হুবহু একই লাইন ✓ … > coupon, কোনটি কোন সারি বোঝার উপায় নেই। (৩) .not.toBe(expected + 1) একটি দুর্বল assertion: শুধু একটি ভুল মান বাদ দেয়, বাকি সব (9999 সহ) মেনে নেয়। লিখুন .toBe(expected). শিক্ষা: সবুজ suite-এর বিশ্বাসযোগ্যতা যাচাই করতে কোড ইচ্ছা করে ভেঙে দেখুন, যেমন এখানে 9999; কোনো test লাল না হলে test-ই ভুল।

  4. গুনে বলুন: একটি Go package-এ তিনটি test function, যাদের ভেতরে t.Run দিয়ে যথাক্রমে ৪, ৫ আর ৬টি সারি, আর একটি সাধারণ test (subtest নেই)। একই সারিগুলো pytest-এ তিনটি parametrize-করা function আর একটি সাধারণ function. (ক) go-junit-report-এর XML-এ tests কত? (খ) pytest-এর --junitxml-এ কত? (গ) পার্থক্য কেন?

    (ক) ৩ + (৪ + ৫ + ৬) + ১ = ১৯; সত্যিকারের run: <testsuites tests="19">. (খ) ৪ + ৫ + ৬ + ১ = ১৬; সত্যিকারের run: 16 passed, XML-এ tests="16". (গ) Go-তে subtest-যুক্ত প্রতিটি parent function নিজেও একটি test হিসেবে রিপোর্ট হয়, তাই তিনটি বাড়তি; pytest-এ parametrize-করা function নিজে কোনো আলাদা item নয়, শুধু তার সারিগুলো। দুই দলের সংখ্যা তুলনার আগে এই নিয়ম মাথায় রাখুন।

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

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

ক্রমGo-তে একটি table-driven test লেখা আর চালানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. requirement থেকে partition আর সীমা বেছে সারির তালিকা বানানো
  2. _test.go ফাইলে TestXxx(t *testing.T) function খোলা
  3. name, input আর want কলামসহ struct-এর slice-এ সারি লেখা
  4. loop-এ প্রতিটি সারি t.Run(tc.name, …) দিয়ে চালানো
  5. got আর want না মিললে input, got, want-সহ t.Errorf
  6. go test -v -run দিয়ে চালিয়ে ব্যর্থ সারির নাম পড়া

একটি JUnit test-এ assertEquals(actualTotal, 299) লেখা, আর কোড ৩০০ ফেরত দিল। বার্তা কী হবে?

  • expected: <299> but was: <300>
  • test পাস করবে
  • expected: <300> but was: <299>
  • compile error

Go-র table-driven test-এ একটি সারিতে t.Errorf ডাকা হলো। কী ঘটে?

  • পুরো package-এর test থেমে যায়
  • সারিটি ব্যর্থ চিহ্নিত হয়, কিন্তু চলা থামে না
  • শুধু এই subtest সাথে সাথে থেমে যায়
  • বার্তা ছাপা হয়, কিন্তু test পাস থাকে

Vitest-এ it.each([{ total: 2999, expected: 299 }])("$total taka -> $expected", …). রিপোর্টে test-এর নাম কী হবে?

  • $total taka -> $expected
  • [1]
  • {"total":2999,"expected":299}
  • 2999 taka -> 299

JUnit 5/6-এ একই test method পাঁচটি ভিন্ন input দিয়ে চালাতে কোন জোড়া সবচেয়ে উপযুক্ত?

  • @ParameterizedTest আর @CsvSource
  • @Test আর method-এর ভেতরে for loop
  • @BeforeEach আর @Test
  • @Nested আর @Test

একই coupon-এর ভুলে pytest-এর JUnit XML-এ tests="6" failures="1", কিন্তু Go থেকে go-junit-report দিয়ে বানানো XML-এ tests="7" failures="2". কারণ কী?

  • Go আরেকটি আলাদা bug ধরেছে
  • go-junit-report XML-এর পুরোনো সংস্করণ লেখে
  • Parent test নিজেও গোনা হয়, আর সন্তানের ব্যর্থতায় সেটিও ব্যর্থ
  • Go test-গুলো parallel চলেছে বলে একটি দুবার গোনা হয়েছে

নিজের ল্যাপটপে চালানো JUnit Console Launcher-এর XML রিপোর্ট একটি প্রকাশ্য forum-এ দিতে চান। আগে কী করবেন?

  • শুধু failure-এর বার্তা মুছে দেবেন
  • hostname আর <properties> অংশ সরাবেন বা নিরপেক্ষ করবেন
  • XML-কে JSON-এ রূপান্তর করবেন
  • কোনো কিছু না, XML-এ শুধু test-এর ফল থাকে

কোন framework-এর standard রূপে কোনো assertion function নেই, আর যাচাই সাধারণ if দিয়ে লেখা হয়?

  • pytest
  • Vitest
  • JUnit Jupiter
  • Go-র testing package

শব্দকোষ

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

মনে রাখুন

  1. xUnit-এর অংশ: test case, fixture, assertion, suite, runner আর রিপোর্ট; নতুন framework দেখলে এই ছয়টি খুঁজুন।
  2. টেবিলের চার রূপ: parametrize, it.each, @ParameterizedTest + @CsvSource, struct-এর slice + t.Run; সারির নাম অর্থবহ রাখুন।
  3. ক্রম: JUnit, unittest আর testify-তে আগে expected; Vitest আর AssertJ-এ আগে actual. উল্টালে ফল ঠিক, বার্তা মিথ্যা।
  4. Go: assertion নেই; t.Errorf চলতে দেয়, t.Fatalf থামায়; বার্তায় input, got আর want.
  5. JUnit XML: সবার সাধারণ রিপোর্ট, কিন্তু গোনার নিয়ম আলাদা (Go-তে parent-ও test); শেয়ারের আগে hostname আর system property সরান।

পরের পর্বে: চার ভাষায় test লেখা আর পড়া শিখলেন। এবার test আগে, কোড পরে: TDD-র red-green-refactor চক্র, এক উদাহরণ থেকে তিনটিতে গিয়ে কোড সাধারণ করা (triangulation), আর বাজারঘরের একটি নিয়ম ধাপে ধাপে, প্রতিটি ধাপে সত্যিকারের pytest run.

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

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