Why Claude Code 3.2 Beats Human Junior Engineers for Repetitive Coding Tasks in 2026

// user_crud.go
// Package handlers implements HTTP handlers for the User resource.
// This code was generated by Claude Code 3.2 (v3.2.1) on 2026-04-15 for the Acme Corp HR codebase.
// All generated code includes full error handling, input validation, and OpenAPI annotations.
package handlers

import (
    "context"
    "database/sql"
    "encoding/json"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    _ "github.com/lib/pq" // PostgreSQL driver
    "go.uber.org/zap"
)

// User represents the User resource in the Acme HR system.
type User struct {
    ID        string    `json:"id" db:"id" binding:"required,uuid"`
    Email     string    `json:"email" db:"email" binding:"required,email"`
    FirstName string    `json:"first_name" db:"first_name" binding:"required,min=2,max=50"`
    LastName  string    `json:"last_name" db:"last_name" binding:"required,min=2,max=50"`
    Role      string    `json:"role" db:"role" binding:"required,oneof=admin editor viewer"`
    CreatedAt time.Time `json:"created_at" db:"created_at"`
    UpdatedAt time.Time `json:"updated_at" db:"updated_at"`
}

// UserRepository defines the interface for User data access.
// Claude Code 3.2 generates interface-compliant implementations by default to support testing.
type UserRepository interface {
    Create(ctx context.Context, u *User) error
    GetByID(ctx context.Context, id string) (*User, error)
    Update(ctx context.Context, u *User) error
    Delete(ctx context.Context, id string) error
    List(ctx context.Context, limit, offset int) ([]*User, error)
}

// UserHandler holds dependencies for User HTTP handlers.
type UserHandler struct {
    repo   UserRepository
    logger *zap.Logger
}

// NewUserHandler initializes a new UserHandler with the provided repository and logger.
func NewUserHandler(repo UserRepository, logger *zap.Logger) *UserHandler {
    return &UserHandler{
        repo:   repo,
        logger: logger,
    }
}

// CreateUser handles HTTP POST /users requests.
// Includes input validation, duplicate email checks, and structured error responses.
func (h *UserHandler) CreateUser(c *gin.Context) {
    var user User
    // Bind and validate request body against User struct tags
    if err := c.ShouldBindJSON(&user); err != nil {
        h.logger.Warn("failed to bind create user request", zap.Error(err))
        c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body", "details": err.Error()})
        return
    }

    // Check for existing user with same email to avoid duplicates
    existing, err := h.repo.GetByID(c.Request.Context(), user.ID)
    if err == nil && existing != nil {
        h.logger.Info("duplicate user ID attempted", zap.String("id", user.ID))
        c.JSON(http.StatusConflict, gin.H{"error": "user with this ID already exists"})
        return
    }

    // Set timestamps before persisting
    user.CreatedAt = time.Now().UTC()
    user.UpdatedAt = time.Now().UTC()

    // Persist user to database
    if err := h.repo.Create(c.Request.Context(), &user); err != nil {
        h.logger.Error("failed to create user", zap.Error(err), zap.String("email", user.Email))
        // Check for duplicate email constraint violation
        if err.Error() == "pq: duplicate key value violates unique constraint \"users_email_key\"" {
            c.JSON(http.StatusConflict, gin.H{"error": "user with this email already exists"})
            return
        }
        c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create user"})
        return
    }

    h.logger.Info("user created successfully", zap.String("id", user.ID), zap.String("email", user.Email))
    c.JSON(http.StatusCreated, user)
}

// GetUser handles HTTP GET /users/:id requests.
func (h *UserHandler) GetUser(c *gin.Context) {
    id := c.Param("id")
    if id == "" {
        c.JSON(http.StatusBadRequest, gin.H{"error": "user ID is required"})
        return
    }

    user, err := h.repo.GetByID(c.Request.Context(), id)
    if err != nil {
        if err == sql.ErrNoRows {
            h.logger.Info("user not found", zap.String("id", id))
            c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
            return
        }
        h.logger.Error("failed to get user", zap.Error(err), zap.String("id", id))
        c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to retrieve user"})
        return
    }

    c.JSON(http.StatusOK, user)
}

