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.
When we develop software, it 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.
When a software is declared 'done,' Quality Assurance (QA) tests 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 one of 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 (ADD / SUBTRACT / MULTIPLY / DIVIDE) 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.
One feature at a time:
Two features at a time:
|ADD / SUBTRACT||ADD / MULTIPLY||ADD / DIVIDE|
|SUBTRACT / MULTIPLY||SUBTRACT / DIVIDE||MULTIPLY / DIVIDE|
Three features at a time:
|ADD / SUBTRACT / MULTIPLY||ADD / MULTIPLY / DIVIDE|
|SUBTRACT / MULTIPLY / DIVIDE||SUBTRACT / DIVIDE / ADD|
Four features at a time:
|ADD / SUBTRACT / MULTIPLY / DIVIDE|
- 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 the number 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.... enter unit tests.
- Unit Tests are QA for the software core done by machine calculations, therefore free of human errors.
- Unit Tests will send inputs to the software core and evaluate the result.
- The fact that it is done by code helps test a big number of cases and vary the inputs accordingly.
Typical Unit Test Structure
|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 Tests include 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
At Number8 our programmers implement necessary code to ensure your software products can handle all functions and develop as needed. If you are interested in learning more about our development process or if you think you are qualified to join our team, then give us a call at (502) 890-7665 today!
- 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.