Some say that transitioning from being a manual tester to an automation developer is a natural process and another evolutionary part of the testing field. Many of the testers I talk with describe how sick and tired they are of manually testing the same processes and reviewing test documents over and over again… They see themselves in automation testing roles while also increasing their salary (which is important too).
Even though the transition from manual testers to automation developers is an obvious one, still it doesn’t mean it’s not hard and many times I encounter the question – “How can I transfer to automation testing?”.
I decided to create a guide explaining how to do such a transformation, and what steps testers should go through in order to achieve his or her first job in automation testing.
Although both roles (manual and automation) are positioned under the same department and usually managed by the same person (a QA manager for instance), the transition still requires acquiring automation knowledge from scratch.
In the diagram below you will be able to see all the steps manual testers need to learn in order to become automation developers. I’ll explain each one of these steps in this guide, while mentioning the exact subjects you need to learn in each step, and include helpful resources to achieve your goal of learning automation 🎯
*Although many automation developers are not familiar with all these diagram steps, this is something we should always strive for in our automation journey. Don’t be scared of the number of subjects that need to be learned. You don’t need to learn them all, and of course not all at the same time.
Automation Testing for Beginners Guide – Table of Contents
- Object-Oriented Programming Language
- Development Ecosystem
- Unit Testing Framework
- Server Side and Client Side
- Test Automation Infrastructure
- Standards and Best Practices
No matter the language you choose, the language’s principles are the same as such: Data Types, Variables, Operators, Statements, OOP (Classes, Objects, Methods, Constructors, Inheritance, Abstract Classes, Interfaces, Polymorphism), Exceptions & Errors, Files, Regular Expressions…
Resources: There are plenty of tutorials for learning different languages, and when it comes to independent learning – I always prefer learning from videos (Udemy/YouTube), rather than from a book:
- If you want to learn C#, you can go for Mosh Hamedani or Tim Corey’s great courses (there are plenty more other than these two of course).
- If you want to learn Java, you should check out Tim Buchalka and Imtiaz Ahmad’s tutorials, in addition to this extensive one – Beginners Book.
- For Python there’s Mosh Hadedani again, and there’s Free Code Camp which is pretty good too and of course many others.
The development ecosystem relates to all the complementary subjects that complete the core studies of the programming language you’ve decided to learn. These are subjects that are not related to a specific language and they will help you in the process of writing efficient, clean and bug-free code. Here is a (partial) list of subjects included under this category: Data Structures, Algorithm, Clean Code, Application Programming Interface (API), Design Patterns, Version Control Management (Git), Repositories, Build Management Tools (Maven / Gradle / Ivy…), Package Managers (NPM / Composor / Nuget / Pip / Gems…).
Resources: Each of these subjects has a long list of tutorial resources, I’ll emphasize a few of the best ones I know of:
- For design patterns: Christopher Okhravi’s course
- For Git: Jason Taylor’s course
- For clean code: Mosh Hamedani’s course
Now, we’re starting to get closer to the testing and test automation world, in which we have a bunch of frameworks for unit testing. These frameworks enable us to take the code we’ve written, and turn it into testable code, by using meta-data functions such as: Annotations or Attributes. In addition, using these frameworks we can insert testing functionalities, various executions mechanisms, reports, etc.
There are a couple popular frameworks, such as:
- JUnit & TestNG for Java
- MSTest, NUnit & xUnit for C#
- Unittest & pytest for Python
These are a couple of subjects you should learn when starting to work with unit testing frameworks: Annotations / Attributes, Runners (with Parallel), Assertions, Test Suites, CI Integration.
Resources: Let’s divide the resources according to the framework type:
- Here‘s a nice tutorial for TestNG.
- Recently I wrote a blog about JUnit 5.
- A couple tutorials on NUnit from C#Corner, Mosh Hamedani and TestProject Blog.
- On pytest you can learn from JetBrainsTV and Automation Panda among others.
In this part, we will dive into both the server side and client side, and understand why we need to know both:
In my opinion, Web Services and their various protocols are the first things automation developers should learn when trying to specialize in server side testing. Brace yourself for some heavy initials:
- Simple Object Access Protocol (SOAP)
- Representational State Transfer (REST)
- Web Services Description Language (WDSL)
- Universal Description, Discovery and Integration (UDDI)
Data Structures are the types of data we transfer between services, they are different formats represented eventually by files, most of which in XML and (primarily) JSON formats. You should be familiar with these formats and learn the languages that can extract information out of them, such as: Xpath and JSONPath.
The main part of Server Side testing comes in the form of API Testing – API requests sent to another side, while expecting it to return a response (which we later on parse, compile and test). There is no GUI and no elements or objects (that do exist in Client Side testing, such as: buttons, text fields, etc). We don’t get the “look and feel” when it comes to API Testing.
Here as well, you will have to learn to work with the tools and API Testing frameworks, such as: REST Assured, REST Sharp, Http Client. The important subjects you will have to learn in order to write API Testing are:
- Methods: GET / POST / DELETE / PUT / PATCH
- Dynamic Payload
Resources: You’ve got some basic explanations over at RestAPITutorial’s Site, and a wonderful series of REST Sharp video tutorials by Karthik KK’s ExecuteAutomation. Dave Westerveld also has great tutorials on the subject, including his most recent one: The Simplified Guide to API Testing.
Database Testing is less common in the industry, and yet in order to connect to databases, we need to learn all about the layers working with them, such as: JDBS (Java DataBase Connectivity) – An API for Java, defining how clients can access other databases. This API includes different interfaces such as: Driver, Connection, Statement, ResultSet… Even in the world of .NET. There are APIs that are already bundled with the framework itself, such as: SQL, OLEDB, OLDB and more.
Almost every DB has a framework or API ready in any programming language with which we can interact with our code. We just need to familiarize ourselves with their functionalities and how to work with such frameworks.
Resources: These two YouTube channels have a great series of tutorial videos:
On the HTML level, we should know what is a DOM, how a web app is built, what are HTML tags (especially know the common ones), Attributes, Browser’s Developer Tools (very important, especially the Console, Elements and Network sections).
- These two are additional good resources you can learn HTML from: Learn-html and QHMit.
Web automation is the most popular in the automation testing industry and with the largest ecosystem. The leading platform (by far!) is Selenium WebDriver, no wonder that new generation web automation tools such as TestProject are built on top of Selenium. Although recently we’ve been seeing more and more web automation tools that are not Selenium-based, such as: Cypress, Puppeteer, Nightwatch.js and TestCafe.
Either way, since many of the test automation tools and solutions out there (not just for web) are based on the WebDriver protocol (formerly known as JSON Wire Protocol), we should thoroughly learn all about its ecosystem, WebDriver and WebElement interfaces, understand what is RemoteWebDriver and all the functions that implement them: Locators, Synchronization, Switches, Actions, Page Objects, Interacting Browsers, JSExecutor, Event Listeners.
Resources: There are PLENTY! There’s an extensive tutorial at Software Testing Material, and Karthik KK’s ExecuteAutomation has a massive series of video tutorials in C#. At Nikolay Advolodkin’s UltimateQA you can also find a bunch more! For all of you Hebrew speakers out there, you can also check out my free online course here. Forgive me all those I did not list here, there is just way too many. I encourage you to also check out courses on Udemy or Pluralsight and start digging…
Most automation developers dealing with mobile testing usually write their tests with Appium, but there are other platforms as well (such as: EarlGray, Esspresso, Robotium, Selendroid, Calabash), although they are a minority in today’s automation testing market. There are also new generation free automation tools such as TestProject that simplify Appium’s framework setup significantly and provide Appium based recording and development tools for mobile.
The biggest advantages of Appium are that facts that it:
- Supports two of the most popular operating systems: Android and iOS (Oh, and even supports Firefox OS for those who are into that).
- Supports the WebDriver protocol, thus anyone coming from the world of Selenium web automation won’t find the transition into Appium too difficult. In fact, the framework can (and should) be the same one for both Selenium and Appium, which is a huge advantage, no need to start writing a new framework in say… UFT (which also supports mobile).
Therefore, the Appium subjects you need to learn will usually come after you’re familiar with Selenium WebDriver. Appium’s code libraries are actually an extension to Selenium, and we need to focus on that. In addition, we should learn Appium’s architecture, which is different from Selenium (Here we have Appium Server instead of ChromeDriver/GeckoDriver, etc…).
So, once you’re all done with learning Selenium – You should focus on the following subjects: Appium Driver, Appium Methods, Appium Gestures, Appium Environment (Client – Server), Android Debug Bridge (ADB), XCode.
Resources: Just like Selenium, there are plenty of resources out there for Appium. It’s no secret that Appium’s setup process is quite a headache, but you can simply watch how to do it with step-by-step tutorials, such as:
- Rahul Shetty’s Udemy course
- And follow AppiumPro created by none other than Jonathan Lipps, the Project Lead for Appium!
Although automation testing of desktop apps is less common than web and mobile described above, there are still some organizations in need of it like air supply. Especially if they have a central Back Office system written in Winform or WPF for example, and they need to do some heavy testing on it. I must say, the number of tools supporting desktop apps is relatively low, and most are not that common and not that mature.
In this market, I feel that commercial tools are the leading ones (as opposed to the web and mobile app market, which have open source solutions leading the way and also completely free tools such as TestProject). Some of the popular commercial tools are: TestComplete, Ranorex, UFT, Tosca which do a good job in this desktop automation field (but require highly paid licensing), whereas from the free and open source side – We mostly have WinAppDriver, Winium (which is no longer maintained) and White.
Working with these free tools continues in general the WebDriver protocol, and in fact the actions are more or less the same, but the initialization of objects will be different.
This is probably the most important part of any automation developer role (along with learning a programming language).
So far you’ve learned how to write web, mobile, desktop or server automation testing, great! Now, you need to learn how to write it well, with an automation infrastructure that will be strong, intelligent, modular, bullet-proof to changes (as much as possible) and that will be able to maintain our project for as long as it can and with minimum effort.
The investment on a solid test automation infrastructure is the longest and most crucial for any project, and incorporates modular components (just like doing a puzzle or connecting Lego parts).
These are the subjects you will need to learn in order to write a test automation infrastructure: Object Repository, Failure Mechanism, Recovery, Reporting System, Screen Shots, Screen Casts, External Config Files, Several Client Support, Parallel Executions, Logging System, Database Support, Data Driver Testing, Keyword Driven Testing, Behavior Driven Development, Time Schedulers.
Resources: Unfortunately, while the Internet is packed with great resources for working with web, mobile and server automation testing tools, it’s almost impossible to find good guides for actually building a test automation infrastructure. A while back I wrote about the fundamentals for a successful test automation framework, and one of the most important courses on the subject is by Karthik KK’s ExecuteAutomation which I highly recommend (but it’s only for web).
And again, for all of you Hebrew speakers out there, I have a Full Stack Test Automation course, that includes writing infrastructures for various platforms (Mobile, Web, Desktop, Visual, Electron, Server, etc).
Just like with software projects, even in automation testing we have writing standards and best practices. I’m not just referring to the process of writing and designing the code (such as SOLID or Clean Code). But rather mostly about designing our tests – How are we planning our automation tests, what are the assumptions we need while working on automation, analyzing ROI of our product and features, designing the architecture of the project (and not just the testing), and using different techniques such as: Isolating tests and environments, Refactoring to remove duplicate code, investigating errors and test failures and more.
Resources: I did not really find any resources online, since these are advanced automation testing subjects that usually come along with automation consultants (at least from what I’m familiar with).
Ok, so the DevOps world is not exactly the world of automation testing. Yet, even in DevOps we use automation processes, though not necessarily of testing, which is where many get confused. So, why did I include DevOps into this ultimate automation testing guide? 🤔
- Because we (automation developers) interact with classic DevOps teams and we need to know how to “connect” our testing suite into the automatic process of version releases (In other words – CI/CD).
- Because in small startup companies, it might very well be the case that the automation developer is also the DevOps guy (who will probably even be responsible for more tasks – A true Full Stack Test Automation).
The fact we now work in Agile environments (quick software development) and aspire to have automatic CI/CD pipelines – Makes it very important to learn the DevOps role in all that’s related to automation. You should focus on learning the following: Continuous Deployment, Continuous Integration, Building Tools, Grid, Git, and Docker-based virtualization systems.
Resources: Edureka’s YouTube channel has a bunch of tutorial videos on DevOps.
Git enables us to manage our code efficiently. I mean, we can’t save our code locally on our computers, right? We usually are not the only developers in the team, meaning other developers will need to work on the same projects, each contributing their own lines of code to the project. So we need a place to manage all of this code we’re creating! We’d also want it to be saved on some sort of cloud repository (such as GitHub).
This is how it works for every software project, and the same will be for our software automation testing project as well.
The subject you should learn when working with Git are: Push, Pull, Merge, Github, BitBucket, GitLab, Branch, Fork.
The software build process is the most important part of the CI/CD process, and is responsible for assembling all our sources (our code) and creating software out of them, for example, .exe file. There are quite a few build automation tools out there, the common ones are Maven for Java and MSBuild for .NET. When writing our automation project, we will also want to build our software, so that eventually the execution will occur from one single source (for example by a command line or executing a .bat file).
These are the subject you should learn when it comes to builds: Dependencies, Plugins, POM, Profiles, Build Life Cycle (Validate, Compile, Test, Package, Verify, Install, Deploy).
Ok, so it’s no secret we all want to execute our automation tests in parallel, on different environments and clients (Web/Mobile), mainly in order to save time. We have quite a bit of regression tests and running on various environments is an expensive process. Thus, we’d want to minimize costs by running in parallel. The most popular platform these days for parallel execution is Selenium Grid. When it comes to commercial solutions, we also have cloud services such as: Perfecto Mobile, Sauce Labs, BrowserStack, etc… To implement that, we’d need to learn about the Grid architecture (Client–Server, or Hub–Nodes) with configurations and parameters.
I’ve already mentioned this CI term a couple of times in this guide – Continuous Integration process is designed for helping us release software versions faster and more efficiently. This is not a simple task, especially given the fact usually an R&D team includes a couple of dev teams, and the automation team is also, of course, an integral part of this process – Responsible for writing, maintaining and uploading the testing suite. Team collaboration is key here.
Automation developers should at the very least know how to work with such tools (even one of them), and be familiar with how to write: Jobs, Schedulers, Pipeline, Parameters, Dependencies, Plugins, Reports.
Resources: On the same ProgrammingKnowledge YouTube channel I mentioned before, there’s also a great Jenkins tutorial!
Automation developers should be familiar with Docker technology due to the cutting-edge technology it brings. We deal quite a lot with the virtualization field in everything that’s related to executing on different machines. So yes, we can use outdated technologies of VMWare or VirtualBox, which would consume quite a few company resources. Whereas with Docker images and containers we can create virtual environments pretty easily and at low cost. Automation testing execution has never been easier now that we have Zalenium for example (a dockerized Selenium Grid infrastructure).
Before diving deep into the practices, it’s very important to learn the “behind the scenes” of this technology by studying: Virtualization, Daemon, Images, Containers, dockerfile, docker-compose, Docker Hub, Zalenium, Swarm, Selenoid, Kitematic, Kubernates, PoweShell.
So, what did we learn from this (long) guide? 🧐
First of all, we’ve seen the exact steps every manual tester needs to learn in order to transition into becoming a test automation developer, steps which include: studying, studying, and some more studying 🎓 Yes, there is A LOT to learn in this wonderful world of automation testing, and please don’t get the wrong impression – Not all automation developers know all of these subjects. Just as not all software developers know all development technologies (programming languages and frameworks, etc).
The goal of this Automation Testing Guide is NOT to scare you, but rather open your eyes and mind 👀🤯
Anyone who has questions following this guide or suggestions for more relevant resources I might have missed – Feel free to reach out and leave a comment below!
Happy Testing and Good Luck! ✨