Forem: Julia Pottinger

Guide to creating an effective Test Automation Strategy

Julia Pottinger — Thu, 02 Sep 2021 17:05:21 +0000

Test Automation is increasingly being introduced to companies to solve issues and reduce the time to market for products. However, for test automation efforts to not be ad hoc and to get the return on investment that test automation brings, the team should work together to create a Test Automation Strategy.

A test automation strategy defines the tools and frameworks used to get reusable, automated scripts, as well as how to create those scripts and maintain them. It is most effective when it is understood by your entire team as they are going to be the ones to implement it. Test automation can provide valuable returns on investment, such as faster time to market, more reliable, faster tests. However, it takes a lot of time and effort and you don't want to dive into writing automated scripts without first having a test automation strategy.

Your strategy should define how you're going to go about doing automation, who is going to be writing it, when are you going to be running it and what environments you're going to use. It fully defines the what, why, when, how and where of your test automation initiative. Let’s break down the what, why, when, how and where that will be in your test automation strategy.

Read full article here: https://juliapottinger.com/guide-to-creating-an-effective-test-automation-strategy/

Or watch the video tutorial

Expect Assertion WebdriverIO

Julia Pottinger — Tue, 09 Mar 2021 21:36:02 +0000

WebdriverIO Expect Assertion is powerful, intuitive and comes built in to the test runner when you install WebdriverIO. It allows you to add assertions in your test. In this video I will walk through

Installing WebdriverIO v7
What is WebdriverIO Expect
How to use WebdriverIO Expect
Example of different commands
Matcher Options
How WebdriverIO Expect compares to Chai Assertions
Why I prefer WebdriverIO Expect over Chai Assertions
How to use both WebdriverIO Expect and Chai Assertions in your WebdriverIO project

Let me know which assertion you prefer.

Roadmap to improving your Agile QA Toolkit

Julia Pottinger — Sat, 30 Jan 2021 16:10:11 +0000

An Agile QA does more than write test cases or execute them. They participate in activities such as "Estimating Stories" and "Backlog Grooming", interact with developers, attend daily scrum and sprint-planning sessions and they AUTOMATE.

QA's are expected to be knowledgeable on the different tools and methodologies used, find the root cause, bringing fresh ideas and perspectives while still ensuring that releases are sent out on time.

How do you set yourself up for success or make an impact? An Agile QA toolkit will allow you to be knowledgeable in the right areas, think quickly on your feet, be ready to grasp promotion and opportunities for growth as well as be confident and efficient in carrying out tasks. You will gain applicable knowledge about automation tools, testing concepts and approaches as well as be able to better handle challenges, be more prepared and empowered for change.

Join me as I walk you through my journey to being an impactful QA as well as give you a guide on how you can create your toolkit to be impactful.

You will take the following from the talk:

Being ready for change and applying lessons from past projects to future projects.
Testing tools and approaches needed for a consultant toolkit (Getting Started and improving on what you have)
Be prepared to grab opportunities and grow as a QA Consultant

Our Journey into Tech - Testing

Julia Pottinger — Fri, 20 Nov 2020 19:20:56 +0000

I had a great conversation with Beth Marshall about our journey into testing. We talk about the different paths that we have taken to end up at the same place - passionate about quality. We also fangirl about the amazing Angie Jones and speak about how we are dealing with COVID and work from home.

Take a listen

Test Automation Best Practices: Deciding What and When to Automate

Julia Pottinger — Mon, 26 Oct 2020 19:10:09 +0000

Test automation is generally introduced into a project to solve issues such as repetitive manual work, working with large data sets, or getting faster feedback in a CI/CD pipeline. With this buzz around test automation, you may be considering going forth and automating "all the things." You may have selected the testing framework and the team that would do the test automation. But have you seriously considered what you should automate or how feasible it is for you to automate everything?

