टेस्टिंग एपीआई

यूज़र इंटरफ़ेस (यूआई) एलिमेंट के साथ इंटरैक्ट करने के तीन मुख्य तरीके हैं:

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

इनमें से कुछ एपीआई, सिमैंटिक्स ट्री में एक या उससे ज़्यादा नोड को रेफ़र करने के लिए, SemanticsMatcher स्वीकार करते हैं.

फ़ाइंडर

एक या एक से ज़्यादा नोड चुनने के लिए, onNode और onAllNodes का इस्तेमाल किया जा सकता है. हालांकि, सबसे ज़्यादा इस्तेमाल की जाने वाली खोजों के लिए, सुविधा देने वाले फ़ाइंडर का भी इस्तेमाल किया जा सकता है. जैसे, onNodeWithText और onNodeWithContentDescription. पूरी सूची देखने के लिए, Compose Testing cheat sheet पर जाएं.

कोई एक नोड चुनें

composeTestRule.onNode(<<SemanticsMatcher>>, useUnmergedTree = false): SemanticsNodeInteraction

// Example
composeTestRule
    .onNode(hasText("Button")) // Equivalent to onNodeWithText("Button")

एक से ज़्यादा नोड चुनना

composeTestRule
    .onAllNodes(<<SemanticsMatcher>>): SemanticsNodeInteractionCollection

// Example
composeTestRule
    .onAllNodes(hasText("Button")) // Equivalent to onAllNodesWithText("Button")

अनमर्ज किया गया ट्री

कुछ नोड, अपने चाइल्ड नोड की सिमैंटिक जानकारी को मर्ज करते हैं. उदाहरण के लिए, दो टेक्स्ट एलिमेंट वाले बटन में, टेक्स्ट एलिमेंट के लेबल मर्ज हो जाते हैं:

MyButton {
    Text("Hello")
    Text("World")
}

सिमैंटिक्स ट्री ��िखाने के लिए, किसी टेस्ट में printToLog() का इस्तेमाल करें:

composeTestRule.onRoot().printToLog("TAG")

यह कोड, इस आउटपुट को प्रिंट करता है:

Node #1 at (...)px
 |-Node #2 at (...)px
   Role = 'Button'
   Text = '[Hello, World]'
   Actions = [OnClick, GetTextLayoutResult]
   MergeDescendants = 'true'

अगर आपको मर्ज नहीं किए गए ट्री के किसी नोड से मैच करना है, तो useUnmergedTree को true पर सेट करें:

composeTestRule.onRoot(useUnmergedTree = true).printToLog("TAG")

यह कोड, इस आउटपुट को प्रिंट करता है:

Node #1 at (...)px
 |-Node #2 at (...)px
   OnClick = '...'
   MergeDescendants = 'true'
    |-Node #3 at (...)px
    | Text = '[Hello]'
    |-Node #5 at (83.0, 86.0, 191.0, 135.0)px
      Text = '[World]'

useUnmergedTree पैरामीटर, सभी फ़ाइंडर में उपलब्ध है. उदाहरण के लिए, यहां इसका इस्तेमाल onNodeWithText फ़ाइंडर में किया गया है.

composeTestRule
    .onNodeWithText("World", useUnmergedTree = true).assertIsDisplayed()

दावे

एक या उससे ज़्यादा मैचर वाले फ़ाइंडर से मिले SemanticsNodeInteraction पर assert() को कॉल करके, दावे की जांच करें:

// Single matcher:
composeTestRule
    .onNode(matcher)
    .assert(hasText("Button")) // hasText is a SemanticsMatcher

// Multiple matchers can use and / or
composeTestRule
    .onNode(matcher).assert(hasText("Button") or hasText("Button2"))

सबसे आम दावे करने के लिए, सुविधा देने वाले फ़ंक्शन का भी इस्तेमाल किया जा सकता है. जैसे, assertExists, assertIsDisplayed, और assertTextEquals. Compose Testing cheat sheet में जाकर, पूरी सूची देखी जा सकती है.

नोड के कलेक्शन पर दावे की जांच करने के लिए भी फ़ंक्शन होते हैं:

// Check number of matched nodes
composeTestRule
    .onAllNodesWithContentDescription("Beatle").assertCountEquals(4)
// At least one matches
composeTestRule
    .onAllNodesWithContentDescription("Beatle").assertAny(hasTestTag("Drummer"))
// All of them match
composeTestRule
    .onAllNodesWithContentDescription("Beatle").assertAll(hasClickAction())

कार्रवाइयां

किसी नोड पर कार्रवाई इंजेक्ट करने के लिए, perform…() फ़ंक्शन को कॉल करें:

composeTestRule.onNode(...).performClick()

यहां कार्रवाइयों के कुछ उदाहरण दिए गए हैं:

performClick(),
performSemanticsAction(key),
performKeyPress(keyEvent),
performGesture { swipeLeft() }

पूरी सूची देखने के लिए, Compose Testing cheat sheet पर जाएं.

मैचर

आपके Compose कोड की जांच करने के लिए, कई तरह के मैचर्स उपलब्ध हैं.

हैरारकीकल मैच करने वाले टूल

हायरार्किकल मैचिंग की सुविधा की मदद से, सिमैंटिक ट्री में ऊपर या नीचे जाकर मैचिंग की जा सकती है.

fun hasParent(matcher: SemanticsMatcher): SemanticsMatcher
fun hasAnySibling(matcher: SemanticsMatcher): SemanticsMatcher
fun hasAnyAncestor(matcher: SemanticsMatcher): SemanticsMatcher
fun hasAnyDescendant(matcher: SemanticsMatcher):  SemanticsMatcher

यहां इन मैचर के इस्तेमाल के कुछ उदाहरण दिए गए हैं:

composeTestRule.onNode(hasParent(hasText("Button")))
    .assertIsDisplayed()

सिलेक्टर्स

टेस्ट बनाने का एक और तरीका है, चुनने वाले टूल का इस्तेमाल करना. इससे कुछ टेस्ट को ज़्यादा आसानी से पढ़ा जा सकता है.

composeTestRule.onNode(hasTestTag("Players"))
    .onChildren()
    .filter(hasClickAction())
    .assertCountEquals(4)
    .onFirst()
    .assert(hasText("John"))

Compose Testing cheat sheet में जाकर, पूरी सूची देखी जा सकती है.

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

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