android-espresso ट्यूटोरियल
Android-एस्प्रेसो के साथ शुरुआत करना

टिप्पणियों

एस्प्रेसो सेटअप निर्देश

• अपना परीक्षण वातावरण सेट करें
• एस्प्रेसो डाउनलोड करें
• इंस्ट्रूमेंटेशन रनर सेट करें
• उदाहरण build.gradle फ़ाइल
• एनालिटिक्स
• पहली परीक्षा जोड़ें
• चल रहे परीक्षण इस गाइड में एसडीके प्रबंधक का उपयोग करके एस्प्रेसो को स्थापित करना और ग्रैडल का उपयोग करके इसे बनाना शामिल है। Android Studio अनुशंसित है।

अपना परीक्षण वातावरण सेट करें

चंचलता से बचने के लिए, हम अत्यधिक अनुशंसा करते हैं कि आप परीक्षण के लिए उपयोग किए जाने वाले वर्चुअल या भौतिक डिवाइस (सिस्टम) पर सिस्टम एनिमेशन बंद कर दें।

अपने डिवाइस पर, सेटिंग्स के तहत-> डेवलपर विकल्प निम्नलिखित 3 सेटिंग्स को अक्षम करते हैं:

• विंडो एनीमेशन स्केल
• संक्रमण एनीमेशन पैमाना
• एनिमेटर अवधि पैमाने

एस्प्रेसो डाउनलोड करें

• सुनिश्चित करें कि आपने नवीनतम एंड्रॉइड सपोर्ट रिपॉजिटरी को एक्स्ट्रा के तहत स्थापित किया है (निर्देश देखें)।

• अपने ऐप की बिल्ड.ग्रेडल फ़ाइल खोलें। यह आमतौर पर शीर्ष-स्तरीय बिल्ड.ग्रेड फ़ाइल नहीं है, लेकिन ऐप / बिल्ड.ग्रेड है।

• निर्भरता के अंदर निम्नलिखित पंक्तियाँ जोड़ें:

  androidTestCompile 'com.android.support.test.espresso: एस्प्रेसो-कोर: 2.2.2' androidTestCompile 'com.android.support.test: धावक: 0.5'

• अधिक कलाकृतियों के लिए डाउनलोड अनुभाग देखें (एस्प्रेसो-कॉन्ट्रिब, एस्प्रेसो-वेब, आदि)

• इंस्ट्रूमेंटेशन रनर सेट करें

उसी बिल्ड में जोड़ें। android.defaultConfig में निम्न पंक्ति दर्ज करें: testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" उदाहरण build.gradf फ़ाइल

apply plugin: 'com.android.application'

    android {
        compileSdkVersion 22
        buildToolsVersion "22"
    
        defaultConfig {
            applicationId "com.my.awesome.app"
            minSdkVersion 10
            targetSdkVersion 22.0.1
            versionCode 1
            versionName "1.0"
    
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        }
    }

dependencies {
    // App's dependencies, including test
    compile 'com.android.support:support-annotations:22.2.0'

    // Testing-only dependencies
    androidTestCompile 'com.android.support.test:runner:0.5'
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
}

एनालिटिक्स

यह सुनिश्चित करने के लिए कि हम प्रत्येक नई रिलीज़ के साथ सही रास्ते पर हैं, परीक्षण धावक विश्लेषण एकत्र करता है। अधिक विशेष रूप से, यह प्रत्येक आह्वान के लिए परीक्षण के तहत आवेदन के पैकेज नाम का एक हैश अपलोड करता है। यह हमें एस्प्रेसो के साथ-साथ उपयोग की मात्रा के साथ अद्वितीय पैकेजों की गणना दोनों को मापने की अनुमति देता है।

यदि आप इस डेटा को अपलोड नहीं करना चाहते हैं, तो आप परीक्षण धावक को निम्नलिखित तर्क पास करके ऑप्ट आउट कर सकते हैं: अक्षमतावाद "सच" (कस्टम तर्क पास कैसे करें) देखें।

पहली परीक्षा जोड़ें

Android Studio src / androidTest / java / com.example.package / में डिफ़ॉल्ट रूप से परीक्षण बनाता है

नियमों का उपयोग करके उदाहरण JUnit4 परीक्षण:

