अपने ऐप्लिकेशन की गतिविधियों की जांच करें

ऐक्टिविटी, आपके ऐप्लिकेशन में उपयोगकर्ता के हर इंटरैक्शन के लिए कंटेनर के तौर पर काम करती हैं. इसलिए, यह टेस्ट करना ज़रूरी है कि डिवाइस-लेवल के इवेंट के दौरान, आपके ऐप्लिकेशन की ऐक्टिविटी कैसे काम करती हैं. जैसे:

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

खास तौर पर, यह पक्का करना ज़रूरी है कि ऐक्टिविटी लाइफ़साइकल में बताए गए इवेंट के जवाब में, आपकी ऐक्टिविटी सही तरीके से काम करे.

इस गाइड में, यह आकलन करने का तरीका बताया गया है कि आपके ऐप्लिकेशन की ऐक्टिविटी, अपनी लाइफ़साइकल की अलग-अलग स्थितियों में ट्रांज़िशन के दौरान, डेटा की इंटिग्रिटी और बेहतर उपयोगकर्ता अनुभव को बनाए रखने में कितनी सक्षम है.

Compose में ऐक्टिविटी की जांच करना

Jetpack Compose की मदद से बनाए गए किसी ऐप्लिकेशन की जांच करते समय, आम तौर पर createAndroidComposeRule का इस्तेमाल करके, अपनी ऐक्टिविटी लॉन्च की जाती है और यूज़र इंटरफ़ेस (यूआई) के कॉम्पोनेंट के साथ इंटरैक्ट किया जाता है.

हालांकि, डिवाइस-लेवल के इवेंट की जांच करने के लिए, आपको ऐक्टिविटी की लाइफ़साइकल को सीधे तौर पर मैनेज करना होगा. जैसे, कॉन्फ़िगरेशन में बदलाव करना या ऐक्टिविटी को बैकग्राउंड में डालना या सिस्टम से खत्म करना. इसके लिए, अंडरलाइंग ActivityScenario फ़्रेमवर्क का इस्तेमाल किया जाता है.

Compose टेस्ट नियम, इस सिनेरियो को आपके लिए अपने-आप रैप और मैनेज करता है. इस गाइड में, आपको मॉडर्न यूज़र इंटरफ़ेस (यूआई) की जांच और स्टैंडर्ड लाइफ़साइकल मैनेजमेंट के बीच के अंतर को कम करने के लिए, यह पैटर्न दिखेगा:

@get:Rule
val composeTestRule = createAndroidComposeRule<MyActivity>()

@Test fun testEvent() {
    val scenario = composeTestRule.activityRule.scenario

    // ...
}

किसी ऐक्टिविटी की स्थिति को कंट्रोल करना

अपने ऐप्लिकेशन की ऐक्टिविटी की जांच करने का एक अहम पहलू यह है कि अपने ऐप्लिकेशन की ऐक्टिविटी को खास स्थितियों में रखा जाए. अपने टेस्ट के "दिए गए" हिस्से को तय करने के लिए, ActivityScenario इंस्टेंस का इस्तेमाल करें, जो AndroidX Test लाइब्रेरी का हिस्सा है. इस क्लास का इस्तेमाल करके, अपनी ऐक्टिविटी को उन स्थितियों में रखा जा सकता है जो डिवाइस-लेवल के इवेंट को सिम्युलेट करती हैं.

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

यह एपीआई, खास तौर पर यह आकलन करने के लिए सही है कि टेस्ट के तहत कोई ऐक्टिविटी, खत्म या बनाई जाने पर कैसे काम करती है. इस सेक्शन में, इस एपीआई के सबसे सामान्य इस्तेमाल के उदाहरण दिए गए हैं.

कोई ऐक्टिविटी बनाना

टेस्ट के तहत ऐक्टिविटी बनाने के लिए, यहां दिए गए स्निपेट में दिखाया गया कोड जोड़ें:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
       launchActivity<MyActivity>().use {
       }
    }
}

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

Google का सुझाव है कि टेस्ट पूरा होने पर, ऐक्टिविटी पर close को कॉल करें. इससे, जुड़े हुए संसाधन साफ़ हो जाते हैं और आपके टेस्ट की स्थिरता बेहतर होती है. ActivityScenario , Closeable को लागू करता है. इसलिए, use एक्सटेंशन लागू किया जा सकता है, ताकि ऐक्टिविटी अपने-आप बंद हो जाए.

इसके अलावा, createAndroidComposeRule का इस्तेमाल करके, हर टेस्ट से पहले ऐक्टिविटी को अपने-आप लॉन्च किया जा सकता है. साथ ही, इसे बंद किया जा सकता है. इसके अलावा, आपको Compose यूज़र इंटरफ़ेस (यूआई) की जांच के तरीकों और ActivityScenario का ऐक्सेस भी दिया जा सकता है. यहां दिए गए उदाहरण में, किसी नियम को तय करने और उससे किसी सिनेरियो का इंस्टेंस पाने का तरीका बताया गया है:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule
    val composeTestRule = createAndroidComposeRule<MyActivity>()

    @Test fun testEvent() {
        val scenario = composeTestRule.activityRule.scenario
    }
}

