Właśnie pobrałem Android Studio, które jest oparte na Intellij Idea.

Jak stworzyć testy?

Zauważyłem, że istnieje opcja utworzenia modułu testowego, ale wydaje się, że to nic nie robi, tylko tworzy nowy projekt za pomocą src

Próbowałem także nacisnąć klawisz skrótu CTRL + AlT + T, który pozwala na tworzenie testów jednostkowych na istniejącej klasie, ale wydaje się, że chce umieścić go w bieżącym projekcie. Oczywiście to nie pomaga w TDD

Czy ktoś ma tu jakieś doświadczenie?

Ta odpowiedź jest dla osób, które dopiero zaczynają testowanie Androida. Podam dwa proste przykłady, które pomogą Ci zobaczyć, jak działa testowanie. Jeśli będziesz śledzić kolejne 10 minut, wszystko będzie gotowe do rozpoczęcia dodawania testów do własnej aplikacji. Myślę, że będziesz zaskoczony, jakie to proste. Z pewnością tak.

Wprowadzenie do testowania Androida

Istnieją dwa różne rodzaje testów, które możesz wykonać.

• Lokalne testy jednostkowe. Są one uruchamiane lokalnie na JVM (wirtualnej maszynie języka Java). Ponieważ są lokalne, są szybkie. Możesz ich użyć do testowania części kodu, które wymagają tylko języka Java, a nie interfejsów API systemu Android. (Czasami możesz stworzyć fałszywy obiekt API, aby przetestować więcej rzeczy lokalnie. Nazywa się to mockowaniem . Przykładem Contextjest mock ).
• Testy instrumentalne. Te testy są uruchamiane na prawdziwym urządzeniu lub w emulatorze. To sprawia, że ​​są wolniejsze niż testy lokalne. Są jednak bardziej elastyczne, ponieważ masz dostęp do pełnego interfejsu API systemu Android.

Utwórz nowy projekt, a zobaczysz następujące domyślne foldery.

Wszystko już jest i czeka, aż stworzysz testy. Wszystko jest już skonfigurowane!

Jak tworzyć lokalne testy jednostkowe

Otwórz ExampleUnitTestplik pokazany na powyższym obrazku. powinno wyglądać mniej więcej tak:

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        assertEquals(4, 2 + 2);
    }
}

Naciśnij podwójną zieloną strzałkę, aby uruchomić wszystkie testy, lub pojedynczą zieloną strzałkę, aby uruchomić tylko jeden. (W tym przypadku jest tylko jeden test, więc obaj robią to samo).

Powinien minąć (o ile 2 + 2nadal 4jest czytany w tej odpowiedzi). Gratulacje, właśnie przeprowadziłeś pierwszy test!

Wykonywanie własnego testu

Napiszmy nasz własny test. Najpierw dodaj tę klasę do głównego projektu aplikacji, abyśmy mieli coś do przetestowania:

public class MyClass {
    public int add(int a, int b) {
        return a + b;
    }
}

Teraz zmień addition_isCorrect()metodę w klasie testowej tak, aby była podobna do poniższego kodu (lub po prostu dodaj inną metodę o innej nazwie):

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        MyClass myClass = new MyClass();
        int result = myClass.add(2, 2);
        int expected = 4;
        assertEquals(expected, result);
    }
}

Uruchom go ponownie i powinieneś zobaczyć, jak minął. Gratulacje, właśnie stworzyłeś swój pierwszy test! (No cóż, technicznie rzecz biorąc, to było moje, ale, hej, wystarczająco blisko. Co moje, jest twoje.)

Jak tworzyć testy instrumentalne

Otwórz ExampleInstrumentedTestplik. powinno wyglądać mniej więcej tak:

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
    @Test
    public void useAppContext() throws Exception {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        assertEquals("com.example.myapp", appContext.getPackageName());
    }
}

Naciśnij ponownie jeden z tych zielonych przycisków.

Jeśli masz podłączone prawdziwe urządzenie lub skonfigurowany emulator, powinien on je uruchomić i uruchomić aplikację. Gratulacje, właśnie przeprowadziłeś swój pierwszy test instrumentalny!

Wykonywanie własnego testu

Testy instrumentalne wykorzystują espresso do przeprowadzania testów. To trochę jak twój własny mały użytkownik robota, który możesz przetestować swoją aplikację. Możesz powiedzieć mu, aby zrobił coś takiego, jak naciśnięcie przycisku lub odczytanie właściwości TextView.

Możesz napisać instrukcje, jak wykonać test ręcznie, ale ponieważ dopiero zaczynamy, użyjmy funkcji automatycznego nagrywania . To bardzo proste.

