describe('UserService.createUser')
  it('creates a user with valid email and password')
  it('returns validation error when email is missing')
  it('returns validation error when password is shorter than 8 characters')
  it('hashes the password before storing')
  it('returns conflict error when email already exists')
  it('sends welcome email after successful creation')
  it('rolls back database insert if email sending fails')

it('test1')
it('should work')
it('handles error')
it('createUser test')
it('calls bcrypt.hash')  // testing implementation, not behavior

// BAD -- too vague
expect(result).toBeTruthy();
expect(error).toBeDefined();

// GOOD -- specific and informative
expect(result.status).toBe(201);
expect(result.body.user.email).toBe('[email protected]');
expect(error.message).toContain('password must be at least 8 characters');
expect(error.code).toBe('VALIDATION_ERROR');

// imports
import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
import { UserService } from '../src/services/UserService';
import { UserRepository } from '../src/repositories/UserRepository';
import { EmailService } from '../src/services/EmailService';

// mock dependencies
jest.mock('../src/repositories/UserRepository');
jest.mock('../src/services/EmailService');

describe('UserService', () => {
  let userService: UserService;
  let mockUserRepo: jest.Mocked<UserRepository>;
  let mockEmailService: jest.Mocked<EmailService>;

  beforeEach(() => {
    mockUserRepo = new UserRepository() as jest.Mocked<UserRepository>;
    mockEmailService = new EmailService() as jest.Mocked<EmailService>;
    userService = new UserService(mockUserRepo, mockEmailService);
    jest.clearAllMocks();
  });

  describe('createUser', () => {
    const validInput = {
      email: '[email protected]',
      password: 'secureP@ss123',
      name: 'Test User',
    };

    it('creates a user and returns the user object without password', async () => {
      mockUserRepo.findByEmail.mockResolvedValue(null);
      mockUserRepo.create.mockResolvedValue({ id: '1', ...validInput, password: undefined });
      mockEmailService.sendWelcome.mockResolvedValue(undefined);

      const result = await userService.createUser(validInput);

      expect(result.id).toBe('1');
      expect(result.email).toBe(validInput.email);
      expect(result).not.toHaveProperty('password');
      expect(mockUserRepo.create).toHaveBeenCalledTimes(1);
      expect(mockEmailService.sendWelcome).toHaveBeenCalledWith(validInput.email);
    });

    it('throws ConflictError when email already exists', async () => {
      mockUserRepo.findByEmail.mockResolvedValue({ id: '2', email: validInput.email });

      await expect(userService.createUser(validInput)).rejects.toThrow('Email already registered');
      expect(mockUserRepo.create).not.toHaveBeenCalled();
    });

    it('throws ValidationError when password is too short', async () => {
      const weakPassword = { ...validInput, password: 'short' };

      await expect(userService.createUser(weakPassword)).rejects.toThrow(/password must be at least/i);
    });

    it('does not persist user if welcome email fails', async () => {
      mockUserRepo.findByEmail.mockResolvedValue(null);
      mockUserRepo.create.mockResolvedValue({ id: '1', ...validInput });
      mockEmailService.sendWelcome.mockRejectedValue(new Error('SMTP connection failed'));
      mockUserRepo.deleteById.mockResolvedValue(undefined);

      await expect(userService.createUser(validInput)).rejects.toThrow('SMTP connection failed');
      expect(mockUserRepo.deleteById).toHaveBeenCalledWith('1');
    });
  });
});

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { calculateDiscount } from '../src/pricing';

