Behavior বা Expectation সেট করা

EasyMock একটি শক্তিশালী Java-based mocking framework যা unit testing এবং test-driven development (TDD) এ ব্যবহৃত হয়। EasyMock ব্যবহার করে, আপনি আপনার কোডের নির্ভরশীলতাগুলিকে mock করতে পারেন এবং তাদের আচরণ নির্ধারণ করতে পারেন। এই প্রক্রিয়াটিকে Behavior Setting বা Expectation Setting বলা হয়। এখানে আমরা বিস্তারিতভাবে দেখব কিভাবে EasyMock এ behavior বা expectations সেট করা যায়।

1. Behavior বা Expectation সেট করার মৌলিক ধারণা

Behavior Setting বা Expectation Setting হল এমন একটি প্রক্রিয়া যেখানে আপনি মক অবজেক্টের জন্য নির্দিষ্ট মেথড কলের প্রত্যাশা নির্ধারণ করেন এবং সেই মেথড কল হলে কী রিটার্ন বা আচরণ হবে তা নির্ধারণ করেন। এটি মূলত আপনার টেস্ট কেসে নির্দিষ্ট পরিস্থিতি তৈরি করতে ব্যবহৃত হয়।

2. EasyMock এর Expectation সেট করার ধাপ

EasyMock এ Expectation Setting সাধারণত নিম্নলিখিত ধাপগুলো অনুসরণ করে:

1. Mock Creation: প্রথমে মক অবজেক্ট তৈরি করা।
2. Setting Expectations: মক অবজেক্টের মেথড কলের প্রত্যাশা নির্ধারণ করা।
3. Replay: মক অবজেক্টকে কার্যকরী করা যাতে এটি নির্ধারিত আচরণ অনুসরণ করে।
4. Test Execution: টেস্ট চালানো যা মক অবজেক্টের সাথে ইন্টারঅ্যাক্ট করে।
5. Verification: যাচাই করা যে মক অবজেক্টের প্রত্যাশিত মেথড কলগুলো হয়েছে কিনা।

3. EasyMock এ Expectation সেট করার উদাহরণ

ধরা যাক, আমাদের একটি UserService ক্লাস রয়েছে যা UserDao ক্লাসের উপর নির্ভরশীল। আমরা EasyMock ব্যবহার করে UserDao ক্লাসের মক তৈরি করব এবং UserService টেস্ট করব।

Step 1: প্রয়োজনীয় ডিপেন্ডেন্সি যোগ করা (Maven)

আপনার Maven প্রকল্পে EasyMock এবং JUnit এর জন্য dependency যোগ করতে হবে।

<dependencies>
    <!-- EasyMock Dependency -->
    <dependency>
        <groupId>org.easymock</groupId>
        <artifactId>easymock</artifactId>
        <version>4.3</version> <!-- সর্বশেষ ভার্সন ব্যবহার করুন -->
        <scope>test</scope>
    </dependency>
    
    <!-- JUnit Dependency -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Step 2: UserDao ইন্টারফেস

public interface UserDao {
    User findUserById(int id);
    void saveUser(User user);
}

Step 3: UserService ক্লাস

public class UserService {
    private UserDao userDao;

    // Constructor-based dependency injection
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    public String getUserName(int id) {
        User user = userDao.findUserById(id);
        if (user != null) {
            return user.getName();
        }
        return "Unknown";
    }

    public void registerUser(User user) {
        userDao.saveUser(user);
    }
}

Step 4: User ক্লাস

public class User {
    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Step 5: EasyMock ব্যবহার করে টেস্টিং

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class UserServiceTest {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        // Mock Object তৈরি করা
        userDaoMock = EasyMock.createMock(UserDao.class);

        // UserService এর ইনস্ট্যান্স তৈরি করা এবং মক UserDao ইনজেক্ট করা
        userService = new UserService(userDaoMock);
    }

    @Test
    public void testGetUserName() {
        // মক অবজেক্টের জন্য Expectation সেট করা
        User mockUser = new User(1, "John Doe");
        EasyMock.expect(userDaoMock.findUserById(1)).andReturn(mockUser);

        // মক অবজেক্টকে Replay মোডে পাঠানো
        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        String userName = userService.getUserName(1);

        // ফলাফল Assert করা
        assertEquals("John Doe", userName);

        // Verify করা যে মক অবজেক্টের প্রত্যাশিত মেথড কল হয়েছে কিনা
        EasyMock.verify(userDaoMock);
    }

    @Test
    public void testRegisterUser() {
        // মক অবজেক্টের জন্য Expectation সেট করা (void মেথডের জন্য)
        User newUser = new User(2, "Jane Smith");
        userDaoMock.saveUser(newUser);
        EasyMock.expectLastCall().once();

        // মক অবজেক্টকে Replay মোডে পাঠানো
        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        userService.registerUser(newUser);

        // Verify করা যে মক অবজেক্টের প্রত্যাশিত মেথড কল হয়েছে কিনা
        EasyMock.verify(userDaoMock);
    }
}

ব্যাখ্যা:

1. Mock Creation:
   • EasyMock.createMock(UserDao.class) ব্যবহার করে UserDao ইন্টারফেসের একটি মক অবজেক্ট তৈরি করা হয়েছে।
2. Setting Expectations:
   • EasyMock.expect(userDaoMock.findUserById(1)).andReturn(mockUser);: এখানে আমরা নির্ধারণ করেছি যে, যদি findUserById(1) মেথডটি কল হয়, তাহলে এটি mockUser রিটার্ন করবে।
   • userDaoMock.saveUser(newUser); এবং EasyMock.expectLastCall().once();: এখানে আমরা নির্ধারণ করেছি যে, saveUser(newUser) মেথডটি একবার কল হতে হবে এবং কোন রিটার্ন ভ্যালু নেই (void মেথড)।
