Commons CLI এর জন্য Unit Testing

Apache Commons CLI ব্যবহার করে কমান্ড-লাইন আর্গুমেন্ট প্যার্সিং করার পর, আপনাকে নিশ্চিত করতে হবে যে আপনার অ্যাপ্লিকেশনটি সঠিকভাবে কাজ করছে। এটি করার জন্য, ইউনিট টেস্টিং (Unit Testing) একটি অপরিহার্য অংশ। ইউনিট টেস্টিং কমান্ড-লাইন আর্গুমেন্টগুলির বিভিন্ন সম্ভাব্য ইনপুটের জন্য কার্যকারিতা যাচাই করতে সাহায্য করে। এটি কমান্ড-লাইন আর্গুমেন্ট প্যার্সিং এর সঠিকতা নিশ্চিত করতে এবং ভবিষ্যতে কোডের পরিবর্তনগুলি ত্রুটি সৃষ্টি করছে কিনা তা ট্র্যাক করতে সহায়তা করে।

এখানে আমরা দেখব কিভাবে Apache Commons CLI এর জন্য ইউনিট টেস্ট তৈরি করা যায় এবং JUnit লাইব্রেরি ব্যবহার করে কমান্ড-লাইন অপশনগুলির জন্য টেস্ট করা যায়।

1. JUnit ব্যবহার করে Apache Commons CLI এর Unit Testing

JUnit হলো Java এর জন্য একটি জনপ্রিয় টেস্টিং ফ্রেমওয়ার্ক। এটি একটি শক্তিশালী টুল যা ইউনিট টেস্ট লেখার এবং রান করার জন্য ব্যবহৃত হয়। JUnit 5 বা JUnit 4 ব্যবহার করে আপনি কমান্ড-লাইন অপশন এবং আর্গুমেন্টগুলির জন্য ইউনিট টেস্ট তৈরি করতে পারেন।

উদাহরণ: Command Line Argument Parsing এর Unit Test

ধরা যাক, আমাদের একটি কমান্ড-লাইন অ্যাপ্লিকেশন রয়েছে যা username, password, এবং verbose অপশন গ্রহণ করে। আমরা এখন এটি জন্য একটি ইউনিট টেস্ট তৈরি করব।

Command Line Parsing ক্লাস:

import org.apache.commons.cli.*;

public class CommandLineParserExample {

    public static void main(String[] args) {

        // Command Line Options তৈরি করা
        Options options = new Options();

        // "username" অপশন যোগ করা
        Option usernameOption = new Option("u", "username", true, "Username for login");
        options.addOption(usernameOption);

        // "password" অপশন যোগ করা
        Option passwordOption = new Option("p", "password", true, "Password for login");
        options.addOption(passwordOption);

        // "verbose" অপশন (একটি ফ্ল্যাগ অপশন)
        Option verboseOption = new Option("v", "verbose", false, "Enable verbose output");
        options.addOption(verboseOption);

        // CommandLineParser তৈরি করা
        CommandLineParser parser = new DefaultParser();
        HelpFormatter formatter = new HelpFormatter();

        try {
            // আর্গুমেন্ট পার্স করা
            CommandLine cmd = parser.parse(options, args);

            // আর্গুমেন্টগুলির মান প্রিন্ট করা
            String username = cmd.getOptionValue("username");
            String password = cmd.getOptionValue("password");
            boolean verbose = cmd.hasOption("verbose");

            System.out.println("Username: " + username);
            System.out.println("Password: " + password);
            System.out.println("Verbose: " + verbose);

        } catch (ParseException e) {
            System.out.println("Parsing failed. Reason: " + e.getMessage());
            formatter.printHelp("CommandLineParserExample", options);
        }
    }
}

2. Unit Test তৈরি করা

এখন আমরা JUnit ব্যবহার করে এই কমান্ড-লাইন প্যার্সিং এর জন্য একটি ইউনিট টেস্ট তৈরি করব।

JUnit টেস্ট কোড:

import org.apache.commons.cli.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CommandLineParserTest {

    @Test
    public void testValidArguments() {
        // Command Line Options তৈরি করা
        Options options = new Options();
        options.addOption("u", "username", true, "Username for login");
        options.addOption("p", "password", true, "Password for login");
        options.addOption("v", "verbose", false, "Enable verbose output");

        String[] args = {"-u", "john_doe", "-p", "password123", "-v"};

        // CommandLineParser তৈরি করা
        CommandLineParser parser = new DefaultParser();
        try {
            CommandLine cmd = parser.parse(options, args);

            // Test valid username
            assertEquals("john_doe", cmd.getOptionValue("username"));
            // Test valid password
            assertEquals("password123", cmd.getOptionValue("password"));
            // Test verbose flag
            assertTrue(cmd.hasOption("verbose"));

        } catch (ParseException e) {
            fail("Command line arguments parsing failed: " + e.getMessage());
        }
    }

    @Test
    public void testMissingArgument() {
        // Command Line Options তৈরি করা
        Options options = new Options();
        options.addOption("u", "username", true, "Username for login");
        options.addOption("p", "password", true, "Password for login");

        String[] args = {"-u", "john_doe"};

        // CommandLineParser তৈরি করা
        CommandLineParser parser = new DefaultParser();
        try {
            CommandLine cmd = parser.parse(options, args);
            // Test that password argument is missing
            assertNull(cmd.getOptionValue("password"));
        } catch (ParseException e) {
            assertTrue(e.getMessage().contains("Missing required option: p"));
        }
    }

    @Test
    public void testInvalidOption() {
        // Command Line Options তৈরি করা
        Options options = new Options();
        options.addOption("u", "username", true, "Username for login");

        String[] args = {"-x", "invalid_option"};

        // CommandLineParser তৈরি করা
        CommandLineParser parser = new DefaultParser();
        try {
            parser.parse(options, args);
            fail("Expected ParseException for invalid option");
        } catch (ParseException e) {
            assertTrue(e.getMessage().contains("unrecognized option: -x"));
        }
    }
}