describe('calculateDiscount', () => {
  it('applies percentage discount correctly', () => {
    expect(calculateDiscount(100, { type: 'percentage', value: 20 })).toBe(80);
  });

  it('applies flat discount correctly', () => {
    expect(calculateDiscount(100, { type: 'flat', value: 15 })).toBe(85);
  });

  it('never returns a negative price', () => {
    expect(calculateDiscount(10, { type: 'flat', value: 50 })).toBe(0);
  });

  it('handles zero price gracefully', () => {
    expect(calculateDiscount(0, { type: 'percentage', value: 50 })).toBe(0);
  });

  it('rounds to two decimal places for currency', () => {
    const result = calculateDiscount(99.99, { type: 'percentage', value: 33 });
    expect(result).toBe(66.99);
    // Explicitly verify no floating point drift
    expect(result.toString()).not.toContain('000000');
  });

  it('throws on negative discount value', () => {
    expect(() => calculateDiscount(100, { type: 'percentage', value: -10 }))
      .toThrow('Discount value must be non-negative');
  });

  it('throws on discount percentage above 100', () => {
    expect(() => calculateDiscount(100, { type: 'percentage', value: 150 }))
      .toThrow('Percentage discount cannot exceed 100');
  });

  it('throws on unknown discount type', () => {
    expect(() => calculateDiscount(100, { type: 'bogo' as any, value: 1 }))
      .toThrow(/unknown discount type/i);
  });
});

"""Tests for user_service module."""
import pytest
from unittest.mock import AsyncMock, MagicMock, patch
from datetime import datetime, timezone

from app.services.user_service import UserService, UserNotFoundError, DuplicateEmailError
from app.models.user import User


@pytest.fixture
def mock_db():
    """Create a mock database session."""
    db = MagicMock()
    db.commit = MagicMock()
    db.rollback = MagicMock()
    db.add = MagicMock()
    db.query.return_value.filter.return_value.first.return_value = None
    return db


@pytest.fixture
def mock_email_client():
    """Create a mock email client."""
    client = AsyncMock()
    client.send_welcome.return_value = True
    return client


@pytest.fixture
def user_service(mock_db, mock_email_client):
    """Create UserService with mocked dependencies."""
    return UserService(db=mock_db, email_client=mock_email_client)


@pytest.fixture
def sample_user():
    """Create a sample user for testing."""
    return User(
        id=1,
        email="[email protected]",
        name="Test User",
        created_at=datetime(2026, 1, 1, tzinfo=timezone.utc),
    )


class TestCreateUser:
    """Tests for UserService.create_user method."""

    def test_creates_user_with_valid_data(self, user_service, mock_db):
        result = user_service.create_user(
            email="[email protected]",
            password="secureP@ss123",
            name="New User",
        )

        assert result.email == "[email protected]"
        assert result.name == "New User"
        mock_db.add.assert_called_once()
        mock_db.commit.assert_called_once()

    def test_raises_duplicate_email_error(self, user_service, mock_db, sample_user):
        mock_db.query.return_value.filter.return_value.first.return_value = sample_user

        with pytest.raises(DuplicateEmailError, match="already registered"):
            user_service.create_user(
                email="[email protected]",
                password="secureP@ss123",
                name="Duplicate",
            )

        mock_db.add.assert_not_called()

    def test_rolls_back_on_commit_failure(self, user_service, mock_db):
        mock_db.commit.side_effect = Exception("Connection lost")

        with pytest.raises(Exception, match="Connection lost"):
            user_service.create_user(
                email="[email protected]",
                password="secureP@ss123",
                name="Fail",
            )

        mock_db.rollback.assert_called_once()

    @pytest.mark.parametrize(
        "password,reason",
        [
            ("short", "too short"),
            ("nouppercase1!", "missing uppercase"),
            ("NOLOWERCASE1!", "missing lowercase"),
            ("NoDigits!!", "missing digit"),
            ("", "empty"),
        ],
    )
    def test_rejects_weak_passwords(self, user_service, password, reason):
        with pytest.raises(ValueError):
            user_service.create_user(
                email="[email protected]",
                password=password,
                name="Test",
            )

    def test_strips_whitespace_from_email(self, user_service, mock_db):
        result = user_service.create_user(
            email="  [email protected]  ",
            password="secureP@ss123",
            name="Spaces",
        )
        assert result.email == "[email protected]"

    def test_lowercases_email(self, user_service, mock_db):
        result = user_service.create_user(
            email="[email protected]",
            password="secureP@ss123",
            name="Upper",
        )
        assert result.email == "[email protected]"


