East Asia and the Pacific Rim Unit Test Review

Unit Testing

What Is Unit Test?

Unit Tests are software programs written to exercise other software programs (chosen Code Under Test, or Production Lawmaking) with specific preconditions and verify the expected behaviours of the CUT.

Unit of measurement tests are ordinarily written in the same programming language as their code under test.

Each unit of measurement examination should be small and exam only limited piece of code functionality. Test cases are often grouped into Test Groups or Test Suites. There are many open source unit test frameworks. The popular ones usually follow an xUnit blueprint invented by Kent Beck, for example, JUnit for Java and CppUTest for C/C++.

Unit tests should also run very fast. Ordinarily, nosotros expect to run hundreds of unit test cases within a few seconds.

Why Unit of measurement Examination

The purpose of unit testing is not for finding bugs. It's a specification for the expected behaviours of the lawmaking under test. The code under test is the implementation for those expected behaviours. So unit exam and the code nether test are used to check the correctness of each other, and protect each other. Later on when someone changed the code nether examination, and it changed the behaviour that is expected past the original writer, the exam volition neglect. If you lot lawmaking is covered by reasonable unit test, you tin can maintain the lawmaking without breaking the existing characteristic. That'south why Michael Feathers define legacy lawmaking as code without unit of measurement test.

The purpose for unit testing is rather protect what we have implemented than to observe whatsoever defects, only like the anchors ready by a rock climber along his way up the stone. These anchors assistance him to protect what he has accomplished.

Purpose of Unit Exam

The purpose of unit of measurement test can exist summarised as:

Facilitates changes
- It protects the behaviours decided by the previous programmers. So that people tin can change the code without breaking the existing features.
Simplifies integration
- Unit test tests the basic units of the programme, the functions and the classes. It makes sure the basic units are functioning every bit expected. When these units are integrated together, we can split up the integration problems (the coupling problems) from the unit of measurement internal issues (the cohesion issues).
Documentation
- Well-written unit of measurement test can be used every bit documentation for the functionality of the code under examination. Unit exam contains information typically you lot cannot find from the code nether test, for example, the design purpose of the original programming who wrote the lawmaking, and how the lawmaking is expected to be used. Unit test as documentation, dissimilar other traditional documentation, it doesn't "lie". Because if it lies, the test would fail. And that indicates either the test or the code is wrong.
Design tool
- Unit of measurement test is also an of import pattern tool. Unit test requires testability from the lawmaking understand. Like shooting fish in a barrel-to-test usually means easy-to-apply. So unit test could be used to make certain the design has consideration from the perspective of utilize, rather than but from the perspective of implementation. Testable code needs better modularity and fewer dependencies. Then that the unit examination tin can easily take a minor role of the code under examination (a "unit") without taking intendance of the overwhelming amount of dependencies. Then unit test could exist used to make sure the design has "loftier cohesion, low coupling".

Why on "Unit" Level?

"Yep, it'southward important to use automated examination to protect the existing functionalities. But why does it need to exist on the unit level?"

You might wonder. Why don't nosotros but employ thorough automatic functional or system tests to protect the program?

Total cost of buying – Unit of measurement test is based on the abstraction level of the programming linguistic communication. It's simply some code exercising other code. It doesn't demand to run in the same environment as the product. For compiled programming linguistic communication, it doesn't even demand to use the same compiler equally the production. The creating and running price of unit of measurement examination is very low. If designed properly, the cost of maintaining is too very low. You may not become the same level of confidence from one successful unit test case as you tin get from a functional test. You will need many small unit test cases to go approximately the same level of conviction. But the cost of these pocket-size unit test cases is all the same much lower than owning a few functional test cases.

If a software code base hasn't got any unit test for the past 2 years, in that location will be extra cost for applying unit of measurement test to this code base. The cost comes mostly from two sources:

The toll of applying a exam framework to the code project. This is relatively easier for dynamic programming languages similar Python, Ruby or Javascript. Usually, information technology's as well picayune for Coffee and C# projection. It tin be quite tricky for C/C++ project. No matter like shooting fish in a barrel or hard, this is just one-time investment.
The existing code base of operations is not testable. The code was designed without considering the testability. Applying unit test to this kind of code base often involves improving the electric current pattern. Doing and then doesn't only increment the cost of creating test, but also has potential price of introducing new bugs by changing the blueprint. So applying unit test to existing code base should be combined with other works that need the change from the code under test – when you lot have to modify that piece of code regardless.

Internal Quality vs. External Quality – High level automated test like functional test and system examination checks the external quality of the software. External quality ways how well the software is operation according to the requirement. Unit of measurement examination is not as effective as the functional examination in protecting the external quality. On the other hand, unit test ensures some of the internal qualities of the software. Internal quality hither means the testability of the code and how well the code is protected. A testable design is in general a skillful blueprint. Other levels of automatic test cannot serve this purpose also as unit test.

Quality of feedback When you passed a functional test, you could be very confident about the functionality you but tested. Just when you found it fail, usually you demand to do some debugging to encounter what is incorrect. Unit examination might be able to give you more precise information about what is working and what is broken.