ব্যাখ্যা:

1. testValidArguments(): এই টেস্টে আমরা সঠিক আর্গুমেন্ট ব্যবহার করছি এবং নিশ্চিত হচ্ছি যে প্রতিটি অপশন সঠিকভাবে পার্স হয়েছে।
2. testMissingArgument(): এই টেস্টে, আমরা একটি অপর্যাপ্ত আর্গুমেন্ট (যেমন password) পাঠাচ্ছি এবং ত্রুটি নিশ্চিত করছি।
3. testInvalidOption(): এই টেস্টে, আমরা একটি ভুল অপশন (-x) প্রদান করছি এবং নিশ্চিত করছি যে এটি সঠিকভাবে ত্রুটি প্রদান করছে।

টেস্ট রান:

mvn test

যদি সবকিছু সঠিকভাবে কাজ করে, তবে টেস্টগুলি সফল হবে।

3. মনে রাখার বিষয়

• Error Handling: যখন আপনি ParseException পেয়েছেন, তখন এটি পুরো কমান্ড লাইন প্যার্সিং প্রক্রিয়া থামিয়ে দেয়। আপনি যদি আরও বিস্তারিত ত্রুটি বার্তা চান, তবে HelpFormatter ব্যবহার করে আরও পরিষ্কারভাবে ত্রুটি বার্তা দিতে পারেন।
• JUnit টেস্ট: আপনার কমান্ড-লাইন অপশনগুলির কার্যকারিতা পরীক্ষা করার জন্য JUnit টেস্ট করা একটি গুরুত্বপূর্ণ স্টেপ। এটি ভবিষ্যতে পরিবর্তন করা হলে সঠিকভাবে কাজ করছে কিনা নিশ্চিত করতে সাহায্য করবে।
• বিভিন্ন আর্গুমেন্ট এবং অপশন পরীক্ষা: পাসওয়ার্ড বা অন্যান্য অপশনগুলির জন্য আপনি আলাদা টেস্ট লিখে যাচাই করতে পারেন যেন আর্গুমেন্ট পার্সিং সঠিকভাবে হচ্ছে।

Apache Commons CLI ব্যবহার করে কমান্ড-লাইন আর্গুমেন্টের জন্য ইউনিট টেস্ট তৈরি করা সহজ এবং কার্যকরী। আপনি JUnit ব্যবহার করে কমান্ড-লাইন অপশন, আর্গুমেন্ট এবং ত্রুটি সঠিকভাবে টেস্ট করতে পারেন। এটি নিশ্চিত করে যে আপনার অ্যাপ্লিকেশন সঠিকভাবে ইনপুট গ্রহণ করছে এবং সঠিকভাবে আর্গুমেন্ট প্রক্রিয়া করছে। CLI অ্যাপ্লিকেশনগুলির জন্য ইউনিট টেস্ট গুরুত্বপূর্ণ, কারণ এটি আপনাকে ভবিষ্যতে কোড পরিবর্তনের প্রভাব ট্র্যাক করতে এবং সম্ভাব্য ত্রুটি দ্রুত সনাক্ত করতে সহায়তা করে।

Unit Testing এর ভূমিকা

Unit testing হল একটি প্রক্রিয়া যেখানে আপনি আপনার কোডের ছোট ছোট ইউনিট বা ফাংশনগুলি পরীক্ষা করেন, যাতে নিশ্চিত করা যায় যে প্রতিটি অংশ সঠিকভাবে কাজ করছে। Command Line Parsing-এর ক্ষেত্রে, ইউনিট টেস্ট তৈরি করা গুরুত্বপূর্ণ, কারণ এটি নিশ্চিত করে যে আপনার কমান্ড লাইন অপশনগুলি সঠিকভাবে পার্স করা হচ্ছে এবং সঠিক আউটপুট প্রদান করছে। বিশেষ করে Apache Commons CLI ব্যবহার করলে, আপনার CLI অপশন এবং আর্গুমেন্টগুলির বৈধতা পরীক্ষা করা প্রয়োজন।

Apache Commons CLI এর মাধ্যমে কমান্ড লাইন অপশন পার্স করার জন্য আপনি JUnit বা অন্যান্য টেস্ট ফ্রেমওয়ার্ক ব্যবহার করে ইউনিট টেস্ট তৈরি করতে পারেন। এখানে, আমরা দেখব কিভাবে JUnit ব্যবহার করে Apache Commons CLI এর কমান্ড লাইন পার্সিংয়ের জন্য ইউনিট টেস্ট তৈরি করা যায়।

1. Apache Commons CLI Parsing কোড

প্রথমে, একটি সিম্পল কমান্ড লাইন পার্সিং কোড তৈরি করি, যেটি পরে ইউনিট টেস্ট করা হবে।

import org.apache.commons.cli.*;

public class CommandLineApp {