class TestGetUser:
    """Tests for UserService.get_user method."""

    def test_returns_user_when_found(self, user_service, mock_db, sample_user):
        mock_db.query.return_value.filter.return_value.first.return_value = sample_user

        result = user_service.get_user(user_id=1)

        assert result.id == 1
        assert result.email == "[email protected]"

    def test_raises_not_found_for_missing_user(self, user_service, mock_db):
        mock_db.query.return_value.filter.return_value.first.return_value = None

        with pytest.raises(UserNotFoundError):
            user_service.get_user(user_id=999)

    def test_raises_value_error_for_invalid_id(self, user_service):
        with pytest.raises(ValueError):
            user_service.get_user(user_id=-1)

        with pytest.raises(ValueError):
            user_service.get_user(user_id=0)

package user_test

import (
    "context"
    "errors"
    "testing"
    "time"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "github.com/stretchr/testify/require"

    "myapp/internal/user"
)

// MockUserStore implements user.Store interface for testing
type MockUserStore struct {
    mock.Mock
}

func (m *MockUserStore) FindByEmail(ctx context.Context, email string) (*user.User, error) {
    args := m.Called(ctx, email)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*user.User), args.Error(1)
}

func (m *MockUserStore) Create(ctx context.Context, u *user.User) error {
    args := m.Called(ctx, u)
    return args.Error(0)
}

func TestCreateUser(t *testing.T) {
    t.Run("creates user with valid input", func(t *testing.T) {
        store := new(MockUserStore)
        svc := user.NewService(store)

        store.On("FindByEmail", mock.Anything, "[email protected]").Return(nil, user.ErrNotFound)
        store.On("Create", mock.Anything, mock.AnythingOfType("*user.User")).Return(nil)

        u, err := svc.Create(context.Background(), "[email protected]", "Test User")

        require.NoError(t, err)
        assert.Equal(t, "[email protected]", u.Email)
        assert.Equal(t, "Test User", u.Name)
        assert.NotEmpty(t, u.ID)
        store.AssertExpectations(t)
    })

    t.Run("returns error when email already exists", func(t *testing.T) {
        store := new(MockUserStore)
        svc := user.NewService(store)

        existing := &user.User{ID: "123", Email: "[email protected]"}
        store.On("FindByEmail", mock.Anything, "[email protected]").Return(existing, nil)

        _, err := svc.Create(context.Background(), "[email protected]", "Test")

        require.Error(t, err)
        assert.True(t, errors.Is(err, user.ErrDuplicateEmail))
        store.AssertNotCalled(t, "Create", mock.Anything, mock.Anything)
    })

    t.Run("returns error on empty email", func(t *testing.T) {
        store := new(MockUserStore)
        svc := user.NewService(store)

        _, err := svc.Create(context.Background(), "", "Test")

        require.Error(t, err)
        assert.Contains(t, err.Error(), "email is required")
    })

    t.Run("respects context cancellation", func(t *testing.T) {
        store := new(MockUserStore)
        svc := user.NewService(store)

        ctx, cancel := context.WithCancel(context.Background())
        cancel() // cancel immediately

        store.On("FindByEmail", mock.Anything, mock.Anything).Return(nil, ctx.Err())

        _, err := svc.Create(ctx, "[email protected]", "Test")

        require.Error(t, err)
        assert.True(t, errors.Is(err, context.Canceled))
    })
}

