अपने टेस्ट सिंक करना

Compose के टेस्ट, डिफ़ॉल्ट रूप से आपके यूज़र इंटरफ़ेस (यूआई) के साथ सिंक होते हैं. जब आप ComposeTestRule के साथ कोई दावा या कार्रवाई कॉल करते हैं, तो टेस्ट पहले से सिंक हो जाता है. यह तब तक इंतज़ार करता है, जब तक यूआई ट्री खाली न हो जाए.

आम तौर पर, आपको कोई कार्रवाई करने की ज़रूरत नहीं होती. हालांकि, कुछ खास मामलों में आपको कार्रवाई करनी पड़ सकती है.

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

हालांकि, अगर आपने अपने टेस्ट को सिंक करने वाले तरीकों का इस्तेमाल नहीं किया, तो कोई रीकंपोज़िशन नहीं होगा. साथ ही, यूज़र इंटरफ़ेस (यूआई) ऐसा दिखेगा जैसे वह रुका हुआ हो.

@Test
fun counterTest() {
    val myCounter = mutableStateOf(0) // State that can cause recompositions.
    var lastSeenValue = 0 // Used to track recompositions.
    composeTestRule.setContent {
        Text(myCounter.value.toString())
        lastSeenValue = myCounter.value
    }
    myCounter.value = 1 // The state changes, but there is no recomposition.

    // Fails because nothing triggered a recomposition.
    assertTrue(lastSeenValue == 1)

    // Passes because the assertion triggers recomposition.
    composeTestRule.onNodeWithText("1").assertExists()
}

ध्यान दें कि यह ज़रूरी शर्त सिर्फ़ Compose के क्रम-वार तरीके से बनाए गए यूज़र इंटरफ़ेस (यूआई) पर लागू होती है. यह ऐप्लिकेशन के बाकी हिस्सों पर लागू नहीं होती.

ऑटोमैटिक सिंक की सुविधा बंद करना

ComposeTestRule के ज़रिए कोई दावा या कार्रवाई कॉल करने पर, जैसे कि assertExists(), आपका टेस्ट Compose यूज़र इंटरफ़ेस (यूआई) के साथ सिंक हो जाता है. कुछ मामलों में, आपको इस सिंक की सुविधा को बंद करना पड़ सकता है. साथ ही, घड़ी को खुद कंट्रोल करना पड़ सकता है. उदाहरण के लिए, किसी ऐनिमेशन के सटीक स्क्रीनशॉट लेने के लिए, समय को कंट्रोल किया जा सकता है. ऐसा तब किया जा सकता है, जब यूज़र इंटरफ़ेस (यूआई) अब भी व्यस्त हो. ऑटोमैटिक सिंक की सुविधा बंद करने के लिए, mainClock में autoAdvance प्रॉपर्टी को false पर सेट करें:

composeTestRule.mainClock.autoAdvance = false

आम तौर पर, इसके बाद आपको समय को खुद आगे बढ़ाना होगा. advanceTimeByFrame() की मदद से, ठीक एक फ़्रेम या advanceTimeBy() की मदद से, तय समय के लिए आगे बढ़ाया जा सकता है:

composeTestRule.mainClock.advanceTimeByFrame()
composeTestRule.mainClock.advanceTimeBy(milliseconds)

खाली संसाधन

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

अपने टेस्ट में, इन आइडलिंग रिसॉर्स को बनाएं और रजिस्टर करें, ताकि यह तय करते समय इनका ध्यान रखा जाए कि टेस्ट किया जा रहा ऐप्लिकेशन व्यस्त है या खाली है. आपको तब तक कोई कार्रवाई नहीं करनी है, जब तक आपको अतिरिक्त आइडलिंग रिसॉर्स रजिस्टर करने की ज़रूरत न हो. उदाहरण के लिए, अगर आपने कोई बैकग्राउंड जॉब चलाई है, जो Espresso या Compose के साथ सिंक नहीं है.

यह एपीआई, Espresso के आइडलिंग रिसॉर्स से काफ़ी मिलता-जुलता है. इससे यह पता चलता है कि टेस्ट किया जा रहा विषय खाली है या व्यस्त है. `IdlingResource` के लागू होने की जानकारी रजिस्टर करने के लिए, Compose टेस्ट नियम का इस्तेमाल करें.

composeTestRule.registerIdlingResource(idlingResource)
composeTestRule.unregisterIdlingResource(idlingResource)

मैन्युअल तरीके से सिंक करना

कुछ मामलों में, आपको Compose यूज़र इंटरफ़ेस (यूआई) को अपने टेस्ट या टेस्ट किए जा रहे ऐप्लिकेशन के अन्य हिस्सों के साथ सिंक करना होगा.

waitForIdle() फ़ंक्शन, Compose के खाली होने का इंतज़ार करता है. हालांकि, यह फ़ंक्शन autoAdvance प्रॉपर्टी पर निर्भर करता है:

composeTestRule.mainClock.autoAdvance = true // Default
composeTestRule.waitForIdle() // Advances the clock until Compose is idle.

composeTestRule.mainClock.autoAdvance = false
composeTestRule.waitForIdle() // Only waits for idling resources to become idle.

ध्यान दें कि दोनों ही मामलों में, waitForIdle() पेंडिंग ड्रॉ और लेआउट पास का भी इंतज़ार करता है.

इसके अलावा, घड़ी को तब तक आगे बढ़ाया जा सकता है, जब तक कोई तय शर्त पूरी न हो जाए advanceTimeUntil().

composeTestRule.mainClock.advanceTimeUntil(timeoutMs) { condition }

ध्यान दें कि दी गई शर्त में, उस स्थिति की जांच की जानी चाहिए जिस पर इस घड़ी का असर पड़ सकता है. यह सिर्फ़ Compose की स्थिति के साथ काम करता है.

शर्तों का इंतज़ार करना

ऐसी कोई भी शर्त जो बाहरी काम पर निर्भर करती है. जैसे, डेटा लोड करना या Android's मेज़र या ड्रॉ (यानी, Compose के बाहर मेज़र या ड्रॉ), को ज़्यादा सामान्य कॉन्सेप्ट का इस्तेमाल करना चाहिए. जैसे, waitUntil():

composeTestRule.waitUntil(timeoutMs) { condition }

आप waitUntil हेल्पर में से किसी का भी इस्तेमाल कर सकते हैं:

composeTestRule.waitUntilAtLeastOneExists(matcher, timeoutMs)

composeTestRule.waitUntilDoesNotExist(matcher, timeoutMs)

composeTestRule.waitUntilExactlyOneExists(matcher, timeoutMs)

composeTestRule.waitUntilNodeCount(matcher, count, timeoutMs)

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

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