अपने फ़्रैगमेंट की जांच करना

इस विषय में बताया गया है कि टेस्ट में फ़्रेमवर्क से मिलने वाले एपीआई को कैसे शामिल किया जाए जो हर फ़्रैगमेंट के व्यवहार का आकलन करते हैं.

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

• आपका फ़्रैगमेंट किसी खास पैरंट ऐक्टिविटी पर निर्भर नहीं होना चाहिए या फ़्रैगमेंट.
• आपको फ़्रैगमेंट की व्यू हैरारकी नहीं बनानी चाहिए, जब तक कि फ़्रैगमेंट उपयोगकर्ता को दिखता हो.

ये परीक्षण करने की शर्तें सेट अप करने में मदद करने के लिए, AndroidX fragment-testing लाइब्रेरी FragmentScenario क्लास का इस्तेमाल करके फ़्रैगमेंट बनाएं और उन्हें Lifecycle.State.

डिपेंडेंसी तय करना

FragmentScenario का इस्तेमाल करने के लिए fragment-testing-manifest आर्टफ़ैक्ट को अपने debugImplementation का इस्तेमाल करने वाली ऐप्लिकेशन की build.gradle फ़ाइल और androidTestImplementation का इस्तेमाल करने वाला fragment-testing आर्टफ़ैक्ट नीचे दिया गया उदाहरण:

dependencies {
    def fragment_version = "1.8.2"

    debugImplementation "androidx.fragment:fragment-testing-manifest:$fragment_version"

    androidTestImplementation "androidx.fragment:fragment-testing:$fragment_version"
}

dependencies {
    val fragment_version = "1.8.2"

    debugImplementation("androidx.fragment:fragment-testing-manifest:$fragment_version")

    androidTestImplementation("androidx.fragment:fragment-testing:$fragment_version")
}

इस पेज के परीक्षण उदाहरण Espresso और Truth लाइब्रेरी. इस पर जानकारी के लिए अन्य उपलब्ध परीक्षण और अभिकथन लाइब्रेरी में हो, तो यहां देखें AndroidX Test के लिए प्रोजेक्ट सेट अप करें.

फ़्रैगमेंट बनाना

FragmentScenario में फ़्रैगमेंट लॉन्च करने के लिए, ये तरीके शामिल हैं परीक्षणों में:

• launchInContainer() का इस्तेमाल किया जा सकता है. FragmentScenario इसे अटैच करता है फ़्रैगमेंट को गतिविधि के रूट व्यू कंट्रोलर में जोड़ें. यह गतिविधि शामिल है फ़ील्ड खाली है.
• launch() फ़्रैगमेंट के यूज़र इंटरफ़ेस के बिना टेस्ट किया जा सकता है. FragmentScenario अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है इस तरह के फ़्रैगमेंट को किसी खाली गतिविधि में जोड़ता है, जो काम नहीं करता रूट व्यू कहते हैं.

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

यहां दिए गए कोड के उदाहरण में, हर तरीके का इस्तेमाल करके अपने फ़्रैगमेंट को लॉन्च करने का तरीका बताया गया है:

launchInContainer() का उदाहरण

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEventFragment() {
        // The "fragmentArgs" argument is optional.
        val fragmentArgs = bundleOf(“selectedListItem” to 0)
        val scenario = launchFragmentInContainer<EventFragment>(fragmentArgs)
        ...
    }
}

launch() का उदाहरण

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEventFragment() {
        // The "fragmentArgs" arguments are optional.
        val fragmentArgs = bundleOf("numElements" to 0)
        val scenario = launchFragment<EventFragment>(fragmentArgs)
        ...
    }
}

डिपेंडेंसी दें

अगर आपके फ़्रैगमेंट पर डिपेंडेंसी है, तो आपके पास यह कस्टम FragmentFactory डिपेंडेंसी देकर launchInContainer() या launch() तरीके.

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEventFragment() {
        val someDependency = TestDependency()
        launchFragmentInContainer {
            EventFragment(someDependency)
        }
        ...
    }
}

FragmentFactory का इस्तेमाल करके, अपने फ़्रैगमेंट के लिए डिपेंडेंसी, देखें फ़्रैगमेंट मैनेजर.

फ़्रैगमेंट को नई स्थिति पर ले जाएं

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

