The Importance of Testing and the Impact of a Bug in Production

In literature there are several articles that talk about how the resolution of a bug (or defect) is more expensive the later the problem is discovered.

Wanting to cite some, we find the article .

Regardless of where the scales lean, I think it is clear that being able to identify an issue as early as possible allows you to save time and money thanks to the reduction in effort needed to perform a fix.

In fact, if a problem is identified in the development phase, the development team will directly perform the fix in the work environment that they master 100% (e.g. the development server) before the software is released in subsequent environments where all the application tests are also performed (non-regression testing). Otherwise, if a problem is identified in a Testing environment or, worse, in a Production environment, it will be necessary to run the fix in all the underlying environments and then repeat all the non-regression tests to validate the quality of the intervention (i.e., make sure you have not introduced further bugs - regressions - following the fix).

In my opinion, the illustrates these concepts very well. Below is an "excerpt" with a focus on what was described above:

» conducted in 2001 but still valid today in terms of principles and best practices.

🔗 Do you like Techelopment? Check out the (TDD) techniques.

Unit testing: is the test of the single functionality that a developer is implementing. The type of technology is not relevant, whether it is Front-End development (e.g. JavaScript), API (e.g. serverless functions), Back-End (e.g. Java, Node.js, PHP, ...), Database, or Desktop and Mobile applications, there must always be at least one unit test for each developed functionality. It does not necessarily have to be run manually, it can be automated with TDD techniques.

Integration testing: each functionality is not an end in itself, it is always part of a more extensive development that includes the other features of the product (or application) that we are creating. For this reason, immediately after unit testing, it is necessary to run integration tests that verify the functioning of the individual functions once integrated with all the others.

System testing: this is the testing phase that we could define as "the dress rehearsal" of a show. It is the moment in which our application is tested in its entirety in terms of integrations with external systems such as third-party APIs, legacy systems, distributed databases, trusted network connections and so on.

Non-regression testing (abbreviated to NRT): perhaps the most important phase. Unlike the other phases that are performed sequentially, non-regression tests belong to a specific phase but must be performed iteratively every time changes are made to the code in any phase of the software life cycle. In fact, this type of testing aims to verify that the changes to the code introduced by new features and any fixes performed have not created malfunctions (regressions) in the parts of the software (or application) that worked correctly before the latest changes to the code. In short: what worked before must continue to work.

Testing methods (or types)

Of course, the basic approach involves manually executing tests for the following types:

• 
  Functional testing: testing the functionality and UI of an application in terms of satisfying functional requirements (e.g. submitting a form in the Desktop version and Mobile version of the site)


• 
  Non-functional testing or Technical testing: this type of testing focuses on the following aspects:

1. 
   Security: evaluating the robustness of the application from the point of view of potential cyber attacks


2. 
   Performance: measuring the performance of the application to identify potential bottlenecks or degradation of response times


3. 
   Reliability: reliability of the application in terms of its ability to handle errors and ensure usability of the service offered.


4. 
   Load & Stress Testing: identifying the load limits of the application to evaluate its adequacy with non-technical requirements such as number of requests per second and number of users using the application.


5. 
   Usability: specific tests to evaluate whether the UI of an application respects the principles of usability such as easy identification of menus and focus areas of the screens.

A more advanced approach than that of performing manual testing involves the adoption of Testing Automation.

Testing Automation is a real branch of computer science that consists in the development or integration of systems capable of automating both functional and non-functional tests. Thanks to automation, human errors or errors in the evaluation of the expected result will be avoided.

Main Testing Automation Systems

Functional Testing:

1. 
   Selenium - : This tool allows you to automate testing also for mobile (iOS, Android, Tizen).
   ⭐ Open-source
   


2. 
   Playwright - : an integrated environment to record and run your tests.
   💲Free / Payment
   


3. 
   LambdaTest - : integrated suite for enterprise testing.
   💲Payment
   

Non-functional testing:

1. 
   Apache JMeter - 
   💲Payment
   


2. 
   Tricentis Neoload - 
   
   Medium:
   
   facebook:
   
   X:
   
   youtube:
   
   
   
   
   
   

   
   
   
   References
   

   
   
   
   
   
   
   
   
   
   Vollständiger Original-Bericht

   Ausführliche Details, Code-Beispiele & Hersteller-Stellungnahme auf dev.to.

   ↗ Original-Artikel auf dev.to lesen