    public static void main(String[] args) {
        // অপশন তৈরি করা
        Options options = new Options();
        options.addOption("f", "file", true, "File to process");
        options.addOption("v", "verbose", false, "Enable verbose output");

        CommandLineParser parser = new DefaultParser();
        HelpFormatter formatter = new HelpFormatter();

        try {
            // কমান্ড লাইন আর্গুমেন্ট পার্স করা
            CommandLine cmd = parser.parse(options, args);

            // --file অপশন চেক করা
            if (cmd.hasOption("f")) {
                String filePath = cmd.getOptionValue("f");
                System.out.println("File to process: " + filePath);
            }

            // --verbose অপশন চেক করা
            if (cmd.hasOption("v")) {
                System.out.println("Verbose output enabled");
            }

        } catch (ParseException e) {
            System.out.println("Parsing failed. Reason: " + e.getMessage());
            formatter.printHelp("CommandLineApp", options);
        }
    }
}

এটি একটি সিম্পল কমান্ড লাইন অ্যাপ্লিকেশন যেখানে -f এবং -v অপশন আছে। -f অপশনটি একটি ফাইল পাথ নেয় এবং -v অপশনটি ভের্বোস আউটপুট সক্ষম করে।

2. JUnit দিয়ে Unit Test তৈরি করা

এখন আমরা JUnit ব্যবহার করে উপরের কমান্ড লাইন পার্সিং কোডের জন্য টেস্ট তৈরি করব। এখানে, আমরা দুটি টেস্ট তৈরি করব:

1. -f অপশনটি সঠিকভাবে পার্স হচ্ছে কিনা পরীক্ষা করা।
2. -v অপশনটি সঠিকভাবে পার্স হচ্ছে কিনা পরীক্ষা করা।

JUnit 5 এ টেস্ট তৈরি করা

এটি করার জন্য প্রথমে আপনার pom.xml (Maven) বা build.gradle (Gradle) ফাইলে JUnit ডিপেনডেন্সি যোগ করতে হবে।

Maven ডিপেনডেন্সি:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.7.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.7.0</version>
    <scope>test</scope>
</dependency>

Gradle ডিপেনডেন্সি:

testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.7.0'

এখন, আমরা JUnit ব্যবহার করে Unit Test তৈরি করব:

import org.apache.commons.cli.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CommandLineAppTest {

    @Test
    public void testFileOption() {
        // অপশন তৈরি
        Options options = new Options();
        options.addOption("f", "file", true, "File to process");
        options.addOption("v", "verbose", false, "Enable verbose output");

        // কাস্টম আর্গুমেন্ট
        String[] args = {"-f", "input.txt"};

        CommandLineParser parser = new DefaultParser();

        try {
            // কমান্ড লাইন আর্গুমেন্ট পার্স করা
            CommandLine cmd = parser.parse(options, args);

            // --file অপশন চেক করা
            assertTrue(cmd.hasOption("f"));
            assertEquals("input.txt", cmd.getOptionValue("f"));
        } catch (ParseException e) {
            fail("Parsing failed. Reason: " + e.getMessage());
        }
    }

    @Test
    public void testVerboseOption() {
        // অপশন তৈরি
        Options options = new Options();
        options.addOption("f", "file", true, "File to process");
        options.addOption("v", "verbose", false, "Enable verbose output");

        // কাস্টম আর্গুমেন্ট
        String[] args = {"-v"};

        CommandLineParser parser = new DefaultParser();

        try {
            // কমান্ড লাইন আর্গুমেন্ট পার্স করা
            CommandLine cmd = parser.parse(options, args);

            // --verbose অপশন চেক করা
            assertTrue(cmd.hasOption("v"));
        } catch (ParseException e) {
            fail("Parsing failed. Reason: " + e.getMessage());
        }
    }

    @Test
    public void testMissingFileArgument() {
        // অপশন তৈরি
        Options options = new Options();
        options.addOption("f", "file", true, "File to process");

        // কাস্টম আর্গুমেন্ট
        String[] args = {"-f"};

        CommandLineParser parser = new DefaultParser();

        try {
            // কমান্ড লাইন আর্গুমেন্ট পার্স করা
            CommandLine cmd = parser.parse(options, args);
            fail("Expected ParseException not thrown.");
        } catch (ParseException e) {
            assertEquals("Missing argument for option: f", e.getMessage());
        }
    }

    @Test
    public void testUnknownOption() {
        // অপশন তৈরি
        Options options = new Options();
        options.addOption("f", "file", true, "File to process");

        // কাস্টম আর্গুমেন্ট
        String[] args = {"-x"};

        CommandLineParser parser = new DefaultParser();

        try {
            // কমান্ড লাইন আর্গুমেন্ট পার্স করা
            parser.parse(options, args);
            fail("Expected ParseException not thrown.");
        } catch (ParseException e) {
            assertEquals("Unrecognized option: -x", e.getMessage());
        }
    }
}

3. Unit Test এর ব্যাখ্যা

1. testFileOption(): এই টেস্টটি পরীক্ষা করে যে, -f অপশনটি সঠিকভাবে পার্স হচ্ছে কিনা এবং তার মান হিসেবে "input.txt" সেট করা হচ্ছে কিনা।
2. testVerboseOption(): এখানে, -v অপশনটি সঠিকভাবে পার্স হচ্ছে কিনা এবং এটি সক্রিয় হচ্ছে কিনা তা পরীক্ষা করা হয়।
3. testMissingFileArgument(): এই টেস্টে, যদি -f অপশন দেওয়া হয় কিন্তু তার মান না দেওয়া হয়, তাহলে ParseException হওয়া উচিত।
4. testUnknownOption(): এখানে, -x অপশনটি একটি অজানা অপশন হিসেবে পরীক্ষা করা হয়, এবং এর ফলে ParseException হওয়া উচিত।

4. JUnit টেস্ট রান করা

আপনি যদি Maven ব্যবহার করেন, তাহলে নিচের কমান্ড দিয়ে টেস্ট চালাতে পারেন:

mvn test

অথবা যদি Gradle ব্যবহার করেন, তাহলে:

gradle test

এটি সমস্ত টেস্ট চালাবে এবং প্রতিটি টেস্টের ফলাফল দেখাবে।

সারাংশ

Apache Commons CLI লাইব্রেরি ব্যবহার করে কমান্ড লাইন অপশন পার্সিংয়ের জন্য ইউনিট টেস্ট তৈরি করা গুরুত্বপূর্ণ। এটি নিশ্চিত করে যে আপনার কমান্ড লাইন আর্গুমেন্ট সঠিকভাবে পার্স হচ্ছে এবং প্রত্যাশিত ফলাফল প্রদান করছে। JUnit ব্যবহার করে আপনি সহজেই CLI অপশন পার্সিংয়ের জন্য টেস্ট তৈরি করতে পারেন, যেমন আর্গুমেন্টের উপস্থিতি পরীক্ষা করা, ত্রুটির শর্ত চেক করা, এবং অজানা অপশনগুলির জন্য সঠিক ত্রুটি বার্তা নিশ্চিত করা।

Apache Commons CLI লাইব্রেরি কমান্ড লাইন আর্গুমেন্ট পার্সিং সহজ করে তোলে। তবে, অ্যাপ্লিকেশন ডেভেলপমেন্টের সময় Mocking এবং Stubbing এর মাধ্যমে কোডের টেস্টিং করা গুরুত্বপূর্ণ হয়ে ওঠে। Mocking এবং Stubbing হল টেস্টিং কৌশল যা অবজেক্টগুলির আচরণ সিমুলেট করতে ব্যবহৃত হয়, যাতে আপনি ইউনিট টেস্টের জন্য নির্দিষ্ট আর্গুমেন্ট এবং আউটপুট পরীক্ষা করতে পারেন।

এই গাইডে, আমরা Apache Commons CLI ব্যবহার করে কিভাবে Mocking এবং Stubbing টেকনিক প্রয়োগ করা যায় তা দেখব।

Mocking এবং Stubbing: সংজ্ঞা

• Mocking: এটি একটি টেস্টিং কৌশল যেখানে আপনি কোনো অবজেক্টের আচরণ প্রাক-নির্ধারণ করেন। সাধারণত এটি অবজেক্টের সাথে সুনির্দিষ্ট মিথস্ক্রিয়া পরীক্ষার জন্য ব্যবহৃত হয়।
• Stubbing: এটি একটি টেস্টিং কৌশল যেখানে একটি মেথডের আউটপুট প্রাক-নির্ধারণ করা হয়, সাধারণত কোন নির্দিষ্ট আর্গুমেন্ট দিয়ে মেথডটি চালানোর সময়।

Mocking এবং Stubbing সাধারণত Mockito বা EasyMock লাইব্রেরি ব্যবহার করে করা হয়। এই গাইডে আমরা Mockito ব্যবহার করে Apache Commons CLI এর জন্য Mocking এবং Stubbing কৌশল প্রয়োগ করার উদাহরণ দেখবো।

ধাপ 1: Maven এ Mockito যোগ করা

প্রথমে, আপনার pom.xml ফাইলে Mockito লাইব্রেরি যোগ করতে হবে:

<dependencies>
    <!-- Mockito Dependency -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>3.12.4</version>
        <scope>test</scope>
    </dependency>
</dependencies>

এটি Mockito লাইব্রেরি অন্তর্ভুক্ত করবে, যা Mocking এবং Stubbing এর জন্য ব্যবহৃত হবে।

ধাপ 2: Apache Commons CLI এর জন্য Mocking এবং Stubbing টেকনিক প্রয়োগ করা

Mocking Example: CommandLineParser Mock করা

এখানে আমরা CommandLineParser এর একটি মক তৈরি করব এবং এর মেথডের আচরণ মক করব।

import org.apache.commons.cli.*;
import org.mockito.Mockito;
import org.junit.jupiter.api.Test;

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

public class MockingExample {

