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

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

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

इनमें से कुछ एपीआई, सेमेटिक्स ट्री में एक या एक से ज़्यादा नोड का रेफ़रंस देने के लिए, 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 कोड की जांच करने के लिए, कई तरह के मैचर उपलब्ध हैं.

हैरारकी मैचर

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

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: यह टूल, व्यू-आधारित यूज़र इंटरफ़ेस (यूआई) के लिए है. हालांकि, Compose की जांच के कुछ पहलुओं के लिए, Espresso के बारे में जानकारी मददगार हो सकती है.