// UpdateUser handles HTTP PUT /users/:id requests.
func (h *UserHandler) UpdateUser(c *gin.Context) {
    id := c.Param("id")
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        h.logger.Warn("failed to bind update user request", zap.Error(err))
        c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body", "details": err.Error()})
        return
    }

    // Ensure ID in path matches ID in body
    if user.ID != id {
        c.JSON(http.StatusBadRequest, gin.H{"error": "path ID does not match body ID"})
        return
    }

    // Check if user exists before updating
    existing, err := h.repo.GetByID(c.Request.Context(), id)
    if err != nil {
        if err == sql.ErrNoRows {
            c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
            return
        }
        h.logger.Error("failed to check existing user", zap.Error(err))
        c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update user"})
        return
    }

    // Preserve original created_at timestamp
    user.CreatedAt = existing.CreatedAt
    user.UpdatedAt = time.Now().UTC()

    if err := h.repo.Update(c.Request.Context(), &user); err != nil {
        h.logger.Error("failed to update user", zap.Error(err), zap.String("id", id))
        c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update user"})
        return
    }

    h.logger.Info("user updated successfully", zap.String("id", id))
    c.JSON(http.StatusOK, user)
}

// DeleteUser handles HTTP DELETE /users/:id requests.
func (h *UserHandler) DeleteUser(c *gin.Context) {
    id := c.Param("id")
    if id == "" {
        c.JSON(http.StatusBadRequest, gin.H{"error": "user ID is required"})
        return
    }

    // Check if user exists before deleting
    _, err := h.repo.GetByID(c.Request.Context(), id)
    if err != nil {
        if err == sql.ErrNoRows {
            c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
            return
        }
        h.logger.Error("failed to check existing user for delete", zap.Error(err))
        c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete user"})
        return
    }

    if err := h.repo.Delete(c.Request.Context(), id); err != nil {
        h.logger.Error("failed to delete user", zap.Error(err), zap.String("id", id))
        c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete user"})
        return
    }

    h.logger.Info("user deleted successfully", zap.String("id", id))
    c.JSON(http.StatusNoContent, nil)
}

// ListUsers handles HTTP GET /users requests with pagination.
func (h *UserHandler) ListUsers(c *gin.Context) {
    limit := 10 // default limit
    offset := 0 // default offset
    if c.Query("limit") != "" {
        if err := json.Unmarshal([]byte(c.Query("limit")), &limit); err != nil || limit < 1 || limit > 100 {
            c.JSON(http.StatusBadRequest, gin.H{"error": "invalid limit parameter (must be 1-100)"})
            return
        }
    }
    if c.Query("offset") != "" {
        if err := json.Unmarshal([]byte(c.Query("offset")), &offset); err != nil || offset < 0 {
            c.JSON(http.StatusBadRequest, gin.H{"error": "invalid offset parameter (must be non-negative)"})
            return
        }
    }

    users, err := h.repo.List(c.Request.Context(), limit, offset)
    if err != nil {
        h.logger.Error("failed to list users", zap.Error(err))
        c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list users"})
        return
    }

    c.JSON(http.StatusOK, users)
}

// 20260415120000_create_users_table.js
// Database migration: Create users table for Acme HR system.
// Generated by Claude Code 3.2 (v3.2.1) on 2026-04-15, compliant with Acme migration standards.
// All migrations include rollback logic, constraint validation, and idempotency checks.

const { Pool } = require('pg');
const logger = require('../utils/logger'); // Acme standardized logger

// Migration configuration
const MIGRATION_NAME = '20260415120000_create_users_table';
const TABLE_NAME = 'users';

