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

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

आम तौर पर, आपको कुछ भी नहीं करना पड़ता. हालांकि, कुछ ऐसे मामले हैं जिनके बारे में आपको पता होना चाहिए.

टेस्ट को सिंक्रनाइज़ करने पर, आपके 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()
}

ध्यान दें कि यह ज़रूरी शर्त सिर्फ़ कंपोज़ करने की सुविधा के लिए लागू होती है. यह ऐप्लिकेशन के बाकी हिस्सों पर लागू नहीं होती.

अपने-आप सिंक होने की सुविधा बंद करना

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

composeTestRule.mainClock.autoAdvance = false

आम तौर पर, आपको समय खुद ही आगे बढ़ाना होगा. advanceTimeByFrame() की मदद से, एक फ़्रेम आगे बढ़ाएं या advanceTimeBy() की मदद से, वीडियो को किसी खास अवधि के लिए आगे बढ़ाएं:

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

निष्क्रिय संसाधन

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

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

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

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

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

कुछ मामलों में, आपको Compose UI को अपने टेस्ट या उस ऐप्लिकेशन के अन्य हिस्सों के साथ सिंक करना होगा जिसकी जांच की जा रही है.

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 }

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

शर्तें पूरी होने का इंतज़ार करें

ऐसी कोई भी शर्त जो बाहरी काम पर निर्भर करती है, जैसे कि डेटा लोड करना या Android का मेज़र या ड्रॉ (यानी, 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 की टेस्टिंग के कुछ पहलुओं के लिए अब भी मददगार हो सकती है.