Effective Locator Strategy for Mobile App Automation using Appium

Effective Locator Strategy for Mobile App Automation using Appium

Introduction:

Mobile App Automation using Appium involves various ways to locate elements for effective testing. In this blog, we’ll se the Mobile app automation Using Appium Inspector, we can inspect elements on both iOS and Android devices.

Now we’ll go for locating the Android Element

  • Mobile App Testing tools are available in the market right now are as follows:
    • Katalon
    • Appium
    • Espresso
    • XCTest
    • Robotium
    • Selndroid
    • Flutter
    • Robot Framework
    • iOS-driver
    • Xamarin

So currently we are going to Inspecting the Locator Strategy for Mobile App Automation using Appium, For the initial setup of Appium for Android device you can refer this blog How To Configure Our System For Real Mobile App Automation. This  blog will guide you for the mobile app automation using Appium setup on Android device.

We have various ways to locate the elements for mobile app automation using Appium Inspector, mainly we have the following ways to locate the elements:

  • Id
  • Xpath
  • Customized Xpath
  • Accessible Id

First, we’ll see how to locate the specific element for Mobile App Automation using Appium

After starting the session on an Android phone you will see the below Appium inspector window

Mobile App Automation - 1

In this image, you can see the mobile screen, App source, and Selected Element tabs.

When you select the particular element on the mobile screen displayed on Appium Inspector, You will see the below image, I have selected the C button from a calculator for mobile app automation using appium.

Mobile App Automation using Appium - 2

Now we can see the DOM content is loaded in the App Source tab, and the Attributes and values will be displayed in the Selected Element tab.

Now we’ll see how to locate the element from the Selected Element tab.

Select Element

In the above image you can see the attribute and values to locate the element

Now we can see the Locator strategies to locate this element for mobile app automation using appium. First, we’ll see locating the element using the Id

First, we’ll have to see the available Attributes for that particular element and then try to locate the element. So copy the ID from given Selected Element tab as shown below

Copied-id

So now We’ll see how to check whether the Id is a valid locator or not.

  • For that first click on the Search bar
Search Bar
  • Then make sure you have selected the correct locator Strategy as shown in the below image.
search for element
  • Now after clicking on the search element, you will get to see the identified element as shown in the below image
Mobile App automation using appium. -3
  • As the element is getting highlighted it indicated that we can use that ID to locate that particular element

Now we’ll see locating elements using XPath for Mobile App Automation using Appium

In a similar way to Id we can locate the element using Xpath, So for first we need to click on the Xpath shown in the below image.

Mobile App Automation using Appium-4

Now click on the search button explained above

XPath

Make sure that you have selected the XPath as Locator Strategy as shown. Then Paste the copied XPath in the Selector Box and click on the Search Button, so then you can see the below image the element is located by the XPath

Locate XPath

The element is getting highlighted and that means we can use this XPath to locate this element

Now we’ll see how to use customized XPath for Mobile App Automation

This allows us to handle parameterization and overcome limitations when ID or XPath is not available by default. So for that, we need to know how we can create XPath

  • The first step is you need to find the class for that particular element
Mobile App AUtomation-5
  • As you can see the above image, class is present for that particular element. So first step is we need to copy this class value
  • The next step is to choose the attribute you want to use the value of.
Mobile App Automation-6
  • These are the various attributes you can use to customize XPath
  • So after that, you can create the Customized XPath, So here is a sample XPath I have used to locate the equal button from the Calculator app
  • In this XPath, I have chosen text attribute. So in the below image, you can see the combination of class and attribute and value. This is how we can create customized XPath
XPath Mobile App Automation
  • As shown in the below image you can see the Located element
Located Elements
  • So when the requirement is there to create a parameterized locator or ID is not available, at that time you can use Customized XPath

For accessibility Id you can follow similar steps like ID to locate the element. The only condition is Accessibility ID should be available for that particular element

Now we’ll go for locating the iOS element for Mobile App Automation using Appium

For iOS automation We’ll be going to see how we can locate the element. To locate elements on iOS devices following strategies are available

  • Accessibility Id
  • XPath
  • Customized XPath

Now we’ll see how to locate the element using Accessibility ID on iOS device.

For that, we’ll have to start the Appium Session on iOS. After starting the Appium session on iOS device you  will get to see the below window of Appium inspector

Appium Inspector

This will be the home page of the calculator on the iOS App. On this screen, you can see three windows Mobile screen, App Source, and Selected  Element. When you select any of the elements displayed on the Mobile screen the screen will be shown below.

Mobile Screen

In the above Image, I have selected the AC button which is for All Clear. After selecting that element the DOM content is loaded in the App Source window and in the Selected Element window we can see the attributes and values that can be used for inspecting the elements.

We have so many options to locate the element as you can see in the Selected Element window. We have accessibility ID, XPath, and customized XPath for Mobile App Automation using Appium.

Now we’ll see how to locate the element using accessibility id for Mobile App Automation using Appium

So first we’ll go to search for element as shown in the below image

Element Search

As shown in the above image you can see that I have selected Locator Strategy as the Accessibility ID and the value I have passed the accessibility ID got from the Selected Element window. Now, I’ll click on the Search button.

The system will display the result window below.

Search Button

