लोकल यूनिट टेस्ट तैयार करें

लोकल टेस्ट, Android डिवाइस या एमुलेटर के बजाय, सीधे आपके वर्कस्टेशन पर चलता है. इसलिए, यह जांच करने के लिए Android डिवाइस के बजाय, आपके लोकल Java वर्चुअल मशीन (JVM) का इस्तेमाल करता है. लोकल टेस्ट की मदद से, अपने ऐप्लिकेशन के लॉजिक का आकलन तेज़ी से किया जा सकता है. हालांकि, Android फ़्रेमवर्क की मदद से, यह तय किया जा सकता है कि किस तरह के टेस्ट किए जा सकते हैं.

यूनिट टेस्ट, कोड के छोटे सेक्शन के व्यवहार की पुष्टि करता है. इसे टेस्ट की जा रही यूनिट कहा जाता है. ऐसा करने के लिए यह कोड उस कोड को एक्ज़ीक्यूट करता है और नतीजे की जांच करता है.

यूनिट टेस्ट आम तौर पर आसान होते हैं. हालांकि, अगर जांच की जा रही यूनिट को टेस्ट करने के हिसाब से डिज़ाइन नहीं किया गया है, तो इनका सेटअप करना मुश्किल हो सकता है:

• आपको जिस कोड की पुष्टि करनी है, यह ज़रूरी है कि टेस्ट में वह कोड ऐक्सेस किया जा सके. इसके लिए उदाहरण के लिए, निजी तरीके को सीधे टेस्ट नहीं किया जा सकता. इसके बजाय, क्लास की जांच करें सार्वजनिक एपीआई का इस्तेमाल कर रहा है.
• अलग-अलग यूनिट टेस्ट चलाने के लिए, टेस्ट की जा रही यूनिट की डिपेंडेंसी को ऐसे कॉम्पोनेंट से बदलना होगा जिन्हें आप कंट्रोल करते हैं. जैसे, नकली कॉम्पोनेंट या अन्य टेस्ट डबल. यह खास तौर पर तब समस्या पैदा करता है, जब आपका कोड Android फ़्रेमवर्क पर निर्भर करता हो.

Android में सामान्य इकाई परीक्षण रणनीतियों के बारे में जानने के लिए, पढ़ें कि क्या टेस्ट.

लोकल टेस्ट लोकेशन

डिफ़ॉल्ट रूप से, लोकल यूनिट टेस्ट की सोर्स फ़ाइलें module-name/src/test/ में रखी जाती हैं. Android Studio का इस्तेमाल करके नया प्रोजेक्ट बनाते समय, यह डायरेक्ट्री पहले से मौजूद होती है.

टेस्टिंग डिपेंडेंसी जोड़ना

JUnit टेस्टिंग फ़्रेमवर्क से मिलने वाले स्टैंडर्ड एपीआई का इस्तेमाल करने के लिए, आपको अपने प्रोजेक्ट के लिए टेस्टिंग डिपेंडेंसी भी कॉन्फ़िगर करनी होंगी.

ऐसा करने के लिए, अपने ऐप्लिकेशन के मॉड्यूल की build.gradle फ़ाइल खोलें और यह जानकारी दें लाइब्रेरी को डिपेंडेंसी के तौर पर इस्तेमाल करता है. testImplementation फ़ंक्शन का इस्तेमाल करके यह बताएं कि ये ऐप्लिकेशन पर लागू नहीं होते, बल्कि लोकल टेस्ट सोर्स सेट पर लागू होते हैं:

dependencies {
  // Required -- JUnit 4 framework
  testImplementation "junit:junit:$jUnitVersion"
  // Optional -- Robolectric environment
  testImplementation "androidx.test:core:$androidXTestVersion"
  // Optional -- Mockito framework
  testImplementation "org.mockito:mockito-core:$mockitoVersion"
  // Optional -- mockito-kotlin
  testImplementation "org.mockito.kotlin:mockito-kotlin:$mockitoKotlinVersion"
  // Optional -- Mockk framework
  testImplementation "io.mockk:mockk:$mockkVersion"
}

