Versioning & CI/CD

The goal of CI/CD is to verify that any new source code update to an application does not generate errors, such as regressions or anomalies.

Continuous integration is a software brick that allows us to automate many tasks, like compiling the code, unit tests, functional tests, etc.

GitFlow, used for versioning, is a workflow that we exploit as an overlay to use with the Git branch system. The main purpose of GitFlow is to enable running high-level commands on the development branches, and thus saves a lot of time for developers.

The practice of versioning & CI/CD involves implementing a number of good practices.

The importance of versioning and unique source code.

One of the prerequisites for continuous integration is that the source manager is unique and versioned. To do this we use Git version management software.

The source manager contains all versioned sources of the product, specifically the timeline of all changes made to the application. The advantage of this tool is that it makes it easy to access the architecture of earlier versions.

In addition, we work with the GitFlow methodology. The "Flow" extension linked to our Git provides additional controls and allows developers to perform complex operations on a source code repository.

Regularly integrate changes (commits).

Developers integrate their changes every day, so testers can regularly test the latest changes. As a result, the risk of conflicts in the code is diminished, and when they do arise, are detected more quickly. This allows us to correct detected problems early, and therefore allows us to maintain a product of high quality and functionality.

Set up integration tests.

When a coding function is realized, a piece of code is developed in parallel to test it. The idea is to design the tests before coding the application’s components. Therefore, it is the tests that will influence how to code.

This virtuous circle, which needs to be methodical in its use in development, generates an increase in the quality of the modifications and therefore the final application.

Test the application in an environment identical to the production environment.

The test environment configuration must be similar to the production environment. Thus the tests are carried out under the "real" conditions of the final environment which generates a certain harmony when the modifications are delivered in the final product. A lot of bad surprises are avoided in this way.

Our engineers are currently using several work environments: 

• A development environment.
• A preproduction environment.
• A production environment.

Our progressive approach to implementing continuous integration in our various projects is part of a constant dynamic to increase the quality of the applications that we develop. This method significantly improves coding quality, and thus the final product.

The benefits of continuous integration for your digital projects*

• Serenity and Visibility: beyond the peace of mind that comes with automated testing, all developers see what is happening, allowing them to better anticipate and adapt their next developments.
• Quick code discrepancy detection: developers are quickly informed of regressions, bugs, or other anomalies and can take corrective actions promptly and continuously. The earlier the errors are detected in a project, the less time it takes to correct them.
• Immediate availability of the application: a version of the functional application is always available for a test or a demonstration.

*Depending of the type of project, continuous integration may be implemented more or less easily.

Automated testing and Test Driven Development (TDD) are complementary but separate principles.

Automated testing and Test Driven Development (TDD) are complementary but separate principles.

• • Red: Create a failing test.
  • Green: Write the piece of code that makes this test successful.
  • Refactor: Refactor the code.

Many tools exist to set up automated tests and to conduct Test Driven Development: PHP Code Sniffer, PHPUnit, Selenium, Selenium IDE, Selenium WebDriver, Jenkins, etc.

Development Quality Control: Automated Testing

The tests are carried out in a very specific order: we begin with deploying unit tests, followed by integration tests and we finally generate functional end-to-end tests.

Unit Testing

These tests are automated. They ensure and verify that the components of the application function properly in an independent manner. We may also refer to them as "qualifying tests".

Integration Tests

Also automated, this type of test is carried out to ensure and verify that the features communicate well between themselves. This process allows us to be certain that all features interact well with one other, in accordance with project specifications.

End-to-end Functional Tests

Whether they are manual or automated, these tests ensure that the software meets the scenarios of usage detailed by users. The tester will run end-to-end acceptance tests on business processes and will then make sure they meet the customer's needs. If all business scenarios meet the customer's expectations, then the application’s objective has been attained.

Impacts on your product quality:

• Fewer bugs: significant decrease in the number of bugs and regressions.
• Advanced tests: a final product, fully and, most importantly, regularly tested.
• An evolutionary product: the guarantee of having a sustainable and easily maintainable product in the long-term.
• Functional software fast delivery: provision of a functional product available at any time for a demonstration.
• Risk reduction: the discovery of defects in the application is as fast as possible.