As shown in the screenshot, the AC button is highlighted after successfully finding the window element. The count for the found element is 1, and you can use this accessibility ID to locate this specific element.

Note: So for locating the elements using XPath and customized XPath you can refer the steps mentioned for Android.

  • Preffered Locator Strategy: As you can see the Selected element window, We have multiple options to locate the element for Mobile App Automation. So there might be a confusion to select the correct locator strategy. So here are some key points which you can consider while choosing the locator strategy
    • Most preferred locator strategy will be id (Android) or accessibility id (iOS). Because id’s are designed to be unique for direct access.
    • name locator strategy can be used if the particular element have the unique name which can be used to locate element.
    • The XPath are more likely to use if id not available or we have requirement to create locator which needs to be parameterized.

Conclusion:

As we see, we have multiple ways to locate the elements on the Mobile Application. Here in this blog, we got to know the the locator strategies to locate the elements on Android and iOS Application for Mobile App Automation using Appium. So you have multiple options to locate the elements, From which you have to decide which strategy suits best for your requirements. So as mentioned above id is fastest way to locate elements, But you have choice to use XPath and customized XPath for parameterization. https://github.com/appium/appium-inspector/releases

Overall, this blog provides an overview of how to locate elements Mobile App Automation using Appium Inspector. Additionally, it explains the various locator strategies you can choose based on the requirements of your test script.

How to configure Windows Desktop for Android App Automation using Appium?

How to configure Windows Desktop for Android App Automation using Appium?

Setting up Appium for testing on real devices for android app automation can be tricky. Many testers struggle with installing the right software, setting environment variables, and connecting their devices properly. These issues can cause a lot of frustration and slow down the testing process. 

In this blog, we’ll make it easy for you. We’ll walk you through each step, from installing necessary software like the Java Development Kit (JDK) and Android Studio, to setting up your Android device for android app automation. We’ll also show you how to install Appium, configure it correctly, and use tools like Appium Inspector to interact with your app. 

By following this simple guide, you’ll be ready to test your mobile apps on real devices quickly and efficiently. 

What is Appium testing in Android App Automation

Appium is an open-source automation tool used for testing mobile applications. It allows testers to automate native, hybrid, and mobile web applications on iOS and Android platforms using the WebDriver protocol. Appium provides a unified API (Application Programming Interface) that allows you to write tests using your preferred programming language (such as Java, Python, JavaScript, etc.) and test frameworks. It supports a wide range of automation capabilities, including gestures, device rotation, multi-touch actions, and handling various types of mobile elements. Appium enables cross-platform testing, where the same tests can be executed on multiple devices, operating systems, and versions, providing flexibility and scalability in mobile app testing or android testing. 

Advantages of Using Appium in Android App Automation: 

  1. Appium is an open source and free tool available for testers and developers. 
  1. Appium supports both real device and emulators/simulators testing.
  1. Appium is compatible with popular testing frameworks and tools, making it easy to integrate into existing testing workflows and environments.

Advantages of using real device for Android App Automation: 

  1. Real device allows you to check your application under different network like 2G,3G,4G and 5G.
  1. Using real device we can test hardware specific features like GPS, fingerprint and camera.
  1. Using a real device provides more accuracy by taking some factors into consideration like device battery, processor, memory and device size. 

Step→1 

Install Java Development Kit (JDK): 

  • Set JAVA_HOME as environment variable.
Step-1-1-Image Android App Testing
  • Also add jdk’s bin folder path in Path environment variable.
Step-1-2-Image Android app

Step→2 

Install Android Studio: 

  • After successful installation now we will set the ANDROID_HOME environment variable.
Step-2-1-Image
  • Also put platform tools path in path variable.
Step-2-2-Image automation
  • Now open cmd and run adb  in command line and it should get executed successfully. 
Step-2-3-Image

Step→3 

Install Node.js: 

  • If you haven’t already installed Node.js, you can download and install it from the official Node.js website. 
  • Once the installation is complete check node version using command node -v also npm -v.

Step→4 

Install Appium for real device testing using command npm install -g appium in command line:

  • Verify appium version using appium -v  in command line.
  • Now run the command appium  in command line using this command your server should start and we are ready to do testing.
Step-4-1-Image Android app automation

Step→5

Install Appium for real device testing using command npm install -g appium in command line:

  • Now run appium-doctor  in command line to check weather every dependency required for appium has been installed successfully.
Step-5-1-Image Android app automation

Step→6 

Now we need to install UIAutomator driver which allows to interact with the UI elements of Android apps during automated testing. It provides improved stability and performance compared to the original UIAutomator driver. To install it use this command appium driver install uiautomator2  in command line.

Step→7 

Now for real device testing we also need to make some changes on device side too so we need to enable  developer option for this:

  • Open setting and click on about phone.
Stedp-7-1-Image
  • Click on software information.
  • Click on Build number 5 times to enable developer mode.
Step-7-2-Image
  • Now once this option is enabled we need to enable usb debugging option as well.
Step-7-3-Image Android App Automation

Note: Above information to enable the developer mode its for SAMSUNG device it will be different for other device type.

What is Appium Inspector in Android App Testing?

Appium inspector is a tool which provides testers with a graphical user interface  for inspecting and interacting with elements within mobile applications.

Step→8 