@RunWith(AndroidJUnit4.class)
@LargeTest
public class HelloWorldEspressoTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule(MainActivity.class);

    @Test
    public void listGoesOverTheFold() {
        onView(withText("Hello world!")).check(matches(isDisplayed()));
    }
}

परीक्षण चल रहा है

Android स्टूडियो में

एक परीक्षण कॉन्फ़िगरेशन बनाएँ

एंड्रॉइड स्टूडियो में:

• रन मेनू खोलें -> कॉन्फ़िगरेशन संपादित करें

• एक नया Android टेस्ट कॉन्फ़िगरेशन जोड़ें

• एक मॉड्यूल चुनें

• एक विशिष्ट इंस्ट्रूमेंटेशन रनर जोड़ें:

  android.support.test.runner.AndroidJUnitRunner

नए बनाए गए कॉन्फ़िगरेशन को चलाएं।

ग्रैडल के माध्यम से कमांड-लाइन से

निष्पादित

./gradlew connectedAndroidTest

एस्प्रेसो में मूल रूप से तीन घटक होते हैं:

1. व्यूमैचर्स - वर्तमान दृश्य पदानुक्रम में दृश्य खोजने की अनुमति देता है

2. ViewActions - विचारों पर कार्रवाई करने की अनुमति देता है

3. ViewAssertions - एक दृश्य की स्थिति का दावा करने की अनुमति देता है

बेस एस्प्रेसो टेस्ट

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3

1. दृश्य ढूँढता है
2. दृश्य पर एक क्रिया करता है
3. पुष्टि करता है

एक विकल्प मेनू आइटम की जाँच करना (स्क्रीनशॉट लेने के लिए चम्मच का उपयोग करके)

/**
 * @author piotrek1543
 *
 * This example provides a specific UI testing problem and how it is already solved 
 * with Google's Espresso. Notice that I used also Spoon framework, as Espresso 
 * lacks of taking screenshots functionality.
 */

@RunWith(AndroidJUnit4.class)
public class MainActivityAndroidTest {
    @Rule
    public ActivityTestRule<MainActivity> mRule = new ActivityTestRule<>(MainActivity.class);

    @Test
    public void checkIfSettingsMenuItemsAreVisible() throws InterruptedException {
        //open OptionsMenu to see available items
        openActionBarOverflowOrOptionsMenu(mRule.getActivity());
        //create a screenshot with 'options_menu' TAG
        Spoon.screenshot(mRule.getActivity(), "options_menu");
        //check if Settings item is Visible
        onView(withText(R.string.action_settings)).check(matches(isDisplayed()));
        //check if `Sort` item is Visible
        onView(withText(R.string.action_sort)).check(matches(isDisplayed()));
        //perform click on `Sort` OptionsMenu item
        onView(withText(R.string.action_sort)).perform(click());
        //create a screenshot with 'options_menu_sort' TAG
        Spoon.screenshot(mRule.getActivity(), "options_menu_sort");
        //check if `Sort -> By Value id` item is Visible
        onView(withText(R.string.menu_sort_length)).check(matches(isDisplayed()));
        //check if `Sort -> By Joke length` item is Visible
        onView(withText(R.string.menu_sort_a_z)).check(matches(isDisplayed()));
    }
}

परीक्षण देखें

onView(withId(R.id.greet_button)) // withId(R.id.my_view) is a ViewMatcher
.perform(click())                 // click() is a ViewAction
.check(matches(not(isEnabled())); // matches(isEnabled()) is a ViewAssertion

आईडी से कुछ दृश्य देखें

onView(withId(R.id.pay))

पाठ द्वारा देखें

onView(withText("Pay"))
onView(withText(R.string.pay))

हैलो वर्ल्ड एस्प्रेसो उदाहरण

यह एक हैलो वर्ल्ड उदाहरण बनाने के लिए एक ट्यूटोरियल है: इस उदाहरण के लिए उपयोग किया जाता है: एंड्रॉइड स्टूडियो 2.3;

खाली गतिविधि के साथ एक नया प्रोजेक्ट बनाने के लिए एंड्रॉइड स्टूडियो का उपयोग शुरू करने के लिए। फिर हम ऐप में कुछ सरल कार्यक्षमता जोड़ते हैं जिन्हें हम परीक्षण कर सकते हैं: हम एक बटन जोड़ते हैं जब क्लिक एक टेक्स्टव्यू में "हैलो वर्ल्ड" प्रदर्शित करता है।

गतिविधि कोड इस तरह दिखता है:

package com.example.testing.helloworld;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        final TextView textView = (TextView) findViewById(R.id.textView);

        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                textView.setText("Hello World!");
            }
        });
    }
}

