Best Practices & Testing

npm install -D eslint prettier eslint-config-prettier eslint-plugin-react eslint-plugin-react-hooks

# Init ESLint config
npx eslint --init

module.exports = {
  env: {
    browser: true,
    es2022:  true,
    node:    true,
  },
  extends: [
    'eslint:recommended',
    'plugin:react/recommended',
    'plugin:react-hooks/recommended',
    'prettier', // Tắt các rules conflict với Prettier — phải để cuối
  ],
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType:  'module',
    ecmaFeatures: { jsx: true },
  },
  rules: {
    'no-unused-vars':    ['warn', { argsIgnorePattern: '^_' }],
    'no-console':        ['warn', { allow: ['warn', 'error'] }],
    'react/prop-types':  'warn',
    'react/react-in-jsx-scope': 'off', // React 17+ không cần import React
  },
  settings: {
    react: { version: 'detect' },
  },
};

{
  "semi":          true,
  "singleQuote":   true,
  "tabWidth":      2,
  "trailingComma": "es5",
  "printWidth":    100,
  "arrowParens":   "avoid"
}

npm install -D husky lint-staged
npx husky install

# Add pre-commit hook
npx husky add .husky/pre-commit "npx lint-staged"

{
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "eslint --fix",
      "prettier --write"
    ],
    "*.{json,md,css}": [
      "prettier --write"
    ]
  }
}

# Cho Vite/React project — dùng Vitest (nhanh hơn Jest, tích hợp Vite)
npm install -D vitest @testing-library/react @testing-library/user-event @testing-library/jest-dom jsdom

# Cho Node.js — dùng Jest
npm install -D jest @jest/globals supertest

import { describe, it, expect } from 'vitest';
import { formatPrice, formatDate } from './formatters';

describe('formatPrice', () => {
  it('formats number to VND currency', () => {
    expect(formatPrice(100000)).toBe('100.000 ₫');
    expect(formatPrice(1500000)).toBe('1.500.000 ₫');
  });

  it('returns "0 ₫" for 0', () => {
    expect(formatPrice(0)).toBe('0 ₫');
  });

  it('handles negative numbers', () => {
    expect(formatPrice(-5000)).toBe('-5.000 ₫');
  });
});

describe('formatDate', () => {
  it('formats ISO date to dd/MM/yyyy', () => {
    expect(formatDate('2024-01-15')).toBe('15/01/2024');
  });
});

const request = require('supertest');
const app = require('../src/app');
const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();
let authToken;

beforeAll(async () => {
  // Tạo user test và lấy token
  const res = await request(app)
    .post('/api/auth/register')
    .send({ email: 'test@test.com', username: 'testuser', password: 'Password123' });
  
  authToken = res.body.token;
});

afterAll(async () => {
  // Dọn sạch test data
  await prisma.user.deleteMany({ where: { email: 'test@test.com' } });
  await prisma.$disconnect();
});

describe('POST /api/todos', () => {
  it('creates a todo when authenticated', async () => {
    const res = await request(app)
      .post('/api/todos')
      .set('Authorization', `Bearer ${authToken}`)
      .send({ title: 'Test todo', priority: 'high' });

    expect(res.status).toBe(201);
    expect(res.body).toMatchObject({
      title:     'Test todo',
      priority:  'high',
      completed: false,
    });
  });

  it('returns 401 without auth token', async () => {
    const res = await request(app).post('/api/todos').send({ title: 'Test' });
    expect(res.status).toBe(401);
  });

  it('returns 400 for empty title', async () => {
    const res = await request(app)
      .post('/api/todos')
      .set('Authorization', `Bearer ${authToken}`)
      .send({ title: '' });

    expect(res.status).toBe(400);
  });
});

import pytest
from pathlib import Path
from organizer import categorize_file, organize_directory

# Dùng tmp_path fixture của pytest (tự tạo và xóa folder tạm)
def test_categorize_image(tmp_path):
    file = tmp_path / "photo.jpg"
    assert categorize_file(file) == "Images"

def test_categorize_document(tmp_path):
    file = tmp_path / "report.pdf"
    assert categorize_file(file) == "Documents"