Install appium inspector for windows using below link  appium inspector.

Step→9

Start the appium session using command appium -a 127.0.0.1 -p 4723

Step-9-1-Image
  • Alternatively we can use appium GUI  Appium GUI to start the server 

i. Enter the host as 127.0.0.1 

ii. Enter port number as 4723

Step-9-2-Image Android

iii. If you are using Appium GUI for start server.we need to also add remote path for Appium inspector

Step-9-3-Image

Step→10

Open the appium inspector enter remote host as 127.0.0.1 and port as 4723.

Step-10-1-Image

Configuring Desired Capabilities using Appium for Android App Automation: 

When setting up automation with Appium for Android devices, it’s crucial to define the desired capabilities appropriately. These capabilities act as parameters that instruct Appium on how to interact with the device and the application under test. 

deviceName: This parameter specifies the name of the device being used for testing. It’s essential to provide an accurate device name to ensure that Appium connects to the correct device. 

udid: The Unique Device Identifier (UDID) uniquely identifies the device among all others. Appium uses this identifier to target the specific device for automation. Make sure to input the correct UDID of the device you intend to automate. 

platformName: Here, the platform name is set to “Android,” indicating that the automation is targeted towards the Android platform. 

platformVersion: This parameter denotes the version of the Android platform installed on the device. 

automationName: Appium supports multiple automation frameworks, and here, “UiAutomator2” is specified as the automation name. UiAutomator2 is a widely used automation framework for testing Android apps. 

appPackage: The app package is the unique identifier for the application under test. It’s essential for Appium to know which app to launch and interact with during automation.  

appActivity: This parameter specifies the main activity of the application that needs to be launched. 

  • For device udid run adb device command  in command line 
  • For device name and version we can check software information from android settings 
  • For application package and appActivity we can download Apk Info application from play store 
appActivity-1 Android App
  • For application bundle Id and App activity  
appActivity-2
appActivity-3

Step→11

Once you enter the remote host and port number enter below capabilities to open calculator application from your android devic for android testing.

The images below illustrate how I started the Appium server using the Appium GUI and successfully opened the Calculator app in Appium Inspector with the specified capabilities and now it’s ready to inspect your app to prepare for automated testing efficiently. 

Step-11-1-Image app automation
Step-11-2-Image Android app automation

Conclusion:

Setting up Appium for testing on real Android devices can initially seem daunting due to the numerous steps involved and the technical nuances of configuring software and environment variables. However, by following this step-by-step guide, the process becomes manageable and straightforward.  

Investing the time and effort to configure Appium correctly pays off by significantly enhancing the efficiency and effectiveness of your mobile testing strategy. This setup not only improves the

Click here for more blogs of software testing and test automation.

Software Testing Skills: Balancing Technical and Soft Skills

Software Testing Skills: Balancing Technical and Soft Skills

After spending years in the software testing field, many SDETs/Test Engineers showcase strong technical abilities and hard work. However, despite their skill and effort, some may find themselves feeling undervalued, lacking the recognition and success they had hoped for, highlighting the importance of software testing skills.

Conversely, there are also SDETs/Test Engineers who possess solid technical knowledge and have rapidly gained recognition for their contributions, resulting in significant career advancement. What do you believe sets them apart? Could it be luck, connections, a positive reputation with seniors, or another factor?

Indeed, a crucial distinction lies between the two categories. Individuals in the first group solely emphasize technical skills and hard work, while those in the second group strike a balance between technical expertise and soft skills, allowing them to work smartly.

But what exactly are these soft skills, and why are they pivotal for career growth?

Absolutely, Technical skills are undoubtedly paramount as they form the solid foundation upon which one’s expertise is built. Without acquiring strong technical skills, initiating or sustaining a career in the long run can prove to be quite challenging.

However, it’s essential to recognize that these technical skills must be complemented by Soft skills to maximize outcomes and achieve goals within optimized timelines. Just like hand in hand, the synergy between Technical and Soft skills fosters excellence in work and facilitates goal attainment.

By now, it’s evident that Soft Skills hold immense significance not only in the software testing field but also across various other domains. Despite their importance, these skills are often overlooked amidst work pressure, tight deadlines, and a focus on problem-solving or achieving test results.

Let’s delve into some of the most common Soft skills, well-known to everyone, yet frequently neglected in practice.

Here are the most common soft skills for software testing professionals:

Common Soft Skills for a Software Testing Career

Let’s dive deeper into each of these skills to understand their significance and how they contribute to success in the software testing field.

It is a foundational skill in software testing that contributes to the accuracy, reliability, and overall quality of software products. Testers who possess this skill play a crucial role in ensuring that software meets quality standards, satisfies user requirements, and delivers a positive user experience.

software testing soft skills

Benefits :

  • Effective Bug Identification: Testers who pay close attention can find even small issues in the software, helping developers fix them faster.
  • Ensuring Quality: Attention to detail ensures that all parts of the software meet the required standards by carefully reviewing documents and test cases.
  • Improving User Experience: Testers focus on making sure the software is easy to use and error-free, which makes users happier and more likely to keep using the product.
  • Identifying Risks Early: By carefully examining requirements and designs, testers can catch potential problems before they become serious issues, saving time and money.
  • Building Trust: Thorough testing builds trust in the software among clients and users, showing that it’s reliable and high-quality.
  • Encouraging Improvement: Testers who pay attention to detail help their teams get better over time by learning from mistakes and finding ways to improve their processes.

