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

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

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

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

फ़ाइंडर

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

कोई एक नोड चुनना

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

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

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

मैचर

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 की जानकारी, Compose की टेस्टिंग के कुछ पहलुओं के लिए मददगार साबित हो सकती है.