def test_categorize_unknown(tmp_path):
    file = tmp_path / "data.xyz"
    assert categorize_file(file) == "Others"

def test_organize_moves_files(tmp_path):
    # Tạo files test
    (tmp_path / "photo.jpg").touch()
    (tmp_path / "doc.pdf").touch()
    (tmp_path / "music.mp3").touch()
    
    organize_directory(tmp_path)
    
    # Kiểm tra files đã di chuyển đúng chỗ
    assert (tmp_path / "Images"    / "photo.jpg").exists()
    assert (tmp_path / "Documents" / "doc.pdf").exists()
    assert (tmp_path / "Audio"     / "music.mp3").exists()

def test_organize_handles_empty_dir(tmp_path):
    # Không nên raise exception với folder rỗng
    organize_directory(tmp_path)
    assert True  # Reached without exception

Đây là function tôi cần test:
[paste function code]

Viết unit tests với Jest/Vitest cho function này:
- Happy path (input hợp lệ)
- Edge cases (empty, null, boundary values)
- Error cases (invalid input)
Đặt mỗi test case trong describe/it rõ ràng

# Tên Dự Án

> Một dòng mô tả ngắn gọn và hấp dẫn về dự án.

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org)

## ✨ Tính năng

- ✅ Authentication (JWT)
- ✅ CRUD operations
- ✅ File upload
- 🚧 Email notifications (coming soon)

## 🚀 Bắt đầu nhanh

### Yêu cầu hệ thống
- Node.js 18+
- npm 9+

### Cài đặt

```bash
git clone https://github.com/your-username/project-name.git
cd project-name
npm install
cp .env.example .env   # Điền thông tin cấu hình
npm run dev
```

Truy cập: http://localhost:3000

## ⚙️ Cấu hình (.env)

| Biến                | Mô tả                     | Mặc định   |
|---------------------|---------------------------|------------|
| `PORT`              | Port server                | `3000`     |
| `DATABASE_URL`      | Chuỗi kết nối database     | Bắt buộc   |
| `JWT_SECRET`        | Secret key cho JWT         | Bắt buộc   |
| `ALLOWED_ORIGIN`    | CORS allowed origin        | `http://localhost:5173` |

## 📡 API Endpoints

| Method | Endpoint           | Mô tả              | Auth |
|--------|--------------------|--------------------|------|
| POST   | `/api/auth/register` | Đăng ký tài khoản | ❌   |
| POST   | `/api/auth/login`    | Đăng nhập          | ❌   |
| GET    | `/api/todos`         | Lấy danh sách todo | ✅   |
| POST   | `/api/todos`         | Tạo todo mới       | ✅   |

## 🧪 Chạy Tests

```bash
npm test              # Chạy tất cả tests
npm run test:watch    # Watch mode
npm run test:coverage # Xem test coverage
```

## 🤝 Đóng góp

Pull requests được chào đón. Xem [CONTRIBUTING.md](CONTRIBUTING.md) để biết thêm.

## 📝 License

MIT © [Tên của bạn]

type(scope): description

[optional body]

[optional footer]

------- CÁC TYPES -------
feat:     Thêm tính năng mới
fix:      Sửa bug
docs:     Thay đổi documentation
style:    Format code (không đổi logic)
refactor: Refactor code (không feat, không fix)
test:     Thêm hoặc sửa tests
chore:    Cập nhật build scripts, dependencies

------- VÍ DỤ -------
feat(auth): add JWT refresh token endpoint
fix(api): return 404 when post not found
docs(readme): add API endpoints table
test(todos): add edge cases for empty title
chore(deps): upgrade prisma to v5.8

# Main branch = production-ready, luôn deployable
# Mỗi feature/fix = 1 branch riêng

# 1. Tạo feature branch từ main
git checkout main
git pull origin main
git checkout -b feat/add-search-filter

# 2. Code, commit thường xuyên
git add -p                         # Chọn từng hunk để add
git commit -m "feat(posts): add search by title"

# 3. Push và tạo Pull Request
git push -u origin feat/add-search-filter
# → Tạo PR trên GitHub → Code review → Merge

