Testing Guide

import { render, screen } from '@testing-library/react';
import { describe, it, expect } from 'vitest';
import { UserProfile } from './UserProfile';

describe('UserProfile', () => {
  it('renders user information correctly', () => {
    const user = {
      name: 'John Doe',
      email: 'john@example.com',
    };

    render(<UserProfile user={user} />);

    expect(screen.getByText('John Doe')).toBeInTheDocument();
    expect(screen.getByText('john@example.com')).toBeInTheDocument();
  });

  it('handles missing user gracefully', () => {
    render(<UserProfile user={null} />);

    expect(screen.getByText('No user found')).toBeInTheDocument();
  });
});

import { renderHook, waitFor } from '@testing-library/react';
import { describe, it, expect } from 'vitest';
import { useUserData } from './useUserData';

describe('useUserData', () => {
  it('fetches user data successfully', async () => {
    const { result } = renderHook(() => useUserData('user-123'));

    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
    });

    expect(result.current.data).toBeDefined();
    expect(result.current.error).toBeNull();
  });
});

import { test, expect } from '@playwright/test';

test.describe('Authentication Flow', () => {
  test('user can log in successfully', async ({ page }) => {
    await page.goto('http://localhost:3000/login');

    await page.fill('input[name="email"]', 'test@example.com');
    await page.fill('input[name="password"]', 'password123');
    await page.click('button[type="submit"]');

    await expect(page).toHaveURL('http://localhost:3000/dashboard');
    await expect(page.locator('h1')).toContainText('Dashboard');
  });

  test('shows error for invalid credentials', async ({ page }) => {
    await page.goto('http://localhost:3000/login');

    await page.fill('input[name="email"]', 'wrong@example.com');
    await page.fill('input[name="password"]', 'wrongpassword');
    await page.click('button[type="submit"]');

    await expect(page.locator('.error-message')).toBeVisible();
  });
});

package service

import (
	"testing"
	"github.com/stretchr/testify/assert"
)

func TestCalculateTotal(t *testing.T) {
	tests := []struct {
		name     string
		items    []Item
		expected float64
	}{
		{
			name:     "empty cart",
			items:    []Item{},
			expected: 0.0,
		},
		{
			name: "single item",
			items: []Item{
				{Price: 10.00, Quantity: 2},
			},
			expected: 20.00,
		},
		{
			name: "multiple items",
			items: []Item{
				{Price: 10.00, Quantity: 2},
				{Price: 5.00, Quantity: 3},
			},
			expected: 35.00,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := CalculateTotal(tt.items)
			assert.Equal(t, tt.expected, result)
		})
	}
}

package handler

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
	"github.com/stretchr/testify/assert"
)

func TestCreateUserHandler(t *testing.T) {
	// Setup
	reqBody := map[string]string{
		"name":  "John Doe",
		"email": "john@example.com",
	}
	body, _ := json.Marshal(reqBody)
	req := httptest.NewRequest(http.MethodPost, "/users", bytes.NewBuffer(body))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	// Execute
	handler := NewUserHandler(mockUserService)
	handler.CreateUser(w, req)

	// Assert
	assert.Equal(t, http.StatusCreated, w.Code)

	var response map[string]interface{}
	json.Unmarshal(w.Body.Bytes(), &response)
	assert.Equal(t, "John Doe", response["name"])
}

package integration

import (
	"context"
	"testing"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestUserServiceIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test")
	}

	// Setup test database
	db := setupTestDB(t)
	defer db.Close()

	ctx := context.Background()
	userService := NewUserService(db)

	// Create user
	user, err := userService.CreateUser(ctx, &CreateUserRequest{
		Name:  "Test User",
		Email: "test@example.com",
	})
	require.NoError(t, err)
	assert.NotEmpty(t, user.ID)

	// Fetch user
	fetchedUser, err := userService.GetUser(ctx, user.ID)
	require.NoError(t, err)
	assert.Equal(t, user.Email, fetchedUser.Email)

	// Update user
	err = userService.UpdateUser(ctx, user.ID, &UpdateUserRequest{
		Name: "Updated Name",
	})
	require.NoError(t, err)

	// Verify update
	updatedUser, err := userService.GetUser(ctx, user.ID)
	require.NoError(t, err)
	assert.Equal(t, "Updated Name", updatedUser.Name)
}