फ़्रैगमेंट को किसी दूसरी लाइफ़साइकल स्थिति पर ले जाने के लिए, कॉल करें moveToState(). इस तरीके में इन स्थितियों को आर्ग्युमेंट के तौर पर इस्तेमाल किया जा सकता है: CREATED, STARTED, RESUMED, और DESTROYED. यह तरीका, किसी स्थिति के हिसाब से काम करता है जहां आपके फ़्रैगमेंट वाले फ़्रैगमेंट या गतिविधि में बदलाव होता है किसी भी वजह से चुना जा सकता है.

यहां दिए गए उदाहरण में, INITIALIZED स्थिति में टेस्ट फ़्रैगमेंट लॉन्च किया गया है और फिर उसे RESUMED स्थिति में ले जाता है:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEventFragment() {
        val scenario = launchFragmentInContainer<EventFragment>(
            initialState = Lifecycle.State.INITIALIZED
        )
        // EventFragment has gone through onAttach(), but not onCreate().
        // Verify the initial state.
        scenario.moveToState(Lifecycle.State.RESUMED)
        // EventFragment moves to CREATED -> STARTED -> RESUMED.
        ...
    }
}

फ़्रैगमेंट फिर से बनाएं

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

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEventFragment() {
        val scenario = launchFragmentInContainer<EventFragment>()
        scenario.recreate()
        ...
    }
}

FragmentScenario.recreate() फ़्रैगमेंट और उसके होस्ट को बंद कर देता है और फिर उन्हें फिर से बनाता है. जब FragmentScenario क्लास, टेस्ट में फ़्रैगमेंट, फ़्रैगमेंट को फिर से बनाता है वह लाइफ़साइकल वाली स्थिति में वापस आ जाता है जिसमें वह खत्म होने से पहले थी.

यूज़र इंटरफ़ेस (यूआई) फ़्रैगमेंट के साथ इंटरैक्ट करना

टेस्ट में मौजूद अपने फ़्रैगमेंट में यूज़र इंटरफ़ेस (यूआई) ऐक्शन को ट्रिगर करने के लिए, इसका इस्तेमाल करें एस्प्रेसो व्यू मैचर व्यू के एलिमेंट के साथ इंटरैक्ट करने के लिए:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEventFragment() {
        val scenario = launchFragmentInContainer<EventFragment>()
        onView(withId(R.id.refresh)).perform(click())
        // Assert some expected behavior
        ...
    }
}

अगर आपको फ़्रैगमेंट में किसी तरीके को कॉल करने की ज़रूरत हो, जैसे कि जवाब देना विकल्प मेन्यू से चुनकर ऐसा किया जा सकता है. का इस्तेमाल करके FragmentScenario.onFragment() और किसी FragmentAction:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEventFragment() {
        val scenario = launchFragmentInContainer<EventFragment>()
        scenario.onFragment { fragment ->
            fragment.myInstanceMethod()
        }
    }
}

डायलॉग से जुड़ी कार्रवाइयों को टेस्ट करें

FragmentScenario में भी जांच की जा सकती है डायलॉग के फ़्रैगमेंट. हालांकि, डायलॉग के फ़्रैगमेंट इनमें यूज़र इंटरफ़ेस (यूआई) एलिमेंट हैं, तो उनका लेआउट एक अलग विंडो में भर जाता है, की तुलना में कम संसाधनों से कम होती है. इसी वजह से, डायलॉग फ़्रैगमेंट की जांच करने के लिए FragmentScenario.launch().

यहां दिए गए उदाहरण में, डायलॉग बॉक्स खारिज करने की प्रोसेस की जांच की गई है:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testDismissDialogFragment() {
        // Assumes that "MyDialogFragment" extends the DialogFragment class.
        with(launchFragment<MyDialogFragment>()) {
            onFragment { fragment ->
                assertThat(fragment.dialog).isNotNull()
                assertThat(fragment.requireDialog().isShowing).isTrue()
                fragment.dismiss()
                fragment.parentFragmentManager.executePendingTransactions()
                assertThat(fragment.dialog).isNull()
            }
        }

        // Assumes that the dialog had a button
        // containing the text "Cancel".
        onView(withText("Cancel")).check(doesNotExist())
    }
}