Continuous Integration with GitHub Actions

Introduction

In Lab 8 of DPS909, I explored the power of Continuous Integration (CI), specifically through GitHub Actions. This lab was a great opportunity to enhance my project by automating tests, ensuring quality control, and learning to integrate workflows into real-world development practices.

CI ensures that code remains functional and bug-free with every change. It prevents breaking the default branch by continuously running tests. For this lab, I not only integrated CI into my own project but also contributed tests to my partner’s project. This blog post reflects on my journey through these tasks.

Setting Up GitHub Actions for My Project

To set up CI in my project, I created a GitHub Actions Workflow. This workflow was triggered whenever:

• A push was made to the main branch.
• A pull request was created targeting the main branch.

YAML Workflow Configuration

Below is the YAML file I used for my GitHub Actions workflow:

name: CI Workflow

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Set up C++
        uses: actions/setup-cpp@v1
        with:
          compiler: gcc

      - name: Build the project
        run: |
          mkdir build
          cd build
          cmake ..
          make

      - name: Run Tests
        run: |
          cd build
          ctest

This workflow checks out my repository, builds the project using CMake, and runs the tests I wrote in Lab 7.

Testing CI with a Pull Request

To ensure the workflow was working as expected, I:

1. Created a new branch, add-more-tests.
2. Added new tests for a different function in my project.
3. Pushed the branch to my repository and opened a pull request targeting the main branch.

The CI workflow ran as expected:

• Initially, I broke one of the tests intentionally to observe a failure. The logs clearly showed the issue, which made debugging straightforward.
• After fixing the test, the CI passed, confirming the workflow's success.

Merging this pull request into the main branch gave me confidence that my project was protected from unintentional bugs.

Contributing Tests to a Partner’s Project

In the second part of the lab, I collaborated with my classmate, Inder Parmar, and contributed tests to their repository, Tailor4Job.

My Pull Request: #11

• Task: I added a test case for their jobFilter function to ensure it handles edge cases correctly.
• Challenges: Their repository used a different framework and setup than mine. Understanding their testing tools and project structure took some time.
• Outcome: My pull request passed their CI workflow successfully. This experience taught me the importance of writing tests that align with a project’s existing structure and guidelines.

Reflection on Continuous Integration

Setting up CI was a game-changer for my development workflow. Here are some key takeaways:

• Proactive Bug Prevention: CI ensures bugs are caught early, reducing the risk of breaking the default branch.
• Ease of Collaboration: Automated tests give confidence when merging code from multiple developers.
• Improved Debugging: CI logs provided detailed insights into test failures, making debugging faster and more efficient.

Collaborating on a partner's repo was an enriching experience, as it gave me exposure to a different codebase, testing environment, and workflow.

Optional Challenges

While I didn’t fully implement the optional challenges, I explored:

1. Adding a Linter: Automating linting as part of CI helps catch style and syntax issues early.
2. Development Containers: I experimented with setting up a reproducible development environment using Docker and Codespaces.

These steps can further enhance project quality and ease of onboarding for new contributors.

Conclusion

Lab 8 taught me the importance of integrating CI workflows into development projects. CI ensures consistent quality control and fosters collaboration, making it an invaluable tool in modern software development.

You can check out my project’s successful CI run and the pull request to my partner’s project below:

• CI Workflow Run: GitHub Actions
• Partner's Repo PR: Pull Request #11

This lab has truly enhanced my understanding of automation, testing, and collaboration in open-source development.