// Table-driven tests for validation
func TestValidateEmail(t *testing.T) {
    tests := []struct {
        name    string
        email   string
        wantErr bool
    }{
        {"valid email", "[email protected]", false},
        {"valid with subdomain", "[email protected]", false},
        {"valid with plus", "[email protected]", false},
        {"empty string", "", true},
        {"missing @", "userexample.com", true},
        {"missing domain", "user@", true},
        {"missing local part", "@example.com", true},
        {"double @", "user@@example.com", true},
        {"spaces in local", "us [email protected]", true},
        {"unicode domain", "user@ex\u00e4mple.com", true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := user.ValidateEmail(tt.email)
            if tt.wantErr {
                assert.Error(t, err, "expected error for email: %q", tt.email)
            } else {
                assert.NoError(t, err, "unexpected error for email: %q", tt.email)
            }
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // Test fixtures
    fn sample_user() -> User {
        User {
            id: 1,
            email: "[email protected]".to_string(),
            name: "Test User".to_string(),
            created_at: chrono::Utc::now(),
        }
    }

    mod create_user {
        use super::*;

        #[test]
        fn creates_user_with_valid_data() {
            let repo = MockUserRepo::new();
            repo.expect_find_by_email()
                .returning(|_| Ok(None));
            repo.expect_create()
                .returning(|u| Ok(u.clone()));

            let service = UserService::new(Box::new(repo));
            let result = service.create_user("[email protected]", "secureP@ss123", "New User");

            assert!(result.is_ok());
            let user = result.unwrap();
            assert_eq!(user.email, "[email protected]");
            assert_eq!(user.name, "New User");
        }

        #[test]
        fn returns_error_for_duplicate_email() {
            let repo = MockUserRepo::new();
            repo.expect_find_by_email()
                .returning(|_| Ok(Some(sample_user())));

            let service = UserService::new(Box::new(repo));
            let result = service.create_user("[email protected]", "secureP@ss123", "Dup");

            assert!(result.is_err());
            assert!(matches!(result.unwrap_err(), UserError::DuplicateEmail(_)));
        }

        #[test]
        fn returns_error_for_empty_email() {
            let repo = MockUserRepo::new();
            let service = UserService::new(Box::new(repo));

            let result = service.create_user("", "secureP@ss123", "Test");

            assert!(result.is_err());
            assert!(matches!(result.unwrap_err(), UserError::ValidationError(_)));
        }

        #[test]
        #[should_panic(expected = "password must not be empty")]
        fn panics_on_empty_password() {
            let repo = MockUserRepo::new();
            let service = UserService::new(Box::new(repo));

            // This should panic, not return an error
            let _ = service.create_user("[email protected]", "", "Test");
        }
    }

    mod validate_email {
        use super::*;

        #[test]
        fn accepts_valid_emails() {
            let valid = vec![
                "[email protected]",
                "[email protected]",
                "[email protected]",
            ];
            for email in valid {
                assert!(validate_email(email).is_ok(), "should accept: {}", email);
            }
        }

        #[test]
        fn rejects_invalid_emails() {
            let invalid = vec![
                ("", "empty string"),
                ("@example.com", "missing local part"),
                ("user@", "missing domain"),
                ("userexample.com", "missing @"),
                ("user@@example.com", "double @"),
            ];
            for (email, reason) in invalid {
                assert!(validate_email(email).is_err(), "should reject ({}): {}", reason, email);
            }
        }
    }

    // Async test (requires tokio::test)
    mod async_operations {
        use super::*;

        #[tokio::test]
        async fn fetches_user_from_remote_api() {
            let mut mock_client = MockHttpClient::new();
            mock_client.expect_get()
                .with(eq("https://api.example.com/users/1"))
                .returning(|_| Ok(r#"{"id":1,"name":"Remote User"}"#.to_string()));

            let service = RemoteUserService::new(mock_client);
            let user = service.fetch_user(1).await.unwrap();

            assert_eq!(user.name, "Remote User");
        }

        #[tokio::test]
        async fn handles_api_timeout() {
            let mut mock_client = MockHttpClient::new();
            mock_client.expect_get()
                .returning(|_| Err(HttpError::Timeout));

            let service = RemoteUserService::new(mock_client);
            let result = service.fetch_user(1).await;

            assert!(matches!(result, Err(UserError::NetworkError(_))));
        }
    }
}

1. Setup -- Create real or in-memory dependencies (test database, temp files)
2. Seed -- Insert test data into the dependency
3. Execute -- Call the code under test
4. Assert -- Verify the result AND the side effects on the dependency
5. Cleanup -- Tear down test data (or let the framework handle it)

import request from 'supertest';
import { app } from '../src/app';
import { db } from '../src/database';

describe('POST /api/users', () => {
  beforeAll(async () => {
    await db.migrate.latest();
  });

  afterEach(async () => {
    await db('users').truncate();
  });

  afterAll(async () => {
    await db.destroy();
  });

  it('returns 201 and creates user in database', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ email: '[email protected]', password: 'Secure123!', name: 'Test' })
      .expect(201);

    expect(response.body.user.email).toBe('[email protected]');
    expect(response.body.user).not.toHaveProperty('password');

    // Verify side effect: user exists in database
    const dbUser = await db('users').where({ email: '[email protected]' }).first();
    expect(dbUser).toBeDefined();
    expect(dbUser.name).toBe('Test');
  });

  it('returns 409 when email already exists', async () => {
    // Seed
    await db('users').insert({ email: '[email protected]', password: 'hash', name: 'Existing' });

    const response = await request(app)
      .post('/api/users')
      .send({ email: '[email protected]', password: 'Secure123!', name: 'Dup' })
      .expect(409);

    expect(response.body.error).toContain('already registered');
  });

  it('returns 400 with validation errors for missing fields', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({})
      .expect(400);

    expect(response.body.errors).toEqual(
      expect.arrayContaining([
        expect.objectContaining({ field: 'email' }),
        expect.objectContaining({ field: 'password' }),
      ])
    );
  });

  it('returns 415 for non-JSON content type', async () => {
    await request(app)
      .post('/api/users')
      .set('Content-Type', 'text/plain')
      .send('not json')
      .expect(415);
  });
});

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from app.models import Base, User
from app.repositories.user_repo import UserRepository