# 4. Sau khi merge, xóa branch
git checkout main
git pull origin main
git branch -d feat/add-search-filter

# Xem diff trước khi commit
git diff --staged

# Nhờ Copilot CLI generate commit message
# (Copilot sẽ đọc diff và suggest message chuẩn Conventional Commits)
git commit   # Copilot sẽ suggest message trong terminal

cd backend

# Cài Vitest (nhanh hơn Jest, tương thích Jest API)
npm install --save-dev vitest supertest @vitest/coverage-v8

# Thêm script vào package.json
# "test": "vitest run"
# "test:watch": "vitest"
# "test:coverage": "vitest run --coverage"

# Tạo thư mục test
mkdir tests tests/unit tests/integration
touch tests/unit/utils.test.js tests/integration/auth.test.js tests/integration/notes.test.js

// tests/unit/utils.test.js — Unit test cho helper functions
// Prompt Copilot: "Viết unit tests cho các functions trong utils.js"
import { describe, it, expect } from 'vitest';

// Ví dụ: test helper function validateEmail
function validateEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

function validatePassword(password) {
  return password.length >= 8;
}

describe('validateEmail', () => {
  it('trả về true với email hợp lệ', () => {
    expect(validateEmail('user@example.com')).toBe(true);
    expect(validateEmail('user+tag@domain.co')).toBe(true);
  });

  it('trả về false với email không hợp lệ', () => {
    expect(validateEmail('notanemail')).toBe(false);
    expect(validateEmail('@domain.com')).toBe(false);
    expect(validateEmail('')).toBe(false);
  });
});

describe('validatePassword', () => {
  it('chấp nhận password đủ 8 ký tự', () => {
    expect(validatePassword('12345678')).toBe(true);
    expect(validatePassword('LongPassword123')).toBe(true);
  });

  it('từ chối password ngắn hơn 8 ký tự', () => {
    expect(validatePassword('short')).toBe(false);
    expect(validatePassword('')).toBe(false);
  });
});

// tests/integration/auth.test.js — Integration test cho auth endpoints
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import request from 'supertest';
import app from '../../src/app.js'; // Export app riêng (không gọi app.listen)
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

// Cleanup database trước và sau test suite
beforeAll(async () => {
  await prisma.user.deleteMany({ where: { email: { contains: '@test.com' } } });
});

afterAll(async () => {
  await prisma.user.deleteMany({ where: { email: { contains: '@test.com' } } });
  await prisma.$disconnect();
});

describe('POST /api/auth/register', () => {
  it('đăng ký thành công với thông tin hợp lệ', async () => {
    const res = await request(app)
      .post('/api/auth/register')
      .send({ email: 'newuser@test.com', password: 'Password123', name: 'Test User' });

    expect(res.status).toBe(201);
    expect(res.body).toHaveProperty('token');
    expect(res.body.user.email).toBe('newuser@test.com');
    expect(res.body.user).not.toHaveProperty('password'); // Không trả về password
  });

  it('trả về 409 khi email đã tồn tại', async () => {
    // Đăng ký lần 2 với cùng email
    const res = await request(app)
      .post('/api/auth/register')
      .send({ email: 'newuser@test.com', password: 'Password123' });

    expect(res.status).toBe(409);
    expect(res.body.error).toMatch(/đã được đăng ký/);
  });
});

describe('POST /api/auth/login', () => {
  it('đăng nhập thành công với thông tin đúng', async () => {
    const res = await request(app)
      .post('/api/auth/login')
      .send({ email: 'newuser@test.com', password: 'Password123' });

    expect(res.status).toBe(200);
    expect(res.body).toHaveProperty('token');
  });

  it('trả về 401 với mật khẩu sai', async () => {
    const res = await request(app)
      .post('/api/auth/login')
      .send({ email: 'newuser@test.com', password: 'WrongPassword' });

    expect(res.status).toBe(401);
  });
});

# Chạy tất cả tests một lần
npm test

# Chạy tests ở chế độ watch (tự reload khi save file)
npm run test:watch

# Chạy tests với coverage report
npm run test:coverage

# Chạy chỉ một file test cụ thể
npx vitest run tests/integration/auth.test.js

