text: Von Larry Mumah16. Oktober 2018 0 0
  Testing products before delivery is not new. Machines of any kind are extensively tested for stability, running time and safety before they reach the customer. So, it's easy to test properties of physical products. But how can software be tested?
  The software technology differentiates in various testing types. In this blog entry, we will limit ourselves to one of the common types of tests: Unit Tests. They are easy to use and maintain at relatively low cost and thus represents a major development support.
  Unit Tests, in their most primitive form verify, that a tiny unit of the whole software will return expected output parameters from given input. Unit tests belong to the so-called "black box" tests. It is not necessary to understand the internal functionality of code part that is tested, if the defined expectations are fulfilled
  A key benefit of unit testing is that they exist during the development of the software, helping to detect errors in the early stages. In phases of development the program does not have to be fully developed – individual modules of the software can be tested in isolation. When adjustments are made, for example due to customer change requests, it can be continuously verified that functions work correctly and changes cause no unexpected side effects. If several developers work on one software product, they can constantly check that their own changes have no unexpected (negative) side effects on other parts.
  Especially for larger projects, the overhead of writing unit tests is initially considered inefficient. In the long run, it is worth having unit tests in a project from the beginning. Due to the automated execution of these tests, it helps to ensure that on further extension of the software, it runs without errors.
  A general rule: The later one bug is found, the more expensive is the correction.
  Problems and reasons against unit tests?
  Below we provide answers to common problems and reasons that speak against creating unit tests.
  This method is too complicated to test
  If a test fails for a complicated method, it is even more difficult to find the cause of the problem. So, if a method is so extensive and covers multiple functionalities, these different functions should be outsourced. These smaller software parts can be tested individually.
  In general, the more complex the functionality, the more important are tests. Unit tests help to understand the methods and above all they support the maintainability of the program.
  How should a test detect errors in my functions if I write both myself?
  A common question for topic of unit tests. Unit tests just support the development process, because the developer actively considers possible scenarios. One guideline that can be followed is that unit tests should be written from the perspective of a product user. It does not test the implementation, but the desired behavior of a functionality.
  Furthermore, experience has shown that frequently invalid inputs are tested. Often in manual testing scenarios, the developer only thinks about what a desired result is. It is also interesting to see how applications respond to unanticipated inputs, such as performing an action on non-existent data.
  Preparing the tests is more complicated than what I want to test.
  There are several reasons why preparing a unit test can be complicated. On the one hand, the creation of the test data can be extensive. In this case, it makes sense to provide test data centrally for all unit tests, as they can be used for further tests, too. This often happens when writing tests for functions that access data from an external data source.
  On the other hand, some methods are difficult to test in isolation because of its surroundings.
  Here, the consideration to outsource the method may be useful.
  I have no time writing unit tests
  Under pressure, developers often just see the extra work of writing some unit tests and forget the actual benefit. Especially in time of quick feature development, more common mistakes are made. That is why unit testing is even important in these times. The following picture shows a vicious cycle of not writing unit tests:
  Unit tests are excellent to test software during development and thus significantly increase software quality. Preventing errors in all modules can consistently ensure that the result contains less errors and is manageable. Writing the unit tests from the beginning, help reduce the extra work involved. This makes sure that care is taken that the individual functions can be tested as standalone functions.
  From experience, developers notice right after a period of time the enormous value of unit tests, in which they feel more comfortable with changes or further developments.