लोकल यूनिट टेस्ट क्लास बनाना

आपको अपनी लोकल यूनिट टेस्ट क्लास को JUnit 4 टेस्ट क्लास के तौर पर लिखना होता है.

ऐसा करने के लिए, एक ऐसी क्लास बनाएं जिसमें एक या उससे ज़्यादा टेस्टिंग के तरीके शामिल हों. आम तौर पर, ये तरीके module-name/src/test/ में होते हैं. टेस्ट का तरीका, @Test एनोटेशन से शुरू होता है. इसमें उस कॉम्पोनेंट के किसी एक हिस्से की जांच करने और उसकी पुष्टि करने के लिए कोड होता है जिसकी आपको जांच करनी है.

यहां दिए गए उदाहरण में, लोकल यूनिट टेस्ट क्लास को लागू करने का तरीका बताया गया है. कॉन्टेंट बनाने टेस्ट करने का तरीका emailValidator_correctEmailSimple_returnsTrue()पुष्टि करने की कोशिश isValidEmail(),जो ऐप्लिकेशन में मौजूद एक तरीका है. परीक्षण फ़ंक्शन वापस आ जाएगा अगर isValidEmail() भी 'सही' दिखाता है, तो यह सही है.

import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test

class EmailValidatorTest {
  @Test fun emailValidator_CorrectEmailSimple_ReturnsTrue() {
    assertTrue(EmailValidator.isValidEmail("name@email.com"))
  }

}

import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

class EmailValidatorTest {
  @Test
  public void emailValidator_CorrectEmailSimple_ReturnsTrue() {
    assertTrue(EmailValidator.isValidEmail("name@email.com"));
  }
}

आपको पढ़ने लायक टेस्ट बनाने चाहिए, ताकि यह आकलन किया जा सके कि आपके ऐप्लिकेशन से उम्मीद के मुताबिक नतीजे मिलते हैं. हमारा सुझाव है कि आप junit.Assert, Hamcrest या Truth जैसी किसी एश्योरेशन लाइब्रेरी का इस्तेमाल करें. ऊपर दिया गया स्निपेट, junit.Assert का इस्तेमाल करने का उदाहरण है.

नकली Android लाइब्रेरी

जब लोकल यूनिट टेस्ट किए जाते हैं, तो Android Gradle प्लग-इन में लाइब्रेरी जिसमें Android फ़्रेमवर्क के सभी API शामिल हैं, वह वर्शन का इस्तेमाल किया जा सकता है. लाइब्रेरी में सभी सार्वजनिक तरीक़ों और की क्लास में शामिल हो सकते हैं, लेकिन इन तरीकों में मौजूद कोड हटा दिया गया है. अगर कोई है जिन तरीकों को ऐक्सेस किया जाता है उनमें से कुछ टेस्ट में अपवाद की जानकारी मिलती है.

इससे Android में क्लास का रेफ़रंस देते समय, लोकल टेस्ट बनाए जा सकते हैं फ़्रेमवर्क जैसे Context. इससे भी अहम बात यह है कि इससे आपको अपनी साइट पर फ़्रेमवर्क भी शामिल है.

Android डिपेंडेंसी को मॉक करना

आम तौर पर, यह पता लगाना एक समस्या होती है कि कोई क्लास स्ट्रिंग संसाधन का इस्तेमाल कर रही है या नहीं. आप Context में getString() तरीके को कॉल करके स्ट्रिंग रिसॉर्स पाएं क्लास. हालांकि, स्थानीय जांच में Context या इसके किसी भी तरीके का इस्तेमाल नहीं किया जा सकता, क्योंकि ये Android फ़्रेमवर्क से जुड़े हैं. आम तौर पर, getString() को कॉल करने के लिए, क्लास से बाहर निकलना पड़ता है. हालांकि, ऐसा हमेशा नहीं किया जा सकता. इसका समाधान यह है कि Context का एक मॉक या स्टब बनाएं, जो getString() तरीके को शुरू करने पर हमेशा एक ही वैल्यू दिखाता हो.