Najpierw dodaj przycisk do swojego interfejsu użytkownika, abyśmy mieli nad czym pracować. Ja to zrobiłem:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.myapp.MainActivity">

    <Button
        android:id="@+id/myButton"
        android:text="Click me"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</android.support.constraint.ConstraintLayout> 

Następnie w menu naciśnij Uruchom> Nagraj test espresso .

Po uruchomieniu kliknij przycisk w emulatorze, a następnie, aby zakończyć, wybierz OK w oknie dialogowym Nagraj. Powinien automatycznie wygenerować następujący kod testowy.

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

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

    @Test
    public void mainActivityTest() {
        ViewInteraction appCompatButton = onView(
                allOf(withId(R.id.myButton), withText("Click me"), isDisplayed()));
        appCompatButton.perform(click());
    }
}

Wspaniały! Właśnie stworzyłeś swój pierwszy test instrumentalny! To było super łatwe. Prawdopodobnie powinieneś dodać asercję, aby uczynić to prawdziwym testem, ale jest to również łatwe do zrobienia z rejestratorem. Obejrzyj ten film, aby przejść nieco głębiej.

Dalsze badanie

Najpierw obejrzałam filmy, a potem przeczytałam dokumentację. To wszystko jest bardzo pomocne. Ostatni odsyłacz prowadzi do serii artykułów, w których omówiono kilka ważnych kwestii, o których należy pomyśleć przy wyborze elementów do przetestowania.

• Android Testing Patterns (krótkie serie filmów od programistów Androida)
• Pierwsze kroki z testowaniem (dokumentacja systemu Android)
• Trzy kroki do jakości kodu przez TDD

Edycja: Od wersji 0.1.8 jest to teraz obsługiwane w IDE . Postępuj zgodnie z instrukcjami tam, zamiast korzystać z poniższych instrukcji.

Postępując zgodnie z instrukcją użytkownika wtyczki Android Gradle, mogłem uzyskać testy działające w wierszu poleceń, wykonując następujące kroki na nowo utworzonym projekcie (użyłem domyślnego pakietu „com.example.myapplication”):

1. Dodaj katalog src / instrumentTest / java na potrzeby testów
2. Dodaj klasę testową (rozszerzającą ActivityTestCase) do pakietu com.example.myapplication.test
3. Uruchom urządzenie wirtualne
4. W wierszu poleceń (w katalogu MyApplicationProject / MyApplication) użyj polecenia „../gradlew connectedInstrumentTest”

To uruchomiło moje testy i umieściło wyniki testów w MyApplicationProject / MyApplication / build / reports / instrumentTests / connected. Jestem nowy w testowaniu aplikacji na Androida, ale wygląda na to, że działa dobrze.

Z poziomu IDE można spróbować uruchomić tę samą klasę testową. Musisz

1. Zaktualizuj build.gradle, aby wyświetlić Maven Central jako repozytorium
2. Zaktualizuj build.gradle, dodaj JUnit 3.8 jako zależność instrumentuTestCompile, np. InstrumentTestCompile 'junit: junit: 3.8'
3. W „Struktura projektu” ręcznie przesuń JUnit na pierwsze miejsce w kolejności zależności

Jednak to się nie powiedzie (w ścieżce klasy używanej podczas uruchamiania testów brakuje katalogu wyjściowego testu). Nie jestem jednak pewien, czy to zadziała niezależnie od tego, ponieważ rozumiem, że wymagany jest program uruchamiający testy dla systemu Android.

Sugerowałbym użycie pliku gradle.build .

1. Dodaj katalog src / androidTest / java do testów (tak jak Chris zaczyna wyjaśniać)

2. Otwórz plik gradle.build i określ tam:

   android {
   
       compileSdkVersion rootProject.compileSdkVersion
       buildToolsVersion rootProject.buildToolsVersion
   
       sourceSets {
   
           androidTest {
               java.srcDirs = ['androidTest/java']
           }
       }
   }

3. Naciśnij „Synchronizuj projekt z plikiem Gradle” (na górnym panelu). Powinieneś zobaczyć teraz folder „java” (wewnątrz „androidTest”) ma kolor zielony.

4. Teraz możesz tam tworzyć dowolne pliki testowe i je wykonywać.

Myślę, że ten post autorstwa Rexa St Johna jest bardzo przydatny do testowania jednostkowego w Android Studio.

_{(źródło: rexstjohn.com )}

Android Studio v.2.3.3

Podświetl kontekst kodu, który chcesz przetestować, i użyj skrótu: CTRL+ SHIFT+T

Skorzystaj z interfejsu dialogowego, aby zakończyć konfigurację.

Struktura testowa powinna odzwierciedlać układ pakietu projektu w celu uzyskania najlepszych wyników, ale możesz ręcznie tworzyć testy niestandardowe, pod warunkiem, że masz poprawny katalog i ustawienia kompilacji.