module.exports = {
  /**
   * Run the migration: create users table with all required constraints.
   * @param {Pool} db - PostgreSQL connection pool
   * @returns {Promise}
   */
  async up(db) {
    const client = await db.connect();
    try {
      await client.query('BEGIN');

      // Idempotency check: skip if table already exists
      const tableExists = await client.query(
        `SELECT EXISTS (
          SELECT FROM information_schema.tables 
          WHERE table_schema = 'public' 
          AND table_name = $1
        )`,
        [TABLE_NAME]
      );

      if (tableExists.rows[0].exists) {
        logger.info(`Migration ${MIGRATION_NAME} skipped: table ${TABLE_NAME} already exists`);
        await client.query('COMMIT');
        return;
      }

      // Create users table with all required columns and constraints
      await client.query(`
        CREATE TABLE ${TABLE_NAME} (
          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
          email VARCHAR(255) NOT NULL UNIQUE,
          first_name VARCHAR(50) NOT NULL CHECK (char_length(first_name) >= 2),
          last_name VARCHAR(50) NOT NULL CHECK (char_length(last_name) >= 2),
          role VARCHAR(20) NOT NULL CHECK (role IN ('admin', 'editor', 'viewer')),
          created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
          updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
        )
      `);

      // Create index on email for faster lookups
      await client.query(`CREATE UNIQUE INDEX idx_users_email ON ${TABLE_NAME} (email)`);

      // Create index on role for filtered queries
      await client.query(`CREATE INDEX idx_users_role ON ${TABLE_NAME} (role)`);

      // Add table comment for documentation
      await client.query(`
        COMMENT ON TABLE ${TABLE_NAME} IS 'Stores user accounts for Acme HR system'
      `);
      await client.query(`
        COMMENT ON COLUMN ${TABLE_NAME}.id IS 'Unique identifier for the user (UUID v4)'
      `);
      await client.query(`
        COMMENT ON COLUMN ${TABLE_NAME}.email IS 'User email address, unique across all users'
      `);
      await client.query(`
        COMMENT ON COLUMN ${TABLE_NAME}.role IS 'User access role: admin (full access), editor (modify), viewer (read-only)'
      `);

      // Verify table was created successfully
      const verifyResult = await client.query(
        `SELECT COUNT(*) FROM information_schema.tables WHERE table_name = $1`,
        [TABLE_NAME]
      );

      if (parseInt(verifyResult.rows[0].count) !== 1) {
        throw new Error(`Table ${TABLE_NAME} not found after creation`);
      }

      logger.info(`Migration ${MIGRATION_NAME} completed successfully`);
      await client.query('COMMIT');
    } catch (err) {
      await client.query('ROLLBACK');
      logger.error(`Migration ${MIGRATION_NAME} failed`, { error: err.message, stack: err.stack });
      throw err; // Re-throw to let migration runner handle failure
    } finally {
      client.release();
    }
  },

  /**
   * Rollback the migration: drop users table if it exists.
   * @param {Pool} db - PostgreSQL connection pool
   * @returns {Promise}
   */
  async down(db) {
    const client = await db.connect();
    try {
      await client.query('BEGIN');

      // Idempotency check: skip if table does not exist
      const tableExists = await client.query(
        `SELECT EXISTS (
          SELECT FROM information_schema.tables 
          WHERE table_schema = 'public' 
          AND table_name = $1
        )`,
        [TABLE_NAME]
      );

      if (!tableExists.rows[0].exists) {
        logger.info(`Rollback ${MIGRATION_NAME} skipped: table ${TABLE_NAME} does not exist`);
        await client.query('COMMIT');
        return;
      }

      // Drop table with CASCADE to remove dependent indexes/comments
      await client.query(`DROP TABLE IF EXISTS ${TABLE_NAME} CASCADE`);

      // Verify table was dropped
      const verifyResult = await client.query(
        `SELECT COUNT(*) FROM information_schema.tables WHERE table_name = $1`,
        [TABLE_NAME]
      );

      if (parseInt(verifyResult.rows[0].count) !== 0) {
        throw new Error(`Table ${TABLE_NAME} still exists after rollback`);
      }

      logger.info(`Rollback ${MIGRATION_NAME} completed successfully`);
      await client.query('COMMIT');
    } catch (err) {
      await client.query('ROLLBACK');
      logger.error(`Rollback ${MIGRATION_NAME} failed`, { error: err.message, stack: err.stack });
      throw err;
    } finally {
      client.release();
    }
  }
};

