Summary: Unit Tests are a level of software testing where individual units of a software are tested. The purpose is to validate that each unit of the software performs as designed. Learn more about the role of unit tests for quality assurance engineers.
Described concisely and directly, Unit Tests is Quality Assurance (QA) for the core of your software. The main difference between Unit Tests and regular QA is that Unit Tests are not done by a user interacting with the software directly. In fact, they are done by a programmer with code.
Why Programmers Include Unit Tests for QA Engineers
Software must meet an objective or main requirement.
The core of the software is the code that relates directly to that objective.The core is essential. If it does not function correctly, the software has no purpose.
Examples of software cores:
Online Payment
- – the code that processes the credit card or web payment method given by the user.
Hotel Booking Engine
- – the code that associates the user’s information to the hotel room and saves this to a database.
Scientific Calculator
- –the code that performs the actual calculations and returns a result.
To test the software to assure it satisfies its objective.
In a controlled environment, QA tests every core function possibility, making sure nothing breaks and everything works as expected. The core is outlined clearly with every oneof its cases for QA to test continuously.
The number of tests QA needs to perform can grow rapidly.
For instance, take a basic calculator (a relatively simple, single page application) that uses 4 basic functions. At first, QA needs to test the calculator’s 4 basic functions. However, to ensure quality, QA needs to test every possible combination of functions at one time.
For a basic calculator application that has four functions, QA needs to run 15 tests continuously to ensure it works properly.Each scenario should be tested with its own input and all outputs need to be verified. Now imagine another a new function is added to the app, for example, the trigonometric function sine. You have to test all the above functions again, but this time with the sine code added.
With the addition of 1 function, the number of tests increases from 15 to 31.The addition of 1 function doubles thenumber of tests to perform and forces QA to repeat tests. A typical scientific calculator includes at least 13 functions: add, subtract, multiply, divide, percent, sine, cosine, tangent, square root, nth root, exponent, log, factorial.That yields a grand total of 8191 different test cases to perform!
This amount of QA is not feasible for a person to perform. Hence, unit tests. In addition, Unit Tests are QA for the software core done by machine calculations, therefore free of human errors.
More information on Unit Tests
Typical Unit Test Structure
| Given… | Inputs |
| It (when)… | Code to be tested. |
| Should (then)… | Evaluation of results. |
- In the ‘Given’ section the programmer declares the inputs that will be passed to the feature tested. This can be a single number (like the calculator) or a different input, like a database object.
- In the ‘It’ section, the programmer details the function or code that will be run and tested.
- In the ‘Should’ section the results are evaluated and the Unit Test passes or fails.
- Unit Testsinclude objects called ‘Mocks’ which resemble a database record. The programmer hardcodes the Mock’s attributes values, but it is important to note that the attributes are the same as a database record attributes, making it able to be tested.
Unit Tests are not fancy, unnecessary code
- Unit Tests run quickly while verifying outputs correctly.
- They are scalable and fit for applications with multiple requirements.
- When a new variable is added, tests that verified the old cases can be reused.
- Unit Tests are not a luxury, but an advanced way of doing QA by code that is needed when the software that wants to be tested has too many cases for a human to consider.
- Plus, they are free from a human error, like passing a wrong input or interpreting the result incorrectly.
- Unit Tests make QA more efficient while making it harder for its members to enter, as they will require a programming background.