2. Proactive communication:

In software testing proactive communication involves initiating and maintaining effective communication within the team and with Developers, Clients, and Stakeholders, throughout the testing process.

software testing soft skills

Benefits :

  • Improved Team Collaboration: Proactive communication fosters better collaboration among team members, ensuring everyone is on the same page regarding project goals, tasks, and timelines.
  • Early Issue Identification: By sharing updates and insights regularly, team members can quickly identify potential issues or roadblocks in the testing process, allowing for timely resolution.
  • Enhanced Problem-Solving: Proactive communication encourages team members to openly discuss challenges and brainstorm solutions, leading to more effective problem-solving and faster resolution of issues.
  • Increased Efficiency: Clear and proactive communication helps streamline workflows and eliminate misunderstandings, reducing the likelihood of rework or delays in the testing process.
  • Effective Task Coordination: By communicating task assignments, dependencies, and priorities proactively, team members can coordinate their efforts more efficiently, ensuring that testing activities progress smoothly.
  • Boosted Morale: Open and transparent communication creates a positive work environment where team members feel valued and supported, leading to higher morale and job satisfaction.
  • Continuous Improvement: Proactive communication encourages feedback and discussion about testing processes and practices, enabling the team to identify areas for improvement and implement changes to enhance overall efficiency and effectiveness.

3. Good data organizing and presentation skills :

It involves the ability to effectively structure, format, and present data in a clear, concise, and meaningful manner.

software testing skills

Benefits :

  • Clarity in Reporting: Testers often need to compile and present data regarding test results, defects, and overall testing progress. Strong data organizing skills ensure that information is presented clearly and concisely, making it easier for clients/stakeholders to understand and interpret.
  • Effective Communication: Well-organized data facilitates effective communication with developers, project managers, and other stakeholders. Testers can convey testing findings and insights more effectively, leading to quicker decision-making and problem-resolution.
  • Identifying Patterns and Trends: By organizing data systematically, testers can identify patterns, trends, and correlations in software behavior or defect occurrences. This enables them to make more informed decisions about where to focus testing efforts and how to prioritize issues for resolution.
  • Facilitating Root Cause Analysis: When defects or issues arise, well-organized data allows testers to conduct thorough root cause analysis. They can trace the origins of problems more efficiently, leading to more accurate diagnoses and more effective solutions.
  • Enhancing Documentation: Good data organizing skills contribute to the creation of comprehensive and well-structured test documentation. Test plans, test cases, and test reports are more informative and useful when data is organized logically and presented in a clear format.
  • Demonstrating Value: Effective data presentation showcases the value of testing efforts to stakeholders. By presenting data in a compelling and visually appealing manner, testers can demonstrate the impact of their work on software quality, project success, and overall business objectives.

4. Time management :

In the software testing profession time management involves efficiently allocating and prioritizing time to complete testing tasks, meet deadlines, and ensure the timely delivery of high-quality software. Here are the benefits of effective time management in software testing

Time Management

Benefits :

  • Meeting Deadlines: Proper time management allows testers to schedule and prioritize tasks effectively, ensuring that testing activities are completed on time and within project deadlines.
  • Optimizing Resource Allocation: By managing time efficiently, testers can allocate resources, such as human resources and testing tools, in a way that maximizes productivity and minimizes waste.
  • Enhancing Testing Coverage: With good time management, testers can allocate sufficient time to different testing activities, including test planning, execution, and defect resolution, ensuring comprehensive testing coverage and thorough validation of the software.
  • Improving Test Quality: Properly managing time allows testers to dedicate adequate time to each testing activity, reducing the likelihood of rushing through tests or skipping important steps. This results in higher-quality testing outcomes and more reliable software.
  • Identifying Risks Early: Time management enables testers to allocate time for risk assessment and mitigation activities, such as identifying potential risks, creating contingency plans, and conducting risk-based testing. Early identification of risks helps prevent issues from escalating and ensures smoother project execution.

5. Critical Thinking while Planning Tasks:

It plays a crucial role in planning tasks in the software testing profession.

Critical Thinking while Planning Tasks

Benefits :

  • Identification of Test Objectives: Critical thinking helps testers analyze project requirements and objectives thoroughly, ensuring that testing activities are aligned with the goals of the project. This ensures that testing efforts are focused on verifying the functionality, performance, and quality attributes that are most critical to the project’s success.
  • Effective Test Strategy Development: Critical thinking enables testers to evaluate different testing approaches and methodologies critically, selecting the most appropriate strategy for the given project context. This ensures that testing efforts are efficient, cost-effective, and capable of uncovering potential defects and issues effectively.
  • Optimized Test Coverage: Critical thinking allows testers to analyze the software under test critically, identifying key areas and functionalities that require testing priority. By prioritizing testing efforts based on criticality and risk, testers can optimize test coverage and ensure that testing resources are allocated effectively.
  • Risk Assessment and Mitigation: Critical thinking helps testers assess potential risks and vulnerabilities in the software accurately. By critically analyzing project requirements, dependencies, and constraints, testers can identify and prioritize risks, allowing them to develop targeted risk mitigation strategies and allocate testing resources accordingly.
  • Identification of Test Scenarios: Critical thinking enables testers to identify and define test scenarios comprehensively. They consider various factors such as user workflows, boundary conditions, error handling, and performance requirements. This ensures that testing coverage is thorough. Critical scenarios are adequately tested as a result.
  • Adaptability to Changes: Critical thinking equips testers with the ability to adapt and adjust testing plans dynamically. They respond to changing project requirements, priorities, or constraints. Testers critically evaluate the impact of changes on testing objectives and strategies. They make informed decisions and adjust testing plans accordingly. This ensures continued alignment with project goals.

