When we say technical skills, many of us think about test automation and coding. But those are not the only skills testers should have. And even testers who don’t write code at all should still work on improving these skills. Let’s see some of them 👇
Table of Contents
With the rise of microservices and the decline of monolithic applications, it’s really important for a tester to understand how API testing works. Here are some things you should understand to be able to use the tools and create valuable tests for REST APIs:
📌 What APIs are
API is short for application programming interface. APIs provide the communication between a system’s components, or between different systems.
📌 HTTP request components
These are the URI and endpoint, the HTTP methods, and the request body.
📌 HTTP request methods
Most common ones are:
- GET – used to read information from the server.
- POST – used to create new entities.
- PUT – used for updating resources on the server.
- DELETE – used to delete resources.
📌 HTTP response statuses meanings
There are many resources where you can read explanations on all status codes, like this one, and below you can see the five classes into which they are grouped:
- Informational responses (1xx).
- Success response messages (2xx).
- Redirect responses (3xx).
- Client errors (4xx).
- Server-side errors (5xx).
📌 Query parameters
HTTP requests can be sent with parameters inside the URL. For example, you can perform a simple Google search, and you’ll see that the URL is updated with a parameter at the end:
- The JSON basic syntax (the key-value pair) – is also important to understand because most tools use the JSON format for the request and responses body.
- How authentication and authorization work – authentication is the process of presenting your credentials and the system validating them, while authorization is the process of allowing or denying the account’s access.
📌 Tools like Postman can come in handy for API testing. They provide “snippets”, or ready-to-use scripts, so you don’t necessarily need to know how to write the code:
Working with Databases
Another important component of a system under test can be the database (or DB, for short) 💹 This is where all the data of the application is stored. Database testing plays a big role in the testing process because it confirms that the information in the front-end matches that in the back-end.
Let’s look at an example. The UI allows the user to enter multiple shipping addresses. After the user completes a form with all the data, they receive a message that the new address was successfully saved. However, when they log back in, they don’t see the new address. This means that the data was not correctly saved in the database.
You can perform a query in the DB and see exactly what happens. This will help the developers understand the problem and impact quicker, and it does not take up a lot of the tester’s time either.
Many of you are probably already familiar with Relational Database Management Systems (RDBMS) and the SQL (Structured Query Language) used to interact with them. According to statista, the top used database management systems in 2022 are still RDBMS.
SQL is used to create, update, and remove databases, as well as create, update, and delete the tables inside the databases, and to insert, search, update, and delete database records into these tables. If you don’t know SQL yet, you can check this SQL 101 guide for QAs, which will explain in-depth how to work with it 📘
However, some NoSQL databases are catching up and starting to earn some popularity. These are typically non-relational databases, that store data in a format different than relational tables. MongoDB is one example of it.
Another important skill for a tester is understanding version control (or source control). Version control systems are a type of tool that deals with recording changes to files and keeping a track of modifications done to said files.
Version control tools are very useful when working in teams, but also for undoing any potential mistakes made in the code. It’s also important to note that version control can apply to all types of files, including documentation.
The most widely used version control system at the moment is Git. Its basic concepts you should understand are:
📌 Local vs remote repositories
Git repositories track and save the history of all changes made to the files in the project. The remote repository is the shared code. This is where all the changes from the team are sent. The local repository is a copy of the project code and includes all the local changes that have not been yet pushed to the server.
Branching allows team members to create copies of the production version of the code to fix bugs or add features, without modifying the existing version. For example, most projects will have different branches for the release version, for the development version (the unreleased still in progress version), and for features. As a tester, you might need to test on a specific branch, before the changes are merged in the common base.
After a developer makes changes locally, they can commit these changes. Commits are like local snapshots of the current state of the branch, to which you can always come back, or you can view the changes. All the commits history is saved in Git, so you can see when specific changes have been introduced to the codebase.
If you want to learn more about Git, you can check this guide.
Using Developer Tools
Web browsers’ developer tools can be a web tester’s best friend 🔨 They are usually pretty straightforward and can help you investigate potential issues in your application. Some cool things you can do with them include:
- Viewing calls sent from the web client, and the responses received.
- Tracking the web apps’ performance.
- Simulating slower network connections.
- Emulating different devices, or specific resolutions/screen sizes.
- Taking screenshots or video recordings of the test steps.
- Simulating different geographic regions.
Last but not least on our list of technical skills for testers, is working with the command line. The command line is an interface, that takes in text commands, and then passes them on to the computer’s operating system to run 🏃♀️
In Windows, you can use the Command Prompt (just run ‘cmd’), or PowerShell. Mac OS has the Terminal, and Linux has CLI (Command-Lune interface). Some common commands are:
- cd – used to navigate to a specific location on the machine.
- cd.. – allows you to move up one directory.
- ls – lists all the files and directory from the current directory.
- mkdir – for creating a new directory.
- touch – for creating a new file.
- cp / copy – copy/paste.
- grep / findstr – this command lets you list all the files that match a specific regular expression.
These are just some quick examples, but you can also use the help command and see a complete list. After you get used to using the command line, it will get easier, especially since you will know what to look for.
Just because some testers don’t do automation testing, they can and should still benefit from some technical skills. The main ones covered in this article are API testing, working with databases, version control, using browser developer tools, and command-line.
If you have other skills you want to recommend to your fellow testers, let me know in the comments 💬