Skip to content
Skillpedia
Testing40k · #5205

javascript-typescript-jest

Teaches your agent to write efficient tests in JavaScript and TypeScript using Jest. It helps ensure code quality and proper functioning.

What it does

This tool helps you create tests for your JavaScript and TypeScript code using the Jest library. It teaches best practices for organizing your tests, simulating parts of your code that depend on others (like external APIs), and verifying that everything works as expected.

When to use it

  • ✓When you write code in JavaScript or TypeScript.
  • ✓To ensure your code works correctly after making changes.
  • ✓To simulate external dependencies and test only your logic.

Example of what to ask your AI

“How can I test a function that makes a call to an external API?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/github/awesome-copilot/blob/main/skills/javascript-typescript-jest/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/github/awesome-copilot/blob/main/skills/javascript-typescript-jest/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool organizes your tests into specific files and uses commands like `describe` and `it` to structure tests. To simulate dependencies, it uses functions like `jest.mock` and `jest.spyOn` to create fake versions of these dependencies, allowing you to test your code in isolation.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add github/awesome-copilot --skill javascript-typescript-jest

Or download just the file:

curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/javascript-typescript-jest/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Test Structure

  • Name test files with .test.ts or .test.js suffix
  • Place test files next to the code they test or in a dedicated __tests__ directory
  • Use descriptive test names that explain the expected behavior
  • Use nested describe blocks to organize related tests
  • Follow the pattern: describe('Component/Function/Class', () => { it('should do something', () => {}) })

Effective Mocking

  • Mock external dependencies (APIs, databases, etc.) to isolate your tests
  • Use jest.mock() for module-level mocks
  • Use jest.spyOn() for specific function mocks
  • Use mockImplementation() or mockReturnValue() to define mock behavior
  • Reset mocks between tests with jest.resetAllMocks() in afterEach

Testing Async Code

  • Always return promises or use async/await syntax in tests
  • Use resolves/rejects matchers for promises
  • Set appropriate timeouts for slow tests with jest.setTimeout()

Snapshot Testing

  • Use snapshot tests for UI components or complex objects that change infrequently
  • Keep snapshots small and focused
  • Review snapshot changes carefully before committing

Testing React Components

  • Use React Testing Library over Enzyme for testing components
  • Test user behavior and component accessibility
  • Query elements by accessibility roles, labels, or text content
  • Use userEvent over fireEvent for more realistic user interactions

Common Jest Matchers

  • Basic: expect(value).toBe(expected), expect(value).toEqual(expected)
  • Truthiness: expect(value).toBeTruthy(), expect(value).toBeFalsy()
  • Numbers: expect(value).toBeGreaterThan(3), expect(value).toBeLessThanOrEqual(3)
  • Strings: expect(value).toMatch(/pattern/), expect(value).toContain('substring')
  • Arrays: expect(array).toContain(item), expect(array).toHaveLength(3)
  • Objects: expect(object).toHaveProperty('key', value)
  • Exceptions: expect(fn).toThrow(), expect(fn).toThrow(Error)
  • Mock functions: expect(mockFn).toHaveBeenCalled(), expect(mockFn).toHaveBeenCalledWith(arg1, arg2)
FAQ

What are 'mocks'?

Mocks are fake versions of parts of your code (like functions or modules) that you use during testing. They allow you to control the behavior of these parts and test your code without relying on external or complex systems.

Why use tests?

Tests help ensure your code is working as expected and to catch errors quickly, especially when you make changes. They give you more confidence that the code won't break.

What is 'snapshot testing'?

Snapshot testing is a technique for testing user interfaces or complex data structures. It takes a 'snapshot' of the expected output and, in future tests, compares the current output to this snapshot to see if there have been unexpected changes.

Details

Original description by the author

Best practices for writing JavaScript/TypeScript tests using Jest, including mocking strategies, test structure, and common patterns.

repo: github/awesome-copilot

Popularity

GitHub stars
40k
Ranking position
#5205
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills