QA TOUCH + GITLAB

Connect GitLab issues and pipelines to your QA Touch project

Post bugs to a GitLab repository with the labels you pick, keep issues in sync, and open pipeline runs, stages and jobs from inside QA Touch.

Setup: access token, username and API key, project mapping

Bugs go to GitLab. Pipeline results come back to QA Touch.

Map a GitLab repository to a QA Touch project once. Testers log bugs where they test, developers triage in GitLab, and everyone can see the pipeline.

  • Problem: Bugs found in testing are retyped into GitLab.

    With the integration: Bugs logged in QA Touch go to the repository’s Issues tab, with GitLab labels you choose.

  • Problem: Checking a pipeline means switching to GitLab.

    With the integration: Pipeline status, stages and job logs open inside the project.

  • Problem: It’s hard to show how a project’s GitLab link relates to its tests.

    With the integration: A GitLab Integration Summary report ties the integration to test cases and test runs.

Illustrative sample data. Names and statuses are examples.

What the integration does

Five capabilities from QA Touch’s GitLab, pipelines and integration reports guides.

Bugs posted to GitLab Issues

Bugs created in QA Touch go to the Issues tab of the repository mapped to the project. When you create an issue, you can pick multiple GitLab labels to keep it organized.

Issues tabCustom labels

Issues kept in sync

QA Touch’s guide describes two-way sync. View, add and edit issues from QA Touch, including the title and status, and the changes are reflected in GitLab.

Pipelines in the project

See the mapped project’s pipelines. Open one for its status, commit message, branch, commit SHA, who triggered it, timing and environment.

Stages, jobs and logs

Three tabs: Pipeline for stages and jobs, Variables for CI/CD variables, and Jobs for a flat list with logs. Search jobs or filter by status.

GitLab Integration Summary

Add this report from a project’s Integration Reports tab. Give it a title and a duration, then export it as CSV or PDF.

From access token to a pipeline in QA Touch

Step through the flow. The screens are schematic, drawn from the paths and labels in QA Touch’s guides.

GitLab Preferences → Access Tokens

Create a personal access token

Add a token, name the application, and select all the scopes. Keep the token to enter in QA Touch.

QA Touch Administrator → Integration Settings

Connect with a username and API key

Click GitLab. In the GitLab integration overlay, enter your GitLab Username and GitLab API Key, then click Connect.

QA Touch project → Project Integration Mapping

Map a GitLab project

Open the QA Touch project, click Project Integration Mapping, select the GitLab project or repository, and save.

QA Touch bug GitLab Issues

Post bugs, edit issues

Bugs created in QA Touch are sent to the repository's Issues tab. Pick GitLab labels when you create an issue. Title and status can be edited from QA Touch.

QA Touch GitLab integration → GitLab Pipelines

Open a pipeline and its jobs

Click a pipeline in the list. Stages run left to right, each with a job count. Expand a job for its logs, artifacts and output.

Illustrative sample data. Names, SHAs and values are examples.

What changes for your QA team

Fewer tabs, fewer handoffs, and more context on every failure.

No double entry for bugs

A bug logged once in QA Touch reaches the repository, so testers don’t retype it in GitLab.

Bugs stay with the code

Issues live in the same repository as the code, and the sync described in the guide keeps both tools current.

Pipeline context on hand

Branch, commit SHA, who triggered it and job logs sit beside the result, so a failure arrives with its history.

A report to share

The GitLab Integration Summary exports as CSV or PDF, ready to hand to people outside the project.

Who uses it, and for what

Choose a role to see a scenario the integration supports.

The team's code lives in GitLab

You want each QA Touch project tied to the right repository.

What they do

  1. Create the access token in GitLab with all scopes.
  2. Connect GitLab under Administrator, Integration Settings.
  3. Map a GitLab project in each QA Touch project's Project Integration Mapping.

Result: the project can post issues and show pipelines.

You found a bug during a test run