Exhaustive testing is impossible. This is one of the key principles of software testing. While test automation significantly expands test scope and coverage, automating EVERY test takes more cost, effort, and time than is practical. Before any test automation begins, it is imperative for you to make a data-driven decision on what you will and will not automate --- and in what priority. When deciding what to automate, there are some basic items to consider, such as the automated test level at which you will be creating your tests. Automated Tests can be placed into three main levels: Unit Tests, Service/API Layer Tests, and User Interface Tests; you should evaluate the pros and cons of writing tests at each of these different levels before proceeding.

Regardless of which level of automated testing you perform, the objective should be to automate what brings the most value and impact, areas always tested for every release, and areas hard to test manually. You should also look at areas where there are huge amounts of data to be processed. All of these factors must be considered before automating. If you create automated tests blindly or on a whim, it increases the likelihood you will not get as much value from it as you should.

Detailed below are five (5) critical areas/factors to be aware of as you consider integrating automated testing into your current workflow.

Automate your smoke tests.

Ensuring that your application functions on a basic level is very important and should be done after each change or when a new build is made. This can be integrated into a CI/CD pipeline in order to verify that show-stopping bugs are caught early. Smoke tests ensure that the most important aspects and basic components of an application are functioning correctly. They test areas that always need to work and can help you decide whether a build or application is stable enough to proceed with further testing. Automating your smoke tests can:

Help to quickly detect show-stopping bugs early, such as app/webpage not loading, user unable to login, user not able to create an account, or payment services being down.
Enable faster troubleshooting of new and regression bugs. Smoke tests by nature have high coverage and shallow depth. This results in a wide variety of test cases being tested without going too deeply into the application. Once these critical areas are working, it allows you to go deeper into the application to test other features.
Result in less manual interaction and be time-saving. By integrating your automated tests into your Continuous Integration/Continuous Delivery (CI/CD) pipeline, your smoke tests are tested before a build is completed. This means that a build is not given to QA unless those smoke automated tests pass.

Automate tests that are always run, such as regression tests or tests always found at the beginning of every workflow.

This allows you to have a set of stable tests vital to the application. For example, creating a user account would need to be done before the user can login and view the dashboard, make payments, etc. By creating an automated regression suite, you can:

Run tests that quickly identify any bugs resulting from changes in the software. These changes may be new features or defect fixes.
Have a set of stable tests. Regression tests are normally for existing functionality, which means these functionalities are not new and have been tested multiple times. This prevents flaky automation tests, and you then must spend a lot of time manually testing since you are unsure whether the tests really failed or not.
Save time since you can now focus your manual testing efforts on more edge cases.

Automate extensive tests

Exhaustive tests such as inputting large sets of data, testing a form, or tests requiring the tester to do the same workflow multiple times but with a wide variety of data should be automated. You can create data-driven automated tests that can result in time being saved. For forms, automation allows you to quickly test different combinations of inputs to the form, such as whether fields are missing, incomplete, etc. Data-driven testing is very beneficial as it allows you to only modify the data instead of the test script to get different results. It is also very reusable and efficient.

Automate tests that require multiple configurations

This could include tests on different Operating Systems(OS) and Browser Combinations. This can be tedious to do manually and, if automated, can help save time. Automated tests can be run on different environments (such as Dev, QA, Staging, Integration, or PROD) by simply changing the environment variable. Tests can also be run in parallel, which reduces the time needed for execution. You can use different CI tools such as CircleCI to specify the OS, browser, and environments on which you want the parallel tests to be run. Ensure that you follow best practices when creating parallel tests in order to get as much benefit from these tests as possible.

Automate your performance tests.

This lets you avoid launch failures, bad user experiences, and performance regressions. Performance testing checks how the system performs under load and stress and also identifies bottlenecks. It checks the speed, response time, reliability, resource usage, and scalability of a software program under their expected workload. Automation can help you easily generate thousands of users to see how the application will respond. For example, Fandango is one of America's largest ticketing sites (with up to 36 million monthly movie-goers purchasing tickets from their site), and they wanted to ensure they were prepared for the movie Star Wars: The Last Jedi. They wanted to find out what their peak performance was and how to identify bottlenecks. QualityWorks automated their performance tests and provided them with reports that would help to identify bottlenecks and, as a result, they had a successful movie sale launch. This is something they can continue to use to ensure the performance of their website is up to a certain standard.

