Implement Pre-Commit Hook to check code coverage greater than 85 percent Nest.js

Implement Pre-Commit Hook to check code coverage greater than 85 percent Nest.js

Ensuring code quality and test coverage is a vital aspect of software development.
Pre-commit hooks provide an excellent way to enforce certain checks before allowing code to be committed. In this article, we'll guide you through the process of implementing a pre-commit hook to check code coverage greater than 80% in a Nest.js project using Husky and Jest.

Step 1: Create a Repository and Clone

Start by creating a new repository on your preferred version control platform (e.g., GitHub, GitLab, or Bitbucket). Clone the repository to your local machine:

                         git clone repository-url
                         cd repository-name
                        

Step 2: Install Required Packages

Install the necessary packages for testing and code coverage:

                    npm install --save-dev husky jest @nestjs/testing
                        

Let's briefly explain each package:

Husky: A tool for managing Git hooks.
Jest: A JavaScript testing framework widely used for testing Node.js applications.
@nestjs/testing: The testing module for Nest.js applications.

Step 3: Set Up Husky with npm Package Scripts

Initialize Husky in your project by running the following command:

                    npm pkg set scripts.prepare="npx husky install"
                        

This command sets the `prepare` script in your `package.json` to run `npx husky install` during the preparation phase.

Step 4: Run npm Prepare

Execute the following command to trigger the prepare script:

                    npm run prepare
                        

This command installs Husky and sets up the necessary hooks in your Git repository.

Step 5: Add a Pre-Commit Hook for Code Coverage

Now, add a pre-commit hook that checks code coverage before allowing a commit. Run the following command:

                    npx husky add .husky/pre-commit "npm run test:cov"
                        

This command adds a pre-commit hook that executes the test:cov npm script before every commit. The test:cov script runs Jest with coverage reporting.

Step 6: Update Package.json Scripts

In your `package.json` file, update the scripts section to include the `test:cov` script and the `prepare` scripts:

                    {
                      "scripts": {
                        "build": "nest build",
                        "start": "nest start",
                        "test": "jest",
                        "test:cov": "jest --coverage",
                        "prepare": "npx husky install"
                      },
                      "jest": {
                        // Jest configuration
                      }
                    }
                    
                        

Add below code to check code coverage in package.json file:

                    "coverageThreshold": {
                     "global": {
                       "all": true,
                       "check-coverage": true,
                       "statements": 85,
                       "branches": 85,
                       "functions": 85,
                       "lines": 85
                     }
                    }
                        

Make sure your Jest configuration includes the appropriate settings for your project.

Here are the sample package.json:

                    {
                      "name": "calculator",
                      "version": "v1",
                      "description": "",
                      "author": "",
                      "private": true,
                      "license": "UNLICENSED",
                      "scripts": {
                        "build": "nest build",
                        "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
                        "start": "nest start",
                        "start:local": "cross-env APPENV=LOCAL nest start --watch",
                        "start:dev": "nest start --watch",
                        "start:debug": "nest start --debug",
                        "start:prod": "node dist/main",
                        "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
                        "test": "jest",
                        "test:watch": "jest --watch",
                        "test:cov": "jest --coverage",
                        "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
                        "test:e2e": "jest --config ./test/jest-e2e.json",
                        "prepare": "npx husky install"
                      },
                      "dependencies": {
                        "@nestjs/cli": "^9.0.0"
                      },
                      "devDependencies": {
                        "@nestjs/testing": "^9.0.0",
                        "@types/jest": "29.5.1",
                        "eslint": "^8.0.1",
                        "husky": "^8.0.3",
                        "jest": "29.5.0",
                        "prettier": "^2.3.2"
                      },
                      "jest": {
                        "moduleFileExtensions": [
                          "js",
                          "json",
                          "ts"
                        ],
                        "rootDir": "src",
                        "testRegex": ".*\\.spec\\.ts$",
                        "transform": {
                          "^.+\\.(t|j)s$": "ts-jest"
                        },
                        "collectCoverageFrom": [
                          "**/*.(t|j)s"
                        ],
                        "coverageDirectory": "../coverage",
                        "testEnvironment": "node",
                        "coveragePathIgnorePatterns": [
                          "main.ts",
                          ".module.ts",
                          ".utils.ts",
                          ".config.ts",
                          ".response.ts",
                          ".pipe.ts",
                          ".interceptor.ts",
                          ".filter.ts",
                          "logger.service.ts",
                          ".shared",
                          "src/modules/dtos",
                          "src/constants",
                          "src/mock"
                        ],
                        "coverageThreshold": {
                          "global": {
                            "all": true,
                            "check-coverage": true,
                            "statements": 85,
                            "branches": 85,
                            "functions": 85,
                            "lines": 85
                          }
                        }
                      }
                    }
                    
                        

Step 7: Try to Commit Your Changes

With the pre-commit hook in place, make changes to your code and attempt to commit them.

Let's check with 85%

The commit will be success if the code coverage is greater than 85%. Right now my code coverage is not 85%. So the commit will be failed.
For this experiment, change the value to 85 as:

                        "coverageThreshold": {
                          "global": {
                            "all": true,
                            "check-coverage": true,
                            "statements": 85,
                            "branches": 85,
                            "functions": 85,
                            "lines": 85
                          }
                        }
                        

Output:

Implement Pre-Commit Hook to check code coverage greater than 85 percent Nest.js

You can see not allowing to commit, because the code coverage is less than 85%.

Let's check with 75%

For this experiment, change the value to 75 as:

                        "coverageThreshold": {
                          "global": {
                            "all": true,
                            "check-coverage": true,
                            "statements": 75,
                            "branches": 75,
                            "functions": 75,
                            "lines": 75
                          }
                        }
                        

Output:

Implement Pre-Commit Hook to check code coverage greater than 85 percent Nest.js

You can see its allowing to commit, because the code coverage is greater than 75%.
The pre-commit hook will run the tests and check code coverage. If the coverage is below the specified threshold, the commit will be rejected.

Advantages of Pre-Commit Hooks for Code Coverage:

Early Detection of Issues:Pre-commit hooks catch issues and low test coverage early in the development process.
Automated Quality Assurance:Automated checks ensure that only code meeting quality and coverage standards is committed.
Consistency:Enforcing coverage thresholds ensures a consistent level of code quality across the project.

---

Conclusion:

Implementing a pre-commit hook for code coverage in Nest.js using Husky and Jest is a proactive approach to maintaining high-quality code.

By following the steps outlined in this article, you can seamlessly integrate this practice into your development workflow, ensuring that every commit meets the specified code coverage standards.

Related Keywords:

Implement Pre-Commit Hook to check code coverage

Pre-Commit Hook to check code coverage greater than 85 percent

Implement Pre-Commit Hook to check code coverage greater than 85 percent Nest.js

Pre-Commit Hook to check code coverage