logo logo

Automation Testing for Beginners – The Ultimate Guide

By Yoni Flenner Test Automation, Appium, Selenium, Tutorials
47 6 comments 13 min
Automation Testing for Beginners – The Ultimate Guide - TestProject.io

 

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 - The Ultimate Guide - TestProject.io

Automation Testing for Beginners Guide – Table of Contents

  1. Object-Oriented Programming Language
  2. Development Ecosystem
  3. Unit Testing Framework
  4. Server Side and Client Side
  5. Test Automation Infrastructure
  6. Standards and Best Practices
  7. DevOps
  8. Conclusion

Object-Oriented Programming Language

An automation developer is actually a software developer. Thus, the basic thing you should learn first is some kind of a programming language that supports Object Oriented methods. Out of the common languages in the automation field, it’s worth mentioning Java and Python which are also considered to be easier to learn. In addition, automation developers also write in C#, JavaScript and some also write in Ruby.

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.
  • For JavaScript you can learn from the renowned Derek Benas who actually has many tutorials about a variety of other subjects too (even some not related to the software field).

 

Development Ecosystem 

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:

 

Unit Testing Frameworks

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:

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:

 

Server Side and Client Side

In this part, we will dive into both the server side and client side, and understand why we need to know both:

Let’s start with the server side.

Server Side – Web Services

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)

Resources: Raghav Pal has a great YouTube course on automating Web Services, and this Guru99 guide has an elaborate explanation on REST.

Server Side – Data Structure

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.

Resources: On QHMit you can find good tutorials for XML, XPath and JSON.

Server Side: API Testing

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
  • Serialize
  • De-Serialize
  • Authentications

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.

Server Side: DB 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:

Client Side – HTML, CSS, JS

Now comes the question – Why do we even need to know the technology behind developing web apps if we are simply going to test it, and not build it!? Well, the obvious answer is – If we automate a web app and our automation engine knows how to read HTML pages, we better be able to know that too. With HTML pages also comes the subject of CSS (responsible for the app’s design) and JavaScript (responsible for the site’s dynamics). You do not need to be a Front End developer, but you should definitely be familiar with the basics, and even a bit beyond.

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).

Resources:

  • W3School is probably the most common site most of you will end up on when looking for resources to learn HTML, CSS and JavaScript (and for good reason!). Although I should mention that as for CSS and JS, in my opinion, you can suffice with simply learning their implementation within the HTML itself.
  • These two are additional good resources you can learn HTML from: Learn-html and QHMit.

Client Side – Web

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… 

Client Side – Mobile

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:

  1. Supports two of the most popular operating systems: Android and iOS (Oh, and even supports Firefox OS for those who are into that).
  2. 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:

Client Side – Desktop

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.

Resources: You should check out the pros and cons of these open source desktop test automation tools I did a while back, and also another one specifically on WinAppDriver.

 

Test Automation Infrastructure

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, Screenshots, 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).

 

Standards and Best Practices

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).

 

DevOps

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? 🤔

  1. 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).
  2. 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

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.

Resources: There’s a tone of Git guides out there, I liked Traversy Media’s the most, and there’s another serious one on Udemy by Jason Taylor.

Build Tool

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).

Resources: The ProgrammingKnowledge Maven videos are pretty good, and this Maven tutorial article from Jenkov’s site is great (This site has many more great knowledge resources too).

Grid/Parallel

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.

Resources: You should definitely take a look at two of these videos by Naveen AutomationLabs, explaining Selenium Grid examples: Part 1 and Part 2.

CI Tool

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.

There are a couple of CI tools out there, the most popular among them being Jenkins, and others such as: Bamboo, TeamCity, etc.

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!

Docker

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.

Resources: There are a lot of great Udemy courses on this subject, such as Bret Fisher’s, and this course too by Karthik KK’s ExecuteAutomation, oriented towards the automation testing world.

 

Conclusion

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! ✨
Yoni

—

Reference: http://atidcollege.co.il

About the author

Yoni Flenner

A software engineer who likes to test things programmatically, and he’s doing it for a living for the past 10 years: https://atidcollege.co.il

Comments

47 6 comments

Leave a Reply

FacebookLinkedInTwitterEmail