6. Adaptability :

In the software testing profession, adaptability in software testing skills is crucial. Testers need to respond effectively to changes. These changes can include project requirements, priorities, technologies, or constraints.

Adaptability

Benefits :

  • Flexibility in Test Planning: Testers can adapt their testing strategies and plans to accommodate changes in project scope, timelines, or priorities. This ensures that testing efforts remain aligned with evolving project needs and objectives.
  • Quick Response to Changes: Adaptability allows testers to respond quickly to changes in software requirements, design, or functionality. They can adjust test cases, test scripts, and test data as needed. This ensures comprehensive coverage of new features or modifications.
  • Efficient Resource Allocation: Testers can adaptively allocate testing resources, such as persons, tools etc based on changing project demands. This ensures that resources are utilized efficiently and effectively to support testing activities.
  • Effective Risk Management: Adaptability enables testers to identify and respond proactively to emerging risks or challenges in the testing process. They can adjust testing priorities, focus areas, or methodologies to mitigate risks and ensure they adequately address critical areas.
  • Enhanced Problem-Solving: Adaptability fosters a problem-solving mindset among testers, enabling them to overcome obstacles or challenges encountered during testing. They can explore alternative approaches, techniques, or tools to address complex testing scenarios effectively.
  • Continuous Improvement: Adaptability promotes a culture of continuous improvement within testing teams. Testers actively seek feedback, reflect on past experiences, and implement changes to enhance testing processes and practices over time.
  • Customer Satisfaction: Adaptable testers respond to feedback from end-users or clients. They incorporate preferences or requirements into the testing process. This leads to higher levels of customer satisfaction. It ensures that the software meets user needs effectively.

7. Empathy and customer-centric approach :

In the software testing profession, an empathy and customer-centric approach involves considering the perspective, needs, and experiences of end-users throughout the testing process.

Empathy and customer-centric approach

Benefits :

  • Improved User Satisfaction: Testers can ensure that the software meets users’ needs effectively. This is done by understanding their perspective and requirements. It leads to higher levels of user satisfaction.
  • Enhanced Usability: Taking an empathetic approach helps testers identify usability issues early in the testing process. This allows for improvements that result in a more user-friendly software interface.
  • Better Bug Detection: Testers who empathize with users are more likely to anticipate how they will interact with the software. This leads to better identification of potential bugs or defects. These issues could affect user experience.
  • Enhanced Brand Loyalty: Users develop a sense of loyalty to the brand when they feel that the software understands and addresses their needs. They are more likely to stay committed and engaged. This loyalty often leads to repeat business and positive word-of-mouth referrals.
  • Alignment with Business Goals: An approach centered around the customer ensures that software testing efforts align with broader business goals. These goals may include increasing revenue, improving market share, or enhancing customer satisfaction.

Conclusion:

In conclusion, software testing skills encompass expertise in various testing methodologies. Technical skills equip you with the knowledge to execute these methodologies effectively. Soft skills complement your efforts by meticulously organizing details in a presentable manner. They also enhance your flexibility and adaptability to navigate dynamic changes in client requirements. This ensures the delivery of a product that meets the end user’s expectations. Therefore, achieving a perfect balance between technical and soft skills is pivotal for recognition and advancement in your career.

Click Here to read more blogs for Software Testing Tips and Practices.

Automate TOTP 2-Factor Authentication (2FA) with Playwright

Automate TOTP 2-Factor Authentication (2FA) with Playwright

Understanding 2FA Authenticator Apps and Time-based One-Time Passwords (TOTP)

2FA Login using TOTP: In an era where cybersecurity is paramount, two-factor authentication (2FA) has become a cornerstone of online security. Authenticator apps and Time-based One-Time Passwords (TOTP) offer an additional layer of protection beyond traditional password-based security measures. This guide aims to elucidate the concept of 2FA authenticator apps, delve into the workings of TOTP, and provide insights into their importance in digital security. 

2FA Authentication Image

What are 2FA Authenticator Apps?

Authenticator apps generate time-based one-time passwords (TOTPs) on mobile devices for authentication. They serve as a secure means of implementing 2FA, requiring users to provide both something they know (their password) and something they have (their mobile device with the authenticator app installed). 

How Do 2FA Authenticator Apps Work? 

How 2FA Authentication works
  1. Initialization: When setting up 2FA for an online account, users typically scan a QR code or manually enter a secret key provided by the service into their authenticator app. 
  1. Code Generation: Once initialized, the authenticator app generates TOTPs based on a shared secret key and the current time. These TOTPs are typically six-digit codes that change every 30 seconds. 
  1. Authentication: During login, users enter the current TOTP from their authenticator app along with their password. The service verifies the entered TOTP against the expected value based on the shared secret key. 

