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

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

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

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