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

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 पर माइग्रेट करते समय, आपको एक जैसे Compose एलिमेंट, कई पारंपरिक Android व्यू में नेस्ट किए हुए मिल सकते हैं. जैसे, RecyclerView या ViewPager में. ऐसे मामलों में, Compose की स्टैंडर्ड खोज जैसे onNodeWithText("Save") "Multiple nodes found" गड़बड़ी के साथ फ़ेल हो सकती है.

इन एलिमेंट के बीच अंतर करने के लिए, डाइनैमिक टेस्ट टैग शामिल करने के लिए, प्रोडक्शन कोड में बदलाव करने के बजाय, 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()
}
TestSnippets.kt

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