Time-based One-Time Passwords (TOTP): 

TOTP generates short-lived authentication codes using a shared secret key and the current time. The algorithm combines the secret key with the current time interval to produce a unique, one-time password that is valid only for a brief period, typically 30 seconds. TOTP ensures that even if an attacker intercepts a generated code, it quickly becomes obsolete, enhancing security. 

Importance of Authenticator Apps and TOTP: 

  1. Enhanced Security: Authenticator apps provide an additional layer of security beyond passwords, significantly reducing the risk of unauthorized access to online accounts. 
  1. Protection Against Phishing: Because TOTP codes generate locally on your device and change with time, they resist phishing attacks that aim at stealing static passwords.
  1. Convenience: Authenticator apps offer a convenient and user-friendly method of implementing 2FA, eliminating the need to rely on SMS-based authentication methods that may be vulnerable to SIM swapping attacks. 

Authenticator apps and Time-based One-Time Passwords (TOTP) play a crucial role in safeguarding online accounts against unauthorized access and cyber threats. By incorporating 2FA with authenticator apps into their security protocols, individuals and organizations can significantly enhance their digital security posture in an increasingly interconnected world. 

Now we need to set up the Authenticator App: 

Setup 2FA authenticator app 

Use a phone app like 1Password, Authy, LastPass Authenticator, or Microsoft Authenticator, etc. to get 2FA codes when prompted during sign-in.

Scan the QR code. 

Use an authenticator app from your phone to scan. If you are unable to scan, enter this text code instead.

The displayed QR code encodes the following information: 

otpauth://totp/<DOMAIN>/issuer:<USERNAME>?secret=<SECRET>

This encoded URL includes: 

  • The protocol (otpauth) signals that an authenticator app should open this URL (DOMAIN).
  • the type (totp) 
  • a label (USERNAME) that is a colon-separated combination of issuer and username 
  • a secret (SECRET) 
  • the issuer 

The key element for logging in and automating the TOTP process is the supplied secret. 

However, what’s the utilization method for this secret? 

When you scan the QR code with an authenticator app, it combines the secret with the current time to create a unique password. The app then stores the second-factor secret, shows the issuer and username, and generates a new passcode every 30 seconds (though this time frame can be changed).That’s the gist of it! 

You can then employ the passcode as a secondary login factor, providing assurance to services that it is indeed you are accessing your account. 

Automating Login with Playwright for 2FA-Secured Websites

Automating the login process for websites secured with two-factor authentication (2FA) can streamline testing and administrative tasks. Playwright, a powerful automation library, provides the tools necessary to automate interactions with web pages, including those requiring 2FA. 

Prerequisites: 

  1. Install Node.js: Make sure Node.js is installed on your system. You can download it from nodejs.org
  1. Set Up Playwright: Install Playwright using npm, the Node.js package manager, by running the following command in your terminal: 

Steps to Automate Login with Playwright: 

  • Launch a Browser Instance:
  • Navigate to the Login Page:
  • Enter Username and Password:
  • Click on the Login Button:
  • Handle 2FA Authentication:

Playwright supports interacting with elements on the page to handle 2FA. You can wait for the 2FA input field to appear and then fill it with the code. 

The new OTPAuth.TOTP() syntax indicates that an instance of the TOTP class from the OTPAuth library is being created.  

This instance is configured with various parameters such as issuer, label, algorithm, digits, period, and secret, which are used to generate and validate one-time passwords for authentication purposes. 

In essence, new OTPAuth.TOTP() initializes a new TOTP (Time-based One-Time Password) object, allowing the application to generate OTPs for user authentication. 

  • Fill and Submit the 2FA code:

 totp.generate() is a method call on the totp object. This method is provided by the OTPAuth library and is used to generate a one-time password (OTP) based on the TOTP algorithm. 

The generate() method computes the current OTP value based on the TOTP parameters configured earlier, such as the secret key, time period, and algorithm. This OTP is typically used for user authentication purposes. 

Once token holds the generated OTP, it can be used in the subsequent lines of code for filling an authentication code input field and submitting it for authentication. 

Here’s the final code.

Conclusion:

Automating login for 2FA-secured websites using Playwright can enhance efficiency and productivity in various scenarios, from testing to administrative tasks. By following the steps outlined above, you can create robust automation scripts tailored to your specific requirements. 
https://github.com/apurvakolse/playwright-typescript-totp

Feel free to customize and expand upon these steps to suit your needs and the specific requirements of the website you’re working with. 

Disclaimer: Ensure that you have the necessary permissions to automate interactions with websites, and use this knowledge responsibly and ethically. 

Click Here to read more blogs for Software Testing Tips and Practices.

Creating Executable Jar File to execute Cucumber Scenarios

Creating Executable Jar File to execute Cucumber Scenarios

 In this blog, I’m going to share with you how to create executable Jar File for automation framework designed with Cucumber, Java, Selenium and Maven.

What is the executable jar file? 

The executable jar file to execute Cucumber Scenarios includes all build structures files of the framework along with packages, and dependencies. That works as an execution of the test cases.

Why so we need a jar file?