3. Replay:
   • EasyMock.replay(userDaoMock); কল করে মক অবজেক্টকে Replay মোডে পাঠানো হয়। এখন থেকে মক অবজেক্টটি নির্ধারিত আচরণ অনুসরণ করবে।
4. Test Execution:
   • userService.getUserName(1); এবং userService.registerUser(newUser); মেথডগুলি কল করা হয়, যা মক অবজেক্টের মেথডগুলিকে ট্রিগার করে।
5. Verification:
   • EasyMock.verify(userDaoMock); কল করে যাচাই করা হয় যে মক অবজেক্টের প্রত্যাশিত মেথড কলগুলি হয়েছে কিনা।

4. Argument Matchers ব্যবহার করা

EasyMock এ আপনি Argument Matchers ব্যবহার করতে পারেন যখন আপনি মেথড কলের আর্গুমেন্টগুলিকে আরও নমনীয়ভাবে নির্ধারণ করতে চান। উদাহরণস্বরূপ, যদি আপনি জানেন না কোন নির্দিষ্ট ভ্যালু আসবে, তবে আপনি anyInt(), anyString(), ইত্যাদি ব্যবহার করতে পারেন।

উদাহরণ:

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class UserServiceTestWithMatchers {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        userDaoMock = EasyMock.createMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test
    public void testGetUserNameWithMatchers() {
        // Argument Matchers ব্যবহার করে Expectation সেট করা
        User mockUser = new User(1, "John Doe");
        EasyMock.expect(userDaoMock.findUserById(EasyMock.anyInt())).andReturn(mockUser).anyTimes();

        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        String userName1 = userService.getUserName(1);
        String userName2 = userService.getUserName(2);

        // Assert করা
        assertEquals("John Doe", userName1);
        assertEquals("John Doe", userName2);

        EasyMock.verify(userDaoMock);
    }
}

ব্যাখ্যা:

• EasyMock.anyInt(): যেকোনো ইন্টিজার আর্গুমেন্টকে গ্রহণ করে।
• .anyTimes(): মেথডটি যেকোনো সংখ্যকবার কল হতে পারে।

5. Void Methods এর জন্য Expectation সেট করা

Void মেথডগুলি সহজেই EasyMock এ মক করা যায়, তবে এগুলির জন্য কিছু বিশেষ পদ্ধতি অনুসরণ করতে হয়।

উদাহরণ:

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;

public class UserServiceVoidMethodTest {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        userDaoMock = EasyMock.createMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test
    public void testRegisterUserVoidMethod() {
        User newUser = new User(2, "Jane Smith");

        // Void Method এর Expectation সেট করা
        userDaoMock.saveUser(newUser);
        EasyMock.expectLastCall().once();

        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        userService.registerUser(newUser);

        EasyMock.verify(userDaoMock);
    }
}

ব্যাখ্যা:

• userDaoMock.saveUser(newUser);: Void মেথড কল করা হয়েছে।
• EasyMock.expectLastCall().once();: এই মেথডটি একবার কল হবে বলে নির্ধারণ করা হয়েছে।

6. Throwing Exceptions with EasyMock

EasyMock এ আপনি মক অবজেক্টের মেথড কলের সময় এক্সেপশন থ্রো করার expectation সেট করতে পারেন। এটি তখনই ব্যবহৃত হয় যখন আপনি টেস্ট করতে চান আপনার কোড এক্সেপশন হ্যান্ডেল করছে কিনা।

উদাহরণ:

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class UserServiceExceptionTest {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        userDaoMock = EasyMock.createMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test(expected = RuntimeException.class)
    public void testGetUserNameThrowsException() {
        // Exception Throw করার Expectation সেট করা
        EasyMock.expect(userDaoMock.findUserById(1)).andThrow(new RuntimeException("Database error"));

        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো, যা একটি RuntimeException প্রত্যাশা করে
        userService.getUserName(1);

        // এই Assert প্রয়োজন নেই কারণ আমরা exception প্রত্যাশা করছি
    }
}

ব্যাখ্যা:

• EasyMock.expect(userDaoMock.findUserById(1)).andThrow(new RuntimeException("Database error"));: যখন findUserById(1) কল হবে, তখন এটি একটি RuntimeException থ্রো করবে।
• @Test(expected = RuntimeException.class): টেস্টটি নিশ্চিত করে যে একটি RuntimeException থ্রো হবে।

7. Mock Types: Strict vs. Nice vs. Default

EasyMock এ বিভিন্ন ধরণের mocks তৈরি করা যায় যা মেথড কলের সাথে বিভিন্নভাবে আচরণ করে।

1. Default Mock (DefaultBehavior):
   • সমস্ত মেথডের জন্য অপ্রত্যাশিত কল করলে UnexpectedMethodCallException থ্রো করে।
   • উদাহরণ: EasyMock.createMock(UserDao.class);
2. Strict Mock:
   • মেথড কলের অর্ডার অনুযায়ী আচরণ করে।
   • যদি মেথড কলের অর্ডার না মিলে, তাহলে AssertionFailedError থ্রো করে।
   • উদাহরণ: EasyMock.createStrictMock(UserDao.class);
3. Nice Mock:
   • অপ্রত্যাশিত মেথড কলের জন্য কোন এক্সেপশন থ্রো করে না, শুধুমাত্র ডিফল্ট মান রিটার্ন করে।
   • উদাহরণ: EasyMock.createNiceMock(UserDao.class);

উদাহরণ: Strict Mock

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;

public class StrictMockTest {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        // Strict Mock তৈরি করা
        userDaoMock = EasyMock.createStrictMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test
    public void testStrictMock() {
        User mockUser = new User(1, "John Doe");
        EasyMock.expect(userDaoMock.findUserById(1)).andReturn(mockUser).once();

        // Replay
        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        String userName = userService.getUserName(1);
        assertEquals("John Doe", userName);

        // Verify
        EasyMock.verify(userDaoMock);
    }
}

উদাহরণ: Nice Mock

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class NiceMockTest {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        // Nice Mock তৈরি করা
        userDaoMock = EasyMock.createNiceMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test
    public void testNiceMock() {
        User mockUser = new User(1, "John Doe");
        EasyMock.expect(userDaoMock.findUserById(1)).andReturn(mockUser).once();

        // Replay
        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        String userName = userService.getUserName(1);
        assertEquals("John Doe", userName);

        // অপ্রত্যাশিত মেথড কলের জন্য কোন এক্সেপশন হবে না
        userService.getUserName(2); // এই কলটি কোন এক্সেপশন থ্রো করবে না

        // Verify
        EasyMock.verify(userDaoMock);
    }
}

8. Argument Matchers ব্যবহার করা

EasyMock এ আপনি Argument Matchers ব্যবহার করে মেথড কলের আর্গুমেন্টগুলিকে আরও নমনীয়ভাবে নির্ধারণ করতে পারেন। উদাহরণস্বরূপ, যদি আপনি জানেন না কোন নির্দিষ্ট ভ্যালু আসবে, তবে আপনি anyInt(), anyString(), ইত্যাদি ব্যবহার করতে পারেন।

উদাহরণ:

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class UserServiceTestWithMatchers {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        userDaoMock = EasyMock.createMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test
    public void testGetUserNameWithMatchers() {
        // Argument Matchers ব্যবহার করে Expectation সেট করা
        User mockUser = new User(1, "John Doe");
        EasyMock.expect(userDaoMock.findUserById(EasyMock.anyInt())).andReturn(mockUser).anyTimes();

        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        String userName1 = userService.getUserName(1);
        String userName2 = userService.getUserName(2);

        // Assert করা
        assertEquals("John Doe", userName1);
        assertEquals("John Doe", userName2);

        EasyMock.verify(userDaoMock);
    }
}

ব্যাখ্যা:

• EasyMock.anyInt(): যেকোনো ইন্টিজার আর্গুমেন্টকে গ্রহণ করে।
• .anyTimes(): মেথডটি যেকোনো সংখ্যকবার কল হতে পারে।

9. Advanced Expectations: Return Values এবং Exceptions

EasyMock এ আপনি শুধুমাত্র রিটার্ন ভ্যালু নির্ধারণ করতে পারেন না, বরং আপনি মেথড কলের সময় Exceptions থ্রো করার expectation সেট করতে পারেন।

উদাহরণ:

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;

public class UserServiceExceptionTest {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        userDaoMock = EasyMock.createMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test(expected = RuntimeException.class)
    public void testGetUserNameThrowsException() {
        // Exception Throw করার Expectation সেট করা
        EasyMock.expect(userDaoMock.findUserById(1)).andThrow(new RuntimeException("Database error"));

        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো, যা একটি RuntimeException প্রত্যাশা করে
        userService.getUserName(1);

        // এই Assert প্রয়োজন নেই কারণ আমরা exception প্রত্যাশা করছি
    }
}

ব্যাখ্যা:

• EasyMock.expect(userDaoMock.findUserById(1)).andThrow(new RuntimeException("Database error"));: যখন findUserById(1) কল হবে, তখন এটি একটি RuntimeException থ্রো করবে।
• @Test(expected = RuntimeException.class): টেস্টটি নিশ্চিত করে যে একটি RuntimeException থ্রো হবে।

10. Order of Method Calls

EasyMock এ আপনি মেথড কলের অর্ডার নির্ধারণ করতে পারেন, বিশেষ করে Strict Mocks ব্যবহার করার সময়। এটি নিশ্চিত করে যে মেথডগুলি নির্দিষ্ট অর্ডারে কল হয়েছে কিনা।

উদাহরণ:

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;

public class OrderOfMethodCallsTest {

    private UserDao userDaoMock;
    private UserService userService;

    @Before
    public void setUp() {
        // Strict Mock তৈরি করা
        userDaoMock = EasyMock.createStrictMock(UserDao.class);
        userService = new UserService(userDaoMock);
    }

    @Test
    public void testOrderOfMethodCalls() {
        // প্রথম মেথড কলের Expectation
        EasyMock.expect(userDaoMock.findUserById(1)).andReturn(new User(1, "John Doe")).once();

        // দ্বিতীয় মেথড কলের Expectation
        userDaoMock.saveUser(new User(1, "John Doe"));
        EasyMock.expectLastCall().once();

        // Replay
        EasyMock.replay(userDaoMock);

        // টেস্ট চালানো
        userService.getUserName(1);
        userService.registerUser(new User(1, "John Doe"));

        // Verify
        EasyMock.verify(userDaoMock);
    }
}

ব্যাখ্যা:

• Strict Mock ব্যবহার করে, মেথড কলগুলির অর্ডার গুরুত্বপূর্ণ হয়। এখানে প্রথম findUserById(1) কল হবে এবং তারপর saveUser() কল হবে।
• যদি মেথড কলের অর্ডার মেলে না, তবে টেস্টটি ফেল করবে।

সারাংশ

EasyMock হল একটি শক্তিশালী mocking framework যা unit testing এবং TDD-এ নির্ভরশীলতাগুলিকে mock করার মাধ্যমে কোডের কার্যকারিতা পরীক্ষা করতে সহায়ক। Behavior বা Expectation Setting হল EasyMock এর মূল অংশ, যা মক অবজেক্টের মেথড কলগুলির আচরণ নির্ধারণ করে। EasyMock এর মাধ্যমে আপনি:

• মক অবজেক্ট তৈরি করতে পারেন
• মেথড কলের জন্য expectations সেট করতে পারেন
• মক অবজেক্টকে replay মোডে পাঠাতে পারেন
• মেথড কলের সঠিকতা যাচাই করতে পারেন

