Android espresso back button

Тестируем с Espresso

Espresso — это фреймворк для тестирования. Раньше распространялась как отдельная библиотека, но начиная с версии 2.0, Espresso стала частью репозитория Android Support Repository, что позволило быстро и удобно добавить поддержку тестов в ваш проект. Работает на устройствах и эмуляторе.

Писать тесты на Espresso очень удобно, так как много функционала она берёт на себя. Например, не нужно делать фокус на кнопке, проверять доступна ли она на экране и т.д., достаточно обратится к кнопке по её идентификатору или text/description и Espresso уже всё сделает за вас, если кнопка не видна или не доступна на экране то тест автоматом уже не пройдёт.

Espresso использует синхронизацию с основным потоком Main Thread.

Перед чтением статьи перечитайте материал Тестирование приложения, в котором даны основы тестирования.

Сейчас в студии необходимые записи вставляются автоматически.

В секции defaultConfig файла build.gradle модуля есть строка:

А также прописаны зависимости.

Перед тестированием следует отключить системные анимации. В настройках Settings | Developer options есть три опции для анимации, которые желательно отключить.

На этом подготовка закончена.

Прежде чем писать тесты, рассмотрим принцип работы библиотеки.

Espresso имеет несколько основных классов для тестирования:

• Espresso – основной класс. Содержит в себе статические методы, такие как нажатия на системные кнопки (Back, Home), вызвать/спрятать клавиатуру, открыть меню, обратится к компоненту
• ViewMatchers – позволяет найти компонент на экране в текущей иерархии
• ViewActions – позволяет взаимодействовать с компонентом (click, longClick, doubleClick, swipe, scroll и т.д.)
• ViewAssertions – позволяет утвердить состояние компонента

Тест первый — onView()

Допустим, у нас есть приложение из двух экранов. На первом пользователь должен ввести своё имя и нажать на кнопку для перехода на вторую активность, в которой выводится приветственное сообщение. Нечто подобное мы делали в примере Передача данных между активностями. Можете взять пример за основу.

В сокращённом виде код для двух активностей.

Для тестирования в студии уже есть пакет имя_пакета (androidTest), содержащий класс ExampleInstrumentedTest. Не обращаем на него внимания. Вам нужно открыть свой класс MainActivity (или любой другой класс для тестирования) и нажать комбинацию клавиш Ctrl+Shift+T. Появится диалоговое окно с предложением создать новый тест Create New Test. . Соглашаемся, появится диалоговое окно. Отмечаем методы, которые нас интересуют.

Далее указываем местоположение класса.

В созданной заготовке MainActivityTest.java пишем необходимый код.

Тестирование можно запустить через правый щелчок мыши на имени тестируемого класса. В нашем примере в текстовом поле должен напечататься текст «Barsik», произойти щелчок кнопки и проверка текстовой метки во второй активности на наличие текста «Hello Barsik». Если тест будет пройдён, то появится сообщение, подсвеченное зелёным цветом. Для проверки можете в текстовом поле ввести какой-нибудь текст. Тогда, во время тестирования к этому тексту припишется «Barsik», и сравнение на «Hello Barsik» не сработает. Или удалите вторую активность.

Кроме нажатия кнопки (click()) доступны и другие действия над компонентами:

• ViewActions.click()
• ViewActions.typeText()
• ViewActions.pressKey()
• ViewActions.clearText()
• ViewActions.swipeRight()

Также доступно тестирование адаптеров, потоков и других вещей. По ссылкам можно изучить другие примеры.

Источник

Getting Started with Espresso – Android UI Automation

By Akshay Pai, Community Contributor — June 5, 2020

• 
• 
• 
• 

The Android operating system dominates the mobile phone market with a massive 75% market share. From attending meetings to playing games, to collaborative artwork, it can be done on an Android device. Naturally, creating and testing Android applications is quite the rage these days.

Naturally, the development of Android has also ramped up. In fact, 3739 apps are added to Play Store every day. This means that developing an Android app that will get noticed, downloaded, and used consistently has become fairly challenging. App developers need to use the best possible tools at their disposal to give their apps a fighting chance in the digital market. One of these tools that all Android developers and automation test engineers need to use is the Espresso automation framework.

