INTEGRATION BETWEEN SQUASH AND GITLAB
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.
GOOD TO KNOW
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.
HOW IT WORKS
Click on the numbered boxes to go directly to the related details.
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.
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.
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.
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.
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.
As a product owner, follow in GitLab the test execuion progress and the user stories validation.
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.