Argument Matchers, Void Methods, Exceptions throw করা এবং Method Call Order নিয়ন্ত্রণ করার মত advanced features ব্যবহার করে আপনি আপনার টেস্টিং প্রক্রিয়াকে আরও কার্যকরী এবং নমনীয় করতে পারেন। EasyMock এর এই সমস্ত কনসেপ্টগুলি ব্যবহার করে, আপনি আপনার Java অ্যাপ্লিকেশনের unit tests গুলি আরও নির্ভরযোগ্য এবং robust করতে পারেন।

EasyMock হল একটি লাইব্রেরি যা Java-তে mock objects তৈরি এবং তাদের আচরণ কাস্টমাইজ করতে ব্যবহৃত হয়। Behavior বা Expectation ডিফাইন করার মাধ্যমে, আমরা মক অবজেক্টের কার্যকলাপ নির্ধারণ করতে পারি এবং নিশ্চিত করতে পারি যে, আমাদের টেস্টে প্রত্যাশিত আচরণটি ঘটছে।

EasyMock এর মাধ্যমে আমরা একটি মক অবজেক্ট তৈরি করি এবং তার সাথে একটি expectation (অথবা behavior) সেট করি, যা বলবে যে ওই মক অবজেক্টটি কীভাবে কাজ করবে যখন তার উপর নির্দিষ্ট একটি মেথড কল করা হবে।

Behavior বা Expectation ডিফাইন করার প্রক্রিয়া:

1. Mock Object তৈরি করা: প্রথমে একটি মক অবজেক্ট তৈরি করতে হবে যা একটি ইন্টারফেস বা ক্লাসের প্রতিনিধিত্ব করবে।
2. Expectation ডিফাইন করা: তারপর আমরা মক অবজেক্টের জন্য একটি নির্দিষ্ট behavior বা expectation সেট করি, যেমন কোন মেথড কল হলে কী আউটপুট আশা করা হচ্ছে।
3. Replay: মক অবজেক্টটি একটিভেট করার জন্য replay() মেথড ব্যবহার করতে হয়, যাতে মক অবজেক্ট কার্যকরী হয় এবং এর ওপর কাজ শুরু করা যায়।
4. Verify: শেষ পর্যন্ত, verify() মেথড ব্যবহার করে যাচাই করা হয় যে মক অবজেক্টে আশা করা কার্যকলাপ ঘটেছে কিনা।

EasyMock এর মাধ্যমে Behavior বা Expectation ডিফাইন করার উদাহরণ

ধরা যাক, আমাদের একটি Calculator ইন্টারফেস রয়েছে, এবং আমরা তার মক অবজেক্ট তৈরি করে কিছু আচরণ কাস্টমাইজ করতে চাই।

1. Calculator Interface:

public interface Calculator {
    int add(int a, int b);
    int subtract(int a, int b);
}

2. EasyMock Setup এবং Behavior ডিফাইন করা:

import static org.easymock.EasyMock.*;

public class EasyMockBehaviorExample {
    public static void main(String[] args) {
        // 1. Create a mock object of the Calculator interface
        Calculator calculatorMock = createMock(Calculator.class);

        // 2. Define the behavior (Expectation) for the mock object
        expect(calculatorMock.add(2, 3)).andReturn(5);  // Expect add(2, 3) to return 5
        expect(calculatorMock.subtract(5, 3)).andReturn(2);  // Expect subtract(5, 3) to return 2

        // 3. Activate the mock object
        replay(calculatorMock);

        // 4. Test the methods with mock behavior
        System.out.println("Addition result: " + calculatorMock.add(2, 3));  // Should return 5
        System.out.println("Subtraction result: " + calculatorMock.subtract(5, 3));  // Should return 2

        // 5. Verify that the expected methods were called
        verify(calculatorMock);
    }
}

Output:

Addition result: 5
Subtraction result: 2

EasyMock এর Behavior বা Expectation ডিফাইন করার পদ্ধতি:

1. expect(): এই মেথডটি মক অবজেক্টের জন্য একটি expectation সেট করে, অর্থাৎ আমরা জানিয়ে দিই যে নির্দিষ্ট মেথডটি কোন ইনপুটের জন্য কী আউটপুট দিবে।
   • উদাহরণ: expect(calculatorMock.add(2, 3)).andReturn(5);
2. andReturn(): expect() এর পর আমরা andReturn() মেথড ব্যবহার করি যা মক অবজেক্টের জন্য প্রত্যাশিত আউটপুট নির্ধারণ করে।
   • উদাহরণ: andReturn(5) — যখন add(2, 3) মেথড কল হবে, তখন এটি ৫ ফেরত দেবে।
3. replay(): এই মেথডটি মক অবজেক্টকে active করে এবং সেই মক অবজেক্টের behavior অনুযায়ী কাজ করতে বলে। এটি মক অবজেক্টে সেট করা প্রত্যাশিত আচরণ কার্যকর করতে ব্যবহৃত হয়।
   • উদাহরণ: replay(calculatorMock);
4. verify(): এই মেথডটি যাচাই করে যে সমস্ত expectations সঠিকভাবে পূর্ণ হয়েছে কিনা। এটি নিশ্চিত করে যে, আমাদের মক অবজেক্টে নির্ধারিত কার্যকলাপ (methods calls) ঘটেছে।
   • উদাহরণ: verify(calculatorMock);

EasyMock এর মাধ্যমে Multiple Expectations ডিফাইন করা

আপনি একাধিক মেথডের জন্য একাধিক expectationও ডিফাইন করতে পারেন। নিচে একটি উদাহরণ দেওয়া হল যেখানে দুটি মেথডের জন্য আলাদা আলাদা expectation সেট করা হয়েছে।

