0Pricing
Next.js 15 Fullstack Web Apps · Ders

Birim ve Entegrasyon Testleri

Jest ve React Testing Library kullanarak React bileşenleri ve Next.js işlevleri için etkili birim ve entegrasyon testleri yazın.

Birim ve Entegrasyon Testleri, CoddyKit'te ücretsiz bir Next.js 15 Fullstack Web Apps dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Next.js 15 Fullstack Web Apps öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Next.js 15 Fullstack Web Apps kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

Why We Test Our Code

Welcome! In modern web development, especially with complex applications built with Next.js, ensuring your code works as expected is crucial. This is where testing comes in.

  • Reliability: Tests prevent bugs and regressions.
  • Maintainability: Well-tested code is easier to refactor and update.
  • Confidence: You can deploy new features with greater assurance.

We'll focus on Unit Tests (small, isolated parts) and Integration Tests (how parts work together).

Setting Up Jest & RTL

Jest is a popular JavaScript testing framework, and React Testing Library (RTL) is a set of utilities for testing React components. Together, they form a powerful duo for Next.js apps.

First, install the necessary packages:

npm install --save-dev jest @testing-library/react @testing-library/jest-dom jest-environment-jsdom

Your First Unit Test (Function)

A unit test checks a small, isolated piece of code, like a single function. Let's create a simple utility function and then write a test for it.

Here's our utility:

// utils/math.js
function add(a, b) {
  return a + b;
}

// This block makes the file directly runnable via Node.js
if (typeof require !== 'undefined' && require.main === module) {
  console.log("Running add(5, 3):", add(5, 3)); // Expected: 8
  console.log("Running add(10, -2):", add(10, -2)); // Expected: 8
}

Testing the 'add' Function

Now, let's write a test for our add function. Jest uses describe to group tests and test (or it) for individual test cases. expect is used for assertions.

Save this in utils/math.test.js:

// utils/math.test.js
import { add } from './math';

describe('add function', () => {
  test('should correctly add two positive numbers', () => {
    expect(add(1, 2)).toBe(3);
  });

  test('should handle negative numbers', () => {
    expect(add(5, -3)).toBe(2);
  });
});

// To run tests: npx jest

Introducing React Testing Library

React Testing Library (RTL) encourages testing components in a way that mimics how users interact with them. Instead of checking internal state, you query the DOM for elements a user would see or interact with.

  • render: Mounts a React component into a virtual DOM.
  • screen: Provides methods to query the rendered DOM (e.g., getByText, getByRole).
  • @testing-library/jest-dom: Adds custom matchers like toBeInTheDocument.

Testing a Simple React Component

Let's test a basic button component. We'll ensure it renders with the correct text.

First, the component (components/Button.jsx):

// components/Button.jsx
export default function Button({ label, onClick }) {
  return (
    <button onClick={onClick}>
      {label}
    </button>
  );
}

Testing Component Rendering

Now, the test for our Button component. We use render to put it on the screen and screen.getByText to find it, then toBeInTheDocument to confirm its presence.

Save this as components/Button.test.jsx:

// components/Button.test.jsx
import { render, screen } from '@testing-library/react';
import Button from './Button';

describe('Button component', () => {
  test('renders with the correct label', () => {
    render(<Button label="Click Me" />);
    const buttonElement = screen.getByText(/Click Me/i);
    expect(buttonElement).toBeInTheDocument();
  });
});

Simulating User Interactions

Beyond just rendering, we need to test how components respond to user actions. RTL's fireEvent (or userEvent for more realistic interactions) helps simulate clicks, input changes, etc.

We can check if a function passed via props is called.

// components/Button.test.jsx (continued)
import { render, screen, fireEvent } from '@testing-library/react';
import Button from './Button';

describe('Button component interactions', () => {
  test('calls the onClick handler when clicked', () => {
    const handleClick = jest.fn(); // Jest mock function
    render(<Button label="Click Me" onClick={handleClick} />);
    const buttonElement = screen.getByText(/Click Me/i);
    fireEvent.click(buttonElement);
    expect(handleClick).toHaveBeenCalledTimes(1);
  });
});

Integration: Testing Route Handlers

Next.js Route Handlers (API routes in the App Router) are server-side functions. We can test them by directly importing and calling their HTTP methods (like GET, POST) and mocking Next.js's request/response objects.

Here's an example:

// app/api/hello/route.js
import { NextResponse } from 'next/server';

export async function GET() {
  return NextResponse.json({ message: 'Hello from API!' }, { status: 200 });
}

// app/api/hello/route.test.js
import { GET } from './route';

describe('GET /api/hello', () => {
  test('should return a greeting message with status 200', async () => {
    // No need to mock NextRequest/NextResponse directly for simple cases
    // as NextResponse.json returns a standard Response object.
    const response = await GET();
    const json = await response.json();

    expect(response.status).toBe(200);
    expect(json.message).toBe('Hello from API!');
  });
});

Best Practices for Effective Tests

To write useful and maintainable tests:

  • Test user behavior: Focus on what the user sees and does, not internal component state.
  • Keep tests focused: Each test should ideally check one thing.
  • Make tests fast: Slow tests discourage running them often.
  • Readability: Write clear tests that are easy to understand.
  • Mock dependencies: Use jest.mock() or jest.fn() to isolate units and prevent external factors from affecting tests.

Quick Check

Which of the following statements about testing in Next.js with Jest and React Testing Library is TRUE?

Recap: Unit & Integration Testing

Great job! You've learned the fundamentals of unit and integration testing in Next.js:

  • Jest is your testing framework.
  • React Testing Library helps test components like a user would.
  • Unit tests verify small, isolated code units.
  • Integration tests check how different parts (like components and APIs) work together.
  • You can test functions, React components, and Next.js Route Handlers.
  • Best practices include focusing on user behavior and mocking dependencies.

Next up, we'll explore End-to-End testing for full application flows!

Sıkça Sorulan Sorular

“Birim ve Entegrasyon Testleri” dersi ücretsiz mi?

Evet — “Birim ve Entegrasyon Testleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Next.js 15 Fullstack Web Apps kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Next.js 15 Fullstack Web Apps kursu toplamda 4 dersten oluşur.

“Birim ve Entegrasyon Testleri” dersinde ne öğreneceğim?

Jest ve React Testing Library kullanarak React bileşenleri ve Next.js işlevleri için etkili birim ve entegrasyon testleri yazın. Next.js 15 Fullstack Web Apps ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Next.js 15 Fullstack Web Apps öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Next.js 15 Fullstack Web Apps, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Birim ve Entegrasyon Testleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Next.js 15 Fullstack Web Apps dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Next.js 15 Fullstack Web Apps dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Birim ve Entegrasyon Testleri
  2. Playwright ile Uçtan Uca Test
  3. Tek Depolar ve Mikro Ön Uçlar
  4. Sunucu Bileşenlerini Taklit Etme ve Test Etme
← Next.js 15 Fullstack Web Apps Sayfasına Dön