top of page


Are you using GitLab as a DevOps lifecycle management tool and looking for a solution to manage your tests?

Squash easily interfaces with GitLab to sustainably manage your manual and automated tests in a continuous integration and deployment environment.


Squash seamlessly integrates with GitLab to meet the needs of each feature team member involved in the management and the tracking of manual and automated tests.

Sustainable management of tests in continuous integration and deployment context

Structure your manual and automated tests linked to GitLab issues in common repositories to build a homogeneous and easily maintainable test asset in a classic or BDD approach.

No change in work habits

Define your user stories, plan your sprints, launch the execution of your automated tests from your CI/CD pipelines and manage your bugs in GitLab.
Design, plan and execute your tests in Squash.

Full visibility on the progress of the testing process in Squash and GitLab

As a tester, retrieve in Squash the content of GitLab user stories to design and plan tests.

As a product owner, track in GitLab the testing progress and the validation of the user stories.

Streamlining of work for the entire feature team

Easily design your test plans to validate the content of a GitLab iteration or milestone.
Report from Squash issues pre-filled with test data to facilitate their correction.
Write scenarios compatible with several automation technologies and share the associated scripts in a GitLab repository for their implementation.


Tests, executions and all test-related data are managed by Squash: system workload does not depend upon your GitLab instance. This enables company-scale implementations.
The Squash deployment is simplified by the fact that Squash is customizable to various methodologies (Agile, Waterfall), various project phases (initial development, evolutions, maintenance), various kinds of tests (acceptance tests, functional tests, non-regression tests, end-to-end tests, etc.), with or without automation.


Click on the numbered boxes to go directly to the related details.

Learn what product owners, agile test engineers, test automation developers, and the forge do to use the full potential of Squash-GitLab integration.

Open the diagram

full screen


Define user stories and plan sprints in GitLab

As a product owner, define user stories in GitLab, then add them to iterations, milestones or boards.

Squash automatically synchronizes these agile objects as requirements, which can be organized by sprint folders.

Use GitLab to define user stories and plan sprints, which are then synchronized in your test repository.

Beforehand, configure the GitLab perimeter to be synchronized in Squash.

Learn more


Formalize tests in Squash TM and track their design in GitLab

As a tester, define the automation strategy of the tests while designing them. Identify test cases that are good candidates for automation (for example, those that will become non-regression tests), as well as tests that are meant to be executed manually.


Formalize manual and automated test scenarios in Squash using a BDD or classic (actions/results) approach and relying on features that facilitate test writing and maintenance. Then, associate them with the synchronized requirements that they verify.

As product owner or developer, follow the test design progress in parallel in GitLab.


Design execution plans in Squash from a scope of user stories

As a tester, design an execution plan in Squash using a wizard that allows you to easily identify the tests to be executed to validate a scope of GitLab issues (iteration, milestone or set of issues).


Implement automated scripts

As a tester, pass on the list of tests to be automated to the test automation developer.

As an automation engineer or developer, in a classic approach, implement the tests and then link the Squash test cases to the automated scripts contained in a GitLab repository.

In a BDD approach, Squash automatically generates an automation script skeleton in Cucumber or Robot Framework format from each test case. Then, it automatically pushes it into the automation team's Git repository and links it to the BDD test case.

Transmit and implement the list of tests to be automated, whether you are using a classical or a BDD approach.

To smoothen the interactions between the functional tester and the test automation developer, you can set up an automation workflow.
➜ Learn more


Integrate automated test execution into the CI/CD pipeline

As a functional tester, define which automated test plan(s) to run and when to run them. You can, for example, in addition to the UI every night, test the web services on every pull request / merge request.

As an SRE engineer, integrate into the CI/CD pipeline:

  • the operation of the automated test plan (plan retrieval in Squash TM, execution, results feedback and reporting in Squash TM), and

  • optionally, a quality gate to define if the test results are acceptable or not to continue the execution of the downstream pipeline.

Once the configuration is done, the tests are automatically launched according to the defined strategy.

Squash allows the integration of automated test execution into a CI/CD pipeline.

Run manual tests

As a tester, manually run the tests in Squash to verify the user stories.

For failed tests, report issues in GitLab directly from the test runs. They are pre-filled with all the test data to facilitate the exchanges with the developer and allow him to reproduce them easily.

Run your tests manually in Squash, benefit from a follow-up in GitLab.

As a product owner, follow in GitLab the test execuion progress and the user stories validation.

GitLab provides all the visibility necessary for Product Owners to monitor the progress of the QA process.

Analyze the results of automated tests

As a tester, review and analyze every morning the results of automated tests that were run overnight.

As with manual tests, report issues from Squash and track test execution progress in GitLab.

To go further: BDD with Squash

Formalize in Squash the acceptance criteria of GitLab user stories as BDD test cases.


Associate BDD test cases with GitLab issues synchronized in Squash.


Automatically generate a pre-script from a BDD test case on a GitLab repository.


bottom of page