PricingLoginStart free
Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग · पाठ

यूनिट और एकीकरण परीक्षण

JUnit, TestNG या Spock परीक्षण चलाने के लिए Gradle कॉन्फ़िगर करें और परीक्षण निर्भरताएँ प्रबंधित करें।

पाठ 1, कुल 4 में से12 चरण

यूनिट और एकीकरण परीक्षण, CoddyKit पर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

टेस्ट क्यों? Gradle की भूमिका

स्वचालित टेस्टिंग सॉफ़्टवेयर की गुणवत्ता के लिए अत्यंत महत्वपूर्ण है। इससे बग जल्दी खोजने में मदद मिलती है और यह सुनिश्चित होता है कि बदलावों के बाद आपका कोड अपेक्षा के अनुसार काम करता है।

Gradle विभिन्न प्रकार के tests चलाने के लिए उत्कृष्ट अंतर्निहित सहायता देता है, जिससे टेस्टिंग को अपनी बिल्ड प्रक्रिया में शामिल करना आसान हो जाता है।

  • यूनिट टेस्ट: आपके कोड के छोटे, अलग-अलग हिस्सों की पुष्टि करते हैं।
  • इंटीग्रेशन टेस्ट: जाँचते हैं कि आपके सिस्टम के अलग-अलग हिस्से एक साथ कैसे काम करते हैं।

Gradle का डिफ़ॉल्ट टेस्ट सेटअप

जब आप Gradle में java प्लगइन लागू करते हैं, तो यह आपके लिए अपने-आप एक test कार्य कॉन्फ़िगर कर देता है। यह कार्य आपके यूनिट tests खोजने और चलाने के लिए ज़िम्मेदार होता है।

डिफ़ॉल्ट रूप से, Gradle src/test/java (या src/test/groovy) में टेस्ट classes खोजता है और अपेक्षा करता है कि वे मानक नामकरण परंपराओं का पालन करें, जैसे नाम का अंत Test से होना।

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}
// The 'java' plugin automatically creates a 'test' task.
// No explicit 'test' task definition needed here.

JUnit 5 को शामिल करना

टेस्ट लिखने के लिए आपको एक टेस्टिंग फ़्रेमवर्क की आवश्यकता होती है। JUnit 5 Java और Groovy के लिए एक लोकप्रिय विकल्प है। आप इसे अपनी build.gradle file में testImplementation dependency के रूप में घोषित करते हैं।

testImplementation का अर्थ है कि dependency केवल tests को compile और चलाते समय उपलब्ध होती है, आपके मुख्य application code के लिए नहीं।

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
}

अपना पहला यूनिट टेस्ट

आइए, एक सरल Calculator class बनाएँ। प्रदर्शन के लिए हम इस class में एक main method जोड़ेंगे, ताकि इसे चलाया जा सके। इसके बाद यूनिट tests इसके methods की स्वतंत्र रूप से पुष्टि करेंगे।

package com.coddykit;

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("2 + 3 = " + calc.add(2, 3));
    }
}

अपना यूनिट टेस्ट लिखना

अब आइए, अपने Calculator के लिए JUnit 5 test लिखें। यह test जाँचेगा कि add method सही ढंग से काम करता है। Gradle का test कार्य इस test को खोजकर चलाएगा।

package com.coddykit;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3), "2 + 3 should be 5");
    }
}

Gradle के साथ tests चलाएँ

अपने यूनिट tests चलाने के लिए, कमांड लाइन में अपनी परियोजना की मुख्य directory से बस test कार्य निष्पादित करें। Gradle आपके tests को compile करेगा, उन्हें चलाएगा और परिणाम बताएगा।

सफल निष्पादन का अर्थ है कि सभी tests पास हो गए! यदि कोई test विफल होता है, तो Gradle आपको उसका विवरण दिखाएगा।

// In your terminal, navigate to the project root and run:
// gradle test
//
// Expected output will include details about test execution.
// Example excerpt:
// > Task :test
// com.coddykit.CalculatorTest > testAdd() PASSED
//
// BUILD SUCCESSFUL in ...

टेस्ट परिणामों की समीक्षा

Tests चलाने के बाद Gradle विस्तृत reports बनाता है। डिफ़ॉल्ट रूप से, ये reports build/reports/tests/test directory में मिलती हैं।

आपको एक HTML report (index.html) मिलेगी, जो सभी test runs का आसानी से समझ आने वाला सारांश देती है, जिसमें सफलताएँ, विफलताएँ और छोड़े गए tests शामिल हैं।

  • HTML report: सभी tests का दृश्य सारांश।
  • XML report: CI/CD tools के लिए मशीन द्वारा पढ़ा जा सकने वाला प्रारूप।
// Locate your test reports here:
// build/reports/tests/test/index.html