public class EasyMockMultipleExpectations {
    public static void main(String[] args) {
        // Create a mock object of Calculator
        Calculator calculatorMock = createMock(Calculator.class);

        // Define multiple behaviors (expectations)
        expect(calculatorMock.add(3, 4)).andReturn(7);  // Expect add(3, 4) to return 7
        expect(calculatorMock.subtract(10, 5)).andReturn(5);  // Expect subtract(10, 5) to return 5

        // Activate the mock object
        replay(calculatorMock);

        // Test the methods with mock behavior
        System.out.println("Addition result: " + calculatorMock.add(3, 4));  // Should return 7
        System.out.println("Subtraction result: " + calculatorMock.subtract(10, 5));  // Should return 5

        // Verify that the expected methods were called
        verify(calculatorMock);
    }
}

Output:

Addition result: 7
Subtraction result: 5

Summary

EasyMock এর মাধ্যমে Behavior বা Expectation ডিফাইন করা খুবই সহজ এবং কার্যকরী। আমরা মক অবজেক্টের জন্য expect(), andReturn() এর মতো মেথড ব্যবহার করে নির্দিষ্ট ইনপুটের জন্য নির্দিষ্ট আউটপুট প্রত্যাশা (expectation) নির্ধারণ করি। পরে, replay() মেথডের মাধ্যমে সেই মক অবজেক্টটির আচরণ কার্যকরী করি এবং verify() মেথডের মাধ্যমে যাচাই করি যে মক অবজেক্টে প্রত্যাশিত মেথডগুলি সঠিকভাবে কল হয়েছে কিনা।

এই পদ্ধতির মাধ্যমে, আপনি বাইরের নির্ভরতা (dependencies) ব্যবহার না করে শুধুমাত্র আপনার কোডের নির্দিষ্ট অংশের টেস্ট করতে পারেন, যা unit testing কে আরও দ্রুত এবং কার্যকরী করে তোলে।

EasyMock একটি জনপ্রিয় mocking framework যা unit testing এ ব্যবহৃত হয়। এর মাধ্যমে, আপনি mock objects তৈরি করতে পারেন এবং সেগুলির জন্য বিভিন্ন মেথডের return values নির্ধারণ করতে পারেন। এর মাধ্যমে, আপনি সহজেই পরীক্ষা করতে পারেন যে আপনার কোড নির্দিষ্ট শর্তে সঠিকভাবে কাজ করছে কি না, যেমন dependency injection এর মাধ্যমে কন্ট্রোলার বা সার্ভিস লেয়ারের সাথে মডিউলগুলির ইন্টারঅ্যাকশন।

EasyMock এ মেথডের return value নির্ধারণ করার জন্য expect() এবং andReturn() মেথড ব্যবহৃত হয়। এই দুটি মেথডের মাধ্যমে, আপনি নির্দিষ্ট ইনপুটের জন্য mock মেথডের আউটপুট নির্ধারণ করতে পারেন।

Method Return Value নির্ধারণের উদাহরণ

ধরা যাক, আপনার একটি UserService ক্লাস রয়েছে, যা UserRepository ক্লাস থেকে ডেটা নিয়ে থাকে। এখানে, আমরা UserRepository কে মক করতে চাই এবং এর findById() মেথডের জন্য একটি নির্দিষ্ট return value প্রদান করতে চাই।

১. UserRepository Interface

public interface UserRepository {
    User findById(int id);
}

২. UserService Class

public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public String getUserName(int id) {
        User user = userRepository.findById(id);
        return user != null ? user.getName() : "User not found";
    }
}

৩. User Class

public class User {
    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

৪. EasyMock Test Case (Return Value নির্ধারণ)

import static org.easymock.EasyMock.*;
import org.junit.Test;
import static org.junit.Assert.*;

public class UserServiceTest {

