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

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

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

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

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

Finders

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

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

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 की चीट शीट में जाकर, पूरी सूची ब्राउज़ की जा सकती है.

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

// 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()

ध्यान दें: परफ़ॉर्म फ़ंक्शन में कार्रवाइयों को चेन नहीं किया जा सकता. इसके बजाय, perform…() के लिए कई कॉल करें.

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

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

Compose Testing की चीट शीट में जाकर, पूरी सूची ब्राउज़ की जा सकती है.

मैचर

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 टेस्टिंग की चीट शीट में जाकर, पूरी सूची देखी जा सकती है.

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

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