This article will provide a beginner’s guide to using Espresso, helping them get familiar with a framework that is mandatory in order to build Android applications correctly.

What is the Espresso Testing Framework?

Espresso is a testing framework that helps developers write automation test cases for user interface (UI) testing. It has been developed by Google and aims to provide a simple yet powerful framework. It allows both black-box testing as well as testing of individual components during development cycles.

Espresso is highly robust. It allows developers to test both Android native views as well as hybrid web-views. Test cases using this framework can be written in Java or Kotlin ensuring no new skill development is required to use it.

Using this framework, testers will be able to leverage a plethora of features. Synchronized test executions, intent validations, and capabilities to run recipes are some of its prominent features.

This tutorial delves into why an automation test framework needs to be used, when it should be used and how to get started with Espresso.

Should You Use an Automation Testing Framework?

Android App Automation Testing reduces costs and saves a lot of time during development cycles. The initial investment in terms of both cost and time is high for test automation. However, studies and analysis over the years have proven that the ROI on Automation Testing is always higher.

Image Credit: QF Test Analysis

The analysis above shows how automated testing reduces cost over multiple development cycles. Another analysis from Abastrata shows how they were able to reduce the cost of testing per hour from $78 to $17.5.

Image Credit: Abstracta Automation vs Manual

So, keeping these metrics in mind, there is no doubt that testers should use an Automation Test Framework.

Understanding Espresso Android

Espresso automation involves understanding the paradigm in which it has to be used. As a developer, one needs to first understand that it’s purely an Android app UI testing framework. This explains why the Espresso Android framework is built without tight coupling to Android APIs such as getView() and getCurrentActivity().

The first step while starting with Espresso is to assume that you are a user. Create test cases by first identifying which UI element has to be tested and then initiating some action on it (basically interacting with it). This makes sense as it causes testers to write automation test cases that mimic user interactions with the UI.

Espresso’s API Components

Now that we are familiar with Espresso’s design model, let’s look at the four components that make up its high-level components.

1. Espresso

This is the starting point for all test cases. This component provides entry points or methods to start the interaction with the app’s view. Each app’s view has two components.

First is the part of the view that belongs to the app. Testers will be able to interact with it by using the onView() and onData() methods. The second part of the view consists of the components that are provided by the OS ( home screen button, back button, etc). Espresso also provides APIs to interact with non-app components. For example, the pressBack() method to initiate going back.

2. ViewMatchers

Views are always in a hierarchy called the View Hierarchy. For the test cases to navigate the view hierarchy, ViewMatchers are used. Technically, they are a collection of objects and they implement the Matcher interface. Testers will be able to pass one or more of these objects to the OnView() method provided by Espresso Component.

3. ViewActions

These components define the action that has to be performed on any given View. Espresso allows testers to send more than one ViewAction as a collection to the Interaction method. An example of a view action would be the click() method which helps a test script click on a given View’s UI component.

4. ViewAssertions

Assertions complete a test case. They are the components that check if the test has passed or failed. In Espresso Android, the ViewAssertions can be passed to the Check() method from the ViewInteraction package. Matches assertion is the most commonly used check which verifies the final state of the view with what is expected.

Sample Test Case for Espresso Android

Based on the components discussed above, here is how one can write a test case with Espresso using:

1. Java

2. Kotlin

Code Explanation

Here’s what both the Java and Kotin test case above does.

1. Firstly, it tries to find a view with a certain ID and a uniquely identifiable feature. In this case, the script is saying the text “Hello!” on the view is a unique feature.
2. Next, the script performs two actions on that view. It first types “Hello!” on a text box that is present, and then it clicks on a button that exists.
3. Finally, it calls the assertion matches() to check if the view shows “Hello!” once the click is performed. The result will be a successful test case if the view has the desired text on it. Otherwise, the test case fails.

Espresso Test Android Cheat Sheet

Thanks to Google, testers have a clear cheat sheet that they can refer to while developing test cases with Espresso. The cheat sheet below provides references to most of the instances that come with the Espresso Components discussed earlier.

Image Credit: Espresso Framework by Android Developers – Google

Why Use Espresso Instead of Appium?

