Mock Object এর জন্য Verification কনসেপ্ট

Verification হল EasyMock-এ একটি গুরুত্বপূর্ণ কনসেপ্ট যা নিশ্চিত করে যে, মক অবজেক্টের ওপর নির্দিষ্ট মেথডগুলি ঠিকভাবে এবং সঠিক আর্গুমেন্ট সহ কল হয়েছে কিনা। এটি টেস্টিংয়ের পরে চালানো হয় এবং নিশ্চিত করে যে সমস্ত প্রত্যাশিত আচরণ সঠিকভাবে বাস্তবায়িত হয়েছে।

Verification এর মাধ্যমে আপনি মক অবজেক্টের interactions পরীক্ষা করতে পারেন এবং নিশ্চিত হতে পারেন যে, মক অবজেক্টের নির্ধারিত আচরণগুলি টেস্টের সময় ঠিকভাবে ঘটেছে।

1. Verification কনসেপ্ট

Verification মূলত পরীক্ষায় ব্যবহৃত মক অবজেক্টের মেথড কলগুলির সঠিকতা পরীক্ষা করার জন্য ব্যবহৃত হয়। মক অবজেক্টের মেথডকে সঠিকভাবে কল করা হয়েছে কিনা তা যাচাই করতে verify() মেথড ব্যবহার করা হয়।

Verification এর উদ্দেশ্য:

• Ensure Expected Interactions: মক অবজেক্টের যে মেথডগুলির কল আশা করা হচ্ছিল, সেগুলি ঠিকভাবে কল হয়েছে কিনা তা নিশ্চিত করা।
• Detect Missing or Unexpected Interactions: যদি মক অবজেক্টের কোনো মেথড কল না হয়, কিংবা অপ্রত্যাশিতভাবে অন্য মেথড কল হয়, তাহলে তা শনাক্ত করা।
• Test Integrity: টেস্টের মধ্যে ব্যবহৃত মক অবজেক্টের আচরণ নিশ্চিত করা।

2. EasyMock এ Verification প্রক্রিয়া

EasyMock এ Verification করার জন্য মূলত verify() মেথড ব্যবহার করা হয়। এটি নিশ্চিত করে যে, মক অবজেক্টের প্রতি সমস্ত প্রত্যাশিত মেথড কল সঠিকভাবে হয়েছে এবং কোনো অপ্রত্যাশিত কল হয়নি।

Verification এর প্রধান ধাপ:

1. Setup Expectations: মক অবজেক্টের জন্য প্রত্যাশিত আচরণ নির্ধারণ করা হয় (expect() ব্যবহার করে)।
2. Invoke Methods: টেস্ট কোডের মাধ্যমে মক অবজেক্টের মেথড কল করা হয়।
3. Verification: verify() মেথড কল করা হয়, যা নিশ্চিত করে যে, প্রত্যাশিত মেথডগুলি সঠিকভাবে কল হয়েছে।

3. EasyMock Verification উদাহরণ

ধরা যাক, একটি PaymentService ইন্টারফেস এবং একটি TransactionProcessor ক্লাস রয়েছে, যেখানে TransactionProcessor PaymentService এর উপর নির্ভরশীল। আমরা পরীক্ষা করতে চাই যে processPayment() মেথডটি সঠিকভাবে কল হয়েছে কিনা।

Example: PaymentService এবং Verification

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

import static org.easymock.EasyMock.*;

public class EasyMockVerificationExample {

    // Sample interface to be mocked
    public interface PaymentService {
        void processPayment(String accountId, double amount);
    }

    // Class that depends on PaymentService
    public class TransactionProcessor {
        private PaymentService paymentService;

        public TransactionProcessor(PaymentService paymentService) {
            this.paymentService = paymentService;
        }

        public void processTransaction(String accountId, double amount) {
            paymentService.processPayment(accountId, amount);
        }
    }