The developer triages in GitLab, not in QA Touch.

What they do

  1. Log the bug in QA Touch and pick the GitLab labels that apply.
  2. Let the integration post it to the repository's Issues tab.
  3. Edit the title or status from QA Touch if it needs to change.

Result: the bug is in GitLab, labeled for triage.

A tester reported a bug

You want it in the repository you already work from.

What they do

  1. Pick up the issue from the repository's Issues tab.
  2. Fix it and push, then let the pipeline run.
  3. Ask the tester to check the pipeline in QA Touch.

Result: the tester sees your branch, commit and job results with the pipeline.

Checking a build before sign-off

You need the latest pipeline's result and a summary to share.

What they do

  1. Open GitLab Pipelines and the latest pipeline.
  2. Search jobs or filter by status to find failures, and expand a job for its logs.
  3. Add a GitLab Integration Summary report and export it as CSV or PDF.

Result: build status checked, and a report ready to share.

Set it up in four parts

These steps follow QA Touch’s GitLab and GitLab Pipelines guides.

Before you start

  • A GitLab account that can create a personal access token.
  • Administrator access to Integration Settings in QA Touch.
  • A GitLab repository to map to a QA Touch project.

The guides don’t say how often sync runs, how conflicts are handled, or what the pipeline list columns and every status are. They also differ in small ways: one says Submit or Update where the pipelines guide says Connect, and the mapping step mentions a “Secret Group” section. The issues guide mentions GitHub in places, so this page gives no menu path for the issues view. Check each against your screens.

  1. In GitLab, open Preferences, then Access Tokens in the sidebar.
  2. Add a token and name it. The 2019 blog sets a one-year expiry.
  3. Select all scopes: api, read_user, read_repository, write_repository and read_registry. Save the token.
  1. In QA Touch, go to Administrator, then Integration Settings.
  2. Click GitLab to open the GitLab integration overlay.
  3. Enter your GitLab Username and GitLab API Key, then click Connect.
  1. Open the QA Touch project from the Project List.
  2. Click Project Integration Mapping.
  3. Select the GitLab project or repository, then save.
  1. Create bugs in QA Touch to post them to GitLab Issues.
  2. Open GitLab Pipelines from the GitLab integration page and click a pipeline.
  3. For a report, open the project's Integration Reports tab and click Add Integration Reports.

Report details: see the integration reports guide (opens in a new tab), and the GitLab pipelines guide (opens in a new tab) for the pipeline screens.

Connected? See what you can do from a pipeline.

Questions about the GitLab integration

Answers are based on QA Touch’s GitLab, GitLab Pipelines and integration reports guides.

What does the QA Touch GitLab integration do?

It posts bugs from QA Touch to a mapped GitLab repository’s Issues tab, keeps issues in sync, shows pipeline runs with their stages and jobs, and offers a GitLab Integration Summary report.

A GitLab account that can create a personal access token, and Administrator access to Integration Settings in QA Touch. You enter your GitLab Username and API Key, then map a repository to a project.

The GitLab guide says to select all scopes: api, read_user, read_repository, write_repository and read_registry. The 2019 blog also sets a one-year expiry, so plan to renew the token.

The guide and blog describe two-way sync: issues added or edited in QA Touch, including title and status, are reflected in GitLab. They don’t say how often sync runs or how conflicts are resolved.

Status, commit message, branch, commit SHA, who triggered it, created and finished times, duration and environment where applicable. Tabs show stages and jobs, CI/CD variables, and a job list with logs.

The pipelines guide documents expanding jobs, searching, filtering by status and closing the detail view. It doesn’t mention retry or an open-in-GitLab action.

A report you add from a project’s Integration Reports tab. It gives an overview of how the project’s GitLab integration connects with its test cases and test runs. Set a title and duration, save it, and export it as CSV or PDF.

Connect GitLab to QA Touch

Add your token, map your project, and see bugs and pipelines side by side.