Na razie (studio 0.61) wystarczy utrzymanie odpowiedniej struktury projektu. Nie ma potrzeby tworzenia oddzielnego projektu testowego, jak w przypadku zaćmienia (patrz poniżej).

Android Studio ewoluuje, więc powyższe odpowiedzi ostatecznie przestaną mieć zastosowanie. W przypadku aktualnej wersji Android Studio 1.2.1.1 znajduje się fajny samouczek dotyczący testowania pod adresem:

http://evgenii.com/blog/testing-activity-in-android-studio-tutorial-part-1/

Wydaje się, że jedną z głównych zmian jest to, że w Android Studio aplikacja testowa jest zintegrowana z projektem aplikacji.

Nie jestem pewien, czy to pomoże w Twoim konkretnym problemie, ale znalazłem przewodnik dotyczący tworzenia testów z projektem Gradle. Podręcznik użytkownika Android Gradle

Najłatwiejszy sposób, jaki znalazłem, jest usprawniony w moim następującym wpisie na blogu :

1. Utwórz folder, w którym napiszesz wszystkie testy jednostkowe (najlepiej com.example.app.tests)
2. Utwórz nową klasę testową (najlepiej NameOfClassTestedTests, czyli BankAccountLoginActivityTests)
3. Rozszerz InstrumentationTestCase
4. Napisz test jednostkowy zakończony niepowodzeniem, aby upewnić się, że pomyślnie skonfigurowaliśmy testy jednostkowe
5. Zwróć uwagę, że nazwa metody testu jednostkowego musi zaczynać się od słowa „test” (najlepiej testTestedMethodNameExpectedResult () tj. TestBankAccountValidationFailedShouldLogout ())
6. Skonfiguruj projekt pod kątem testów jednostkowych:
7. Otwórz menu „Uruchom ...” i kliknij „edytuj konfiguracje”
8. Kliknij przycisk +
9. Wybierz szablon Android Tests
10. Wprowadź nazwę konfiguracji uruchamiania (najlepiej „Testy AppName”)
11. Wybierz swoją aplikację w module combobox
12. Wybierz przycisk opcji „Wszystko w pakiecie” (zazwyczaj chcesz wybrać tę opcję, ponieważ uruchamia ona wszystkie testy jednostkowe we wszystkich klasach testowych)
13. Wpisz nazwę pakietu testowego z kroku 1 (np. Com.example.app.tests)
14. Wybierz urządzenie, na którym chcesz przeprowadzić testy
15. Zastosuj i zapisz konfigurację
16. Uruchom testy jednostkowe (i spodziewaj się niepowodzenia):
17. Wybierz nowo utworzoną konfigurację testów z menu Uruchom
18. Kliknij przycisk Uruchom i przeczytaj wyniki w konsoli wyników

Powodzenia w uczynieniu Twojego kodu bardziej czytelnym, łatwiejszym w utrzymaniu i dobrze przetestowanym!

Android Studio było swego rodzaju ruchomym celem, najpierw jako wersja zapoznawcza dla programistów, a teraz w wersji beta. Ścieżka do klas Test w projekcie zmieniła się w czasie, ale niezależnie od używanej wersji AS, ścieżka jest zadeklarowana w pliku .iml. Obecnie w wersji 0.8.3 w wewnętrznym pliku iml znajdziesz następujące informacje:

      <sourceFolder url="file://$MODULE_DIR$/src/androidTest/res" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/resources" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/assets" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/aidl" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/java" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/groovy" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/jni" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/rs" isTestSource="true" />

Plik .iml informuje, gdzie należy umieścić klasy testowe.

Począwszy od Android Studio 1.1, mamy oficjalną (eksperymentalną) obsługę pisania testów jednostkowych (działa również Roboelectric).

Źródło: https://sites.google.com/a/android.com/tools/tech-docs/unit-testing-support

Dodaj poniżej lib wewnątrz pliku gradle

 androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })

Utwórz klasę HomeActivityTest w katalogu androidTest i przed uruchomieniem testu dodaj ciąg flurry_api_key i sender_id w pliku zasobów ciągu i zmień wartość niepowodzenia i przypadku sukcesu.

@RunWith(AndroidJUnit4.class)
public class HomeActivityTest
{
    private static final String SENDER_ID = "abc";
    private static final String RELEASE_FLURRY_API_KEY = "xyz";

    @Test
    public void gcmRegistrationId_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(SENDER_ID, appContext.getString(R.string.sender_id));
    }

    @Test
    public void flurryApiKey_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(RELEASE_FLURRY_API_KEY, appContext.getString(R.string.flurry_api_key));
    }
}