    @Test
    public void testTransactionProcessing() {
        // Create a mock object for PaymentService
        PaymentService mockPaymentService = EasyMock.createMock(PaymentService.class);

        // Setup the expectation for mock object
        mockPaymentService.processPayment("12345", 1500.0);
        expectLastCall().once(); // Expect that processPayment is called once with these arguments

        // Activate the mock
        replay(mockPaymentService);

        // Create the object that depends on PaymentService
        TransactionProcessor transactionProcessor = new TransactionProcessor(mockPaymentService);

        // Call the method that will invoke the mocked method
        transactionProcessor.processTransaction("12345", 1500.0);

        // Verify the interactions with the mock
        verify(mockPaymentService);
    }
}

ব্যাখ্যা:

1. Setup Expectations: expect(mockPaymentService.processPayment("12345", 1500.0)) এর মাধ্যমে আমরা প্রত্যাশা করছি যে, processPayment মেথডটি এই আর্গুমেন্ট সহ একবার কল হবে।
2. Invoke Methods: transactionProcessor.processTransaction() কল করার মাধ্যমে মক অবজেক্টের মেথডটি কল করা হয়েছে।
3. Verification: verify(mockPaymentService) এর মাধ্যমে আমরা নিশ্চিত হয়েছি যে, processPayment() মেথডটি একবার সঠিক আর্গুমেন্ট সহ কল হয়েছে।

4. Verification এর অন্যান্য বৈশিষ্ট্য

EasyMock এর verify() মেথডের কিছু গুরুত্বপূর্ণ বৈশিষ্ট্য আছে:

1. Verification on Multiple Calls:

যদি কোনো মেথড একাধিকবার কল করা হয়, তবে আপনি এটি যাচাই করতে পারেন।

Example:

mockPaymentService.processPayment("12345", 1500.0);
mockPaymentService.processPayment("67890", 2000.0);
expectLastCall().times(2);  // Expecting two calls with these arguments

replay(mockPaymentService);
transactionProcessor.processTransaction("12345", 1500.0);
transactionProcessor.processTransaction("67890", 2000.0);
verify(mockPaymentService);  // Will pass as both calls are made

2. Verifying the Call Order:

EasyMock এর মাধ্যমে আপনি কলের অর্ডারও যাচাই করতে পারেন, অর্থাৎ নির্দিষ্ট অর্ডারে মেথড কল করা হয়েছে কিনা।

Example:

// Define expectations for call order
mockPaymentService.processPayment("12345", 1500.0);
expectLastCall().before(mockPaymentService.processPayment("67890", 2000.0));

replay(mockPaymentService);
transactionProcessor.processTransaction("12345", 1500.0);
transactionProcessor.processTransaction("67890", 2000.0);
verify(mockPaymentService);  // Verifies the order of calls

3. Verifying the Number of Calls:

আপনি যাচাই করতে পারেন যে একটি মেথড কতবার কল হয়েছে।

Example:

mockPaymentService.processPayment("12345", 1500.0);
expectLastCall().times(1);  // Expect that processPayment is called once

replay(mockPaymentService);
transactionProcessor.processTransaction("12345", 1500.0);

verify(mockPaymentService);  // Will pass as the method is called once

5. Advantages of Verification in EasyMock

• Test Accuracy: Verification ensures that your mock objects are behaving as expected, and that methods are being called with the correct arguments and in the correct order.
• Detects Missing or Extra Calls: It helps identify if any expected method calls were missed or if unexpected method calls were made.
• Ensures Code Integrity: By verifying interactions, you ensure that your unit test is validating the right behavior and interactions between components.

Verification in EasyMock is a critical step in unit testing with mock objects. It ensures that the expected interactions with mock objects have occurred as planned. By using the verify() method, you can validate that your mock objects have been used correctly, whether it's checking the number of calls, the arguments passed, or the order of method calls. This helps ensure the correctness of your tests and improves the quality of your software.