    @Test
    public void testGetUserName() {
        // Create mock object for UserRepository
        UserRepository mockUserRepository = createMock(UserRepository.class);

        // Create a mock user
        User mockUser = new User(1, "John");

        // Set behavior for the mock object
        expect(mockUserRepository.findById(1)).andReturn(mockUser); // Mock the return value

        // Switch the mock to replay mode
        replay(mockUserRepository);

        // Create UserService with the mock object
        UserService userService = new UserService(mockUserRepository);

        // Test the method
        String result = userService.getUserName(1);
        assertEquals("John", result);

        // Verify that the mock was called as expected
        verify(mockUserRepository);
    }
}

ব্যাখ্যা:

1. createMock(): UserRepository এর মক অবজেক্ট তৈরি করা হয়।
2. expect(): আমরা findById(1) মেথডের জন্য নির্দিষ্ট রিটার্ন ভ্যালু প্রদান করি (যেটি mockUser হবে)।
3. andReturn(): এটি expect() এর সাথে ব্যবহার করা হয় এবং এটি নির্দিষ্ট আউটপুট বা রিটার্ন ভ্যালু ঠিক করে দেয়।
4. replay(): মক অবজেক্টের জন্য আমরা যা নির্ধারণ করেছি, তা বাস্তবায়ন করতে replay() ব্যবহার করা হয়।
5. verify(): পরীক্ষা শেষে, আমরা যাচাই করি যে মক অবজেক্টটি নির্ধারিতভাবে কল হয়েছে কিনা।

Return Value নির্ধারণের আরও কিছু উদাহরণ:

১. Multiple Return Values

আপনি যদি একাধিক কলের জন্য আলাদা return value নির্ধারণ করতে চান, তবে এটি করা যায় andReturn() এর মাধ্যমে।

expect(mockUserRepository.findById(1)).andReturn(mockUser);
expect(mockUserRepository.findById(2)).andReturn(new User(2, "Jane"));

২. Return Value with Different Parameters

আপনি যদি নির্দিষ্ট প্যারামিটার অনুযায়ী আলাদা return value নির্ধারণ করতে চান, তবে এটি এভাবে করতে পারেন:

expect(mockUserRepository.findById(1)).andReturn(mockUser);
expect(mockUserRepository.findById(2)).andReturn(new User(2, "Alice"));

EasyMock এ Return Values নির্ধারণের সুবিধা:

1. Test Independence: EasyMock ব্যবহার করে আপনি আসল ডেটাবেস বা বাহ্যিক সিস্টেমের উপর নির্ভর না করে ইউনিট টেস্ট করতে পারেন।
2. Behavior Control: আপনি মক অবজেক্টের আচরণ নির্ধারণ করে পরীক্ষাগুলি সহজে কন্ট্রোল করতে পারেন।
3. Clear Expectations: expect() এবং andReturn() এর মাধ্যমে, মক অবজেক্টের জন্য স্পষ্ট প্রত্যাশা তৈরি করতে পারেন, যা পরীক্ষার সময় আরও সহজ হয়ে যায়।
4. Increased Testability: EasyMock মকিং এর মাধ্যমে, আপনার কোডের বিভিন্ন অংশ আলাদা আলাদা পরীক্ষা করা যায়, যার ফলে টেস্টিং আরো কার্যকরী হয়।

সারাংশ

EasyMock এর মাধ্যমে method return values নির্ধারণ করা একটি শক্তিশালী উপায় যা unit testing এবং mocking এর মধ্যে ব্যবহৃত হয়। এটি আপনাকে mock objects তৈরি করতে এবং তাদের নির্দিষ্ট আচরণ বা আউটপুট নির্ধারণ করতে সাহায্য করে। expect() এবং andReturn() মেথডের মাধ্যমে আপনি টেস্টের জন্য মক অবজেক্টের return value নির্ধারণ করতে পারেন, যা NullPointerException থেকে মুক্তি পেতে এবং কোডের পরীক্ষামূলক কার্যকারিতা নিশ্চিত করতে সহায়তা করে।

EasyMock এ আপনি mock objects ব্যবহার করে মক মেথডের জন্য exception থ্রো করতে পারেন। এটি তখন উপকারী হয় যখন আপনি কোনো নির্দিষ্ট মেথডের জন্য নির্দিষ্ট exception সিমুলেট করতে চান, যেমন ব্যতিক্রমী পরিস্থিতি পরীক্ষা করার জন্য। এই ধরনের টেস্টিং exception handling এর কার্যকারিতা নিশ্চিত করতে সহায়ক হয়।

EasyMock এ Exception থ্রো করার প্রক্রিয়া:

EasyMock এর মাধ্যমে একটি মক অবজেক্ট তৈরি করার সময়, আপনি expect() মেথডের সাথে andThrow() ব্যবহার করে মেথড কলের জন্য একটি exception নির্ধারণ করতে পারেন। এর মাধ্যমে আপনি নির্দিষ্ট পরিস্থিতিতে মেথড কল করার সময় বিশেষ কোনো exception থ্রো করার আচরণ সিমুলেট করতে পারেন।

ধাপ:

1. Mock Object তৈরি: createMock() ব্যবহার করে একটি মক অবজেক্ট তৈরি করুন।
2. Expectation Setup: expect() ব্যবহার করে নির্দিষ্ট মেথড কলের জন্য একটি exception থ্রো করার জন্য andThrow() ব্যবহার করুন।
3. Replay Mode: replay() মেথড দিয়ে মক অবজেক্টে নির্ধারিত আচরণ চালু করুন।
4. Exception Handling: try-catch ব্লক ব্যবহার করে টেস্টের মধ্যে exception হ্যান্ডেল করুন।

উদাহরণ: EasyMock এ Method Call এর জন্য Exception থ্রো করা

ধরা যাক, আমাদের একটি BankService ক্লাস আছে, যা BankAccount ক্লাসের উপর নির্ভরশীল। আমাদের লক্ষ্য হল, BankService এর withdraw() মেথডের জন্য InsufficientFundsException তৈরি করা এবং তা পরীক্ষা করা।

১. BankAccount ক্লাস (Dependency)

public class BankAccount {
    private int balance;

    public BankAccount(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void withdraw(int amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Insufficient funds to withdraw " + amount);
        }
        balance -= amount;
    }
}

২. BankService ক্লাস (Class Under Test)

public class BankService {
    private BankAccount bankAccount;

    public BankService(BankAccount bankAccount) {
        this.bankAccount = bankAccount;
    }

    public String processWithdrawal(int amount) {
        try {
            bankAccount.withdraw(amount);
            return "Withdrawal successful";
        } catch (InsufficientFundsException e) {
            return e.getMessage();
        }
    }
}

৩. InsufficientFundsException

public class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

৪. EasyMock এর মাধ্যমে Unit Test

import static org.easymock.EasyMock.*;
import org.junit.Test;
import static org.junit.Assert.*;

public class BankServiceTest {