Your Next Step

This list of considerations is not exhaustive by any means but is a great starting point if you're considering how to integrate automation into your current QA workflow. Be strategic and focused in your approach. Sit with your current QA to discuss their current practices and to identify bottlenecks in their process that could be resolved with automation. Automating "all the things" is never the answer. Remember, before creating automated tests, think about the level you want to automate. Then, decide what tests you want to automate that would bring the most ROI for you and your team --- those that are repetitive, time-consuming, not flaky, critical to the business, or that test the performance of the application.

.........

About the Author

Julia is a Lead QA Consultant at QualityWorks with expertise in manual, automated, and API testing and training. She is passionate about sharing her knowledge and experience and contributes to the testing community through writing articles, and delivering testing content on Test Automation University as well as her Youtube Channel and blog. She also conducts testing Bootcamps for persons interested in entering the field of QA.

...........................................................................................................

Looking for ways to accelerate your testing process with automation? Reach out to our testing team at www.qualityworkscg.com

Element Locator Strategy using CSS - Write Dynamic CSS Selectors

Julia Pottinger — Tue, 15 Sep 2020 19:02:20 +0000

CSS Selectors are faster than XPATH and are easier to read. Having durable, well-designed CSS selectors to target elements in your web application is very important and allows for more robust tests. CSS Selectors are also important in development to apply appropriate styles and functionality.

In this video I walk you through the different syntax that CSS offers for id, classname, attributes, element state and element positions.

At the end of this video you will be able to create well-designed, durable and dynamic CSS Selectors for your application or test automation.

Element Locator Strategy - Introduction and best practices

Julia Pottinger — Tue, 04 Aug 2020 17:30:44 +0000

This video is the first in a series on locator strategies.

It introduces you to types of locator strategies and importance of proper locator strategies as well as best practices to follow for testers and developers.

Locators are used by our tests to perform specific actions on a web page such as clicking on a link or button, getting the text of a header or entering some value into an input field.

Run Automated Tests on Microsoft Edge Browser using WebdriverIO

Julia Pottinger — Fri, 31 Jul 2020 21:28:45 +0000

Having your automated tests run on different browsers increases coverage especially if a high percent of traffic for the application come from there.

Follow this tutorial to learn how to run your WebdriverIO automated tests on MicrosoftEdge

Formik and Yup - React field validations

Julia Pottinger — Tue, 14 Jul 2020 17:16:40 +0000

Creating a form can be really simple. However, form validation can cause headaches and may result in stress.

Formik is a library that helps you to get values in and out of form states, handle form submissions as well as validation and error messages.

Yup is a JavaScript schema builder for value parsing and validation.

In this tutorial I walk you through validating your react form using Formik and Yup.

7 Pitfalls that ruin the testing cycle | 7 Mistakes to avoid when doing manual testing

Julia Pottinger — Thu, 09 Jul 2020 17:40:15 +0000

Countless projects with great potential have tanked as a result of the inability to achieve intended product goals within the specified time frame. While this can happen for a myriad of reasons, in the world of software development, QA engineers bear a great responsibility as gatekeepers of quality to ensure the products are ready for release.

Here are 7 software testing tips and considerations to help you prevent product release disasters as a manual tester.

Testing without understanding Requirements
Not Prioritizing Test Cases
Testing Only after you have deployed the code
Not reporting defects correctly
Not implementing traceability across the project
Not time-boxing exploratory testing
Not performing root cause analysis

customCommands with WebdriverIO - addCommand

Julia Pottinger — Thu, 09 Jul 2020 17:19:33 +0000

Learn how to extend the browser instance with your own set of commands by using the WebdriverIO browser method addCommand.

Scroll to top(Back to top) - React and MaterialUI

Julia Pottinger — Thu, 02 Jul 2020 17:52:00 +0000

The Scroll To Top button is a very helpful navigation tool that brings the user to the top of a page without them having to scroll all the way up. On a blog it is very useful. In this tutorial I will show you how to implement this feature with React and MaterialUI.