# Chạy tests match pattern tên
npx vitest run --reporter=verbose

# Cài ESLint (chạy trong thư mục gốc project)
npm install --save-dev eslint @eslint/js

# Khởi tạo config ESLint
npx eslint --init
# Trả lời các câu hỏi:
# - To check syntax and find problems
# - CommonJS (hoặc ESM tùy project)
# - None of these (nếu không dùng framework)
# - No (TypeScript)
# - Node.js
# - JSON format

# Cài Prettier
npm install --save-dev prettier eslint-config-prettier

# Tạo .prettierrc
echo '{"semi":true,"singleQuote":true,"tabWidth":2,"printWidth":100}' > .prettierrc

# Tạo .eslintignore
echo 'node_modules\ndist\ncoverage' > .eslintignore

# Cài Husky và lint-staged
npm install --save-dev husky lint-staged

# Khởi tạo Husky
npx husky init

# Tạo pre-commit hook
echo 'npx lint-staged' > .husky/pre-commit

# Thêm lint-staged config vào package.json:
# "lint-staged": {
#   "*.js": ["eslint --fix", "prettier --write"],
#   "*.{json,md}": ["prettier --write"]
# }

# Test pre-commit hook
git add .
git commit -m "test: add testing setup"
# Hook sẽ tự động chạy ESLint + Prettier trước khi commit

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

name: CI — Lint, Test, Build

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test-backend:
    name: Backend Tests
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js 20
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
          cache-dependency-path: backend/package-lock.json

      - name: Install backend dependencies
        working-directory: ./backend
        run: npm ci

      - name: Run ESLint
        working-directory: ./backend
        run: npm run lint

      - name: Run tests
        working-directory: ./backend
        env:
          DATABASE_URL: "file:./test.db"
          JWT_SECRET: "ci-test-secret-key-32-characters-long"
          NODE_ENV: "test"
        run: npm test

  test-frontend:
    name: Frontend Build Check
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js 20
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
          cache-dependency-path: frontend/package-lock.json

      - name: Install frontend dependencies
        working-directory: ./frontend
        run: npm ci

      - name: Build frontend
        working-directory: ./frontend
        run: npm run build

// ❌ BEFORE: Nhiều vấn đề
async function processOrder(o: any) {
  if (o.status == 'pending') {
    const db = await getDb();
    const u = await db.query(`SELECT * FROM users WHERE id = ${o.user_id}`); // SQL injection!
    if (u.rows.length > 0) {
      if (u.rows[0].balance >= o.amount) {
        await db.query(`UPDATE users SET balance = balance - ${o.amount} WHERE id = ${o.user_id}`);
        await db.query(`UPDATE orders SET status = 'completed' WHERE id = ${o.id}`);
        // Gửi email nhưng không handle error
        sendEmail(u.rows[0].email, 'Order completed');
        return true;
      } else {
        return false;
      }
    }
  }
  return false;
}

// ✅ AFTER: Clean, safe, maintainable
interface Order { id: number; userId: number; amount: number; status: OrderStatus; }
type OrderStatus = 'pending' | 'completed' | 'failed' | 'cancelled';

class InsufficientBalanceError extends Error {
  constructor() { super('Insufficient balance'); this.name = 'InsufficientBalanceError'; }
}

async function processOrder(order: Order): Promise<void> {
  if (order.status !== 'pending') {
    throw new Error(`Cannot process order with status: ${order.status}`);
  }

  const user = await prisma.user.findUniqueOrThrow({ where: { id: order.userId } });

  if (user.balance < order.amount) {
    throw new InsufficientBalanceError();
  }

  // Transaction: cả hai update xảy ra cùng lúc hoặc không cái nào
  await prisma.$transaction([
    prisma.user.update({
      where: { id: order.userId },
      data: { balance: { decrement: order.amount } }
    }),
    prisma.order.update({
      where: { id: order.id },
      data: { status: 'completed' }
    })
  ]);

  // Không block order process nếu email fail
  sendOrderConfirmationEmail(user.email, order).catch(err => {
    console.error('Failed to send confirmation email:', err);
    // Log to monitoring service but don't throw
  });
}