    @Test
    public void testWithdrawWithInsufficientFunds() throws Exception {
        // Create a mock of BankAccount
        BankAccount mockBankAccount = createMock(BankAccount.class);

        // Set up the expectation: when withdraw is called with amount 100, throw InsufficientFundsException
        expect(mockBankAccount.withdraw(100)).andThrow(new InsufficientFundsException("Insufficient funds to withdraw 100"));
        
        // Switch the mock object to replay mode
        replay(mockBankAccount);

        // Create BankService with the mock BankAccount
        BankService bankService = new BankService(mockBankAccount);

        // Call the method under test
        String result = bankService.processWithdrawal(100);

        // Assert that the correct exception message is returned
        assertEquals("Insufficient funds to withdraw 100", result);

        // Verify the behavior of the mock object
        verify(mockBankAccount);
    }
}

ব্যাখ্যা:

1. Mock Object Creation: createMock(BankAccount.class) ব্যবহার করে BankAccount ক্লাসের একটি মক অবজেক্ট তৈরি করা হয়।
2. Expectation Setup: expect(mockBankAccount.withdraw(100)) এর মাধ্যমে আমরা সেট করেছি যে, যখন withdraw(100) কল হবে, তখন InsufficientFundsException থ্রো হবে।
3. Replay Mode: replay(mockBankAccount) ব্যবহার করে মক অবজেক্টে নির্ধারিত আচরণ চালু করা হয়েছে।
4. Test Execution: bankService.processWithdrawal(100) কল করা হয়েছে এবং assertEquals() এর মাধ্যমে পরীক্ষা করা হয়েছে যে, InsufficientFundsException মেসেজ সঠিকভাবে রিটার্ন হচ্ছে কিনা।

Test Case:

• Input: 100 টাকা উত্তোলনের চেষ্টা।
• Expected Output: "Insufficient funds to withdraw 100"
• Explanation: কারণ মক অবজেক্টে withdraw(100) কল করার জন্য InsufficientFundsException থ্রো করা হয়েছে, তাই ফলস্বরূপ এই মেসেজটি রিটার্ন হয়।

EasyMock এ Exception Handling এর সুবিধা:

• Unit Testing: EasyMock ব্যবহার করে আপনি যে মেথডটি পরীক্ষা করছেন তার জন্য নির্দিষ্ট exception সিমুলেট করতে পারেন।
• Error Scenarios Testing: বাস্তব জীবনে যখন exception ঘটবে, তখন সেটি সঠিকভাবে পরিচালিত হচ্ছে কিনা তা পরীক্ষা করা সহজ হয়।
• Cleaner Tests: Mocking এর মাধ্যমে আপনি বাহ্যিক নির্ভরশীলতা বা অবজেক্টের আচরণ পরিবর্তন না করে, একাধিক exception scenario পরীক্ষা করতে পারেন।

EasyMock এর সীমাবদ্ধতা:

• Overhead in Complex Scenarios: জটিল exception handling সিস্টেমে মকিংয়ের জন্য অতিরিক্ত কনফিগারেশন প্রয়োজন হতে পারে।
• Harder to Set Up: কিছু ক্ষেত্রে, একাধিক exception scenario সিমুলেট করার জন্য EasyMock কিছুটা জটিল হতে পারে, বিশেষত যখন একাধিক mock objects ব্যবহৃত হয়।

সারাংশ

EasyMock ব্যবহার করে আপনি একটি মক অবজেক্টে exception থ্রো করতে পারেন, যা আপনাকে unit testing এর সময় নির্দিষ্ট exception scenarios সিমুলেট করতে সাহায্য করে। এটি error handling এবং exception management পরীক্ষার জন্য খুবই উপকারী। EasyMock এর মাধ্যমে আপনি নির্দিষ্ট মেথড কলের জন্য exception থ্রো করতে পারেন এবং সেই অনুযায়ী আপনার কোডের আচরণ যাচাই করতে পারেন।

EasyMock হল একটি জনপ্রিয় টুল যা unit testing এ mock objects তৈরি করতে ব্যবহৃত হয়। যখন আপনি কোনো মক অবজেক্টের মেথডের জন্য একাধিক আচরণ (multiple behavior) সেট করতে চান, তখন EasyMock আপনাকে stubbing করতে সাহায্য করে, যাতে একটি মেথড বিভিন্ন ইনপুটের জন্য বিভিন্ন আউটপুট প্রদান করতে পারে।

এখানে দেখানো হবে কিভাবে EasyMock এর মাধ্যমে একাধিক আচরণ বা multiple behavior সেট করা যায়, যাতে এক মক অবজেক্টের মেথড বিভিন্ন পদ্ধতিতে কাজ করে।

1. Multiple Behavior সেট করার কৌশল

EasyMock-এ multiple behavior সেট করার জন্য, সাধারণত expect() মেথডের মাধ্যমে আপনি একটি মক অবজেক্টের জন্য একাধিক রিটার্ন ভ্যালু নির্ধারণ করতে পারেন। এটি andReturn() এবং andThrow() এর মতো চেইনিং মেথড ব্যবহার করে করা হয়।

1.1 Multiple Return Values

এটি তখন ব্যবহৃত হয় যখন একটি মক অবজেক্টের মেথড একাধিক বার কল হয় এবং প্রত্যেকবার একটি ভিন্ন আউটপুট (return value) দিতে হয়।

import static org.easymock.EasyMock.*;

public class MultipleBehaviorExample {
    public static void main(String[] args) {
        // Create a mock object
        List<String> mockList = createMock(List.class);

        // Stubbing multiple behaviors for the mock object
        expect(mockList.get(0)).andReturn("First Element");
        expect(mockList.get(1)).andReturn("Second Element");
        expect(mockList.get(2)).andReturn("Third Element");

        // Activate the mock object
        replay(mockList);

        // Test the mocked method calls
        System.out.println("First element: " + mockList.get(0)); // Should print "First Element"
        System.out.println("Second element: " + mockList.get(1)); // Should print "Second Element"
        System.out.println("Third element: " + mockList.get(2)); // Should print "Third Element"

        // Verify the interaction with the mock object
        verify(mockList);
    }
}

ব্যাখ্যা:

1. expect(mockList.get(0)): এখানে প্রথম কলের জন্য "First Element" রিটার্ন হবে।
2. andReturn(): একাধিক কলের জন্য আলাদা আলাদা রিটার্ন ভ্যালু নির্ধারণ করা হচ্ছে।
3. replay(mockList): মক অবজেক্টে স্টাবিং চালু করা হচ্ছে, যাতে এটি টেস্টের সময় ব্যবহার করা যেতে পারে।
4. verify(mockList): মক অবজেক্টের মেথড কল যাচাই করা হচ্ছে।

আউটপুট:

First element: First Element
Second element: Second Element
Third element: Third Element

2. Multiple Exceptions Throwing

EasyMock-এ আপনি একাধিক exception ফেলে দেওয়ার জন্য andThrow() ব্যবহার করতে পারেন। এটি বিশেষ করে তখন প্রয়োজন যখন আপনি কিছু নির্দিষ্ট পরিস্থিতিতে exception চান।

উদাহরণ: Multiple Exceptions Using andThrow()

import static org.easymock.EasyMock.*;

public class MultipleExceptionsExample {
    public static void main(String[] args) {
        // Create a mock object
        List<String> mockList = createMock(List.class);

        // Stubbing multiple exceptions for the mock object
        expect(mockList.get(0)).andThrow(new IndexOutOfBoundsException("Index 0 is out of bounds"));
        expect(mockList.get(1)).andThrow(new IllegalArgumentException("Illegal Argument for Index 1"));

        // Activate the mock object
        replay(mockList);

        // Test the mocked method calls with exceptions
        try {
            mockList.get(0);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }

        try {
            mockList.get(1);
        } catch (IllegalArgumentException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }

        // Verify the interaction with the mock object
        verify(mockList);
    }
}

ব্যাখ্যা:

1. expect(mockList.get(0)): এখানে প্রথম কলের জন্য IndexOutOfBoundsException ফেলা হবে।
2. andThrow(): দ্বিতীয় কলের জন্য IllegalArgumentException ফেলা হবে।
3. replay(mockList): মক অবজেক্টের স্টাবিং চালু করা হচ্ছে।
4. verify(mockList): মক অবজেক্টের মেথড কল যাচাই করা হচ্ছে।

আউটপুট:

Caught exception: Index 0 is out of bounds
Caught exception: Illegal Argument for Index 1

3. Multiple Behaviors with Arguments

EasyMock আপনাকে নির্দিষ্ট আর্গুমেন্টের জন্য different behavior সেট করার সুযোগও দেয়। এই ক্ষেত্রে, আপনি andReturn() বা andThrow() এর সাথে শর্ত নির্ধারণ করতে পারেন।

উদাহরণ: Different Behavior with Arguments

import static org.easymock.EasyMock.*;

public class MultipleBehaviorWithArgumentsExample {
    public static void main(String[] args) {
        // Create a mock object
        List<String> mockList = createMock(List.class);

        // Stubbing based on different arguments
        expect(mockList.get(0)).andReturn("Zero Element");
        expect(mockList.get(1)).andReturn("First Element");
        expect(mockList.get(2)).andReturn("Second Element");

        // Activate the mock object
        replay(mockList);

        // Test the mocked method calls with different arguments
        System.out.println("Element at 0: " + mockList.get(0));  // "Zero Element"
        System.out.println("Element at 1: " + mockList.get(1));  // "First Element"
        System.out.println("Element at 2: " + mockList.get(2));  // "Second Element"

        // Verify the interaction with the mock object
        verify(mockList);
    }
}

ব্যাখ্যা:

এখানে mockList.get() মেথডের জন্য বিভিন্ন আর্গুমেন্টের ভিত্তিতে আলাদা আলাদা রিটার্ন ভ্যালু নির্ধারণ করা হয়েছে। যেমন:

• get(0) মেথড কল করলে "Zero Element" রিটার্ন করবে।
• get(1) মেথড কল করলে "First Element" রিটার্ন করবে।
• get(2) মেথড কল করলে "Second Element" রিটার্ন করবে।

আউটপুট:

Element at 0: Zero Element
Element at 1: First Element
Element at 2: Second Element

4. Chained Stubbing (Multiple Method Calls)

আপনি যদি একটি মক অবজেক্টে একাধিক মেথড কলের জন্য আচরণ স্টাব করতে চান, তবে আপনি chained stubbing ব্যবহার করতে পারেন, যেখানে এক মেথডের রিটার্ন ভ্যালু পরবর্তী মেথডের ইনপুট হিসেবে কাজ করবে।

উদাহরণ: Chained Stubbing

import static org.easymock.EasyMock.*;

public class ChainedStubbingExample {
    public static void main(String[] args) {
        // Create a mock object
        List<String> mockList = createMock(List.class);

        // Stubbing multiple methods in a chain
        expect(mockList.get(0)).andReturn("First")
                              .andReturn("Second")
                              .andReturn("Third");

        // Activate the mock object
        replay(mockList);

        // Test the mocked method calls
        System.out.println("First call: " + mockList.get(0));  // "First"
        System.out.println("Second call: " + mockList.get(0)); // "Second"
        System.out.println("Third call: " + mockList.get(0));  // "Third"

        // Verify the interaction with the mock object
        verify(mockList);
    }
}

ব্যাখ্যা:

এখানে mockList.get(0) মেথডটি তিনবার কল করা হয়েছে, এবং প্রতিবার ভিন্ন ভিন্ন রিটার্ন ভ্যালু স্টাব করা হয়েছে:

• প্রথম কলের জন্য "First"
• দ্বিতীয় কলের জন্য "Second"
• তৃতীয় কলের জন্য "Third"

আউটপুট:

First call: First
Second call: Second
Third call: Third

EasyMock-এ multiple behavior সেট করার কৌশলটি আপনাকে একটি মক অবজেক্টের মেথডের জন্য একাধিক আচরণ নির্ধারণ করার ক্ষমতা প্রদান করে। এটি আপনার ইউনিট টেস্টে আরও গতিশীল এবং বাস্তবসম্মত আচরণ সিমুলেট করতে সহায়ক। আপনি multiple return values, multiple exceptions, chained stubbing এবং arguments-based behavior সহ সহজেই মক অবজেক্ট তৈরি এবং পরিচালনা করতে পারেন, যা টেস্টিং প্রক্রিয়াকে আরও কার্যকর এবং রক্ষণাবেক্ষণযোগ্য করে তোলে।