और इस activity_main लिए activity_main लेआउट इस तरह दिखता है:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Say Hello" />
</LinearLayout>

अब हम एस्प्रेसो का उपयोग करके इस नए बनाए गए ऐप के व्यवहार का परीक्षण करना चाहते हैं। आम तौर पर अपने अनुप्रयोग के लिए कोड के भीतर ही है main पैकेज, यूनिट टेस्ट के अंदर हैं test और एस्प्रेसो उपकरण परीक्षण के अंदर हैं androidTest पैकेज। यदि आप एंड्रॉइड स्टूडियो के साथ एक नई खाली गतिविधि परियोजना बनाते हैं, तो उसे पहले से ही उन पैकेजों और कक्षाओं को बनाना चाहिए और यह इस तरह दिखना चाहिए:

एस्प्रेसो के साथ शुरू करने के लिए हमें यह सुनिश्चित करना होगा कि espresso-core निर्भरता build.gradle फ़ाइल में शामिल है (ध्यान दें कि यह compile कीवर्ड के साथ एनोटेट नहीं किया गया है बल्कि इसके बजाय androidTestCompile साथ है)। Android स्टूडियो द्वारा बनाई गई build.gradle फ़ाइल में निर्भरताएँ इस तरह build.gradle चाहिए:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.2.0'
    compile 'com.android.support.constraint:constraint-layout:1.0.2'
    testCompile 'junit:junit:4.12'
}

अब जब सब सेट हो गया है तो हम वास्तविक परीक्षण के साथ शुरू कर सकते हैं: ExampleInstrumentationTest फ़ाइल खोलें और आप देखते हैं कि पहले से ही एक उत्पन्न किया गया उपयोग useAppContext परीक्षण है। हम इस परीक्षण वर्ग को बदलेंगे और हमारे ऐप व्यवहार की जांच करने के लिए एक परीक्षण बनाएंगे:

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule<>(
        MainActivity.class, false, true);

    @Test
    public void checkHelloWorld() throws Exception {
        onView(withId(R.id.textView)).check(matches(withText("")));
        onView(withId(R.id.button)).perform(click());
        onView(withId(R.id.textView)).check(matches(withText("Hello World!")));
    }
}

ExampleInstrumentedTest वर्ग चलाकर परीक्षण प्रारंभ करें। यह परीक्षण तब तीन चीजें करता है:

1. यह जांचता है कि क्या टेक्स्टव्यू में एक रिक्त स्ट्रिंग है ("")
2. यह हमारे लेआउट में बटन पर क्लिक करता है
3. अगर यह "हैलो वर्ल्ड!"

ActivityTestRule शीर्ष परिभाषित करता है जो गतिविधि परीक्षण की शुरुआत में परीक्षण किया है और शुरूआत है इसे। (आप किसी गतिविधि के स्वचालित लॉन्च को भी चालू कर सकते हैं और इसके बजाय इसे प्रत्येक परीक्षण के अंदर मैन्युअल रूप से लॉन्च कर सकते हैं)

परीक्षण नियम काफी सरल हैं:

• onView(withId(R.id.textView)) हमारे अंदर देखने की आईडी के आधार पर वर्तमान स्क्रीन के अंदर एक दृश्य के ऊपर लग रहा है activity_main लेआउट फ़ाइल।
• .check(matches(withText(""))); फिर उस दृश्य पर एक परीक्षण केस करता है।
• .perform(click()) एक दृश्य पर एक क्रिया करता है: यह क्रिया क्लिक, लंबी क्लिक या स्वाइप या कुछ और हो सकती है।

यह एंड्रॉइड एस्प्रेसो इंस्ट्रूमेंटेशन परीक्षणों के साथ शुरू करने के लिए एक ट्यूटोरियल था, मुझे आशा है कि इसने आपको कुछ अंतर्दृष्टि दी है!