We have a framework that contains numerous test cases.Instead of giving you the code, we’ll give you a tool that can run these tests and make reports customized for different needs like quick checks and in-depth checks. Sometimes, the client doesn’t want to see or understand how the framework works. They simply want the final reports like Allure, HTML, or PDF reports which help them assess the quality of the product. The client doesn’t require an IDE like IntelliJ or Eclipse, for instance. They just need a user interface where they can click a button to generate the reports. This approach helps reduce their complexity. In such scenarios, we need a JAR file. This JAR file facilitates the triggering of test cases according to specific Cucumber tags and generates the necessary reports.

Technology used for this project (Executable jar file)

In the software testing world, the commonly used tool is selenium. Most of the creators used this stable and compatible tool for Automation.

Technologies used for executable jar file
  • Selenium: The software testing community has had faith in Selenium since 2004, as it’s been a reliable tool for testing. Most of us are familiar with selenium. If you are a beginner, please check out here
  • Maven: The maven is a build management tool. Maven builds and manages Java-based projects. Maven provides an easy way to share the JARs across several projects. If you want to know more about Maven please check out here 
  • Java: We are using the programming language Java for this project.
  • Cucumber: Cucumber supports behavior-driven development as a tool.

Prerequisites for the project (Executable jar file)

The following tools might have been installed on your system to executable jar file.

  • Java: Please check, is jdk installed on your system? If you cannot find the Java version on your system, please check out here to install Java.
Java prerequisites
  • Maven:  Please check, is maven installed on your system? If you could not find the maven version on your system, please check out here to install maven.
maven prerequisite
  • Cucumber: When you create the maven project, you need to add cucumber plugins in the project setting window. If you wish to explore the cucumber in detail, here is the link Link you can refer to.

Framework Overview of Bdd Cucumber project

 I am assuming you know the basic Bdd cucumber project architecture. For the creation of a jar, we need to modify the folder structure. Here I am highlighting the required files and key factors.

 Let’s see the framework folder structure.

Framework overview for executable jar file

When we created the new project for the executable jar file, we could see the simple folder structure provided by Maven. 

  1. SRC Folder: The SRC folder is the parent folder of a project that will include the main and test folders. For the QA environment, normally we are using the test folder. The main folder is used for the development environment. The created jar contains all files inside the src folder. 
  2. Test Folder: Inside the test folder, Java and resources folders are available. 
  3. Java Folder: This folder contains the Java classes where the actual code is present.
  4. Resources Folder: The Resources folder contains the resources file, test data file, and document files.
  5. Pom.xml: In this file, we are managing the dependencies and plugins that are required for automation.

Structure of the Test Folder

 The test folder design is the base of the executable jar file creation for the cucumber framework. Inside the java folder, we have to create a directory (org.BDD). In this directory, we need to create a subdirectory on the basis of code design Let’s see the subdirectory

Structure of test folder for executable jar file

1. Core

The core folder contains a subfolder. In the core folder, we set the standard code like… 

  • Hooks: This Java class contains the basic before and after functions. These functions are set for the browser initialization and termination. Also, we can set the before and after methods, steps, and scenarios as per project requirements.
  • Main: While executing Java programs, by default, the JDK calls the Main functions. For the execution of a jar, we need the java command, hence we need to define the main class in our framework.
  • TestContext: The TestContext Java class is used to define instances of classes and declare global variables. Here, Java classes extend the TestContext class and inherit the properties and values of the content.
  • TestRunner: The Java class contains the @CucumberOptions properties. In the TestRunner class, we define the glue between the step definitions and feature files. In the case of BDD, this TestRunner class plays an important role.

2. Steps:

 The Steps folder contains the Java classes for step definitions. In this folder, we need to specify the path in the glue option of the @CucumberOptions annotation so that the feature files can detect the step definitions during execution. If the glue is not properly mentioned, an ‘undefined step’ error will occur. 

    Inside the Steps folder, each Java class contains the implementations of the steps as defined in the feature files.

3. Pages:

      The Pages folder contains the page classes that house the actual code. The page functions are called in the step class.

4. Utilities:

      The Utilities folder contains utilities to reduce the repetition of code. It includes the WebUtil class, which contains functions for browser initialization and termination. 

5. Resources:

Normally, this folder is used to store resources such as test data, properties, and configuration files. In this case, we need to declare the feature files inside the resources folder because the created target folder contains a non-editable feature folder. This setup ensures that feature files are correctly packaged and accessible during the build process.

  • Features: Features contain the feature files. We need to provide the path of this folder in glue. Here we provide the path “classpath:Features”  beecause, the jar does not contain the absolute path.
    @cucumberOptions(features = “classpath:Features”, glue = {“org.CSDD”})
    In the feature file, we use the Gherkin language to write test cases.
  • Cucumber.properties: This properties file is used to set the Cucumber configuration. Normally during the execution, this file is detected by Cucumber automatically and the configuration is implemented. The same configuration can be set in the TestRunner class. In the case of CI/CD execution or jar execution, the priority goes to the cucumber.properties file rather than the TestRunner class. Hence, we need to implement the same configuration in both the TestRunner class and the cucumber.properties file.
  • Manifest file: This file is the most important file for executing the jar file. The manifest file by default houses the META-INF folder. This file contains information about the files packaged in a JAR file. This manifest file specifies the Main class and the jar packages that are available in the External Libraries folder. The purpose of having a manifest file is to specify the main class, which is easily detected by the JAR during execution. Without a manifest file, the JAR cannot identify the main class; hence, the JDK is confused about selecting the execution entry point.