Unit test is on the abstraction level of the programming linguistic communication. When running unit test, everything should happen just within the CPU and memory. And each exam case should be small. Therefore, it should run very fast. Typically, you should exist able to run hundreds of unit tests within a few seconds. Including the compiling or other preparation time, the whole procedure of running unit exam should take less than 1 minute.

Unit of measurement exam should also be repeatable. If cipher changes, unit of measurement test runs should ever return the same upshot.

If the unit exam is very fast and repeatable, programmers can run information technology as often as they want, e.g. every a few minutes. The unit test volition continuously provide quality feedback to the programmer. Then that the programmer tin get with a steady progress and focus on more of import things rather than spending also much energy on lilliputian problems.

A reasonable automated test structure should be like a pyramid. At the lesser are a lot of unit test cases. In the eye are much fewer integration level test cases. On the peak, there are even fewer functional/system level tests.

Mutual Misconceptions of Unit Test

Unit test is not as of import as the production code

It is true that in the finish, it's product lawmaking that makes the product. But most software products accept evolutionary life cycles. The lawmaking is not static. It changes over time. Lawmaking without unit test does non have the necessary protection when being changed. Unit test also contains of import information that is not included in the production lawmaking.

Then unit test is simply as of import equally the production lawmaking. They should be in the same SCM repository. They should follow the same coding standard equally the product code.

Unit Exam is done past testing engineers

The purpose of unit test is not for finding bugs. Technically, it checks rather than tests if the code under test has implemented the behaviour intended by the programmer who designed information technology. So the reasonable choice is just let the same developer writes both the exam and the code under test.

Information technology'south likewise encouraged to accept two or more than people pair up to practice the programming together. They write the unit test and the code under exam together. There are many fun means of pair-programming. You lot may find more information in the Test-Driven Evolution section.

You tin can write unit test without changing the lawmaking under test

This is often not true. If the code doesn't accept proficient testability, you might still be able to write unit test for it technically. But the unit of measurement test written for non-testable code is unremarkably very difficult to maintain and understand. Therefore, it doesn't make much sense to have it.

The secret of unit test is non nigh writing examination, but writing testable code under test. We want testable code and piece of cake test, which is a win-win. We don't want non-testable code and hard-to-maintain lawmaking, which is a lose-lose.

I can add together unit test afterward

Well, endeavour request the rock climbers to prepare their anchors later.

Good Unit of measurement Exam Patterns

No news is good news

If the test passes, it should just impress OK (and perhaps some dots to show the progress). No other information.

Dominion of thumb:

No human intervention should be needed to get ready for the test, running the test cases or checking the result.

And when information technology fails, it should provide precise information. The goal is to limit the corporeality of fourth dimension you spend on debugging when the test fails.

Arrange, Act, Assert

A good pattern to follow in a unit of measurement test is "AAA": Arrange, Act and Assert.

If you can easily detect this design in each of your test cases, your tests should exist easy to understand, and they should be adequately specific and to the point. One unit test case should exam only 1 thing. Therefore, there should exist only one gear up of AAA in one exam example. A test case shouldn't be very long (longer than 10 lines of lawmaking) if it follows the AAA pattern.

            import            unittest            grade            TestGroupForTextWrapping            (            unittest            .            TestCase            ):            def            test_should_have_no_wrapping_when_string_length_is_5_and_line_width_is_10            (            self            ):            # Arrange:  Arrange all necessary preconditions and inputs.                        wrapper            =            TextWrapper            (            width            =            ten            )            # Human activity:  Human action on the object or method under test.                        wrapped            =            wrapper            .            wrap            (            "a"            *            5            )            # Assert:  Assert that the expected results take occurred.                        self            .            assertEqual            ([            "a"            *            five            ],            wrapped            )

Behaviour Driven Development (BDD) Manner

Like to the AAA design, the BDD style uses three other keywords to specify each test case: Given, When and Then. (You lot can also apply And as some other keyword.)

          Given The Text Wrapper'southward Width Divers As x And Using '-' As Give-and-take Connector When The Wrapper Wrap Text Length is Less Than 10 Then The Text Should Not Be Wrapped

As you tin can run into, "given-when-and then" maps to "suit-act-affirm" pretty well. They both simply define a state transition of a Finite Country Motorcar (FSM). Y'all can detect more on this in the Uncle Bob'southward article. Some differences:

BDD is more than "outside-in", which means that it emphasises more the external behaviour
With BDD, you lot need to define a domain specific language to write your exam specifications. Because of this, usually you'll need a dissimilar framework. One example for Python is deport.

The Golden Dominion Of a Unit of measurement Exam

In general, a good rule for unit of measurement examination case is:

Each unit exam case should be very limited in scope.

So that:

When the examination fails, no debugging is needed to locate the trouble.
Tests are stable because dependencies are unproblematic.
Less duplication, easier to maintain.

There is no secret to write practiced unit test. In order to write skillful unit examination, y'all demand to create easy-to-test design.

brownsaidecalown.blogspot.com

Source: https://less.works/less/technical-excellence/unit-testing