Manual testers that want to move to test automation should do this gradually by learning one automation skill at a time.
The process of learning test automation is similar with climbing a staircase, one stair at a time.
Each next skill should be just a bit more complex that the previous one.
Many testers don't know how to move from manual testing to test automation.
They don't know either what skills are needed for test automation.
Or how these skills should be learned and in what order.
Where can inspiration be found on how to learn test automation?
Sometimes, inspiration comes from unexpected places.
The process of learning test automation is similar with climbing a staircase, one stair at a time.
Each next skill should be just a bit more complex that the previous one.
Many testers don't know how to move from manual testing to test automation.
They don't know either what skills are needed for test automation.
Or how these skills should be learned and in what order.
Where can inspiration be found on how to learn test automation?
Sometimes, inspiration comes from unexpected places.
Success did not come for him either easy or fast.
Over the years, his works were rejected hundreds of times by the editors of the magazines where he was trying to publish.
Most people, when facing repeated rejections, think of quitting and doing something else, something where they can do better.
Not Stephen King.
Every time he got a rejection note, the note was placed on a nail attached to a wall from his bedroom. The nail and the notes on it were the proof that his writing skills are not good yet and in need of more honing and improvement.
In time, the number of rejection notes increased so much so nail was replaced by a spike with plenty of additional space for the coming rejections.
And he persevered and wrote more.
Initially, he targeted the 1960 version of blogs.
When his novels were accepted there, he moved to writing for second tier magazines and then for the first tier magazines.
Finally, he published his first novel Carrie after 10 years of writing.
To summarize, Stephen Kings's writing process was supported by 3 main activities:
- lots of practice; he wrote for 10 years before publishing his first novel
- driven by honest feedback; the number of rejection notes from the wall's spike showed the true value of his writing
- challenge himself just barely above his current skill level; as soon as his writings were accepted by a publication, he started writing immediately for better publications, challenging his skills this way
So what can we use from Stephen King's story for test automation?
The last activity was the one that caught my attention:
challenge himself just barely above his current skill level
I wasn't sure why it stuck in me, why I could not forget about it.
My first intuition was that it may be related to the way that I was approaching learning about testing.
The way I was learning and still do consisted in
- learning some aspect of testing
- keeping at it until having a good understanding
- starting learning another skill that was close to previous one but a bit more difficult
For example, after learning HTML to understand how web pages are build, I continued with CSS (Cascade Style Sheets) on how styling information is getting added to the HTML elements.
And then continued with JavaScript on how dynamic effects come into play in web pages.
Isn't this the same as
Challenge Yourself Just Beyond Your Current Skill Level?
How can these ideas be applied for learning test automation?
What skills does someone need to start from zero in automated testing?
How does one get started in automation testing?
Going from manual testing to test automation is similar to walking on a staircase.
At the bottom of the staircase, you have manual testing.
Test automation is at the top of the staircase.
So you start walking, one step at a time:
Test Automation (basic skills)
Learn Page Object Model
Learn Object Oriented Programming in Java
Learn the WebDriver framework
Learn JUNIT
Learn the Java basics
Learn Eclipse
Learn how to create XPATH locators
Use browser plugins (Firebug, Firepath, FireCookie)
Learn HTML and CSS
Read how the HTTP protocol works, get and post requests
Understand how browsers work
Manual Testing
A few words below on each stair.
Let's take a specific type of test automation:
web test automation using Java as the programming language and the Selenium WebDriver framework
Since test automation is all about writing code that interacts with the elements of a site through a browser, it is useful to understand more about
- the components of a browser
- the settings that control a browser
- how cookies works
- how browser sessions work
- browser DOM; this is an internal browser structure created from the HTML and CSS code; as soon as a new HTML element is added to the browser DOM, it is displayed on the page in the browser
Read about how the HTTP protocol works
Each page displayed by a browser is part of a website hosted on a web server.
For every page change that happens in the browser, there is communication between the browser and the web server.
This communication happens over the HTTP protocol.
Understanding how HTTP works is useful for test automation as web pages can be requested in a few different ways (get, post requests).
- URL parameters
- parameter coding and decoding
Learn HTML
All websites are built using HTML.
In test automation, we interact with elements of a web page and in order to do this, it is important to understand how these elements are created.
Basic HTML knowledge is useful for test automation:
- common HTML elements: buttons, text boxes, lists, links, etc
- HTML tags
- HTML attributes
After going through HTML theory, reading about CSS clarifies how style sheets are added to HTML code so that the end result is good looking web pages.
Use browser plugins (Firebug, Firepath, Chrome Inspector)
The browser plugins are helpful for providing access to information about
- HTML source of a page: The HTML source of a page can be viewed through the View Page Source option of any browser; a browser plugin like FireBug shows the same information in an easy to understand tree-like format
- XPATH expressions; FirePath and Chrome Inspector are great for this purpose
- cookies; some of the browser plugins such as FireBug not only show the cookie information but allow modifying the cookies' values
- information about the page load; all components of a page are presented, their size, content type and loading time
Learn how to create XPATH locators
Before a test automation script can interact with a web page element, it needs a way of finding the element on the page.
XPATH provides a flexible way of creating locator expressions for finding web page elements.
Learn Eclipse
Test automation is all about writing code in a programming language that interacts with a site in the browser through a test automation framework.
The code development is being done in an application called IDE (integrated development environment).
The IDE used most of the time for Java projects is Eclipse.
Before creating projects in Eclipse, learning about the Eclipse main functionalities is a good idea.
Learn Java basics
Test automation is 100% programming in a language.
In our case, the language is Java.
So you need to learn the Java language basics such as
- basic data types (integer, boolean, string)
- create variables
- data type operators
- boolean operators
- if/else statement
- switch statement
- for statement
- while statement
- arrays
- lists
- other classes from the Java API
Learn JUNIT
JUNIT is a unit testing framework that is typically being used by developers for creating unit tests that validate the code correctness.
For test automation, JUNIT provides a way of creating independent test scripts.
Some of the fundamental JUNIT concepts for test automation are
- test scripts
- assertions
- annotations
- test suites
Learn the Selenium WebDriver framework
The test automation scripts interact with elements of a website through the test automation framework, Selenium WebDriver.
Selenium WebDriver framework has lots of classes specialized in
- managing the browser (WebDriver class)
- interacting with common HTML elements (WebElement class)
- interacting with lists and dropdown lists (Select class)
- finding elements (WebDriverWait class)
- using element locators (By class)
Learn Object Oriented Programming in Java
The next level of Java programming is related to the object oriented concepts.
You need to learn about
All these high level programming concepts will allow you to take your test automation scripts to the next level with the help of ................ Page Object Model
Learn Page Object Model
While learning test automation, your test scripts include WebDriver API commands.
This is ok while learning but these types of scripts are difficult to maintain on the long run.
The WebDriver API commands need to be removed then from the test scripts.
The WebDriver API commands need to be removed then from the test scripts.
The Page Object Model, together with the Object Oriented Concepts, will help you create your own classes that correspond to site pages.
This way, the WebDriver API commands will be included in the Page Object classes and the test scripts use the Page objects.
Start Practicing Your New Test Automation Skills
Learning about test automation is very important but the automation practice is essential.
Start working on your projects as soon as possible.
Create your first test automation project and continue from there.
Is this the end of the learning?
Do you know test automation at this point?
You reached the basic level of test automation and the end of the first staircase.
The next staircase is waiting for you ................
Share this
