इंटरोऑपरेबिलिटी

Compose, आम तौर पर इस्तेमाल होने वाले टेस्टिंग फ़्रेमवर्क के साथ इंटिग्रेट होता है.

Espresso के साथ इंटरऑपरेबिलिटी

हाइब्रिड ऐप्लिकेशन में, व्यू हैरारकी (व्यू और व्यू ग्रुप के लेआउट का क्रम) में Compose कॉम्पोनेंट और Compose कंपोज़ेबल में व्यू (AndroidView कंपोज़ेबल के ज़रिए) मिल सकते हैं.

दोनों में से किसी भी टाइप से मैच करने के लिए, कोई खास तरीका अपनाने की ज़रूरत नहीं है. Espresso के onView की मदद से व्यू मैच किए जाते हैं और ComposeTestRule की मदद से Compose एलिमेंट मैच किए जाते हैं.

@Test
fun androidViewInteropTest() {
    // Check the initial state of a TextView that depends on a Compose state.
    Espresso.onView(withText("Hello Views")).check(matches(isDisplayed()))
    // Click on the Compose button that changes the state.
    composeTestRule.onNodeWithText("Click here").performClick()
    // Check the new value.
    Espresso.onView(withText("Hello Compose")).check(matches(isDisplayed()))
}

Compose इंटरऑप टेस्टिंग के लिए, व्यू-स्कोप वाले सिमैंटिक जोड़ना

Compose की मदद से की जाने वाली खोजों को खास व्यू तक सीमित करना

जटिल यूज़र इंटरफ़ेस (यूआई) को Compose पर माइग्रेट करते समय, आपको कई पारंपरिक Android व्यू में नेस्ट किए गए एक जैसे Compose एलिमेंट मिल सकते हैं. जैसे, RecyclerView या ViewPager में. इन मामलों में, onNodeWithText("Save") जैसी स्टैंडर्ड Compose सर्च, "एक से ज़्यादा नोड मिले" गड़बड़ी के साथ फ़ेल हो सकती है.

इन एलिमेंट में अंतर करने के लिए, डाइनैमिक टेस्ट टैग इंजेक्ट करने के लिए अपने प्रोडक्शन कोड में बदलाव करने के बजाय, Compose टेस्ट को सीधे किसी खास Android व्यू तक सीमित किया जा सकता है.

अपने टेस्ट नियम पर onRootWithViewInteraction एपीआई का इस्तेमाल करें. यह फ़ंक्शन Espresso ViewInteraction को स्वीकार करता है. इससे आपको Espresso का इस्तेमाल करके, किसी खास कंटेनर व्यू को अलग करने और सिर्फ़ उस स्कोप वाली हैरारकी में Compose इंटरैक्शन करने की सुविधा मिलती है.

सूची में मौजूद किसी आइटम के साथ इंटरैक्ट करना

अगर आपको किसी खास RecyclerView पंक्ति में मौजूद Compose एलिमेंट के साथ इंटरैक्ट करना है, तो Espresso का इस्तेमाल करके पंक्ति का पता लगाएं. इसके बाद, Compose इंटरैक्शन को उस पंक्ति तक सीमित करें. यह अन्य सभी लाइनों में मौजूद, एक जैसे Compose एलिमेंट को अनदेखा कर देता है.

@Test
fun testComposeButtonInsideRecyclerViewItem() = runComposeUiTest {
    // Scroll to the desired position using Espresso
    Espresso.onView(withId(recyclerViewId))
        .perform(RecyclerViewActions.scrollToPosition<MyViewHolder>(3))

    // Define an Espresso ViewInteraction that uniquely identifies the row
    val rowView = Espresso.onView(
        allOf(
            withId(rootViewId),
            hasDescendant(withText("Item #3"))
        )
    )

    // Scope the Compose search strictly to that specific row View
    onRootWithViewInteraction(rowView)
        .onNode(hasText("Like"))
        .performClick()
}

ViewPagers में मौजूद अस्पष्टता को दूर करना

जब एक जैसे Compose लेआउट वाले कई फ़्रैगमेंट एक साथ मेमोरी में मौजूद हों, तो खोज को किसी खास फ़्रैगमेंट के रूट व्यू आईडी तक सीमित किया जा सकता है. इससे, मैच होने वाली गड़बड़ियों से बचा जा सकता है.

@Test
fun testComposeButtonInsideViewPagerItem() = runComposeUiTest {
    // Swipe to the desired page using Espresso
    Espresso.onView(withId(viewPagerViewId)).perform(swipeLeft())

    // Identify the specific container view using Espresso
    val fragmentB = Espresso.onView(withId(fragmentRootViewId))

    // The generic text "Save" is now unique within this view scope
    onRootWithViewInteraction(fragmentB)
        .onNode(hasText("Save"))
        .assertIsDisplayed()
}

UiAutomator के साथ इंटरऑपरेबिलिटी

डिफ़ॉल्ट रूप से, कंपोज़ेबल को UiAutomator से सिर्फ़ उनके आसान डिस्क्रिप्टर (दिखाया गया टेक्स्ट, कॉन्टेंट की जानकारी वगैरह) से ऐक्सेस किया जा सकता है. अगर आपको Modifier.testTag का इस्तेमाल करने वाले किसी कंपोज़ेबल को ऐक्सेस करना है, तो आपको उस कंपोज़ेबल के सबट्री के लिए, सेमैंटिक प्रॉपर्टी testTagsAsResourceId को चालू करना होगा. इस सुविधा को चालू करना, उन कंपोज़ेबल के लिए मददगार होता है जिनके पास कोई अन्य यूनीक हैंडल नहीं होता. जैसे, स्क्रोल किए जा सकने वाले कंपोज़ेबल (उदाहरण के लिए, LazyColumn).

सिमैंटिक प्रॉपर्टी को अपनी कंपोज़ेबल हैरारकी में सिर्फ़ एक बार चालू करें, ताकि यह पक्का किया जा सके कि Modifier.testTag वाले सभी नेस्ट किए गए कंपोज़ेबल, UiAutomator से ऐक्सेस किए जा सकें.

Scaffold(
    // Enables for all composables in the hierarchy.
    modifier = Modifier.semantics {
        testTagsAsResourceId = true
    }
){
    // Modifier.testTag is accessible from UiAutomator for composables nested here.
    LazyColumn(
        modifier = Modifier.testTag("myLazyColumn")
    ){
        // Content
    }
}

Modifier.testTag(tag) वाले किसी भी कंपोज़ेबल को By.res(resourceName) का इस्तेमाल करके ऐक्सेस किया जा सकता है. इसके लिए, resourceName की तरह ही tag का इस्तेमाल करना होगा.

val device = UiDevice.getInstance(getInstrumentation())

val lazyColumn: UiObject2 = device.findObject(By.res("myLazyColumn"))
// Some interaction with the lazyColumn.

अतिरिक्त संसाधन

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