How to add Manifest file in project folder structure

For adding the manifest file to your project, there are two ways.

Add the manifest file from the project settings.

  • Assuming you are using the IntelliJ IDEA editor, follow the procedure below:
  • Click on the File menu and select Project Settings.
  • Click on the file menu and select the project setting
  • Select the artifacts from the project structure screen
  • Click on ‘+’ icon, select the jar option -> form module with dependencies  
  • Select the main class ->  select the checkbox of ‘copy to the output directory and link via manifest’ -> enter the directory for META-INF/MANIFEST.MF as ‘project directory + src\test\resources’
  • Click on the Apply button and the OK button
  • You can see the manifest file stored in your resources folder.

Add the manifest file with the org.apache.maven.plugins

Here, we need to add the Maven plugin to the pom.xml file. In this plugin, we need to mention the path where the manifest file is stored and the Main class package.

6. POM.xml File

Maven has the pom.xml file that contains information about the project and configuration details. It contains the default architecture for most projects.

Project dependencies configuration is specified in the pom.xml file as per requirement. We have added the plugins provided by Maven as per our project needs and configuration.

Let’s see some required plugins for jar creation.

  • Maven-jar-plugin: This plugin provides the capability to build the jar. It helps to create a jar for test classes of the project. In this plugin, we need to mention the manifest file path that will decide the main class of the jar file. We can check the latest version of this plugin on the Maven repository. In case, you are having a problem setting the plugin, you can go with the maven-jar-plugin dependencies. 
  • Maven-dependency-plugin: When we create the jar, we will see it in the target folder. The jar file contains the manifest file and packages inside the jar directory or target folder. Hence, this plugin comes into the picture. The plugin copies all dependencies or packages from the pom.xml file and stores them in the jar directory folder (target folder). During execution, the jar requires these dependencies/packages/jars.
  • Maven-resources-plugin: The resources folder contains the test data, properties, and document files. Without this plugin, when we create the jar, the jar doesn’t contain the files from the resources folder. In case we need to provide these files externally to the jar. So, to avoid this painful process, we can use this plugin. This plugin works by copying all files from the resource folder into the jar files. After the creation of the jar file, we can check the availability of this file in the command prompt with this command: “Jar tf file.jar”

How to create the jar

As you have followed the above process and configuration, we can proceed with jar creation. We can create the jar in two ways.

  • Create a jar with the help of the command: ‘mvn package’

In your project directory, open the terminal. Maven has a command to create a jar, which is ‘mvn package’. When you execute this command, it starts the process of creating the JAR and runs your test cases. After the completion of this process, you will find the jar file in the target folder.

  • Create the jar file with maven lifecycle steps

In your IntelliJ IDEA, there is an E-Maven tab. This tab includes the Lifecycle sub-tab.

Follow this process:

Clicks on the lifecycle tab and follow below diagram.

Process to create a jar

Execution of jar file

Once you successfully create the JAR along with the dependencies in the target folder, you can use some commands related to the JAR file.

  • Check the directories in jar file

    To check the directories included in a jar file, you can use the command ‘jar tf filename.jar’.  This command will list all the files and directories contained within the jar file.

Output:

directory of jar file
  • Run the jar file

 Normally, when we run a jar file, the jar file starts with the main class. Whatever configurations the main class includes, those files will execute. The command to run a jar file is: Java jar jarFileName.jar

Output:

  • Run the specific test case from jar

 Normally, we execute the smoke or regression test cases. We differentiate the test cases by tag name. In this project, we have two scenarios with the tags “@addsub” and “@muldiv.”

  Based on the tags, we can select the test cases for execution. Open the terminal and change the directory to the target folder. The command for execution is as follows:   java -cp jarFileName.jar io.cucumber.core.Main featurefileName –tags “@tagname”

Example
java -cp CalculatorBDD-1.0-SNAPSHOT-tests.jar io.cucumber.core.cli.Main Features/Calculator.feature –tags “@smoke”
java -cp CalculatorBDD-1.0-SNAPSHOT-tests.jar io.cucumber.core.cli.Main Features/Calculator.feature –tags “@regression”

Output:

Specific test case from  jar file

Conclusion:

The creation of a jar file for a Cucumber Maven framework, as described, represents a strategic approach that offers flexibility in executing test cases directly from the jar file. This JAR file helps minimize issues related to redundant code and ensures stable and customized execution.

In conclusion, creating a jar with Selenium, Java, and BDD using Cucumber helps deliver high-quality software. By following best practices like designing a robust framework architecture, leveraging Maven plugins, and configuring the cucumber.properties file, we can generate an executable JAR file for effective automation testing.This enhances the stability of the test cases and reduces the failure rate.

Source Code:

Wish to take a look at the source code? You can attain a clearer and more straightforward understanding by visiting the repository at the following URL, where you’ll find a comprehensive guide that outlines the steps to follow.
https://github.com/spurqlabs/JAR-File-Creation-

Click here to read a more blogs to increase your software testing skills.