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

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

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

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

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

@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") जैसे स्टैंडर्ड कंपोज़ खोज फ़ंक्शन में "एक से ज़्यादा नोड मिले" गड़बड़ी हो सकती है.

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

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

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

अगर आपको किसी खास RecyclerView लाइन में मौजूद Compose एलिमेंट के साथ इंटरैक्ट करना है, तो Espresso का इस्तेमाल करके लाइन ढूंढें. इसके बाद, 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()
}
TestSnippets.kt

ViewPager में अस्पष्टता की समस्या हल की गई

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

@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()
}
TestSnippets.kt

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 की जानकारी, Compose की टेस्टिंग के कुछ पहलुओं के लिए अब भी मददगार हो सकती है.