@pytest.fixture(scope="module")
def engine():
    """Create an in-memory SQLite engine for testing."""
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    yield engine
    engine.dispose()


@pytest.fixture
def session(engine):
    """Create a new database session for each test."""
    Session = sessionmaker(bind=engine)
    session = Session()
    yield session
    session.rollback()
    session.close()


@pytest.fixture
def repo(session):
    return UserRepository(session)


class TestUserRepository:
    def test_create_and_find(self, repo, session):
        user = repo.create(email="[email protected]", name="Test")
        session.flush()

        found = repo.find_by_email("[email protected]")
        assert found is not None
        assert found.name == "Test"
        assert found.id == user.id

    def test_find_returns_none_for_missing(self, repo):
        assert repo.find_by_email("[email protected]") is None

    def test_unique_constraint_on_email(self, repo, session):
        repo.create(email="[email protected]", name="First")
        session.flush()

        with pytest.raises(Exception):  # IntegrityError
            repo.create(email="[email protected]", name="Second")
            session.flush()

// Jest
it('processes 10,000 records in under 500ms', () => {
  const records = Array.from({ length: 10_000 }, (_, i) => ({ id: i, value: `item-${i}` }));

  const start = performance.now();
  const result = processRecords(records);
  const elapsed = performance.now() - start;

  expect(result).toHaveLength(10_000);
  expect(elapsed).toBeLessThan(500);
});

# pytest
import time

def test_bulk_insert_performance(repo, session):
    """Bulk insert should handle 1000 records in under 2 seconds."""
    users = [{"email": f"user{i}@example.com", "name": f"User {i}"} for i in range(1000)]

    start = time.monotonic()
    repo.bulk_create(users)
    session.flush()
    elapsed = time.monotonic() - start

    assert elapsed < 2.0, f"Bulk insert took {elapsed:.2f}s, expected < 2.0s"

// Go
func BenchmarkProcessRecords(b *testing.B) {
    records := make([]Record, 10_000)
    for i := range records {
        records[i] = Record{ID: i, Value: fmt.Sprintf("item-%d", i)}
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        ProcessRecords(records)
    }
}

func TestMemoryUsage(t *testing.T) {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    before := m.Alloc

    // Run the operation
    result := ProcessLargeDataset(generateTestData(100_000))

    runtime.ReadMemStats(&m)
    after := m.Alloc

    // Should not allocate more than 50MB for 100K records
    allocatedMB := float64(after-before) / 1024 / 1024
    assert.Less(t, allocatedMB, 50.0, "allocated %.2f MB, expected < 50 MB", allocatedMB)
    _ = result
}