ऐक्टिविटी को नई स्थिति में ले जाना

ऐक्टिविटी को किसी दूसरी स्थिति में ले जाने के लिए, जैसे कि CREATED या STARTED, moveToState को कॉल करें. इस कार्रवाई से, ऐसी स्थिति सिम्युलेट होती है जहां आपकी ऐक्टिविटी, किसी दूसरे ऐप्लिकेशन या सिस्टम की कार्रवाई की वजह से, क्रमशः बंद या पॉज़ हो जाती है.

moveToState के इस्तेमाल का एक उदाहरण, यहां दिए गए कोड स्निपेट में दिखता है:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.moveToState(State.CREATED)
        }
    }
}

ऐक्टिविटी की मौजूदा स्थिति का पता लगाना

टेस्ट के तहत किसी ऐक्टिविटी की मौजूदा स्थिति का पता लगाने के लिए, अपने ActivityScenario ऑब्जेक्ट में मौजूद state फ़ील्ड की वैल्यू पाएं. टेस्ट के तहत किसी ऐक्टिविटी की स्थिति की जांच करना, खास तौर पर तब मददगार होता है, जब ऐक्टिविटी किसी दूसरी ऐक्टिविटी पर रीडायरेक्ट होती है या अपने-आप खत्म हो जाती है. जैसा कि यहां दिए गए कोड स्निपेट में दिखाया गया है:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              startActivity(Intent(activity, MyOtherActivity::class.java))
            }

            val originalActivityState = scenario.state
        }
    }
}

ऐक्टिविटी को फिर से बनाना

जब किसी डिवाइस में संसाधन कम होते हैं, तो सिस्टम किसी ऐक्टिविटी को बंद कर सकता है. ऐसे में, जब उपयोगकर्ता आपके ऐप्लिकेशन पर वापस आता है, तो आपके ऐप्लिकेशन को उस ऐक्टिविटी को फिर से बनाना पड़ सकता है. इन स्थितियों को सिम्युलेट करने के लिए, recreate को कॉल करें:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.recreate()
        }
    }
}

ActivityScenario क्लास, ऐक्टिविटी की सेव की गई इंस्टेंस स्थिति और @NonConfigurationInstance का इस्तेमाल करके एनोटेट किए गए किसी भी ऑब्जेक्ट को बनाए रखती है. ये ऑब्जेक्ट, टेस्ट के तहत आपकी ऐक्टिविटी के नए इंस्टेंस में लोड होते हैं.

ऐक्टिविटी के नतीजे पाना

खत्म हो चुकी किसी ऐक्टिविटी से जुड़ा नतीजा कोड या डेटा पाने के लिए, अपने ActivityScenario ऑब्जेक्ट में मौजूद result फ़ील्ड की वैल्यू पाएं. createAndroidComposeRule का इस्तेमाल करके, यूज़र इंटरफ़ेस (यूआई) की उस कार्रवाई को आसानी से ट्रिगर किया जा सकता है जिससे ऐक्टिविटी खत्म हो जाती है. जैसा कि यहां दिए गए कोड स्निपेट में दिखाया गया है:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule
    val composeTestRule = createAndroidComposeRule<MyActivity>()

    @Test fun testResult() {
        composeTestRule.onNodeWithTag("finish_button").performClick()

        val scenario = composeTestRule.activityRule.scenario
        val resultCode = scenario.result.resultCode
        val resultData = scenario.result.resultData
    }
}

ऐक्टिविटी में कार्रवाइयां ट्रिगर करना

ActivityScenario में मौजूद सभी तरीके, ब्लॉक करने वाले कॉल होते हैं. इसलिए, एपीआई के लिए ज़रूरी है कि उन्हें इंस्ट्रूमेंटेशन थ्रेड में चलाया जाए.

टेस्ट के तहत अपनी ऐक्टिविटी में कार्रवाइयां ट्रिगर करने के लिए, अपने कंपोज़ेबल के साथ इंटरैक्ट करने के लिए, Compose टेस्टिंग एपीआई का इस्तेमाल करें:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule
    val composeTestRule = createAndroidComposeRule<MyActivity>()

    @Test fun testEvent() {
        composeTestRule.onNodeWithText("Refresh").performClick()
    }
}

हालांकि, अगर आपको ऐक्टिविटी पर कोई तरीका कॉल करना है, तो onActivity का इस्तेमाल करके ऐसा सुरक्षित तरीके से किया जा सकता है:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              activity.handleSwipeToRefresh()
            }
        }
    }
}

अन्य संसाधन

टेस्टिंग के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें:

दस्तावेज़

• अपने Compose लेआउट की जांच करना