Mockable Android लाइब्रेरी और मॉकिंग फ़्रेमवर्क Mockito या MockK के तौर पर अपने ऐप्लिकेशन का इस्तेमाल किया जा सकता है. आपके यूनिट टेस्ट में, Android क्लास के मॉक का व्यवहार.

Mockito का इस्तेमाल करके, अपने लोकल यूनिट टेस्ट में मॉक ऑब्जेक्ट जोड़ने के लिए, प्रोग्रामिंग मॉडल का यह तरीका अपनाएं:

1. अपना टेस्टिंग एनवायरमेंट सेट अप करना में बताए गए तरीके के मुताबिक, अपनी build.gradle फ़ाइल में Mockito लाइब्रेरी डिपेंडेंसी शामिल करें.
2. यूनिट टेस्ट क्लास की परिभाषा की शुरुआत में, @RunWith(MockitoJUnitRunner.class) एनोटेशन जोड़ें. इस एनोटेशन से मॉकिटो टेस्ट रनर, ताकि यह पुष्टि की जा सके कि आपने फ़्रेमवर्क का सही तरीके से इस्तेमाल किया है और आपके मॉक ऑब्जेक्ट को शुरू करने की प्रोसेस को आसान बनाता है.
3. Android डिपेंडेंसी के लिए मॉक ऑब्जेक्ट बनाने के लिए, फ़ील्ड के एलान से पहले @Mock एनोटेशन जोड़ें.
4. डिपेंडेंसी के व्यवहार को रोकने के लिए, कोई शर्त तय की जा सकती है और when() और thenReturn() का इस्तेमाल करके, शर्त पूरी होने पर रिटर्न वैल्यू तरीकों का इस्तेमाल करना होगा.

नीचे दिए गए उदाहरण में, Mockito-Kotlin की मदद से Kotlin में बनाए गए मॉकContext ऑब्जेक्ट का इस्तेमाल करने वाली यूनिट टेस्ट बनाने का तरीका बताया गया है.

import android.content.Context
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.Mock
import org.mockito.junit.MockitoJUnitRunner
import org.mockito.kotlin.doReturn
import org.mockito.kotlin.mock

private const val FAKE_STRING = "HELLO WORLD"

@RunWith(MockitoJUnitRunner::class)
class MockedContextTest {

  @Mock
  private lateinit var mockContext: Context

  @Test
  fun readStringFromContext_LocalizedString() {
    // Given a mocked Context injected into the object under test...
    val mockContext = mock<Context> {
        on { getString(R.string.name_label) } doReturn FAKE_STRING
    }

    val myObjectUnderTest = ClassUnderTest(mockContext)

    // ...when the string is returned from the object under test...
    val result: String = myObjectUnderTest.getName()

    // ...then the result should be the expected one.
    assertEquals(result, FAKE_STRING)
  }
}

Mockito फ़्रेमवर्क का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, Mockito API देखें संदर्भ और SharedPreferencesHelperTest श्रेणी सैंपल कोड. साथ ही, Android टेस्टिंग कोडलैब (कोड बनाना सीखना) भी आज़माएं.

गड़बड़ी: "तरीका ... मॉक नहीं है"

अगर Error: "Method ... not mocked मैसेज के साथ, Mockable Android लाइब्रेरी के किसी भी तरीके को ऐक्सेस करने की कोशिश की जाती है, तो यह एक अपवाद दिखाती है.

अगर थ्रो किए गए अपवाद आपके टेस्ट के लिए समस्या पैदा करते हैं, तो आपके पास व्यवहार को बदलने का विकल्प है. ऐसा करने पर, रिटर्न टाइप के आधार पर, मेथड नॉल या शून्य दिखाते हैं. ऐसा करने के लिए, Groovy में अपने प्रोजेक्ट की टॉप-लेवल build.gradle फ़ाइल में यह कॉन्फ़िगरेशन जोड़ें:

android {
  ...
  testOptions {
    unitTests.returnDefaultValues = true
  }