इंटीग्रेशन टेस्ट क्या होते हैं?

जहाँ यूनिट tests अलग-अलग components की जाँच करते हैं, वहीं इंटीग्रेशन tests यह सत्यापित करते हैं कि आपके application के अलग-अलग हिस्से साथ मिलकर सही ढंग से काम करते हैं।

इनमें अक्सर databases, APIs या अन्य बाहरी services के साथ परस्पर क्रिया शामिल होती है, जिससे ये धीमे होते हैं, लेकिन पूरे system के स्वास्थ्य के लिए अत्यंत महत्वपूर्ण हैं।

  • यूनिट tests: तेज़, अलग-अलग, एकल इकाइयों की जाँच करते हैं।
  • इंटीग्रेशन tests: धीमे, कई components को शामिल करते हैं और परस्पर क्रियाओं की जाँच करते हैं।

अलग इंटीग्रेशन स्रोत सेट

इंटीग्रेशन tests को यूनिट tests से अलग रखना एक अच्छी प्रथा है। इससे आप उन्हें स्वतंत्र रूप से चला सकते हैं। आप अपनी build.gradle में एक नया source set परिभाषित करके ऐसा कर सकते हैं।

इस source set का अपना compilation और runtime classpath होगा, जो आपके मुख्य और यूनिट टेस्ट code से अलग होगा।

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

sourceSets {
    integrationTest {
        java {
            srcDirs = ['src/integrationTest/java']
        }
        resources {
            srcDirs = ['src/integrationTest/resources']
        }
        compileClasspath += main.output + test.output
        runtimeClasspath += main.output + test.output
    }
}

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'

    integrationTestImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    integrationTestRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
    // Add other integration-specific dependencies here
}

इंटीग्रेशन tests के लिए कस्टम कार्य

अलग source set बनाने के बाद, अपने इंटीग्रेशन tests चलाने के लिए आपको एक कस्टम Gradle कार्य की आवश्यकता होगी। यह कार्य Test प्रकार का होगा और आपके integrationTest source set का उपयोग करने के लिए कॉन्फ़िगर किया जाएगा।

इसके बाद आप इस कार्य को कमांड लाइन से चला सकते हैं: gradle integrationTest। आम तौर पर check कार्य को integrationTest पर निर्भर बनाया जाता है, ताकि gradle check यूनिट और इंटीग्रेशन दोनों tests चलाए।

// build.gradle (continued from previous scene)
task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    shouldRunAfter test // Ensures unit tests run first
}

check.dependsOn integrationTest // Make 'check' task also run integration tests

त्वरित जाँच: टेस्ट के प्रकार

इन परिस्थितियों पर विचार करें:

  1. किसी utility class की एक method की बिना किसी बाहरी dependency के जाँच करना।
  2. यह जाँचना कि आपका application database से सफलतापूर्वक जुड़कर data प्राप्त कर सकता है या नहीं।

कौन-सी परिस्थिति यूनिट test और कौन-सी इंटीग्रेशन test को सबसे अच्छी तरह दर्शाती है?

इंटरैक्टिव पाठ में इसका उत्तर दें

दोहराव: यूनिट और इंटीग्रेशन टेस्टिंग

बहुत अच्छा! आपने Gradle के साथ tests सेट अप करना और चलाना सीख लिया है।

  • Gradle का java प्लगइन डिफ़ॉल्ट test कार्य देता है।
  • हमने testImplementation का उपयोग करके JUnit 5 dependencies जोड़ीं।
  • हमने gradle test का उपयोग करके बुनियादी यूनिट tests लिखे और चलाए।
  • हमने यूनिट और इंटीग्रेशन tests के बीच का अंतर समझा।
  • हमने इंटीग्रेशन tests के लिए एक अलग source set और कस्टम कार्य कॉन्फ़िगर किया।

अब हम यह जानेंगे कि विस्तृत test reports कैसे बनाई और समझी जाती हैं!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Groovy सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
12
पाठ
48
निःशुल्क सीखना शुरू करेंपूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “यूनिट और एकीकरण परीक्षण” पाठ निःशुल्क है?

हाँ—“यूनिट और एकीकरण परीक्षण” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“यूनिट और एकीकरण परीक्षण” में मैं क्या सीखूँगा?

JUnit, TestNG या Spock परीक्षण चलाने के लिए Gradle कॉन्फ़िगर करें और परीक्षण निर्भरताएँ प्रबंधित करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“यूनिट और एकीकरण परीक्षण” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. यूनिट और एकीकरण परीक्षण
  2. परीक्षण रिपोर्ट और फ़िल्टरिंग
  3. कोड कवरेज और स्थैतिक विश्लेषण
  4. परीक्षण फ़िक्स्चर और साझा परीक्षण कोड
← Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पर वापस जाएँ