# test_data_pipeline.py
# Unit tests for Acme Sales Data Pipeline.
# Generated by Claude Code 3.2 (v3.2.1) on 2026-04-15, compliant with Acme testing standards.
# All test scaffolding includes fixtures, edge cases, and mock external dependencies.

import pytest
import pandas as pd
from unittest.mock import Mock, patch
from datetime import datetime, timedelta
from src.data_pipeline import SalesPipeline, PipelineConfig, PipelineError

# Test configuration
TEST_CONFIG = PipelineConfig(
    source_bucket="acme-sales-data",
    destination_bucket="acme-processed-sales",
    batch_size=1000,
    retry_attempts=3
)

@pytest.fixture
def pipeline():
    """Initialize a SalesPipeline instance with test configuration."""
    return SalesPipeline(config=TEST_CONFIG)

@pytest.fixture
def sample_raw_data():
    """Generate sample raw sales data for testing."""
    return pd.DataFrame({
        "transaction_id": [f"TXN_{i}" for i in range(100)],
        "amount": [199.99, 49.99, 0.0, -10.0, 1500.00] * 20,
        "timestamp": [datetime.now() - timedelta(days=i%7) for i in range(100)],
        "customer_id": [f"CUST_{i%10}" for i in range(100)],
        "product_id": [f"PROD_{i%5}" for i in range(100)]
    })

@pytest.fixture
def mock_s3_client():
    """Mock S3 client to avoid external dependencies in tests."""
    mock_client = Mock()
    # Mock list_objects_v2 to return sample keys
    mock_client.list_objects_v2.return_value = {
        "Contents": [{"Key": f"sales/2026-04-{i:02d}.csv"} for i in range(1, 15)]
    }
    # Mock get_object to return sample CSV data
    mock_client.get_object.return_value = {
        "Body": Mock(read=Mock(return_value=sample_raw_data().to_csv(index=False).encode()))
    }
    return mock_client

def test_pipeline_initialization(pipeline):
    """Test that pipeline initializes with correct configuration."""
    assert pipeline.config.source_bucket == "acme-sales-data"
    assert pipeline.config.batch_size == 1000
    assert pipeline.retry_attempts == 3
    assert pipeline.processed_count == 0

def test_validate_raw_data_valid(pipeline, sample_raw_data):
    """Test validation of valid raw data returns True."""
    result = pipeline.validate_raw_data(sample_raw_data)
    assert result is True

def test_validate_raw_data_missing_column(pipeline):
    """Test validation fails when raw data is missing required columns."""
    invalid_data = pd.DataFrame({"transaction_id": ["TXN_1"], "amount": [199.99]})
    with pytest.raises(PipelineError, match="Missing required columns"):
        pipeline.validate_raw_data(invalid_data)

def test_validate_raw_data_negative_amount(pipeline, sample_raw_data):
    """Test validation flags negative transaction amounts."""
    invalid_data = sample_raw_data.copy()
    invalid_data.loc[0, "amount"] = -50.0
    with pytest.raises(PipelineError, match="Negative transaction amount detected"):
        pipeline.validate_raw_data(invalid_data)

def test_validate_raw_data_zero_amount(pipeline, sample_raw_data):
    """Test validation allows zero transaction amounts (valid for refunds)."""
    valid_data = sample_raw_data.copy()
    valid_data.loc[0, "amount"] = 0.0
    result = pipeline.validate_raw_data(valid_data)
    assert result is True

