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

Espresso Device API का इस्तेमाल करके, अपने ऐप्लिकेशन की जांच करें. ऐसा तब करें, जब डिवाइस के कॉन्फ़िगरेशन में सामान्य बदलाव किए जाते हैं. जैसे, स्क्रीन को घुमाना और स्क्रीन को खोलना. Espresso Device API, डिवाइस-लेवल की कार्रवाइयों को सिम्युलेट करने के लिए, सुझाया गया टूल है. इसका इस्तेमाल, Jetpack Compose की टेस्टिंग के नियमों के साथ किया जा सकता है. अगर Jetpack Compose के लिए यूज़र इंटरफ़ेस (यूआई) टेस्ट लिखने में आपको मदद चाहिए, तो 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 सोर्स सेट में मौजूद मेनिफ़ेस्ट फ़ाइल में, INTERNET और ACCESS_NETWORK_STATE अनुमतियां जोड़ें:

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

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

     android.experimental.androidTest.enableEmulatorControl=true
   

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

   Kotlin

     testOptions {
       emulatorControl {
         enable = true
       }
     }
     

   शानदार

     testOptions {
       emulatorControl {
         enable = true
       }
     }
     

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

   Kotlin

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

   शानदार

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

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

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

स्क्रीन को घुमाने की सुविधा के हिसाब से टेस्ट करना

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

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

   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)
   }
   

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() {
  ...
}