Appium
Q: How Appium works ?
Ans:
Appium is an ‘HTTP Server’ written using a Node.js platform and drives iOS and an Android session using Webdriver JSON wire protocol.
Hence, before initializing the Appium Server, Node.js must be pre-installed on the system.
When Appium is downloaded and installed, then a server is set up on our machine that exposes a REST API.
It receives connection and command request from the client and executes that command on mobile devices (Android / iOS).
It responds back with HTTP responses. Again, to execute this request, it uses the mobile test automation frameworks to drive the user interface of the apps
Q: What are main locator used in Appium ?
Ans:
- Xpath
- ID
- accessibilityID
- className
- androidUIAutomator
Q: How to install any application on Emulator?
Q: How to set chromedriver path in Appium ?
Q: What is use of UiAutomator2Options in Appium 8 ?
Q:List out the limitations of using Appium?
- Appium does not support testing of Android Version lower than 4.2
- Limited support for hybrid app testing. E.g., not possible to test the switching action of application from the web app to native and vice-versa
- No support to run Appium Inspector on Microsoft Windows
Q:Explain how to find DOM element or xPath in a mobile application?
Q:What language does Appium support?
Q:Explain the pros and cons of Appium?
- For programmer irrespective of the platform, he is automating ( Android or iOS) all the complexities will remain under single Appium server
- It opens the door to cross-platform mobile testing which means the same test would work on multiple platforms
- Appium does not require extra components in your App to make it automation friendly
- It can automate Hybrid, Web and Native mobile applications
- Running scripts on multiple iOS simulators at the same time is possible with Appium
- It uses UIAutomator for Android Automation which supports only Android SDK platform, API 16 or higher and to support the older API’s they have used another open source library called Selendroid
Q: Explain what is APPIUM INSPECTOR?
Q:Mention what are the basic requirement for writing Appium tests?
- Driver Client: Appium drives mobile applications as though it were a user. Using a client library you write your Appium tests which wrap your test steps and sends to the Appium server over HTTP.
- Appium Session: You have to first initialize a session, as such Appium test takes place in the session. Once the Automation is done for one session, it can be ended and wait for another session
- Desired Capabilities: To initialize an Appium session you need to define certain parameters known as “desired capabilities” like PlatformName, PlatformVersion, Device Name and so on. It specifies the kind of automation one requires from the Appium server.
- Driver Commands: You can write your test steps using a large and expressive vocabulary of commands.
Q: Mention what are the possible errors one might encounter using Appium?
- Error 1: The following desired capabilities are needed but not provided: Device Name, platformName
- Error 2: Could not find adb. Please set the ANDROID_HOME environment variable with the Android SDK root directory path
- Error 3: openqa.selenium.SessionNotCreatedException: A new session could not be created
- Error 4: How to find DOM element or XPath in a mobile application?
- SessionNotFoundException: On disconnection of Appium connection or Session not established, display this exception
- ElementNotFoundException: When Appium does not find the element it is looking for, this exception is displayed
- WebDriverException: When Driver does not exist, this exception is displayed
- NoSuchContextException: is thrown when the context target that is to be switched to does not exist.
Q: What are native Apps/Mobile Web Apps/hybrid apps ?
- Those Apps are written by using Android SDKs and IOS are known as Native Apps.
- There are mobile web pages that are those web apps that are accessed with mobile. browsers. In the case of the IOS platform, Appium supports Safari and for the Android platform, Chrome or any other built-in browser is used.
- Hybrid app are a mix of native and web applications, like native applications are available on the mobile app stores, and have features similar to native applications, like web applications rely on web browsers to be rendered. Online eCommerce sites and Netflix are some of the best examples of hybrid applications.
.
Q: How can you inspect elements that are present in the Native Android App?
Ans:
1 .With the help of the UI Automator tool that is present in Android SDK, you will be able to access those object locators that are part of the Android Native app.
Steps to use UIAutomator Viewer:
- Launch UIAutomator Viewer: You can find it in the
tools/bindirectory of your Android SDK installation. Runuiautomatorviewerfrom the command line or through Android Studio. - Capture a Screenshot: Click the "Device Screenshot" button in the UIAutomator Viewer to capture the current screen of your connected Android device.
- Inspect Elements: After capturing, you can inspect elements on the screenshot. UIAutomator Viewer will display information about the selected UI element, including its resource ID, class, and text.
2 . Appium Inspector is a feature of Appium that lets you inspect and interact with the elements of your mobile app.
- Steps to use Appium Inspector:
- Start Appium Server: Launch the Appium server on your machine.
- Open Appium Inspector: In Appium Desktop, click the "Start Inspector Session" button.
- Configure Desired Capabilities: Set up the desired capabilities for your test, such as platformName, deviceName, appPackage, and appActivity.
- Start the Session: Click "Start Session" to open the app on the device or emulator.
- Inspect Elements: Use the Inspector's UI to interact with and inspect the elements of the app. You can view element properties and hierarchies.
Q: Mention the method with which you can scroll down in App?
Ans: With the help of the scrollTo () method, you will be able to scroll down in App. Also, such a method will help you to automatically scroll until the specific text is not match.
For Android
TouchAction action = new TouchAction(driver);
action.press(PointOption.point(500, 1000))
.waitAction(WaitOptions.waitOptions(Duration.ofSeconds(1)))
.moveTo(PointOption.point(500, 500))
.release()
.perform();
For iOS
In iOS, scrolling is often performed using the scroll method from the MobileElement class, or by executing mobile-specific commands like mobile:scroll.
public class ScrollDownExample {
public static void main(String[] args) {
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("platformName", "iOS");
capabilities.setCapability("deviceName", "MyDevice");
capabilities.setCapability("app", "/path/to/your/app.app");
IOSDriver<MobileElement> driver = new IOSDriver<>(new URL("http://localhost:4723/wd/hub"), capabilities);
// Scroll down to find a specific element
driver.executeScript("mobile: scroll", ImmutableMap.of("direction", "down"));
// Perform operations on the element if needed
MobileElement element = driver.findElementByAccessibilityId("elementId");
element.click(); // Example action
driver.quit();
}
}
Explanation
Android:
findElementByAndroidUIAutomator allows you to use UIAutomator for scrolling actions.
new UiScrollable(new UiSelector().scrollable(true)).scrollForward() scrolls down in a scrollable view.
iOS:
executeScript("mobile: scroll", ImmutableMap.of("direction", "down")) scrolls the screen in the specified direction.
Q: Is it possible to start an Appium server programmatically?
Ans:
It is possible to start an appium server programmatically. Generally, the commands that are being entered to the command prompt are written in note pad and it is saved with .bat extension and you can click the bat file.
public class AppiumServerManager {
public static void main(String[] args) {
// Create and configure the Appium service
AppiumDriverLocalService appiumService = AppiumDriverLocalService.buildService(
new AppiumServiceBuilder()
.usingAnyFreePort() // Automatically select a free port
.withArgument(ServerFlag.LOG_LEVEL, "info") // Set the log level to info
.withStartUpTimeInSeconds(60) // Adjust startup time if needed
);
// Start the Appium server
appiumService.start();
System.out.println("Appium server started at: " + appiumService.getUrl());
// Add your test automation code here
// Stop the Appium server
appiumService.stop();
System.out.println("Appium server stopped.");
}
}
Q: How to handle hybrid Apps?
Q: How can you inspect elements on the IOS apps?
Ans:
With the help of using an Appium inspector that is a GUI-based tool, you can identify elements on IOS apps. These GUI-based tools are quite similar to that of selenium IDE.
Q: How is it possible to identify Mobile browser objects?
Ans:
you can make use of User-Agent in order to identify objects in the Mobile browser. It is done by using the user agent and then changing the browser as the mobile proxy and thus gets an object.
Q: Write the command that will allow you to identify objects uniquely when there are multiple objects within the same class name using Appium?
Ans:
With the help of the command driver. find element (By.className) it is possible to identify the elements uniquely.
Q: Give the difference between emulator and simulator?
Ans:
The simulator is used for calling IOS virtual devices that will launch from Xcode in MAC. The emulator is used for calling Android virtual devices.
Q: What is Appium’s most considerable limitation?
Ans:
Hand down my chin starting to think and mumbling. If I had to provide one single thing you should be aware of about Appium before starting using it, it would surely be multiple session handling. Since Appium is a server, it serves HTTP requests; you might have two different computers running a test each against the same Appium server:
what happens? As for now, Appium does not support this scenario and the second test will be aborted. This is a considerable limitation because no queuing system comes with Appium. If you need to support multiple sessions, you will need to implement this feature by yourself.
Q: What data exchange is?
Ans:
When we say “data exchange” I am not referring to scenarios like getting or setting the value of a textbox. I am also not referring to getting or setting the value of an element’s attribute. All these things are easy to achieve in Appium as Selenium provides commands just for those.
By “data exchange” I mean exchanging information hosted by complex objects stored in different parts of your review-based app like the window object.
Consider when you dispatch and capture events, your app can possibly do many things and the ways data flows can be handled are many. Some objects might also have a state and the state machine behind some scenarios in your app can be large and articulated. For all these reasons you might experience problems when testing.
Q:List difference between Selenium WebDriver and Appium WebDriver
Ans: Selenium and Appium both use
*JSON wire protocol
*Methods like
sendKeys(),
findByClassName(),
findByElementId(),
findByXPath()
There is a difference between Selenium WebDriver and Appium WebDriver as below.
- Selenium WebDriver Supports mobile web applications using browsers like Firefox, Chrome, Opera, Safari and Appium WebDriver Supports native mobile application installed on iOS and Android devices
- Selenium WebDriver has become standard for automation testing of browser based web applications while RemoteWebDriver class is inherited by Appium WebDriver class. This class with help of Appium server provides additional functions useful in context of mobile test automation.
Q: Describe ways to debug Appium tests.
Ans: Following are some ways we can do:- Any error that occurred during mobile tests can be traced from the logs generated at the Appium server.
- Test scripts created can be debugged with the help of the programming language used in writing these tests.
Q: How can we retrieve the test status of Appium test execution?
- Integrating TestNG with Appium
- ExtentReports that give test status reports in the dashboard
- REST API of BrowserStack App Automate for .apk (Android app) or .ipa (iOS app).
- Built-in reporting tools like Maven and Allure
Q: Difficult Scenarios to automate in Appium
AnsTesting with Appium can be challenging for several reasons, particularly in complex scenarios. Here are some of the most difficult scenarios to test with Appium:
Dynamic Content: Apps with dynamic content that changes frequently (e.g., live feeds, real-time updates) can be difficult to test because the elements you're trying to interact with may not be stable or consistent.
Complex Gestures: Testing complex gestures, such as multi-finger swipes or pinches, can be tricky. These gestures often require precise timing and can be sensitive to variations in device performance or screen sensitivity.
Hybrid and Web Views: Apps that contain a mix of native and web views (hybrid apps) can be challenging. Switching contexts between native and web views, and ensuring actions and assertions work across both, requires careful handling of context switching.
Performance and Load Testing: Evaluating app performance under load or high-stress conditions is difficult. Appium primarily focuses on functional testing, so simulating and accurately testing performance metrics can be complex and may require additional tools.
Device Fragmentation: Testing on a wide range of devices with different screen sizes, OS versions, and hardware configurations introduces variability that can make it difficult to ensure consistent test results.
Handling Alerts and Pop-ups: Interacting with and handling system alerts, permission dialogs, or pop-ups can be cumbersome, especially if they appear unpredictably or require specific timing to handle correctly.
App State and Background Testing: Testing scenarios where the app is put in the background or interacts with other apps (e.g., handling push notifications, interruptions) can be challenging due to the need to simulate and verify app behavior accurately.
Real-Time Communication: Apps that rely on real-time communication (e.g., messaging apps, VoIP apps) can be difficult to test because they involve real-time interactions and dependencies on network conditions.
Localization and Internationalization: Testing an app in multiple languages and locales, ensuring all text and UI elements are displayed correctly and are functional, adds another layer of complexity.
Device-Specific Features: Testing features that are unique to specific devices or OS versions, like biometric authentication or device-specific sensors, can be challenging if you don’t have access to all the required hardware.
Authentication Flows: Handling and automating authentication flows (e.g., OAuth, 2FA) can be complex, especially when dealing with multi-step processes or integration with external services.
Complex Data Inputs: Testing forms or inputs that require complex data sets, such as large files or multiple data fields, can be cumbersome and error-prone
Comments
Post a Comment