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

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