Turn the testing and verification techniques developed earlier in the programme into repeatable automated checks inside a CI/CD pipeline.
This four-hour module develops practical capability in test automation and CI/CD integration, using GitHub Actions to automate static analysis, unit testing and coverage across C/C++, Python and Rust.
Participants build a multi-language pipeline, publish test results, use dependency caching and matrix builds, then extend the workflow with Docker Compose test environments, coverage gates, severity-based static-analysis gates and branch protection.
The module concludes with a complete gated CI/CD pipeline for a polyglot codebase, combining automated verification evidence with merge controls.
View the Full Software Testing & Verification Programme
What You Will Learn
Module 11 brings together verification activities introduced across earlier modules and places them inside an automated delivery workflow.
Participants learn how to configure a CI pipeline that runs:
- Static analysis
- Unit tests
- Coverage measurement
- Integration-test dependencies
- Quality gates
- Merge protection
The module also introduces workflow design decisions around runners, caching, build matrices, fail-fast/fail-slow behaviour, reporting and pipeline ownership.
By the end of the module, participants will have built a CI/CD verification pipeline spanning C/C++, Python and Rust.
Topics
- CI/CD concepts; GitHub Actions workflow structure; GitLab CI stages and jobs
- Self-hosted vs cloud-hosted runners
- Automating static analysis in a pipeline
- Automating unit tests (GoogleTest/Catch2, pytest, cargo test) with JUnit XML reporting
- Dependency caching and matrix builds across languages
- Automating coverage measurement in CI; coverage trend tracking
- Docker Compose test environments for integration testing
- Pipeline gating: soft gates vs hard gates
- Coverage, static-analysis and test-result gating
- Branch protection, required status checks and pipeline health monitoring
Lab 1: Multi-Language CI Pipeline (Static + Unit)
Learning Objectives: GitHub Actions, static analysis automation, unit test automation, matrix builds
Description: Build a GitHub Actions pipeline that runs static analysis and unit tests across all three languages.
Tasks
- Write a GitHub Actions workflow triggered on
pushandpull_request. - Add a static analysis stage running cppcheck/clang-tidy, pylint/mypy and clippy.
- Add a unit test stage running GoogleTest/Catch2, pytest and cargo test.
- Publish test results in JUnit XML format as a pipeline artifact.
- Add dependency caching to reduce pipeline run time.
- Configure a matrix build spanning the three languages.
Extension Tasks
- Add a fail-fast vs fail-slow configuration choice for the static analysis stage.
- Route pipeline failure notifications to a specific owner per language.
Topics Covered
GitHub Actions, Static Analysis Automation, Unit Test Automation, Matrix Builds
Open Source Recommendation
GitHub Actions (free for public repositories) combined with the open-source tools from Modules 2 and 3.
Lab 2: Coverage Automation & Pipeline Gating
Learning Objectives: Coverage automation, Docker Compose test environments, pipeline gating
Description: Extend the Lab 1 pipeline with a coverage stage and enforce quality gates on the result.
Tasks
- Add gcov/lcov, coverage.py and cargo-tarpaulin stages to the pipeline.
- Merge the three languages’ coverage figures into one reported total.
- Stand up a Docker Compose environment for one integration-test dependency.
- Configure a coverage gate that fails the build below a defined threshold.
- Configure a static analysis gate that fails only on high-severity findings.
- Require the pipeline as a required status check before merge.
Extension Tasks
- Add a coverage trend comparison against the previous run.
- Quarantine one deliberately flaky test without masking real failures.
Topics Covered
Coverage Automation, Docker Compose, Pipeline Gating, Branch Protection
Open Source Recommendation
Docker Compose and the same open-source coverage tools from Module 4, run entirely within GitHub Actions’ free tier.
Module 11 Coverage Matrix
| Topic | Lab 1 | Lab 2 |
|---|---|---|
| CI/CD Fundamentals | ✓ | |
| Static Analysis Automation | ✓ | |
| Unit Test Automation | ✓ | |
| Coverage Automation | ✓ | |
| Pipeline Gating | ✓ |
Module Project: Complete Gated CI/CD Pipeline for a Polyglot Codebase
Complete gated CI/CD pipeline for a polyglot codebase: static analysis, unit tests and coverage measurement across C/C++, Python and Rust, enforced by coverage and severity-based quality gates.
The module project combines automated verification activities into one repeatable pipeline.
Participants bring together:
Code Change
↓
CI Trigger
↓
Static Analysis
↓
Unit Tests
↓
Coverage Measurement
↓
Integration-Test Environment
↓
Quality Gates
↓
Required Status Check
↓
Merge Decision
This is the point in the programme where earlier testing techniques become part of a controlled engineering workflow.
From Manual Verification to Automated Evidence
Earlier modules teach how to perform specific verification activities.
Module 11 asks a different question:
How can those activities run consistently whenever the code changes?
The module therefore does not replace static analysis, unit testing or coverage techniques. Instead, it automates the already defined verification activities.
This distinction is important for both curriculum clarity and SEO.
Automating Static Analysis
Module 2 introduces the static-analysis tools themselves.
Module 11 reuses:
- cppcheck
- clang-tidy
- pylint
- mypy
- clippy
inside an automated pipeline.
Participants configure static analysis as a CI stage and later enforce a severity-based gate so that high-severity findings can block the pipeline.
This is why Module 11 should target static analysis automation, not generic static analysis training.
Automating Unit Tests
Module 3 develops unit and component test suites.
Module 11 automates those same language-specific frameworks:
C/C++
GoogleTest / Catch2
Python
pytest
Rust
cargo test
The pipeline publishes results in JUnit XML format as an artifact, giving automated test execution a consistent reporting layer.
Matrix Builds Across C/C++, Python and Rust
The curriculum includes a matrix build spanning the three languages.
This enables a single workflow to coordinate language-specific verification rather than creating unrelated pipelines for each codebase component.
The practical lab also introduces dependency caching to reduce pipeline runtime.
Coverage Automation
Module 4 introduces coverage measurement using:
- Gcov/lcov
- Coverage.py
- Cargo-tarpaulin
Module 11 automates those tools inside the CI workflow.
Participants then combine the resulting coverage figures and apply a threshold-based gate.
This creates a strong internal-link relationship between Module 4 and Module 11 without allowing the two pages to compete for the same primary search intent.
Docker Compose Test Environments
The second lab introduces a Docker Compose environment for an integration-test dependency.
This gives participants a repeatable way to stand up supporting infrastructure required during automated testing. Keep this section focused on test environments in CI/CD rather than broad Docker or container training.
Soft Gates and Hard Gates
The curriculum introduces:
- Soft gates
- Hard gates
as part of pipeline gating.
A useful way to explain this on the page is:
Soft gate
A result is surfaced for review without necessarily blocking progression.
Hard gate
A defined failure condition prevents the pipeline from proceeding successfully.
Within the practical work, participants configure both coverage and severity-oriented controls.
Coverage and Severity-Based Quality Gates
Participants implement two particularly important controls:
Coverage gate
The build fails when coverage drops below a defined threshold.
Static-analysis gate
The pipeline fails only on high-severity findings.
This teaches an important principle: not every finding necessarily needs the same pipeline response.
Branch Protection and Required Status Checks
The final stage connects verification results to the merge decision.
Participants configure the pipeline as a required status check before merge.
This transforms the CI system from passive reporting into an enforcement point for the defined verification policy.
The curriculum also includes branch protection and pipeline health monitoring as broader topics.
Handling Flaky Tests
An extension activity asks participants to quarantine one deliberately flaky test without masking real failures.
That wording is worth preserving because it introduces a realistic CI/CD problem while avoiding the simplistic idea that unreliable tests should merely be disabled.
How Module 11 Connects With Earlier Modules
This page has some of the strongest internal-link opportunities in the whole cluster.
Module 2: Static Analysis & Code Quality
Provides the static-analysis tools that Module 11 automates.
Module 3: Unit & Component Testing
Provides GoogleTest/Catch2, pytest and cargo test suites that are moved into CI.
Module 4: Structural Code Coverage & MC/DC
Provides gcov/lcov, coverage.py and cargo-tarpaulin coverage techniques that Module 11 automates.
Module 6: Integration & Protocol-Level Testing
Introduces integration-testing concepts that can use controlled test dependencies and environments.
How Module 11 Prepares for the Capstone
Module 12 moves from testing techniques into cross-industry standards mapping, verification planning, evidence dossiers and audit-readiness concepts.
The automated pipeline artifacts produced in Module 11 can therefore become part of that broader evidence story.
Frequently Asked Questions
What does the Test Automation & CI/CD Integration module cover?
The module covers CI/CD concepts, GitHub Actions, GitLab CI, automated static analysis, automated unit tests, coverage automation, Docker Compose test environments, quality gates and branch protection.
Which CI/CD platform is used in the practical labs?
The labs use GitHub Actions. GitLab CI stages and jobs are also included in the module topics.
Which programming languages are automated?
The module automates verification across C/C++, Python and Rust.
Which static-analysis tools are automated?
The practical workflow runs cppcheck/clang-tidy, pylint/mypy and clippy.
Which unit-test frameworks are automated?
Participants run GoogleTest/Catch2 for C/C++, pytest for Python and cargo test for Rust.
Are test results published by the pipeline?
Yes. The first lab publishes test results in JUnit XML format as a pipeline artifact.
Does the module cover matrix builds?
Yes. Participants configure a build matrix spanning C/C++, Python and Rust.
Is coverage automated?
Yes. Participants add gcov/lcov, coverage.py and cargo-tarpaulin stages and combine the resulting coverage figures.
Does the module include Docker Compose?
Yes. Lab 2 uses Docker Compose to stand up one integration-test dependency.
Are quality gates included?
Yes. Participants create a coverage gate and a severity-based static-analysis gate.
Is branch protection included?
Yes. Participants require the pipeline as a status check before merge, while branch protection is included in the wider curriculum topics.
Does the module address flaky tests?
Yes. An extension task asks participants to quarantine a deliberately flaky test without masking genuine failures.
What is the Module 11 project?
The project is a Complete Gated CI/CD Pipeline for a Polyglot Codebase, automating static analysis, unit tests and coverage across C/C++, Python and Rust with quality gates.
