Continuous Integration (CI) is a software development practice where developers frequently integrate their code into a shared repository, usually several times a day. Each integration is verified by an automated build and automated tests to detect integration errors as quickly as possible. This practice helps to improve the quality of the software and reduce the time taken to deliver it.

1. Frequent Commits: Developers commit their code changes frequently to the main branch.
2. Automated Builds: Each commit triggers an automated build process.
3. Automated Testing: Automated tests are run to ensure that the new code does not break existing functionality.
4. Immediate Feedback: Developers receive immediate feedback on the integration status.
5. Build Artifacts: Successful builds produce artifacts that can be deployed to staging or production environments.

There are several CI tools available that integrate well with Git repositories. Some popular ones include:

• Jenkins
• Travis CI
• CircleCI
• GitHub Actions
• GitLab CI/CD

Most CI tools require a configuration file in your repository to define the build and test process. The configuration file is usually named .yml or .yaml.

Example: GitHub Actions

Create a .github/workflows/ci.yml file in your repository:

Commit the CI configuration file to your repository and push it to the remote repository:

Once the configuration is pushed, the CI tool will automatically start the build and test process. You can monitor the status of the CI process through the CI tool's dashboard.

1. Create a New Repository: Create a new repository on GitHub.
2. Clone the Repository: Clone the repository to your local machine.
3. Add a Simple Node.js Project:
   • Initialize a new Node.js project with npm init -y.
   • Create a simple test using a testing framework like Jest.
4. Add GitHub Actions Configuration: Add a .github/workflows/ci.yml file with the configuration provided above.
5. Commit and Push: Commit and push the changes to GitHub.
6. Verify CI: Check the Actions tab on GitHub to verify that the CI process runs successfully.

1. Create a New Repository: Done on GitHub.
2. Clone the Repository:

   git clone https://github.com/your-username/your-repo.git
   cd your-repo
   

3. Add a Simple Node.js Project:

   npm init -y
   npm install jest --save-dev
   

   Create a test script in package.json:

   "scripts": {
     "test": "jest"
   }
   

   Create a sum.js file:

   function sum(a, b) {
     return a + b;
   }
   module.exports = sum;
   

   Create a sum.test.js file:

   const sum = require('./sum');
   
   test('adds 1 + 2 to equal 3', () => {
     expect(sum(1, 2)).toBe(3);
   });
   

4. Add GitHub Actions Configuration:

   mkdir -p .github/workflows
   touch .github/workflows/ci.yml
   

   Add the following content to ci.yml:

   name: CI
   
   on:
     push:
       branches:
         - main
     pull_request:
       branches:
         - main
   
   jobs:
     build:
       runs-on: ubuntu-latest
   
       steps:
       - name: Checkout code
         uses: actions/checkout@v2
   
       - name: Set up Node.js
         uses: actions/setup-node@v2
         with:
           node-version: '14'
   
       - name: Install dependencies
         run: npm install
   
       - name: Run tests
         run: npm test
   

5. Commit and Push:

   git add .
   git commit -m "Set up CI with GitHub Actions"
   git push origin main
   

6. Verify CI: Go to the Actions tab on your GitHub repository to see the CI process running.

• Incorrect Configuration File Path: Ensure the CI configuration file is in the correct path (e.g., .github/workflows/ci.yml for GitHub Actions).
• Missing Dependencies: Make sure all necessary dependencies are listed in your package.json file.
• Failing Tests: Ensure your tests are correctly written and passing locally before pushing to the repository.

In this section, you learned how to set up Continuous Integration with Git using GitHub Actions. You configured a CI pipeline to automatically build and test your code on each commit and pull request. This practice helps to ensure code quality and provides immediate feedback to developers. In the next module, we will explore Git best practices and tips to further enhance your Git workflow.