    @Test
    public void testMockCommandLineParser() {
        // CommandLineParser এর মক তৈরি করা
        CommandLineParser parser = Mockito.mock(CommandLineParser.class);
        CommandLine cmd = Mockito.mock(CommandLine.class);

        try {
            // CommandLineParser এর parse() মেথডের মক আচরণ সেট করা
            when(parser.parse(any(), any())).thenReturn(cmd);
            when(cmd.getOptionValue("input")).thenReturn("mockInput.txt");

            // CommandLineParser ব্যবহার করা
            String[] args = {"-i", "input.txt"};
            CommandLine result = parser.parse(new Options(), args);

            // মক করা আউটপুট যাচাই করা
            assertEquals("mockInput.txt", result.getOptionValue("input"));

        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

ব্যাখ্যা:

• আমরা CommandLineParser এবং CommandLine এর মক তৈরি করেছি।
• Mockito এর when() এবং thenReturn() মেথড ব্যবহার করে আমরা মেথডের আউটপুটকে সিমুলেট করেছি।
• getOptionValue("input") মেথডের আউটপুট আমরা মক করেছি যাতে এটি "mockInput.txt" রিটার্ন করে।

Stubbing Example: Option থেকে মান বের করা

এখন, আমরা Option এর মক তৈরি করব এবং একটি নির্দিষ্ট আর্গুমেন্টের জন্য স্টাবিং প্রয়োগ করব।

import org.apache.commons.cli.*;
import org.mockito.Mockito;
import org.junit.jupiter.api.Test;

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

public class StubbingExample {

    @Test
    public void testStubbingOptionValue() {
        // Option এর মক তৈরি করা
        Option input = Mockito.mock(Option.class);
        when(input.getOpt()).thenReturn("i");
        when(input.getDescription()).thenReturn("Input file");

        // Option এর মান স্টাব করা
        when(input.getLongOpt()).thenReturn("input");
        
        // Option স্টাবিংয়ের মাধ্যমে মান যাচাই করা
        assertEquals("i", input.getOpt());
        assertEquals("Input file", input.getDescription());
        assertEquals("input", input.getLongOpt());
    }
}

ব্যাখ্যা:

• এখানে Option ক্লাসের একটি মক তৈরি করেছি এবং getOpt(), getDescription() এবং getLongOpt() মেথডগুলোকে স্টাব করেছি।
• Mockito এর when() মেথড ব্যবহার করে আমরা প্রত্যাশিত আউটপুট সেট করেছি এবং এটি পরীক্ষার জন্য ব্যবহার করেছি।

ধাপ 3: Complex Test Case with CommandLineParser and Mocking

এখন, আমরা একটি জটিল টেস্ট কেস তৈরি করবো যেখানে Apache Commons CLI এর CommandLineParser এবং Options সহ মকিং এবং স্টাবিং ব্যবহৃত হবে।

import org.apache.commons.cli.*;
import org.mockito.Mockito;
import org.junit.jupiter.api.Test;

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

public class ComplexMockingTest {

    @Test
    public void testCommandLineWithMockedParser() {
        // CommandLineParser এবং CommandLine এর মক তৈরি করা
        CommandLineParser parser = Mockito.mock(CommandLineParser.class);
        CommandLine cmd = Mockito.mock(CommandLine.class);
        
        // আর্গুমেন্ট গুলি
        String[] args = {"-i", "input.txt", "-o", "output.txt"};

        try {
            // CommandLineParser এর মক আচরণ সেট করা
            when(parser.parse(any(), eq(args))).thenReturn(cmd);
            when(cmd.hasOption("i")).thenReturn(true);
            when(cmd.getOptionValue("i")).thenReturn("input.txt");
            when(cmd.hasOption("o")).thenReturn(true);
            when(cmd.getOptionValue("o")).thenReturn("output.txt");

            // আর্গুমেন্ট পার্সিং
            cmd = parser.parse(new Options(), args);

            // আর্গুমেন্টের জন্য স্টাব করা মান যাচাই করা
            assertTrue(cmd.hasOption("i"));
            assertEquals("input.txt", cmd.getOptionValue("i"));

            assertTrue(cmd.hasOption("o"));
            assertEquals("output.txt", cmd.getOptionValue("o"));

        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

ব্যাখ্যা:

• আমরা CommandLineParser এবং CommandLine এর মক তৈরি করেছি।
• Mockito এর মাধ্যমে আর্গুমেন্ট পার্সিংয়ের জন্য স্টাবিং করেছি, যেমন hasOption("i") এবং getOptionValue("i") মেথডে মক করা আউটপুট সঠিকভাবে রিটার্ন করতে।
• তারপর আমরা assertTrue এবং assertEquals দিয়ে আর্গুমেন্টের মান যাচাই করেছি।

সারাংশ

Apache Commons CLI এর সাথে Mocking এবং Stubbing টেকনিক ব্যবহার করে আপনি কমান্ড লাইন আর্গুমেন্ট পার্সিংয়ের জন্য ইউনিট টেস্ট তৈরি করতে পারেন। Mockito লাইব্রেরি ব্যবহার করে আপনি সহজেই CommandLineParser, Option, এবং CommandLine এর মতো ক্লাসগুলো মক বা স্টাব করতে পারেন। এটি আপনার অ্যাপ্লিকেশন এবং লাইব্রেরির কোডের আচরণ সঠিকভাবে পরীক্ষা করার সুযোগ দেয়, যা সফটওয়্যার ডেভেলপমেন্টের ক্ষেত্রে গুরুত্বপূর্ণ।

Apache Commons CLI লাইব্রেরি কমান্ড লাইন আর্গুমেন্টের পার্সিং এবং ইনপুট ভ্যালিডেশন খুব সহজভাবে করতে সাহায্য করে। যেহেতু কমান্ড লাইন ইনপুটের মাধ্যমে ব্যবহারকারীরা বিভিন্ন ধরনের আর্গুমেন্ট সরবরাহ করতে পারেন, তাই ইনপুট ভ্যালিডেশন খুবই গুরুত্বপূর্ণ। ইনপুট ভ্যালিডেশন এর মাধ্যমে আপনি নিশ্চিত করতে পারেন যে, ব্যবহারকারী সঠিক আর্গুমেন্ট প্রদান করেছে এবং ভুল ইনপুটের জন্য উপযুক্ত ত্রুটি বার্তা প্রদর্শন করা হচ্ছে।

এখানে, আমরা Command Line Input Validation কীভাবে Apache Commons CLI লাইব্রেরির মাধ্যমে পরীক্ষা করা যায় এবং কীভাবে ত্রুটি বার্তা হ্যান্ডেল করা যায় তা দেখাবো।

1. Command Line Input Validation Setup

কমান্ড লাইন ইনপুট ভ্যালিডেশনের জন্য আপনি সাধারণত কিছু স্ট্যান্ডার্ড চেক করতে পারেন, যেমন:

• আর্গুমেন্টের উপস্থিতি যাচাই করা
• আর্গুমেন্টের টাইপ (যেমন সংখ্যা, স্ট্রিং, ইত্যাদি) যাচাই করা
• আর্গুমেন্টের সীমা যাচাই করা (যেমন বয়স ১৮ থেকে ৬৫ এর মধ্যে হওয়া উচিত)

এখানে, Apache Commons CLI ব্যবহার করে আমরা ইনপুট ভ্যালিডেশন এর জন্য বিভিন্ন চেকিংয়ের উদাহরণ দেখাবো।

2. Example: Command Line Input Validation

ধরা যাক, আমরা একটি প্রোগ্রাম তৈরি করছি যা ব্যবহারকারীর নাম এবং বয়স নেবে এবং কিছু সুনির্দিষ্ট শর্তে ভ্যালিডেশন করবে।

2.1. কোড উদাহরণ: Command Line Input Validation

import org.apache.commons.cli.*;

public class CommandLineInputValidation {

    public static void main(String[] args) {
        // Option অবজেক্ট তৈরি করা
        Options options = new Options();

        // --name অপশন (আর্গুমেন্টের সাথে)
        options.addOption("n", "name", true, "Your name");

        // --age অপশন (আর্গুমেন্টের সাথে)
        options.addOption("a", "age", true, "Your age");

        // CommandLineParser ব্যবহার করা
        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = null;

        try {
            // কমান্ড লাইন আর্গুমেন্ট পার্স করা
            cmd = parser.parse(options, args);

            // --name অপশন চেক করা
            if (!cmd.hasOption("n")) {
                System.out.println("Error: Name is required.");
                printHelp(options);
                System.exit(1);
            }

            // --age অপশন চেক করা
            if (!cmd.hasOption("a")) {
                System.out.println("Error: Age is required.");
                printHelp(options);
                System.exit(1);
            }

            String name = cmd.getOptionValue("n");
            String ageString = cmd.getOptionValue("a");

            // নাম ভ্যালিডেশন
            if (name.length() < 3) {
                System.out.println("Error: Name must be at least 3 characters long.");
                System.exit(1);
            }

            // বয়স ভ্যালিডেশন
            int age;
            try {
                age = Integer.parseInt(ageString);
                if (age < 18 || age > 65) {
                    System.out.println("Error: Age must be between 18 and 65.");
                    System.exit(1);
                }
            } catch (NumberFormatException e) {
                System.out.println("Error: Age must be a valid number.");
                System.exit(1);
            }

            // আউটপুট
            System.out.println("Name: " + name);
            System.out.println("Age: " + age);

        } catch (ParseException e) {
            System.out.println("Error: Invalid command line arguments.");
            System.out.println("Reason: " + e.getMessage());
            printHelp(options);
            System.exit(1);
        }
    }

    // HelpFormatter ব্যবহার করে সাহায্য বার্তা
    private static void printHelp(Options options) {
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("CommandLineInputValidation", options);
    }
}

ব্যাখ্যা:

1. Option Object:
   • --name এবং --age অপশন তৈরি করা হয়েছে এবং তাদের জন্য আর্গুমেন্ট প্রদান করতে বলা হয়েছে।
2. Input Validation:
   • Name Validation: যদি ব্যবহারকারীর নাম ৩টি অক্ষরের কম হয়, তবে একটি ত্রুটি বার্তা প্রদর্শন করা হয়।
   • Age Validation: বয়সটি একটি পূর্ণসংখ্যা হতে হবে এবং ১৮ থেকে ৬৫ এর মধ্যে হতে হবে। অন্যথায়, একটি ত্রুটি বার্তা দেখানো হয়।
3. ParseException Handling:
   • যদি পার্সিংয়ের সময় কোনো সমস্যা হয়, তবে ParseException ব্যবহার করা হয় এবং কাস্টম ত্রুটি বার্তা প্রদর্শন করা হয়।
4. HelpFormatter:
   • যদি কোনো আর্গুমেন্ট সঠিকভাবে না থাকে, তাহলে ব্যবহারকারীকে সাহায্য বার্তা প্রদর্শন করা হয়।

3. Command Line Input Validation Testing

এখন, আপনি বিভিন্ন ইনপুট দিয়ে এই প্রোগ্রামটি পরীক্ষা করতে পারেন এবং কীভাবে এটি ইনপুট যাচাই করে তা দেখুন।

উদাহরণ 1: সঠিক ইনপুট

java CommandLineInputValidation -n John -a 30

আউটপুট:

Name: John
Age: 30

উদাহরণ 2: নামের দৈর্ঘ্য কম

java CommandLineInputValidation -n Jo -a 30

আউটপুট:

Error: Name must be at least 3 characters long.

উদাহরণ 3: বয়স ভুল

java CommandLineInputValidation -n John -a 70

আউটপুট:

Error: Age must be between 18 and 65.

উদাহরণ 4: বয়স পূর্ণসংখ্যা নয়

java CommandLineInputValidation -n John -a abc

আউটপুট:

Error: Age must be a valid number.

উদাহরণ 5: আর্গুমেন্ট না দেওয়া

java CommandLineInputValidation

আউটপুট:

Error: Name is required.
Usage: CommandLineInputValidation
 -a <age>     Your age
 -h, --help   Show help
 -n <name>    Your name

4. Logging Command Line Input Validation

কমান্ড লাইন ইনপুটের ভ্যালিডেশন টেস্ট করার সময়, আপনি লগিং ব্যবহার করে ইনপুটের বিশদ তথ্য সংরক্ষণ করতে পারেন। এর জন্য Java Util Logging বা Log4j লাইব্রেরি ব্যবহার করা যেতে পারে। নিচে java.util.logging ব্যবহার করে লগিং করার একটি উদাহরণ দেওয়া হলো।

import java.util.logging.*;

public class CommandLineInputValidationWithLogging {

    private static final Logger logger = Logger.getLogger(CommandLineInputValidationWithLogging.class.getName());

    public static void main(String[] args) {
        // Logger setup
        ConsoleHandler consoleHandler = new ConsoleHandler();
        logger.addHandler(consoleHandler);
        logger.setLevel(Level.ALL);

        // Validation logic (similar to previous example)
        // Log input and validation steps...
        logger.info("Processing command line input.");
    }
}

এটি লগ ফাইলে বা কনসোলে সমস্ত ভ্যালিডেশন স্টেপস ট্র্যাক করবে, যেমন আর্গুমেন্ট যাচাই এবং ভ্যালিডেশন স্টেটমেন্ট।

সারাংশ

Apache Commons CLI লাইব্রেরি দিয়ে Command Line Input Validation টেস্টিং খুবই সহজে করা যায়। আপনি আর্গুমেন্টের উপস্থিতি, টাইপ এবং পরিসীমা যাচাই করতে পারেন এবং সঠিক ত্রুটি বার্তা প্রদর্শন করতে পারেন। HelpFormatter ব্যবহার করে কাস্টম সাহায্য বার্তা তৈরি করা হয়, এবং ParseException দিয়ে ত্রুটি হ্যান্ডলিং করা যায়। লগিং ব্যবহারের মাধ্যমে ইনপুট এবং আউটপুটের বিশদ ট্র্যাক করা সম্ভব হয়, যা ডিবাগিংয়ের জন্য খুবই উপকারী।

Apache Commons CLI লাইব্রেরি ব্যবহার করে Command Line Parsing অ্যাপ্লিকেশনের Test Coverage এবং Integration Testing করা গুরুত্বপূর্ণ, কারণ এটি নিশ্চিত করে যে কমান্ড লাইন অপশন এবং আর্গুমেন্টগুলি সঠিকভাবে কাজ করছে এবং প্রকল্পের অন্যান্য অংশের সঙ্গে সঠিকভাবে একত্রীকরণ (integrated) হচ্ছে। এটি বিশেষভাবে গুরুত্বপূর্ণ যখন অ্যাপ্লিকেশনটি কমান্ড লাইন ইনপুটের উপর নির্ভরশীল।

এখানে Test Coverage এবং Integration Testing এর জন্য কিছু কৌশল এবং পদ্ধতি দেওয়া হয়েছে যা Apache Commons CLI এর সঙ্গে ব্যবহৃত হতে পারে।

1. Test Coverage for Apache Commons CLI

Test Coverage নিশ্চিত করতে, আপনাকে CLI অপশনগুলির জন্য Unit Tests তৈরি করতে হবে। এটি নিশ্চিত করবে যে আপনার কমান্ড লাইন অপশনগুলি সঠিকভাবে পার্স করা হচ্ছে এবং এর সঠিক আচরণ হচ্ছে।

JUnit ব্যবহার করে Unit Testing

Unit testing এর মাধ্যমে আপনি Apache Commons CLI এর পার্সিং লজিক এবং অপশনগুলো সঠিকভাবে কার্যকর হচ্ছে কিনা তা পরীক্ষা করতে পারেন। এখানে, JUnit ব্যবহার করে CLI অপশনের জন্য টেস্ট তৈরি করা হয়েছে।

JUnit Test Example:

import org.apache.commons.cli.*;
import org.junit.Test;
import static org.junit.Assert.*;

public class CommandLineParserTest {

    @Test
    public void testFileOption() throws ParseException {
        String[] args = {"-f", "testfile.txt"};
        Options options = new Options();
        options.addOption("f", "file", true, "Input file");

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        assertTrue("File option should be present", cmd.hasOption("f"));
        assertEquals("testfile.txt", cmd.getOptionValue("f"));
    }

    @Test
    public void testVerboseOption() throws ParseException {
        String[] args = {"-v"};
        Options options = new Options();
        options.addOption("v", "verbose", false, "Verbose output");

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        assertTrue("Verbose option should be present", cmd.hasOption("v"));
    }

    @Test(expected = ParseException.class)
    public void testMissingArgument() throws ParseException {
        String[] args = {"-f"};
        Options options = new Options();
        options.addOption("f", "file", true, "Input file");

        CommandLineParser parser = new DefaultParser();
        parser.parse(options, args); // Should throw ParseException because the argument is missing
    }
}

ব্যাখ্যা:

• testFileOption(): এটি পরীক্ষা করবে যে -f অপশন প্রদান করা হলে তা সঠিকভাবে পার্স হচ্ছে এবং ফাইল পাথ সঠিকভাবে সেভ হচ্ছে।
• testVerboseOption(): এটি পরীক্ষা করবে যে -v অপশন চালু হলে তা সঠিকভাবে পার্স হচ্ছে।
• testMissingArgument(): এটি পরীক্ষা করবে যে যদি আর্গুমেন্ট ছাড়া কোনো অপশন প্রদান করা হয় (যেমন -f ছাড়া কোনো ফাইল পাথ), তবে এটি একটি ParseException তৈরি করবে।

2. Integration Testing for Command Line Parsing

Integration Testing তখন প্রয়োজন হয় যখন আপনি নিশ্চিত করতে চান যে আপনার CLI অ্যাপ্লিকেশনটি অন্যান্য সিস্টেম বা উপাদানের সাথে সঠিকভাবে ইন্টিগ্রেট হচ্ছে। এটি তখনই গুরুত্বপূর্ণ, যখন আপনার কমান্ড লাইন অপশন এবং অন্যান্য সিস্টেমের কার্যকারিতা একে অপরের উপর নির্ভরশীল।

Integration Testing Example:

ধরা যাক, আপনার CLI অ্যাপ্লিকেশনটি File Reading এবং File Processing করে এবং Output প্রদান করে। আপনাকে এটি পরীক্ষা করতে হবে যে CLI Input, File Handling, এবং Output Generation ঠিকভাবে একত্রিত হচ্ছে।

import org.apache.commons.cli.*;
import org.junit.Test;
import java.io.*;
import static org.junit.Assert.*;

public class CommandLineIntegrationTest {

    @Test
    public void testFileProcessing() throws Exception {
        // Simulate the command line input
        String[] args = {"-f", "testfile.txt"};
        Options options = new Options();
        options.addOption("f", "file", true, "Input file");

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        // Simulate file processing
        if (cmd.hasOption("f")) {
            String filePath = cmd.getOptionValue("f");
            File file = new File(filePath);

            // Check if the file exists
            assertTrue("File should exist", file.exists());

            // Simulate file reading and processing
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String firstLine = reader.readLine();
            reader.close();

            // Check if file contains expected data (example: "Hello World")
            assertEquals("File content mismatch", "Hello World", firstLine);
        }
    }

    @Test
    public void testHelpOption() throws Exception {
        // Simulate the command line input for help
        String[] args = {"-h"};
        Options options = new Options();
        options.addOption("h", "help", false, "Show help");

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        // Check if help option is present
        assertTrue("Help option should be present", cmd.hasOption("h"));
    }
}

ব্যাখ্যা:

• testFileProcessing(): এটি নিশ্চিত করবে যে Command Line থেকে ইনপুট ফাইলের পাথ সঠিকভাবে পাওয়া যাচ্ছে এবং ফাইলটি সঠিকভাবে পড়া এবং প্রক্রিয়া করা হচ্ছে। এই টেস্টে, File Processing এবং File Handling এর মধ্যে ইন্টিগ্রেশন পরীক্ষা করা হয়েছে।
• testHelpOption(): এটি নিশ্চিত করবে যে, যখন -h অপশন প্রদান করা হবে, তখন সঠিকভাবে Help মেসেজ প্রদর্শিত হবে।

3. Mocking External Dependencies in Integration Testing

অনেক সময় আপনার কমান্ড লাইন অ্যাপ্লিকেশনটি অন্য সিস্টেম বা ফাইল সিস্টেমের উপর নির্ভরশীল হতে পারে। এতে, যদি আপনি Integration Test করতে চান, তবে আপনাকে mocking ব্যবহার করতে হতে পারে। এর মাধ্যমে আপনি বাস্তব ফাইল সিস্টেম বা অন্যান্য সিস্টেমের পরিবর্তে মক (mock) ডেটা ব্যবহার করে টেস্ট করতে পারেন।

Mockito Example for Mocking:

import org.apache.commons.cli.*;
import org.mockito.*;
import org.junit.Test;

import java.io.*;

import static org.junit.Assert.*;
import static org.mockito.Mockito.*;

public class CommandLineIntegrationTestWithMocking {

    @Test
    public void testFileProcessingWithMock() throws Exception {
        // Simulate the command line input
        String[] args = {"-f", "testfile.txt"};
        Options options = new Options();
        options.addOption("f", "file", true, "Input file");

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        // Mocking FileReader
        FileReader fileReaderMock = mock(FileReader.class);
        BufferedReader bufferedReaderMock = mock(BufferedReader.class);
        
        when(bufferedReaderMock.readLine()).thenReturn("Hello World");

        // Simulate file reading and processing
        String filePath = cmd.getOptionValue("f");
        assertEquals("testfile.txt", filePath);

        // Check if mocked content is processed correctly
        String firstLine = bufferedReaderMock.readLine();
        assertEquals("Hello World", firstLine);

        // Verify mock interactions
        verify(bufferedReaderMock).readLine();
    }
}

ব্যাখ্যা:

• এখানে, Mockito ব্যবহার করে FileReader এবং BufferedReader মক করা হয়েছে, যাতে বাস্তব ফাইল সিস্টেমে প্রবেশ না করে আপনি সহজে টেস্ট করতে পারেন।
• Mockito এর মাধ্যমে when-thenReturn ব্যবহার করে মক আউটপুট প্রদান করা হয়েছে।

4. Test Coverage Tools

এটা নিশ্চিত করার জন্য যে আপনার Apache Commons CLI কোড যথাযথভাবে টেস্ট করা হচ্ছে, আপনি Test Coverage Tools ব্যবহার করতে পারেন। যেমন:

• JaCoCo (Java Code Coverage)
• Cobertura

এগুলি ব্যবহার করে আপনি জানতে পারবেন কোন অংশগুলি টেস্ট করা হয়েছে এবং কোন অংশগুলি টেস্টের বাইরে রয়েছে, যা আরও উন্নত টেস্ট কভারেজ নিশ্চিত করতে সহায়ক।

সারাংশ

Apache Commons CLI ব্যবহার করে Test Coverage এবং Integration Testing এর জন্য সঠিকভাবে টেস্টিং করা গুরুত্বপূর্ণ, কারণ এটি নিশ্চিত করে যে কমান্ড লাইন অপশন সঠিকভাবে পার্স হচ্ছে এবং অ্যাপ্লিকেশনটির অন্যান্য অংশের সঙ্গে সঠিকভাবে ইন্টিগ্রেট হচ্ছে। JUnit, Mockito এবং log4j ব্যবহার করে আপনি আপনার CLI অ্যাপ্লিকেশনের পারফরম্যান্স, ত্রুটি হ্যান্ডলিং এবং অন্যান্য নির্ভরশীলতা পরীক্ষা করতে পারেন। Integration Testing এর মাধ্যমে আপনি CLI অপশন এবং অন্যান্য সিস্টেমের সাথে ইন্টিগ্রেশন নিশ্চিত করতে পারবেন।