@patch("src.data_pipeline.boto3.client")
def test_fetch_raw_data_success(mock_boto, pipeline, mock_s3_client):
    """Test successful fetching of raw data from S3."""
    mock_boto.return_value = mock_s3_client
    data = pipeline.fetch_raw_data(date_range=(datetime(2026,4,1), datetime(2026,4,14)))
    assert isinstance(data, pd.DataFrame)
    assert len(data) == 100  # 100 rows from sample data
    mock_s3_client.list_objects_v2.assert_called_once()

@patch("src.data_pipeline.boto3.client")
def test_fetch_raw_data_retry(mock_boto, pipeline):
    """Test pipeline retries S3 fetch on transient errors."""
    mock_client = Mock()
    mock_client.list_objects_v2.side_effect = [
        Exception("Transient S3 error"),  # First attempt fails
        Exception("Transient S3 error"),  # Second attempt fails
        {  # Third attempt succeeds
            "Contents": [{"Key": "sales/2026-04-01.csv"}]
        }
    ]
    mock_client.get_object.return_value = {
        "Body": Mock(read=Mock(return_value=pd.DataFrame({"transaction_id": ["TXN_1"], "amount": [199.99]}).to_csv(index=False).encode()))
    }
    mock_boto.return_value = mock_client

    data = pipeline.fetch_raw_data(date_range=(datetime(2026,4,1), datetime(2026,4,1)))
    assert len(data) == 1
    assert mock_client.list_objects_v2.call_count == 3  # 2 retries + 1 success

def test_transform_data(pipeline, sample_raw_data):
    """Test data transformation logic."""
    transformed = pipeline.transform_data(sample_raw_data)
    # Check that amount is converted to decimal with 2 decimal places
    assert transformed["amount"].dtype == "float64"
    assert transformed.loc[0, "amount"] == pytest.approx(199.99, abs=0.01)
    # Check that timestamp is converted to ISO format string
    assert isinstance(transformed.loc[0, "timestamp"], str)
    # Check that customer_id is upper case
    assert transformed.loc[0, "customer_id"] == "CUST_0"

def test_transform_data_duplicate_transactions(pipeline, sample_raw_data):
    """Test transformation removes duplicate transaction IDs."""
    duplicate_data = pd.concat([sample_raw_data, sample_raw_data.iloc[[0]]])  # Add duplicate first row
    transformed = pipeline.transform_data(duplicate_data)
    assert len(transformed) == len(sample_raw_data)  # Duplicates removed

def test_load_processed_data(pipeline, sample_raw_data):
    """Test loading processed data to destination S3 bucket."""
    mock_client = Mock()
    pipeline.s3_client = mock_client
    pipeline.load_processed_data(sample_raw_data, date=datetime(2026,4,15))
    # Assert put_object was called with correct parameters
    mock_client.put_object.assert_called_once_with(
        Bucket="acme-processed-sales",
        Key="sales/2026-04-15.parquet",
        Body=pytest.any(pd.DataFrame.to_parquet)
    )

def test_pipeline_run_success(pipeline, sample_raw_data):
    """Test full pipeline run succeeds with valid data."""
    with patch.object(pipeline, "fetch_raw_data", return_value=sample_raw_data), \
         patch.object(pipeline, "load_processed_data", return_value=True):
        result = pipeline.run(date_range=(datetime(2026,4,1), datetime(2026,4,14)))
        assert result is True
        assert pipeline.processed_count == 100

def test_pipeline_run_validation_failure(pipeline):
    """Test pipeline run fails if raw data validation fails."""
    invalid_data = pd.DataFrame({"invalid_column": [1]})
    with patch.object(pipeline, "fetch_raw_data", return_value=invalid_data), \
         pytest.raises(PipelineError, match="Raw data validation failed"):
        pipeline.run(date_range=(datetime(2026,4,1), datetime(2026,4,14)))