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

कॉम्पोज़ टेस्ट, डिफ़ॉल्ट रूप से आपके यूज़र इंटरफ़ेस (यूआई) के साथ सिंक हो जाते हैं. 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 को लागू करने के लिए, टेस्ट नियम लिखने की सुविधा का इस्तेमाल करें.

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 }

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

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

डेटा लोड करने या 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)