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

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

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

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

फ़ाइंडर

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

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

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

पूरी सूची यहां ब्राउज़ की जा सकती है: टेस्टिंग से जुड़ी काम की बातों की सूची लिखें.

मैच करने वाले

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

हैरारकी मैचर

मैच करने वाले क्रम के हिसाब से, आपको सिमेंटिक्स ट्री में ऊपर या नीचे जाने और परफ़ॉर्म करने में मदद मिलती है मिलता-जुलता है.

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