Espresso and Appium complement each other. Both are test frameworks used for automation but they differ in where they are applicable. Appium helps with testing how well an app responds to various scenarios and how it handles various user flows. Espresso on the other hand helps you test an Android app’s UI and UI component behavior.

Read more about Appium vs Espresso to thoroughly understand the technical differences.

Despite using Appium, it is highly recommended to use Espresso as well to ensure that there is end to end coverage of test cases.

This Android Espresso tutorial strives to offer core information and starting points for action with the Espresso Testing Framework. The initial learning curve might seem a bit steep, which is true for any sort of automation testing. However, with time, it will pay off and you will be saving a lot of time and money.

SDETs and QA teams can use the Espresso Framework on a cloud-based real device lab like BrowserStack to run their Automation tests.

Источник

Автоматизация Android. Супер простое руководство по созданию первого Espresso-теста

Здравствуйте, друзья. В преддверии старта курса «Mobile QA Engineer», хотим поделиться с вами переводом интересного материала.

Что такое Espresso?

Нет, это не напиток, который вы пьете каждый день, чтобы взбодриться. Espresso — это тестовый фреймворк с открытым исходным кодом, разработанный Google. Он позволяет выполнять сложные тесты пользовательского интерфейса на реальном устройстве или эмуляторе. Потребуется ли время, чтобы начать писать сложные тесты для Android?

Возможно. Но ничего не мешает вам сделать первый шаг и научиться писать простые тест-кейсы для Android с помощью фреймворка Espresso прямо сейчас.

Расскажите поподробнее об автоматизации?

Конечно. Автоматизация — это способ ускорить выполнение тестов, сделать их более эффективным и масштабируемым. Ручное тестирование очень важно, но наличие автоматических тестов — гораздо лучший вариант в перспективе.

Существует в основном два типа тестовых фреймворков:

1. Фреймворки, которым не нужен доступ к исходному коду и которые не интегрированы как часть проекта. Например, WebDriver, Appium, QTP.
2. Фреймворки, которым нужен доступ к исходному коду. Например, Espresso, KIF (Keep It Functional).

Espresso — это фреймворк, которому нужен доступ к исходному коду, поэтому для автоматизации нам потребуется доступ к коду проекта. Так как нам нужен проект для работы, давайте создадим его!

Основные компоненты Espresso

Есть три типа методов, доступных в Espresso:

1. ViewMatchers — позволяют найти объект в текущей иерархии представлений
2. ViewAssertions — позволяют проверить состояние объекта и подтвердить, что состояние соответствует критериям
3. ViewActions — эти методы позволяют выполнять различные действия с объектами.

Давайте копнем глубже и посмотрим, как все это работает на реальном примере.

Создание простого приложения для автоматизации

Первое, что нам нужно сделать, — это создать приложение, которое мы будем автоматизировать. Давайте создадим проект в Android Studio. Для этого, конечно, необходимо, чтобы Android Studio был установлен у вас на компьютере.

1. Откройте Android Studio и создайте Bottom Navigation Activity.

Android Studio. Окно «Create New Project»

2. Назовите проект и выберите язык программирования.

Android Studio. Указание имени проекта

3. Перейдите в папку androidTest

Android Studio. Инструментальный тест.

Как вы можете видеть, там написан только один тест, и это не UI-тест, а JUnit-тест.

Сейчас нам нужно добавить простой тест пользовательского интерфейса. Для этого сначала создадим правило для открытия MainActivity.

Давайте добавим импорт аннотации JUnit Rule:

Следующее, что нужно сделать, — это добавить строку кода, указанную ниже, в дополнение к аннотации RunWith:

Теперь мы видим, что ActivityTestRule выделен красным. Это означает, что нам необходимо импортировать функцию ActivityTestRule. Но прежде нам нужно добавить библиотеку, способную сделать это. В двух словах, для этой задачи нам нужна помощь Gradle — системы автоматизации сборки, созданной специально для этой цели.

Давайте перейдем к файлу конфигурации Gradle и добавим эту библиотеку. Откройте файл с именем build.gradle (Module: app) и добавьте строку, указанную ниже:

Android Studio. Добавление зависимости.

