by admin | Feb 18, 2020 | Selenium Testing, Fixed, Blog |
This blog is mainly about discussing Selenium Automation challenges that we come across at our Rota. When we say challenges, though it’s an impediment still it gives the opportunity to explore and that way we get introduced to many things
Basis the experience, we would like to half split this into two categories.
1) Anticipated challenges
2) Un-anticipated challenges
Anticipated Challenges
We always reckon that the things that we are discussing here are not really challenges or some impediment that blocks us from proceeding. These should be considered as tasks that have to be performed by adding some additional coding actions or by integrating an additional concept to the selenium scripts.
1. Improper waits
2. Weak locator selection
3. File uploads
4. Send keys operation in IE
5. Browser zoom settings in IE
6. Zone mismatches setting in IE
7. Windows authentication pop-up during URL launch
8. Seldom windows interactions
9. Sweet alert handles
10. Dynamic data expectation by application
11. Taking snap during alert presence
12. Launching Browser with options
Let’s see one after another to know, what each one is about
Improper waits
Basically when we are working with a web application through a browser we tend to see lot of synchronization problems, that mean there would be a significant problem in rendering the webpage that perhaps due to the poor and sluggish network provisions or at times the design of the webpage itself or sluggish server response i.e. not all the elements may not load at the same instance.
But by nature selenium’s swift is far high and try to interact with the element that it was instructed to do so and fails because the element isn’t loaded properly so far. How do you handle this risk?
The above one is potentially a technical problem, but we have better concepts to achieve that. Based on need and the suitability with proper understanding any of the below wait concept is used
Implicit wait – one mention at the start of the script would help the wait applicable for all the subsequent actions
Explicit wait– This is recommended only when we know that a particular element is expected to be delayed for presence. This wait is applicable to that one particular action, so that way we can ensure we are not waiting on other elements because of this
Fluent wait- This is an advanced explicit wait, it features the recurrence with which the wait has to be executed with the help of polling time.
Improper choice Locators
The only possible way to interact with web elements is by identifying the locators in DOM. If the selection of those is improper that leads to a great mess. A careful study of when to go for what locator is much needed. Here below are some examples of weak locators.
Improper Locators
Do not use Id attribute if at all it has a change of numbers/ if it’s generating dynamically.
Do not use the class name attribute if that has spaces in it.
While writing Xpath matches rather than going with start-with, end-with functions its always advisable to go with contains as its generic
File Uploads
On a few use cases, we might need to deal with uploading the file that’s available some other location also downloading the one from the browser page. Upon understood the task, the right choice of a decision whether or not a third party tool integration is needed to perform, or do we have any libraries that perform tasks for us. Talking to the right set of people or seeking suggestions from experienced peers would help us achieve the task, rather than just shouting out as a blocker.
Possible solutions:-
Observe the DOM attributes for the file path text box in the webpage if at all it is defined with a type parameter as “File”. We can directly send keys the file location (no need to click) that way we can upload file
On the other hand if the possibility one doesn’t work, we will have to integrate the AutoIT / VNC viewer script to upload the file
Using Robot class presented in java we can achieve the action as that helps to impersonate the mouse and keyboard actions
IE problems
Internet explorer being an inbuilt browser on a windows machine is certainly not as much friendly as the other native browsers such as Chrome, Firefox…Etc. the most commonly seen challenges and the way to fix are
Send keys operation: – This is a tedious task unless we knew that we have a workaround to use a 32-bit version of InternetExplorerDriver.exe file, otherwise it is relatively slow with IE.
Zoom Settings: – if at all zoom in is set to some higher value (perhaps 100). Element can’t be clicked as they are not inclined within the clickable window, just taking care of the setting would help us
Security Zones: – The IE browser might not get launched if at all the settings were not set to the same protected mode.
Windows Interaction
On a few occasions windows interaction is unavoidable, however, it’s a not very straight forwarded action still it’s mandatory to perform the action as it’s a business need. Considering them as challenge shout out is not desired, this again generates space for an individual to explore and integrate the other components. Following or some actions which are expected to be encountering.
Accessing the file that was downloaded
Impersonating the mouse and keyboard actions
Run a batch file that’s available in a specific path
Solution:- The possible solutions for any of the above solutions would be to use the Robot class present in java AWT package or to integrate the selenium code with any other external tools such as AutoIT/ VNC viewer or coded UI
Scrolling actions
At times the element that we are looking for may not be visible unless we scroll down to the webpage.
Solution
The possible solution would be through javascript executor which is an interface, help us getting the executeScript operation done through a driver.
The fact that the browser has a bit of implementation of javascript these actions were preferably done through javascript. We can pass the below arguments to the executeScript method to scroll in a browser window
Scroll by method- we can actually specify the location of the elements in terms of co-ordinates, then pass those parameters so that we will have window scrolled down until that place
ScrollTo- This is another offered method to scroll to a specific element, we locate the element to which we wanted to scroll to then pass that locator as a parameter
ScrollHeight- Despite the element location, if we want to scroll down to the bottom of the page, this method can be used
Windows Authentication pop-up
There are some applications that throw windows authentication popup after navigating to the URL, the pop up that comes is neither an alert nor belong the application to locate them in DOM.
Solutions
There are two possible solutions for this problem,
Pass the credentials in URL as http://username:[email protected]
On the other hand, using javascript executor would help, we can do a sendkeys operation within the executeScript method to achieve this
Sweet Alerts
Alert handling is one of the popular mechanism in selenium, I feel many out there wouldn’t even come across these kinds of alerts (Sweet). These would basically be displayed for a few seconds and disappear. The real challenge with these elements is about how to identify them in DOM.
Solution
In order to find the following procedure should be followed
Mouse hover on the sweet alert to make that pop out.
Freeze the DOM (shift+F8) when the element is present on UI, then the related attributes of the elements will be displayed to capture.
Dynamic data expectation by application
Web applications a day on day becoming more advanced, dynamic in order to enhance the user experience. The data that present on one row today may not present at the same place tomorrow also many fields do not accept the duplicate data. Given this advanced behavior, the static test data may not help. Generating the random numbers/ alphabets and appending to the actual value would help to avoid such problems.
Capturing snapshot during the alert present
Though we have take screenshots method also know of a procedure to capture the snap during each action, it is quite not possible with the case when we have an alert appeared on the window, in order to achieve this we should use the below coding snippet.
System.setProperty("webdriver.chrome.driver", "./drivers/chromedriver.exe");
ChromeDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://www.irctc.co.in/eticketing/forgotPassword.jsf");
driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
driver.findElementById("forgot_passwrd:checkDetails1").click();
Thread.sleep(1000);
// take snap
BufferedImage image = new Robot().createScreenCapture
(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));
ImageIO.write(image, "png", new File("./data/Alert.png"));
}
Challenges during browser launch
When we launch a browser to navigate to application URL, we might see the below problems
Notification or info bars, that makes the script to fail
Cache memory not cleared due to which can’t navigate to application home screen
Browser is not opening in maximized mode by default
At times we will have a requirement to open the browser to incognito tab
Solution:- For the above potential problems we have a solution by adding chrome options. we can also set the desired capabilities for any browser such as Mozilla, IE< safri..etc
ChromeOptions op = new ChromeOptions();
// op.setHeadless(true);
op.addArguments("--disable-notifications");
// To run in private mode
op.addArguments("--incognito");
// To start browser in full screen
op.addArguments("--start-fullscreen");
// To disable the yellow info bar
op.addArguments("--disable-infobars");
ChromeDriver driver = new ChromeDriver(op);
driver.get("https://www.google.co.in/");
System.out.println(driver.getTitle());
Un-anticipated challenges
These are a kind of unchecked exceptions which are truly due to the poor implementation. These can’t be expected due to the fact that we may not realize what it can cause until we come across, ideally, these should have been avoided with due diligence and thorough review of the project, but there will be an instance where people miss doing that. Given below were some examples of this category.
- Improper coding standards
- Least concerned about following framework standards
- Improper reporting mechanism
- Improper feasibility analysis
- No proper exception handling
- Improper VCS system existence
Improper coding standards
If the coding standards are not maintained properly within the framework it can lead to great problems. Below are a few things that could eat our cat.
Not using the best suitable data structure to perform data operations
Hard coding the data in a script
Not writing generic methods
The above problems were some high-level ones, which can increase the maintenance effort to our framework as redundant code needs to add, also it could cause significant delay to the script execution.
Least concerned about following framework standards
The purpose of the framework is to build a structure for the project as were to write what? and how? With a proper template structure built, all team members have a common understanding.
A couple of problems seen are,
Not defining the folder structure
Writing the common methods w/o following the interface document given
Adding the dependencies to the build path directly rather than fetching from the POM.xml/ build.gradle file
Improper reporting mechanism
Reports are an essential component to any test automation framework, based on reports the test case is mainly judged whether or not it’s a failed or passed one. It is mandatory to include the report test steps right after every validation to ensure we are capturing the action result to show it to the business stakeholders. Some common problems we may see in terms of report generation on a few frameworks are
No mention of the reported step after validation, ideally these steps are more advised to add it to the common functionalities written
Not mentioning the understandable description in the report, the problem with it is non-technical people may not decipher the results
Not calling the report generation method under right testing annotation rather than writing them at the end of whole test execution as that results in the generation of multiple reports
No meaning full name to the report, that gets generated.
Improper feasibility analysis
It is a fact that 100% automation testing is impossible, below should be taken into consideration whilst taking a decision
A careful study of the use case with the given scope is required to decide whether or not I can be automated.
Understanding the value that it adds by automating the test case is a must. Ideally, we should be able to identify which way can it be validated quickly
No proper exception handling
Exception handling is one important mechanism to understand the cause for the failure. If we fail to catch every exception that may be thrown by the test case during execution that leads to a problem of flakiness, the test will execute till that step and hard stops then when we verify the report we will have all steps passed, but unfortunately not the whole test case is being run. This is one big problem at a business level, so documenting every exception with the help of try with multiple catch blocks is needed. It is equally important to add an understandable description in the report fail step for easy triaging.
No VCS exists in the project
When we work as a team, having a VCS system (GIT, Bit bucket, SVN)in place is a must. Lack of this facilitation will cause problems as it can’t properly merge the changes done by the different team members. It’s not ideal to just copy the changes from one system to another system when we have a system that does this for us very accurately. This will also help us to keep everybody in the team with the latest code base details.
No Documentation
Seldom times we come across certain issues, the workaround would have found after a thorough follow up with different teams. We must realize that the articulating those learning would help the team to a great extent. Continuous retrospection and noting the workaround will service back the team and no need to spend efforts again when they re-occur. This also acts as a pure knowledge base for the team.
Eg: any certificate installation to the java keystores /trust store to hit the application, verifying the hostname, any inputs from the infra team during automation set up installation.
by admin | Feb 20, 2020 | Automation Testing, Fixed, Blog |
It is an Open-source UI based automation library to test your application which runs on Windows OS. It wraps almost all of the libraries used in the Microsoft UI Automation Test Library. We can use FlaUI libraries to automate win32, WinForms, WPF and Windows Store apps.
The below are the libraries provided by FlaUI, we will see the uses of those libraries against each one of them:
FlaUI.core – This Library will has base elements used in the concrete implementations of FlaUI.
FlaUI.UIA2 – This Library is used to automate win32 and winforms applications.
FlaUI.UIA3 – This Library is used to automate WPF and windows store apps.
Prerequisites: – You should have Visual Studio IDE installed in your machine.
Installation of FlaUI:
1. Create a New Project in Visual Studio
2. Right-click on the project and select “Manage NuGet Packages” (Using NuGet Package Manager)
3. Select the ‘Browse’ tab and Search for FlaUI, it will display the FlaUI libraries.
4. Install the below libraries from NuGet package manager
FLAui.core, Flaui.uia2, Flaui.uia3.
NOTE: The downloaded libraries are limited to the project, which means it is not available by default for all projects.
How to launch the application using FlaUI:
1) To start testing one should implement the static method “Launch” from the “Application” class which is available in FlaUI.Core library.
2) You should pass the application path (the application you installed in your machine and you want to automate) as a parameter to the Launch method as given in the below example.
Example:
var msApplication = Application.Launch(@"C:Program FilesMicrosoft OfficeOffice16WINWORD.EXE");
var automation = new UIA3Automation();
var mainWindow = msApplication.GetMainWindow(automation);
The above code tells you
1. How the launch method is implemented using the Application class, and how the application path is passed as a parameter (First Line).
2. In the second line, we are specifying the Automation Library Type (UIA3) used to automate the app.
3. The third line describes getting the main window instance from the application instance.
Searching an Element in the Application:
1) To find the element in the application, we need to specify the treeScope of the AutomationElement.
2) We can specify the AutomationElement by providing conditions like ConditionFactory, ControlType, and action to be performed as explained in the below example.
ConditionFactory cf = new ConditionFactory(new UIA3PropertyLibrary());
mainWindow.FindFirstDescendant(cf.ByName("Text Editor")).AsTextBox().Enter("FlaUI Tutorial");
Code Explanation:
1. The first line is creating the “ConditionFactory” instance, the “ConditionFactory” is the class from “FlaUI.Core”, “ConditionFactory” identifies the element based on the condition.
2. We are specifying the TreeScope {FindFirstDescendant()}, ConditionFactory{ByName()}, ControlType {AsTextBox()} and action {Enter()} of the automation element.
The above helps us to install FlaUI and run an application. We must know how to inspect an element using FLAUInspect. We need the Chocolatey package manager to install Flauinspect, we will see the step by step process of the implementation below.
1. Chocolatey is the package manager for windows. The Flauinspect is a package under the Chocolatey package manager. So it is mandatory to install Chocolatey to inspect the AutomationElement.
2. Go to https://chocolatey.org/install and follow the instructions to install Chocolatey.
3. After installing chocolatey, run this command “choco install flauinspect” in command prompt to install Flauinspect.
4. To launch Faluinspect, run this command “flauinspect”, it will open the Flauinspect application.
Working with Flauinspect:
There are three ways for inspecting an element
Open Flauinspect > go to “Mode” >
1. Hover Mode (Press ctrl and move your mouse pointer focus on the target element)
2. Focus Tracking ()
3. Show XPATH, (combine with any mode listed above) and it will show only the absolute XPath.
Capture Screenshot with FlaUI:
Flaui provide a “Capture” class for the screenshot
Capture.screen();
// It will capture the full screen
Capture.Element("That Element ");
//It will capture the specific element
Capture.Rectangle("Specify the height, width and length")
//It will capture the specific block you specified in the parameter.
We can store the screenshot in a file by using the below lines of code:
var image = Capture.Screen();
image.ApplyOverlays(new MouseOverlay(image.DesktopBounds));
image.ToFile(@"c:tempscreen.png");
NOTE: ToFile(“Your_Location”) method can be used to store the screenshot in a user-specified location.
Perform Mouse Action using FlaUI
The Flaui provides the Mouse Class with different methods as follows:
1. Mouse left click
Mouse.LeftClick();
// left click where the mouse pointer is currently pointed to.
2. Point
Point point = new Point(2435, 234 )
// This will provide the location of the mouse pointer (X-axis and Y-axis).
3. Middle Click
Mouse.Click(MouseButton.Middle, point);
4. MoveTo and MoveBy and Position
Mouse.MoveTo(point)
// Will position the mouse pointer to the New location
Mouse.MoveBy(point)
// it will take the current location and add the point specified in the method then drag the mouse to the location specified.
Mouse.Position(point)
// the traces of the mouse pointer are not displayed.
5. Scroll
Mouse.Scroll(10)
// positive value to scroll up ; Negative Value to scroll down
Mouse.HorizontalScroll(40);
Mouse.VerticalScroll(30);
Perform Keyboard Action using FlaUI
To perform any action the application via Keyboard, the FlaUI provides the Keyboard class with the following methods:
Keyboard.Type("Hello Flaui"); // for a string
Keyboard.Type(VirtualKeyShort.Key_B, VirtualKeyShort.Key_C);
Keyboard.Press(VirtualKeyShort.BACK) // backspace
//For Combinations of multiple keystrokes (To press a key and release a key)
Keyboard.Pressing(VirtualKeyShort.CONTROL);
Keyboard.Press(VirtualKeyShort.Key_A);
Keyboard.Release(VirtualKeyShort.CONTROL);
//Another Way for the combinations key
Keyboard.TypeSimultaneously(VirtualKeyShort.CONTROL,VirtualKeyShort.KEY_A);
NOTE: VirtualKeyShort is available in “FlaUI.Core.WindowsAPI” package
How to highlight the element in FlaUI:
Flaui provides the “DrawHighlight” method which will highlight the AutomationElement.
Automation_Element.DrawHighlight();
Thank you for reading the above article, we would love to hear your comments. Please write to us if you face any issue in using FlaUI, we are happy to help. Happy Testing!
Frequently Asked Questions
-
What is FlaUI?
FlaUI is an open-source .NET library based on the native UI automation libraries of Microsoft that can be used to automate UI-based testing of Windows applications such as win32, WinForms, WPF, and Windows Store apps.
-
Is FlaUI open source?
Yes, FlaUI is indeed an open-source UI-based automation library that can be used to perform Automated UI testing of Windows applications such as win32, WinForms, WPF, and Windows Store apps.
-
How do I install the FlaUI library?
1. Create a new project in Visual Studio.
2. Right-click on the project and select “Manage NuGet Packages”.
3. Select the ‘Browse’ tab and Search for FlaUI.
4. Install the FLAui.core, Flaui.uia2, Flaui.uia3 libraries.
by admin | Feb 21, 2020 | Software Testing, Fixed, Blog |
Continuous Testing is the method of providing feedback to the project stakeholders on quality of build through automated test execution as soon as the build is deployed with the help of QA tool stacks.
Since in the Traditional Software world, there is a waiting period of the development team to receive the feedback from the testing team post-deployment of code, which consecutively delayed the delivery. Continuous Testing came up with the approach of Test Quickly, Test Often and Test everything which helped to improve the code quality and quality of delivery by shortening the delivery cycle through the automated way.
By building the delivery pipeline where automated builds, test, and deployment are Orchestrated in one release workflow, there is seamless feedback on the each of the pipelines and based on the success of each of the pipeline process continues which helps to assess the quality of the release.
Why Continuous Testing (CT)?
It helps tightly connect Testing with Development and Operations team to ensure quicker time to market with better quality and saves cost
Instant feedback to developers and stakeholders on code quality and functional coverage to course-correct
Releasing with speed without quality is compromising Customer objective and hence CT should be plugged into CI and CD to deliver speed with quality to meet Client objective
Agile is shortening the release cycle with maximizing delivery throughput. 90% of delivery happens through Agile practices across Organization and hence DevOps (CI/CD/CT) is the key to meet this objective.
Key of Digital Transformation (which is swiftly happening in later 2018) for any customer is quality and the way to achieve with speed is through Continuous Testing
Popular Tool Stacks
Steps to achieve Continuous Testing:
Assess the number of Applications in-scope
Assess the Application category-UI (Web / Windows), API, Database, and The infrastructure needed for Application to be executed.
Criticality of Application
Number of Test cases / Application
Tooling Strategy
Validate and Assess CI / CD methodology
Framework Requirement Assessment for CI / CD Integration
Build Framework
Validate CT pipeline
Build sanity automation scripts
Integrate with CI / CD pipeline
Fine-tune framework and Test Automation approach
Start building Automation suites to achieve CI/CD/CT
Plan for N and N-1 Automation based on Organization goal
Assess the number of Applications in scope:
1) Before going to Continuous Testing, we need to assess the total number of Applications which need to be moved to CT pipeline needs to be assessed
2) This can be decided based on understanding the lifespan of Application, number of releases (major / minor / Fix release or Trivial) / year, stakeholder understanding and operational users type of this application
Assess the Application Category
1) Based on the number of Applications and its lifespan, understand the technology in which it is built with. Classify the Application type (UI, API, DB or any of 2 or 3 combinations)
2) Classify the Application based on the infrastructure as well. Some Application will work in Linux, some may support Windows as well as Linux etc. Also classify based on Mobile or other technology
Criticality of Application:
Below are the key factors that determine the criticality of Application:
Reputation damage if implemented wrongly or of any quality issue
Financial loss to company
Operational risk
Sensitive information leakage
Legal violation
Number of Test cases per Application
This is as good as understanding the size of Application
Regression Test cases created till date
We also need to categorize this based on UI, DB, API, etc
Tooling Strategy
Below are the pointers that will help to decide the tooling strategy
Organization policy
Organization support to Commercial tools / Open source tool
Organization willingness to invest in tools
Organization willingness to invest on tool training
Feasibility approach outcome / Application
Application classification and the tools support
Level of 3rd party customization involved from the development aspect
Tools support for CT (Integration support with other tools like Test Management, Reporting, Build Management, configuration management, etc)
Validate and assess CI / CD methodology
In order to achieve success in CT, Automation tool and CT requirement should meet the CI / CD requirement as well so that all 3 can communicate to each other successfully and deliver the desired result.
Example If the development team is working on Orchestration on a particular tool like Jenkins and if a Testing team is working on a tool which does not support Jenkins or which require additional effort to bring in this integration, then it is not advisable to use that tool for CT requirement. We should opt for a different tool which has ready-built support for Jenkins. Hence understanding CI / CD requirement beforehand is essential to reduce the effort from CT perspective in the later stage.
Framework Requirement Assessment for CI / CD Integration
Once tooling strategy is complete and CI / CD methodology also assessed, we can understand the Framework requirement to meet CT requirement.
Below are the additional feature expected in Framework for CT:
Re-usable libraries to support for multiple technologies and different object classification
Incorporation of BDD. BDD is a process where Business Analyst, Development team and Automation Testers come closer to work together to extend the functionality based on each release. Features are added by Business Analyst, The development team shares the wireframe + Object information to the Testing team and Automation team adds the code required to add this additional feature.
Connectivity with Test Management tool for reporting purposes. Good Automation framework should have automated Test set creation based on the build configuration, pull the scripts required for execution, execute them and update the result back in Test Management tool based on execution outcome.
Ability to report outcome based on where the trigger has been generated. Adhoc / Standalone execution or execution through CI or trigger from the Test Management tool
Define Dashboard requirement for Management and Key stakeholders
Build Framework
Based on the framework assessment and technologies, build a robust framework to meet the project requirements. It takes approximately 3-6 months to customize and build framework.
Validate CT pipeline
Post building the framework, validate CT pipeline is meeting the project requirement. Here we validate various touchpoints like how automated build definition works, whether Framework is able to integrate with Test Management tool and CI tools and dashboard result is working as expected.
Build Sanity Automation Scripts
Focus on automating sanity Test suites for each application which helps to detect the code stability to proceed for further Testing.
Integrate with CI / CD pipeline
Once the framework is built, Sanity scripts are developed and the CT pipeline is validated. It is time to integrate with the actual CI/ CD pipeline to evaluate CT process integration with CI/CD. Here again, validation is done to check whether Integrated portions provide detailed information to Management and key stake holders of the project.
Fine-tune framework and Test Automation approach
There might be a specific requirements from the project to project certain additional information to Management and that needs to be enhanced either in the framework level or in the CI/CD/CT definition and that needs to be worked out.
Start building Automation suites to achieve CI/CD/CT
Once the current sanity integration is done and tested, now is time to develop Automation scripts for Regression Test cases and develop different Automation suites based on need and integrate with CI/CD.
After adopting all these steps we have achieved CT goal for an Organization.
Plan for N and N-1 Automation based on Organization goal
Once base Regression suite is prepared, next activity would be to increase the coverage through N and N-1 Automation based on Organization requirement which would really bring in CT benefits.
Key Automation Metrics for Continuous Testing
Test Pass Percentage
Quality of Build
Automation Coverage for Sprint / Release
Requirement Coverage for Sprint / Release
Defect Resolution Time
Defect Rejection Ratio
Build success Rate
Application Crash Rate
Since in CT everything is Automated. The above metrics are also captured in an automated way in the dashboard to Management and Key stakeholders.
Schematic View
Key Factors that decide the success rate of Continuous Testing
Willingness of Management to undertake this digital strategy
Willingness of Management to invest time and money towards this initiative
Hiring right resource to perform this Transformation
Proper Analysis on Tool Strategy
Effort spent in Robust Framework creation
Training to key teams on Framework (Key to success is to have separate team for building framework and its customization with the delivery team focusing on building Automation suites)
Framework customization and Maintenance
Dedicated effort to track all these activity
Team should revisit their metrics for every quarter to see if that meets the project requirement and consider revising it to meet project goal
by admin | Jan 7, 2020 | Web Service Testing, Fixed, Blog |
We often get the following question – Which is a better web application automation testing tool Selenium/Protractor? whenever we demonstrate our automation testing capabilities to the clients. Tool selection should be based on the following key attributes, team’s skill-set, Documentation, Training, Online Communities, Programming Languages Support, Reporting, and Software Under Test (SUT) Technologies. In case of open-source test automation tools, you don’t get all the required features in a single package. However, if you go with a commercial tool, most of the required features come in handy in one software suite. In this blog article, we are listing all the web application tools which will help you during test automation tool selection process.
Selenium is an ideal choice for most of the companies for web application automation testing. Once Selenium is chosen, the next question is which programming language can be picked up for scripting. You can write Selenium automated scripts using Python, Java, Ruby, C#, and JavaScript. Choosing a programming language for Selenium scripting is a daunting task for many. However, we strongly recommend you to go with the same language in which your application or product is being developed. The reason is – most of the coding practices which are followed by your development team are applicable for automation testing as well and it enables whole team approach. Before selecting the programming language check whether your testers are comfortable with that programming language. Consider, if your development team is using JavaScript extensively and you are choosing it as scripting language, then your testers may not be interested with JavaScript. So check your testers’ comfort level before choosing a programming language for automation scripting.
Don’t get confused with Tool and Framework. Protractor is an end-to-end test framework for Angular and AngularJS applications. Advantages of Protractor:
- It is built on top of WebDriverJS. So Protractor adds Selenium’s new features whenever it is released.
- Selenium has ID, XPath, CSS, ClassName, LinkText and Name locators. If your SUT is an AngularJS application, then you can use additional locators like repeater, model and binding.
- Writing synchronization steps avoids false positives in automation testing. However, in Protractor, you no need to write sync steps. It waits for page load automatically.
- Protractor also supports BDD Frameworks like Cucumber, Jasmine, and Mocha.
If your development is using JavaScript extensively and SUT is an Angular Application, then Protractor is a good choice for web application automation. Note: you can also achieve all above list advantages in Selenium, if you have an expert automation testing team.
Cypress is an all in one test automation framework. It comes in four plans a free plan (Seed) and three commercial plans (Sprout, Tree, and Forest). What is unique about Cypress? For example: If you want to setup an automation testing framework using JavaScript, you may need Jasmine, WebDriverJS, ChaiJS, and other libraries. However, Cypress is not using Selenium and you need to install only Cypress in order to start writing test scripts. Since Cypress is a paid framework, it has some notable features like Parallelization, Grouping tests, and comprehensive test results. If you have a team which has limited knowledge in automation testing, then Cypress is a go-to automation testing framework.
Sahi Pro comes in three plans for Web, Desktop, and Mobile. You can run your automated tests on any browser. Sahi Pro waits automatically for AJAX and Page Loads. It has in-built object spy and recording options. Sahi has its own script language. You can also integrate your test scripts with continuous integration tools. It is an old and mature automation testing tool. While evaluating Cypress, you can try for Sahi Pro.
Katalon Studio is a test automation framework for Web Testing, API Testing, Mobile Testing and Desktop App Testing and it is built on top of Selenium and provides comprehensive test reporting. Katalon has in-built wrappers which perform Web UI actions. You can also write your own custom keyword using Groovy scripting. It has AI-Powered XPath location mechanism. If you have only manual testers and want to reap quick benefits from automation testing then go for Katalon Studio. Building a strong automation testing team may delay the benefits, however, it ensures the test automation success with any dependencies.
As a test automation services company, we use various automation testing tools. Tool selection is an important step before commencing automation test scripting. We hope this article gives some insights about some popular Web Application Automation Testing Tools. Contact us for your automation testing needs.
by admin | Jan 4, 2020 | Software Testing, Fixed, Blog |
The business of the telecom operators is an evolving landscape with data and non-voice services having surpassed voice services. Telecom companies therefore have the responsibility and must deliver top quality, innovative, and reliable services if they are to retain existing clients and attract new ones for the long term. A wide range of top quality mobile applications is part of the expectations that customers have from telecom companies as part of the evolving landscape. As a leading Software Testing Company our work within the telecom sector enables us to understand the challenges this sector faces with regard to the new trends and technologies. Augmented reality, the Internet of Things (IoT), virtual reality (VR), and many more are all technologies that customers expect, which forces telecom companies to restructure and readjust their traditional business strategies – posing a significant challenge for many operators.
The telecom industry is comprised of sections such as internet service providing, satellite and wireless communication, and more, but to gain and sustain a competitive edge each company must deliver customized and value added solutions to their customers. Innovative solutions for this industry would include software based updates, customer segmentation, customized marketing campaigns, and top quality customer service.
1. The significant and consistent elevation in new technologies, rise of customer expectations, and the increasing number of internet service providers and other competing telecom companies have led to a sharp decline in the profit margins for telecom companies overall. Such companies need to turn their attention toward ICT innovation, and ensure that their organizations remain flexible enough to adapt to the ever evolving digital transformation. As experts in the realm of QA services, we know that QA testing is essential to ensure optimal working of software and the systems, such that they deliver the expected output.
2. As the number of subscribers and a range of products increase, there is a need for tailored solutions. All this in turn makes customer care, operations, configuration of service, billing cycles and other such aspects, a lot more complicated. Telecom companies therefore, have increased spends on getting more resources and customized tools to ensure that customers get what they want and to gain an edge over competitors. As a result the financial overheads have increased significantly. With so much at stake, these companies must ensure that their products not only function as per customer requirements, but that the products are efficient, convenient, and secure. QA testing is therefore essential – not just to ensure proper functioning of the products, but also to mitigate the challenges and risks that telecom companies could face.
3. Meticulous and regular QA testing would ensure the proper implementation of the solutions, while addressing all the existing and possible issues. Telecom companies must ensure that their end to end solutions are properly supported such that their business remains profitable.
4. As mentioned, the challenges that telecom companies face, is the constant restructuring of infrastructure, the IT connectivity, and maintaining focus on offering reliable and affordable services. The most important is network security given that threats to technology are becoming more potent and frequent. The QA testing experts would be able set up a proper process and provide solutions customized to fit the business and customer base of the companies.
5. No business today can succeed without retaining existing customers and attracting a larger customer base. This can happen only when consistently high quality service is provided, along with effective back-end software, and a user-friendly and highly responsive customer use application. QA testing will ensure that telecom services are elevated and there is a significant reduction in the time to market and customer complaints.
As leaders in the realm of QA services for the telecom industry (and more), we have consistently helped our clients with all the features mentioned above. QA testing analyses all the major operating systems, while optimizing their testing along with hardware devices. Our in-depth expertise enables us to ensure the security, functionality, reliability, and compatibility of the applications used by the telecom sector through wide and rigorous software testing. Connect with us for specialized software testing services and a personalized software testing strategy for your business within the telecom sector (and many more).
by admin | Jan 3, 2020 | Automation Testing, Fixed, Blog |
We at Codoid use various automation testing tools. In this blog article, we would like to share the tools that we use and why. As a Test Automation Services Company, using multiple test automation tools/libraries has become inevitable for us to address automation testing challenges. If you don’t know how to use a tool, then your output will be a mess. In-depth knowledge of various automation testing tools is must to deliver high quality automated test scripts. Let’s see the tools we use for automation testing.
For web application automation testing, we use Selenium WebDriver & Protractor. Python, Java, C#, and JavaScript are the programming languages which are predominantly used to write test automation scripts. To enable effective collaboration with the clients’ SPOC, Gherkin steps are written using Cucumber and Behave BDD frameworks. Our Automation CoE Team suggests Selenium best practices periodically to produce quality automated test scripts.
To automate desktop app test cases, we use White Framework and Test Complete. White Framework is an open source library to automate desktop applications. Automating a desktop application using White Framework is no cake walk. It requires in-depth knowledge on White Framework, Win32 API, and C#. As an automation testing company, we have helped our clients to automate their Desktop test cases using both White Framework and Test Complete.
For mobile app automation, the best choice is Appium. Once the automated test scripts are ready for mobile app test cases, we run them on cloud real-devices using BrowserStack and Kobiton platforms.
Firing all the validations SQL queries manually on daily basis is a boring task for a tester. We have setup an automation testing framework using Python and LemonCheeseCake library to compare source and target data. If your team needs any help in automating data quality validations, contact us to explore our test automation solution.
The most apt automation testing tools will invariably lead to successful test automation. As a leading software testing services company, automation testing is one of our core services. continuous learning and following up automation best practices help us to deliver robust test automation suites to our clients efficiently
