Espresso Device API की मदद से, स्क्रीन कॉन्फ़िगरेशन में हुए बदलावों की जांच करें

डिवाइस के कॉन्फ़िगरेशन में सामान्य बदलाव होने पर, अपने ऐप्लिकेशन की जांच करने के लिए Espresso Device API का इस्तेमाल करें. जैसे, स्क्रीन का घूमना और खुलना. Espresso Device API, डिवाइस-लेवल की कार्रवाइयां करने के लिए सुझाया गया टूल है. इसका इस्तेमाल, Jetpack Compose की टेस्टिंग से जुड़े नियमों के साथ किया जा सकता है. अगर आपको Jetpack Compose के लिए यूज़र इंटरफ़ेस (यूआई) टेस्ट लिखने का अनुभव नहीं है, तो अपने कंपोज़ लेआउट की टेस्टिंग करना लेख पढ़ें.

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

Espresso Device API का इस्तेमाल करने के लिए, आपके पास ये चीज़ें होनी चाहिए:

• Android Studio Iguana या इसके बाद का वर्शन
• Android Gradle प्लगिन 8.3 या इसके बाद का वर्शन
• Android Emulator 33.1.10 या इसके बाद का वर्शन
• Android का ऐसा वर्चुअल डिवाइस जिस पर एपीआई लेवल 24 या इसके बाद का वर्शन चलता हो

Espresso Device API के लिए अपना प्रोजेक्ट सेट अप करना

अपने प्रोजेक्ट को इस तरह से सेट अप करें कि वह Espresso Device API के साथ काम कर सके. इसके लिए, यह तरीका अपनाएं:

1. टेस्ट को टेस्ट के लिए डिवाइस पर निर्देश भेजने की अनुमति देने के लिए, androidTest source set में मेनिफ़ेस्ट फ़ाइल में ज़रूरी नेटवर्क अनुमतियां जोड़ें:

     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
   

   अगर आपका टेस्ट, Android 17 (एपीआई लेवल 37) या इसके बाद के वर्शन को टारगेट करता है, तो आपको ACCESS_LOCAL_NETWORK अनुमति भी देनी होगी:

     <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
   

2. gradle.properties फ़ाइल में enableEmulatorControl एक्सपेरिमेंटल फ़्लैग चालू करें:

     android.experimental.androidTest.enableEmulatorControl=true
   

3. मॉड्यूल-लेवल की बिल्ड स्क्रिप्ट में emulatorControl विकल्प चालू करें:

   Kotlin

     testOptions {
       emulatorControl {
         enable = true
       }
     }
     

   Groovy

     testOptions {
       emulatorControl {
         enable = true
       }
     }
     

4. मॉड्यूल-लेवल की बिल्ड स्क्रिप्ट में, Espresso Device लाइब्रेरी को अपने प्रोजेक्ट में इंपोर्ट करें:

   Kotlin

   dependencies {
     androidTestImplementation("androidx.test.espresso:espresso-device:1.1.0")
   }

   Groovy

   dependencies {
     androidTestImplementation 'androidx.test.espresso:espresso-device:1.1.0'
   }

कॉन्फ़िगरेशन में किए गए सामान्य बदलावों के ख़िलाफ़ टेस्ट करना

Espresso Device API में स्क्रीन की दिशा और फ़ोल्ड किए जा सकने वाले डिवाइस की कई स्टेट होती हैं. इनका इस्तेमाल करके, डिवाइस कॉन्फ़िगरेशन में बदलाव किए जा सकते हैं. यहां दिए गए उदाहरणों में, डिवाइस की इन स्थितियों को ट्रिगर करने और Compose टेस्ट के नियमों का इस्तेमाल करके, यूज़र इंटरफ़ेस (यूआई) में हुए बदलावों की पुष्टि करने का तरीका बताया गया है.

स्क्रीन को घुमाने की सुविधा के ख़िलाफ़ टेस्ट करना

स्क्रीन रोटेशन की जांच करने के लिए, ScreenOrientationRule क्लास का इस्तेमाल करके, जांच के दौरान डिवाइस का ओरिएंटेशन तय किया जा सकता है.

यहां एक उदाहरण दिया गया है, जिसमें बताया गया है कि डिवाइस की स्क्रीन घूमने पर, आपके ऐप्लिकेशन पर क्या असर पड़ता है:

1. सबसे पहले, Compose टेस्ट का नियम तय करें. इसके बाद, ScreenOrientationRule क्लास का इस्तेमाल करके, डिवाइस को एक जैसी शुरुआती स्थिति में सेट करें. जैसे, पोर्ट्रेट मोड:

   import androidx.compose.ui.test.assertIsDisplayed
   import androidx.compose.ui.test.assertDoesNotExist
   import androidx.compose.ui.test.junit4.createComposeRule
   import androidx.compose.ui.test.onNodeWithTag
   import androidx.test.espresso.device.EspressoDevice.onDevice
   import androidx.test.espresso.device.action.ScreenOrientation
   import androidx.test.espresso.device.rules.ScreenOrientationRule
   import org.junit.Rule
   import org.junit.Test
   
   class MyConfigurationTest {
   
       // 1. Define the Compose test rule
       @get:Rule
       val composeTestRule = createComposeRule()
   
       // 2. Define the Espresso Device rule for a consistent starting state
       @get:Rule
       val screenOrientationRule = ScreenOrientationRule(ScreenOrientation.PORTRAIT)
   }
   

   अगर आपका टेस्ट, Android 17 (एपीआई लेवल 37) या उसके बाद के वर्शन को टारगेट करता है, तो Espresso Device API के लिए ACCESS_LOCAL_NETWORK अनुमति ज़रूरी है. आपको यह पक्का करना होगा कि ScreenOrientationRule नियम लागू होने से पहले, यह अनुमति दे दी गई हो. GrantPermissionRule नियम को पहले चलाने के लिए, JUnit के RuleChain का इस्तेमाल करें:

   import androidx.test.rule.GrantPermissionRule
   import org.junit.rules.RuleChain
   
   class MyConfigurationTest {
       val grantPermissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_LOCAL_NETWORK)
       val composeTestRule = createComposeRule()
       val screenOrientationRule = ScreenOrientationRule(ScreenOrientation.PORTRAIT)
   
       @get:Rule
       val chain = RuleChain
           .outerRule(grantPermissionRule)
           .around(composeTestRule)
           .around(screenOrientationRule)
   }
   

2. ऐसा टेस्ट बनाएं जो टेस्ट के दौरान डिवाइस को लैंडस्केप ओरिएंटेशन पर सेट करता हो:

   @Test
   fun myRotationTest() {
     ...
     // Sets the device to landscape orientation during test execution.
     onDevice().setScreenOrientation(ScreenOrientation.LANDSCAPE)
     ...
   }
   

3. स्क्रीन रोटेट होने के बाद, composeTestRule का इस्तेमाल करके देखें कि आपके कंपोज़ेबल, नई स्थिति के हिसाब से काम कर रहे हैं या नहीं.

   @Test
   fun myRotationTest() {
     ...
     // Sets the device to landscape orientation during test execution.
     onDevice().setScreenOrientation(ScreenOrientation.LANDSCAPE)
     composeTestRule.onNodeWithTag("NavRail").assertIsDisplayed()
     composeTestRule.onNodeWithTag("BottomBar").assertDoesNotExist()
   }
   

स्क्रीन खुलने पर टेस्ट करना

यहां एक उदाहरण दिया गया है, जिसमें यह बताया गया है कि फ़ोल्ड किए जा सकने वाले डिवाइस पर ऐप्लिकेशन के खुले होने के दौरान स्क्रीन को अनफ़ोल्ड करने पर, ऐप्लिकेशन पर क्या असर पड़ता है. इसकी जांच कैसे करें:

1. सबसे पहले, डिवाइस को फ़ोल्ड करके onDevice().setClosedMode() पर कॉल करके देखें. पक्का करें कि आपके कंपोज़ेबल, स्क्रीन की कम चौड़ाई के हिसाब से अडजस्ट हो जाएं.

   @Test
   fun myUnfoldedTest() {
     onDevice().setClosedMode()
     composeTestRule.onNodeWithTag("BottomBar").assertIsDisplayed()
     composeTestRule.onNodeWithTag("NavRail").assertDoesNotExist()
     ...
   }
   

2. पूरी तरह से खुले हुए मोड पर जाने के लिए, onDevice().setFlatMode() को कॉल करें. देखें कि कंपोज़ेबल, बड़ी साइज़ क्लास के हिसाब से अडजस्ट हो रहे हैं या नहीं.

   @Test
   fun myUnfoldedTest() {
     onDevice().setClosedMode()
     ...
     onDevice().setFlatMode()
     composeTestRule.onNodeWithTag("NavRail").assertIsDisplayed()
     composeTestRule.onNodeWithTag("BottomBar").assertDoesNotExist()
   }
   

यह तय करना कि आपके टेस्ट के लिए किन डिवाइसों की ज़रूरत है

अगर फ़ोल्ड नहीं किए जा सकने वाले डिवाइस पर, फ़ोल्ड करने की कार्रवाइयां करने वाला टेस्ट चलाया जाता है, तो हो सकता है कि टेस्ट पूरा न हो. सिर्फ़ उन टेस्ट को लागू करने के लिए जो इस्तेमाल किए जा रहे डिवाइस के लिए काम के हैं, @RequiresDeviceMode एनोटेशन का इस्तेमाल करें. टेस्ट रनर, उन डिवाइसों पर अपने-आप टेस्ट नहीं चलाता जिन पर टेस्ट किए जा रहे कॉन्फ़िगरेशन काम नहीं करते. डिवाइस की ज़रूरी शर्तों से जुड़े नियम को हर टेस्ट या पूरी टेस्ट क्लास में जोड़ा जा सकता है.

उदाहरण के लिए, अगर आपको यह तय करना है कि टेस्ट सिर्फ़ उन डिवाइसों पर चलाया जाए जिनमें फ़्लैट कॉन्फ़िगरेशन के लिए अनफ़ोल्ड करने की सुविधा काम करती है, तो अपने टेस्ट में यह @RequiresDeviceMode कोड जोड़ें:

@Test
@RequiresDeviceMode(mode = FLAT)
fun myUnfoldedTest() {
  ...
}