मल्टीप्रोसेस एस्प्रेसो

ऐप्लिकेशन के बढ़ने के साथ-साथ, आपको अपने ऐप्लिकेशन के कुछ कॉम्पोनेंट को ऐप्लिकेशन की मुख्य प्रोसेस के अलावा किसी दूसरी प्रोसेस में रखने में आसानी हो सकती है. इन नॉन-डिफ़ॉल्ट प्रोसेस में ऐप्लिकेशन कॉम्पोनेंट की जांच करने के लिए, मल्टीप्रोसेस एस्प्रेसो की सुविधा का इस्तेमाल किया जा सकता है. यह टूल, Android 8.0 (एपीआई लेवल 26) और उसके बाद के वर्शन पर उपलब्ध है. इसकी मदद से, अपने ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) के उन इंटरैक्शन को आसानी से टेस्ट किया जा सकता है जो आपके ऐप्लिकेशन की प्रोसेस की सीमाओं को पार करते हैं. साथ ही, Espresso के सिंक्रनाइज़ेशन की गारंटी को बनाए रखते हैं.

मल्टीप्रोसेस Espresso का इस्तेमाल करते समय, वर्शन और स्कोप से जुड़ी इन बातों का ध्यान रखें:

  • आपके ऐप्लिकेशन को Android 8.0 (एपीआई लेवल 26) या उसके बाद के वर्शन को टारगेट करना होगा.
  • यह टूल सिर्फ़ उन ऐप्लिकेशन कॉम्पोनेंट की जांच कर सकता है जिन्हें आपने अपने ऐप्लिकेशन के पैकेज में शामिल किया है. यह बाहरी प्रोसेस की जांच नहीं कर सकता.

टूल का इस्तेमाल करना

मल्टीप्रोसेस एस्प्रेसो का इस्तेमाल करके, अपने ऐप्लिकेशन में किसी प्रोसेस की जांच करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में espresso-remote आर्टफ़ैक्ट का रेफ़रंस जोड़ें:

app/build.gradle

Groovy

dependencies {
    ...
    androidTestImplementation 'androidx.test.espresso:espresso-remote:3.6.1'
}

Kotlin

dependencies {
    ...
    androidTestImplementation('androidx.test.espresso:espresso-remote:3.6.1')
}

आपको अपने ऐप्लिकेशन के androidTest मेनिफ़ेस्ट में यह भी जोड़ना होगा:

  • एक <instrumentation> एलिमेंट, जो प्रोसेस के बारे में बताता है.
  • <meta-data> एलिमेंट यह दिखाता है कि आपको Multiprocess Espresso का इस्तेमाल करना है.

यहां दिए गए कोड स्निपेट में, इन एलिमेंट को जोड़ने का तरीका बताया गया है:

src/androidTest/AndroidManifest.xml

<manifest ... package="androidx.test.mytestapp.tests">
  <uses-sdk android:targetSdkVersion="27" android:minSdkVersion="14" />
  <instrumentation
    android:name="androidx.test.runner.AndroidJUnitRunner"
    android:targetPackage="androidx.test.mytestapp"
    android:targetProcesses="*">
    <meta-data
      android:name="remoteMethod"
      android:value="androidx.test.espresso.remote.EspressoRemote#remoteInit" />
  </instrumentation>
</manifest>

पिछले स्निपेट से Android फ़्रेमवर्क को पता चलता है कि आपको अपने ऐप्लिकेशन के पैकेज में मौजूद हर प्रोसेस की जांच करनी है. अगर आपको अपने ऐप्लिकेशन की सिर्फ़ कुछ प्रोसेस की जांच करनी है, तो targetProcesses एलिमेंट में कॉमा लगाकर अलग की गई सूची का इस्तेमाल करें:

<instrumentation
    ...
    android:targetProcesses=
            "androidx.test.mytestapp:myFirstAppProcessToTest,
             androidx.test.mytestapp:mySecondAppProcessToTest" ... />

टूल के आर्किटेक्चर को समझना

ऐप्लिकेशन की जांच करने और उसकी डिफ़ॉल्ट प्रोसेस लॉन्च करने के दौरान, यूआई इंटरैक्शन किया जा सकता है. जैसे, बटन दबाने पर सेकंडरी प्रोसेस में कोई गतिविधि शुरू हो जाती है. इसके बाद, Espresso का इस्तेमाल करके क्रॉस-प्रोसेस टेस्टिंग की सुविधा चालू करने के लिए, सिस्टम यह प्रोसेस पूरी करता है:

  1. Android फ़्रेमवर्क, आपके ऐप्लिकेशन के नेविगेशन स्ट्रक्चर को फ़ॉलो करने के लिए, एक नई प्रोसेस बनाता है और उसे शुरू करता है. हर Instrumentation प्रोसेस में, AndroidJUnitRunner का एक नया इंस्टेंस शामिल होता है. इस चरण में, दोनों इंस्ट्रुमेंटेशन प्रोसेस एक-दूसरे से कम्यूनिकेट नहीं कर सकतीं.
  2. हर AndroidJUnitRunner इंस्टेंस, Espresso को अपने टेस्टिंग फ़्रेमवर्क के तौर पर रजिस्टर करता है.
  3. AndroidJUnitRunner के दोनों इंस्टेंस, एक-दूसरे से कनेक्शन बनाने के लिए हैंडशेक करते हैं. साथ ही, हर AndroidJUnitRunner इंस्टेंस, Espresso जैसे सभी रजिस्टर किए गए क्लाइंट को अन्य प्रोसेस में मौजूद उनके काउंटरपार्ट से कनेक्ट करता है, ताकि ये क्लाइंट आपस में सीधे तौर पर बातचीत कर सकें.
  4. हर AndroidJUnitRunner इंस्टेंस, नए जोड़े गए इंस्ट्रूमेंटेशन इंस्टेंस और टेस्टिंग फ़्रेमवर्क क्लाइंट को ढूंढता रहता है. साथ ही, ज़रूरत के मुताबिक अतिरिक्त कम्यूनिकेशन चैनल सेट अप करता है.

पहली इमेज में, इस प्रोसेस का नतीजा दिखाया गया है:

पहली इमेज. Multiprocess Espresso का इस्तेमाल करके, एक से ज़्यादा इंस्ट्रुमेंटेशन प्रोसेस के बीच कम्यूनिकेशन सेट अप करना

अन्य संसाधन

इस विषय के बारे में ज़्यादा जानने के लिए, यहां दिए गए संसाधन देखें.