После добавления, нужно нажать кнопку для синхронизации проекта и затем вернуться к файлу с реализацией теста.

Теперь, когда библиотека добавлена, следующим шагом будет ее импортирование в файле с инструментальным тестом:

Android Studio. Импорт ActivityTestRule.

Хорошо, теперь мы готовы добавить наш первый тест. Введите этот код в ExampleInstrumentedTest:

Android Studio. Добавление теста и импортирование дополнительных элементов

Для нашего теста требуется импортировать дополнительные элементы, прежде чем он начнет работать. Нажмите кнопку «ОК», и мы, собственно, готовы к запуску нашего теста!

Запуск Espresso-тестов

Щелкните правой кнопкой мыши на нашем тесте слева и выберите «Run ExampleInstrumentedTest».

Поскольку это UI-тест, а не модульный тест, дальше мы увидим окно с выбором устройства, на котором мы хотели бы запустить его. У меня уже есть «Nexus 5X» в качестве устройства, поэтому мне нужно просто выбрать его.

В вашем случае, если вы никогда не развертывали Android-проект, выберите ваше реальное Android-устройство или нажмите «Create New Virtual Device» и создайте новое эмулируемое устройство для запуска тестов. Это может быть любое устройство из списка, на котором бы вы хотели запустить тесты.

Нажмите «ОК» и приготовьтесь увидеть магию!

Android Studio. Результаты выполнения теста

Как вы можете видеть, у нас есть набор из двух пройденных тестов: модульного теста, который уже был там, после создания проекта, и нашего теста «clickHomeButton», который мы только что написали.

Android Studio. Выполненный тест.

Как видно из названия, мы нажали только одну кнопку в нижней панели навигации, которая называется «navigation_home» в иерархии MainActivity.

Давайте проанализируем что мы делали в этой цепочке методов:

1. 1. Вызываем «onView». Этот метод является методом типа ViewMatchers. Мы находим объект в нашем Activity для выполнения чего-либо.
2. 2. Далее мы вызываем perform(click()). Этот метод является методом типа ViewActions. Мы указываем конкретное действие, которое нужно выполнить в этом случае — сделать одно нажатие (click). В Espresso доступно еще много методов действий, например:
3. 3. Последнее, что нам нужно сделать, это подтвердить, что действие, которое мы сделали, действительно соответствует нашим критериям, и для этого мы выполняем метод check(isDisplayed()), который является методом типа ViewAssertions. В этом случае мы проверяем, что этот объект (представление) действительно отображался на экране после выполнения действия нажатия.

Иерархия представлений в Android

Уважаемый читатель, я надеюсь, что смог объяснить вам, как писать базовые UI-тесты для Android с помощью Espresso.

Однако, вероятно, не так просто понять, что именно здесь произошло, если не знать, где все эти кнопки расположены и откуда они берутся. Для того, чтобы это узнать, нам нужно перейти в папку «res» с левой стороны, открыть папку «menu» и выбрать «bottom_nav_menu.xml».
Вот что мы увидим там:

Android Studio. Иерархия представления нижнего меню навигации.
Как видите, это строка, которая присваивает имя элементу меню:

Именно это мы используем в нашем коде для запуска тестов. Также есть кнопки меню “navigation_dashboard” и “navigation_notifications”, доступные внизу, так что давайте продолжим и используем их в наших тестах.

Еще больше Espresso-тестов

Нам нужно вернуться к файлу ExampleInstrumentedTest и добавить туда еще пару тестовых функций:

Единственное, что мы добавили, — это проверка еще нескольких элементов меню: “navigation_dashboard” и “navigation_notifications”.

Android Studio. Добавляем еще два теста.

Конечно, эти тесты можно было бы еще больше упростить, но для того, чтобы показать, как все это работает, допустим, что они прекрасно подходят для наших целей.

Давайте продолжим и запустим эти тесты еще раз. Нажмите кнопку «Run».

Android Studio. Результаты выполнения тестов.

Все 4 теста пройдены. Все представления были найдены, нажаты и подтверждены в иерархии представлений.

Заключение

Espresso — это мощное решение для запуска UI-тестов. Теперь, когда вы знаете, как они создаются, вы готовы писать намного более мощные и сложные тесты.

Источник