Clean Code Principles 2025: 30 Rules for Writing Readable Code

const d: number = 86400;
const list1: number[] = [1, 2, 3];

function calc(a: number, b: number): number {
  return a * b * 0.1;
}

const SECONDS_PER_DAY: number = 86400;
const activeUserIds: number[] = [1, 2, 3];

function calculateDiscountedPrice(originalPrice: number, quantity: number): number {
  const DISCOUNT_RATE = 0.1;
  return originalPrice * quantity * DISCOUNT_RATE;
}

# Bad
d = 86400
lst = [1, 2, 3]

def calc(a, b):
    return a * b * 0.1

# Good
SECONDS_PER_DAY = 86400
active_user_ids = [1, 2, 3]

def calculate_discounted_price(original_price: float, quantity: int) -> float:
    DISCOUNT_RATE = 0.1
    return original_price * quantity * DISCOUNT_RATE

const usrMgr = new UserManager();
const btnClkHndlr = () => {};
const genRpt = (dt: Date) => {};

const userManager = new UserManager();
const handleButtonClick = () => {};
const generateReport = (reportDate: Date) => {};

if (user.role === 5) {
  setTimeout(callback, 86400000);
}

const ADMIN_ROLE_ID = 5;
const ONE_DAY_IN_MILLISECONDS = 86400000;

if (user.role === ADMIN_ROLE_ID) {
  setTimeout(callback, ONE_DAY_IN_MILLISECONDS);
}

class DtaRcrd102 {
  private genymdhms: Date;
  private modymdhms: Date;
  private pszqint: number;
}

class Customer {
  private generationTimestamp: Date;
  private modificationTimestamp: Date;
  private recordId: number;
}

class UserService {
  fetchUser(id: number) {}
  retrieveAccount(id: number) {}
  getUserProfile(id: number) {}
  obtainUserSettings(id: number) {}
}

class UserService {
  getUser(id: number) {}
  getAccount(id: number) {}
  getUserProfile(id: number) {}
  getUserSettings(id: number) {}
}

// Long name for a loop variable
for (let arrayIndex = 0; arrayIndex < items.length; arrayIndex++) {
  process(items[arrayIndex]);
}

// Short name for a global constant
const T = 3000;

// Loop variables are short
for (let i = 0; i < items.length; i++) {
  process(items[i]);
}

// Global/module-level is descriptive
const API_REQUEST_TIMEOUT_MS = 3000;

function processOrder(order: Order): OrderResult {
  // Validation (20 lines)
  if (!order.items || order.items.length === 0) throw new Error('No items');
  if (!order.customer) throw new Error('No customer');
  // ... more validation

  // Price calculation (30 lines)
  let total = 0;
  for (const item of order.items) {
    total += item.price * item.quantity;
  }
  const tax = total * 0.1;
  const shipping = total > 100 ? 0 : 10;
  // ... more calculations

  // Payment processing (20 lines)
  const paymentResult = chargeCard(order.customer.cardId, total + tax + shipping);
  // ... payment logic

  // Notification (15 lines)
  sendEmail(order.customer.email, 'Order confirmed');
  // ... notification logic

  return { orderId: generateId(), total, status: 'completed' };
}

function processOrder(order: Order): OrderResult {
  validateOrder(order);
  const pricing = calculatePricing(order.items);
  const paymentResult = processPayment(order.customer, pricing.total);
  notifyCustomer(order.customer, paymentResult);

  return createOrderResult(paymentResult, pricing);
}

function validateOrder(order: Order): void {
  if (!order.items?.length) throw new InvalidOrderError('No items');
  if (!order.customer) throw new InvalidOrderError('No customer');
}

function calculatePricing(items: OrderItem[]): Pricing {
  const subtotal = items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  const tax = subtotal * TAX_RATE;
  const shipping = subtotal > FREE_SHIPPING_THRESHOLD ? 0 : SHIPPING_FEE;
  return { subtotal, tax, shipping, total: subtotal + tax + shipping };
}

function emailClients(clients: Client[]): void {
  for (const client of clients) {
    const record = database.lookup(client.id);
    if (record.isActive()) {
      email(client.email, 'Welcome!');
    }
  }
}

function emailActiveClients(clients: Client[]): void {
  const activeClients = getActiveClients(clients);
  activeClients.forEach(client => sendWelcomeEmail(client));
}

function getActiveClients(clients: Client[]): Client[] {
  return clients.filter(client => isClientActive(client.id));
}

function isClientActive(clientId: number): boolean {
  return database.lookup(clientId).isActive();
}

function sendWelcomeEmail(client: Client): void {
  email(client.email, 'Welcome!');
}

function createUser(
  name: string, email: string, age: number,
  role: string, department: string, isActive: boolean
): User { /* ... */ }

createUser('Alice', 'alice@example.com', 30, 'admin', 'engineering', true);

interface CreateUserParams {
  name: string;
  email: string;
  age: number;
  role: UserRole;
  department: string;
  isActive: boolean;
}

function createUser(params: CreateUserParams): User { /* ... */ }

createUser({
  name: 'Alice',
  email: 'alice@example.com',
  age: 30,
  role: UserRole.ADMIN,
  department: 'engineering',
  isActive: true,
});

let currentUser: User | null = null;

function checkPassword(userName: string, password: string): boolean {
  const user = database.findUser(userName);
  if (user && user.password === hash(password)) {
    // Side effect! A password check function initializes a session
    currentUser = user;
    initializeSession(user);
    return true;
  }
  return false;
}

function verifyPassword(userName: string, password: string): boolean {
  const user = database.findUser(userName);
  return user !== null && user.password === hash(password);
}

function login(userName: string, password: string): LoginResult {
  if (!verifyPassword(userName, password)) {
    return { success: false };
  }
  const user = database.findUser(userName);
  const session = initializeSession(user);
  return { success: true, user, session };
}

function setAndCheckAttribute(name: string, value: string): boolean {
  const attribute = findAttribute(name);
  if (attribute) {
    attribute.value = value;
    return true;
  }
  return false;
}

// Confusing call site
if (setAndCheckAttribute('username', 'alice')) { /* ??? */ }

function attributeExists(name: string): boolean {
  return findAttribute(name) !== null;
}

function setAttribute(name: string, value: string): void {
  const attribute = findAttribute(name);
  if (!attribute) throw new AttributeNotFoundError(name);
  attribute.value = value;
}

// Clear call site
if (attributeExists('username')) {
  setAttribute('username', 'alice');
}

function getAdminUsers(): User[] {
  const users = database.query('SELECT * FROM users');
  return users
    .filter(u => u.role === 'admin')
    .map(u => ({ ...u, displayName: `${u.firstName} ${u.lastName}` }))
    .sort((a, b) => a.displayName.localeCompare(b.displayName));
}

function getModeratorUsers(): User[] {
  const users = database.query('SELECT * FROM users');
  return users
    .filter(u => u.role === 'moderator')
    .map(u => ({ ...u, displayName: `${u.firstName} ${u.lastName}` }))
    .sort((a, b) => a.displayName.localeCompare(b.displayName));
}

function getUsersByRole(role: UserRole): User[] {
  const users = database.query('SELECT * FROM users WHERE role = ?', [role]);
  return users.map(addDisplayName).sort(byDisplayName);
}

function addDisplayName(user: User): User {
  return { ...user, displayName: `${user.firstName} ${user.lastName}` };
}

function byDisplayName(a: User, b: User): number {
  return a.displayName.localeCompare(b.displayName);
}

// Get the user name
const userName = user.getName();

// Iterate over the array
for (const item of items) {
  // Process the item
  processItem(item);
}

// External API limits batch requests to 100 items max (API docs: https://...)
const MAX_BATCH_SIZE = 100;

// Must encode as ISO-8859-1 for legacy system compatibility
// Will switch to UTF-8 after new system migration (JIRA-4521)
const encodedData = encode(data, 'ISO-8859-1');

// Lock must be acquired first due to concurrency issue
// Details: https://wiki.internal/concurrency-fix-2024
await acquireLock(resourceId);

/**
 * Constructor
 */
constructor() {}

/**
 * Returns the id
 * @returns the id
 */
getId(): number {
  return this.id;
}

// Code so clear it needs no comments
class User {
  constructor(
    private readonly id: number,
    private readonly name: string,
  ) {}

  getId(): number {
    return this.id;
  }
}

// TODO fix later
// FIXME this doesn't work
// HACK temporary workaround

// TODO(team-auth): Add OAuth2 token refresh logic [JIRA-1234] @2025-Q2
// FIXME(alice): Race condition on concurrent requests. Need distributed lock [JIRA-5678]
// HACK: Safari 17.2 flexbox bug workaround. Remove after Safari 18 fix

/**
 * Calculates user activity statistics for a given time period.
 *
 * @param userId - The user ID to query statistics for
 * @param startDate - Start date (inclusive)
 * @param endDate - End date (inclusive)
 * @returns Activity statistics object
 * @throws {UserNotFoundError} When the user does not exist
 * @throws {InvalidDateRangeError} When start date is after end date
 *
 * @example
 * const stats = await getUserActivityStats('user-123', '2025-01-01', '2025-03-31');
 * console.log(stats.totalLogins); // 45
 */
async function getUserActivityStats(
  userId: string,
  startDate: string,
  endDate: string,
): Promise<ActivityStats> {
  // ...
}

def get_user_activity_stats(
    user_id: str,
    start_date: str,
    end_date: str,
) -> ActivityStats:
    """Calculate user activity statistics for a given time period.

    Args:
        user_id: The user ID to query statistics for
        start_date: Start date (inclusive, ISO 8601 format)
        end_date: End date (inclusive, ISO 8601 format)

    Returns:
        ActivityStats: Activity statistics object

    Raises:
        UserNotFoundError: When the user does not exist
        InvalidDateRangeError: When start date is after end date

    Example:
        >>> stats = get_user_activity_stats('user-123', '2025-01-01', '2025-03-31')
        >>> stats.total_logins
        45
    """
    ...

function withdraw(account: Account, amount: number): number {
  if (amount > account.balance) return -1;  // Insufficient funds
  if (amount < 0) return -2;                // Negative amount
  if (account.isFrozen) return -3;          // Frozen account

  account.balance -= amount;
  return 0;  // Success
}

const result = withdraw(myAccount, 100);
if (result === -1) { /* handle */ }
else if (result === -2) { /* handle */ }
else if (result === -3) { /* handle */ }

class InsufficientFundsError extends Error {
  constructor(public readonly balance: number, public readonly amount: number) {
    super(`Insufficient funds: balance ${balance}, requested ${amount}`);
    this.name = 'InsufficientFundsError';
  }
}

class AccountFrozenError extends Error {
  constructor(public readonly accountId: string) {
    super(`Account ${accountId} is frozen`);
    this.name = 'AccountFrozenError';
  }
}

function withdraw(account: Account, amount: number): void {
  if (amount < 0) throw new InvalidAmountError(amount);
  if (account.isFrozen) throw new AccountFrozenError(account.id);
  if (amount > account.balance) throw new InsufficientFundsError(account.balance, amount);

  account.balance -= amount;
}

function processPayment(orderId: string, amount: number): PaymentResult {
  // ... 100 lines of logic ...

  // Validation only at the very end
  if (!orderId) return { success: false, error: 'Invalid order ID' };
  if (amount < 0) return { success: false, error: 'Invalid amount' };

  // ... actual payment processing ...
}

function processPayment(orderId: string, amount: number): PaymentResult {
  // Guard clauses: validate first
  if (!orderId) throw new InvalidArgumentError('orderId is required');
  if (amount <= 0) throw new InvalidArgumentError('amount must be positive');

  const order = orderRepository.findById(orderId);
  if (!order) throw new OrderNotFoundError(orderId);

  return paymentGateway.charge(order, amount);
}

abstract class AppError extends Error {
  abstract readonly statusCode: number;
  abstract readonly isOperational: boolean;

  constructor(message: string, public readonly cause?: Error) {
    super(message);
    this.name = this.constructor.name;
    Error.captureStackTrace(this, this.constructor);
  }
}

class NotFoundError extends AppError {
  readonly statusCode = 404;
  readonly isOperational = true;
}

class ValidationError extends AppError {
  readonly statusCode = 400;
  readonly isOperational = true;

  constructor(message: string, public readonly field: string, public readonly value: unknown) {
    super(message);
  }
}

class DatabaseError extends AppError {
  readonly statusCode = 500;
  readonly isOperational = false;  // System error — alert ops
}

try {
  const data = await fetchUserData(userId);
  await processData(data);
  await saveToDatabase(data);
} catch (error) {
  console.log('Something went wrong');  // Swallows everything
}

try {
  const data = await fetchUserData(userId);
  await processData(data);
  await saveToDatabase(data);
} catch (error) {
  if (error instanceof NetworkError) {
    logger.warn('Network error fetching user data', { userId, error });
    await retryWithBackoff(() => fetchUserData(userId));
  } else if (error instanceof ValidationError) {
    logger.error('Invalid user data', { userId, field: error.field });
    throw error;
  } else if (error instanceof DatabaseError) {
    logger.fatal('Database error', { error });
    alertOpsTeam(error);
    throw error;
  } else {
    throw error;  // Re-throw unexpected errors
  }
}

import { Logger } from './logger';
import { Database } from './database';
import { UserRepository } from './repositories/user';
const MAX_RETRIES = 3;
const logger = new Logger('UserService');
export class UserService {
  private db: Database;
  private repo: UserRepository;
  constructor(db: Database) {
    this.db = db;
    this.repo = new UserRepository(db);
  }
  async getUser(id: string): Promise<User> {
    const user = await this.repo.findById(id);
    if (!user) throw new NotFoundError('User not found');
    return user;
  }
}

import { Logger } from './logger';
import { Database } from './database';
import { UserRepository } from './repositories/user';

const MAX_RETRIES = 3;
const logger = new Logger('UserService');

export class UserService {
  private db: Database;
  private repo: UserRepository;

  constructor(db: Database) {
    this.db = db;
    this.repo = new UserRepository(db);
  }

  async getUser(id: string): Promise<User> {
    const user = await this.repo.findById(id);
    if (!user) throw new NotFoundError('User not found');
    return user;
  }
}

// 1. First: Public interface (headline)
export class OrderProcessor {
  async processOrder(orderId: string): Promise<OrderResult> {
    const order = await this.validateAndFetchOrder(orderId);
    const pricing = this.calculatePricing(order);
    return this.executePayment(order, pricing);
  }

  // 2. Middle: Business logic (body)
  private async validateAndFetchOrder(orderId: string): Promise<Order> {
    const order = await this.orderRepo.findById(orderId);
    if (!order) throw new OrderNotFoundError(orderId);
    this.validateOrderState(order);
    return order;
  }

  private calculatePricing(order: Order): Pricing {
    const subtotal = this.sumItems(order.items);
    const discount = this.applyDiscounts(subtotal, order.coupons);
    const tax = this.calculateTax(subtotal - discount);
    return { subtotal, discount, tax, total: subtotal - discount + tax };
  }

  // 3. Last: Implementation details
  private validateOrderState(order: Order): void { /* ... */ }
  private sumItems(items: OrderItem[]): number { /* ... */ }
  private applyDiscounts(amount: number, coupons: Coupon[]): number { /* ... */ }
  private calculateTax(amount: number): number { /* ... */ }
}

// 1. Node.js built-in modules
import { readFile } from 'fs/promises';
import path from 'path';

// 2. External libraries (node_modules)
import express from 'express';
import { z } from 'zod';

// 3. Internal modules — absolute paths
import { AppConfig } from '@/config';
import { Logger } from '@/utils/logger';

// 4. Internal modules — relative paths
import { UserService } from './services/user';
import { OrderService } from './services/order';

// 5. Type imports (TypeScript)
import type { User, Order } from './types';

src/
├── modules/
│   ├── user/
│   │   ├── index.ts          # Only export public API
│   │   ├── user.service.ts
│   │   ├── user.repository.ts
│   │   ├── user.controller.ts
│   │   ├── user.types.ts
│   │   └── __tests__/
│   ├── order/
│   │   ├── index.ts
│   │   └── ...
│   └── payment/
│       ├── index.ts
│       └── ...
├── shared/
│   ├── errors/
│   ├── utils/
│   └── types/
└── infrastructure/
    ├── database/
    ├── cache/
    └── messaging/

// modules/user/index.ts — only the public API
export { UserService } from './user.service';
export type { User, CreateUserDTO } from './user.types';
// UserRepository is NOT exported — internal implementation

describe('UserService', () => {
  describe('createUser', () => {
    it('should create user with valid data', async () => {
      // Arrange
      const userRepo = new InMemoryUserRepository();
      const service = new UserService(userRepo);
      const userData: CreateUserDTO = {
        name: 'Alice',
        email: 'alice@example.com',
      };

      // Act
      const result = await service.createUser(userData);

      // Assert
      expect(result.name).toBe('Alice');
      expect(result.email).toBe('alice@example.com');
      expect(result.id).toBeDefined();
    });
  });
});

it('should handle user lifecycle', async () => {
  const user = await service.createUser(data);
  expect(user.id).toBeDefined();
  const fetched = await service.getUser(user.id);
  expect(fetched.name).toBe(data.name);
  await service.updateUser(user.id, { name: 'Bob' });
  const updated = await service.getUser(user.id);
  expect(updated.name).toBe('Bob');
  await service.deleteUser(user.id);
  await expect(service.getUser(user.id)).rejects.toThrow();
});

describe('UserService', () => {
  it('should create user and return with generated id', async () => {
    const user = await service.createUser(validUserData);
    expect(user.id).toBeDefined();
    expect(user.name).toBe(validUserData.name);
  });

  it('should retrieve existing user by id', async () => {
    const created = await service.createUser(validUserData);
    const fetched = await service.getUser(created.id);
    expect(fetched).toEqual(created);
  });

  it('should update user name', async () => {
    const user = await service.createUser(validUserData);
    await service.updateUser(user.id, { name: 'Bob' });
    const updated = await service.getUser(user.id);
    expect(updated.name).toBe('Bob');
  });

  it('should throw NotFoundError when getting deleted user', async () => {
    const user = await service.createUser(validUserData);
    await service.deleteUser(user.id);
    await expect(service.getUser(user.id)).rejects.toThrow(NotFoundError);
  });
});

it('test1', async () => {
  const r = await s.calc({ a: 100, b: 2, c: 0.1, d: true });
  expect(r).toBe(180);
});

it('should apply 10% discount when premium member orders 2 items at 100 each', async () => {
  // Given
  const order = createOrder({
    items: [{ price: 100, quantity: 2 }],
    isPremiumMember: true,
    discountRate: 0.1,
  });

  // When
  const totalPrice = await pricingService.calculateTotal(order);

  // Then
  expect(totalPrice).toBe(180); // (100 * 2) - 10% discount = 180
});

describe('PasswordValidator', () => {
  it('should return valid when password has 8+ chars with mixed case and numbers', () => {});
  it('should return invalid when password is shorter than 8 characters', () => {});
  it('should return invalid when password lacks uppercase letters', () => {});
  it('should throw EmptyPasswordError when password is empty string', () => {});
});

function getPaymentAmount(employee: Employee): number {
  let result: number;
  if (employee.isSeparated) {
    result = separatedAmount();
  } else {
    if (employee.isRetired) {
      result = retiredAmount();
    } else {
      result = normalPayAmount();
    }
  }
  return result;
}

function getPaymentAmount(employee: Employee): number {
  if (employee.isSeparated) return separatedAmount();
  if (employee.isRetired) return retiredAmount();
  return normalPayAmount();
}

function calculateShippingCost(order: Order): number {
  if (order.shippingMethod === 'standard') {
    return order.weight * 1.5;
  } else if (order.shippingMethod === 'express') {
    return order.weight * 3.0 + 5;
  } else if (order.shippingMethod === 'overnight') {
    return order.weight * 5.0 + 15;
  } else if (order.shippingMethod === 'international') {
    return order.weight * 10.0 + 25;
  }
  throw new Error('Unknown shipping method');
}

interface ShippingStrategy {
  calculate(weight: number): number;
}

const shippingStrategies: Record<string, ShippingStrategy> = {
  standard: { calculate: (w) => w * 1.5 },
  express: { calculate: (w) => w * 3.0 + 5 },
  overnight: { calculate: (w) => w * 5.0 + 15 },
  international: { calculate: (w) => w * 10.0 + 25 },
};

function calculateShippingCost(order: Order): number {
  const strategy = shippingStrategies[order.shippingMethod];
  if (!strategy) throw new UnknownShippingMethodError(order.shippingMethod);
  return strategy.calculate(order.weight);
}

function getActiveAdminEmails(users: User[]): string[] {
  const result: string[] = [];
  for (let i = 0; i < users.length; i++) {
    if (users[i].isActive) {
      if (users[i].role === 'admin') {
        result.push(users[i].email.toLowerCase());
      }
    }
  }
  result.sort();
  return result;
}

function getActiveAdminEmails(users: User[]): string[] {
  return users
    .filter(user => user.isActive)
    .filter(user => user.role === 'admin')
    .map(user => user.email.toLowerCase())
    .sort();
}

// Bad: One class, multiple responsibilities
class UserService {
  createUser(data: CreateUserDTO) {}
  sendEmail(to: string, body: string) {}
  generatePDF(user: User) {}
  logAction(action: string) {}
}

// Good: One class, one responsibility
class UserService { createUser(data: CreateUserDTO) {} }
class EmailService { send(to: string, body: string) {} }
class PDFGenerator { generate(user: User) {} }
class AuditLogger { log(action: string) {} }

interface PaymentProcessor {
  process(amount: number): Promise<PaymentResult>;
}

class StripeProcessor implements PaymentProcessor {
  async process(amount: number) { /* Stripe API */ }
}

class PayPalProcessor implements PaymentProcessor {
  async process(amount: number) { /* PayPal API */ }
}

// Adding a new payment method requires no changes to existing code
class CryptoProcessor implements PaymentProcessor {
  async process(amount: number) { /* Crypto API */ }
}

// Bad: Penguin cannot fly, so it shouldn't extend Bird
class Bird { fly(): void { /* flies */ } }
class Penguin extends Bird {
  fly(): void { throw new Error('Cannot fly!'); }
}

// Good: Separate interfaces
interface FlyingBird { fly(): void; }
interface SwimmingBird { swim(): void; }

class Eagle implements FlyingBird { fly() {} }
class Penguin implements SwimmingBird { swim() {} }

// Bad: Fat interface
interface Worker {
  work(): void;
  eat(): void;
  sleep(): void;
  attendMeeting(): void;
}

// Good: Segregated interfaces
interface Workable { work(): void; }
interface Feedable { eat(): void; }
interface Meetable { attendMeeting(): void; }

class Developer implements Workable, Feedable, Meetable {
  work() {} eat() {} attendMeeting() {}
}

class Robot implements Workable {
  work() {}
  // No need for eat() or attendMeeting()
}

// Bad: High-level module depends on low-level module
class OrderService {
  private mysqlDb = new MySQLDatabase();
  save(order: Order) { this.mysqlDb.insert('orders', order); }
}

// Good: Depend on abstractions
interface OrderRepository {
  save(order: Order): Promise<void>;
  findById(id: string): Promise<Order | null>;
}

class OrderService {
  constructor(private readonly repo: OrderRepository) {}
  async save(order: Order) { await this.repo.save(order); }
}

class MySQLOrderRepository implements OrderRepository { /* ... */ }
class MongoOrderRepository implements OrderRepository { /* ... */ }
class InMemoryOrderRepository implements OrderRepository { /* ... */ }

## Naming
- [ ] Do names reveal intent?
- [ ] No abbreviations?
- [ ] Follows team naming conventions?

## Functions
- [ ] Does each function do one thing?
- [ ] 3 or fewer parameters?
- [ ] No side effects?

## Error Handling
- [ ] Uses appropriate custom errors?
- [ ] Errors are not swallowed?
- [ ] Guard clauses for fail-fast?

## Tests
- [ ] Tests exist for new features?
- [ ] Edge cases covered?
- [ ] Test names describe scenarios?

## Code Structure
- [ ] File under 400 lines?
- [ ] Nesting depth 3 or fewer?
- [ ] DRY principle followed?

## Security
- [ ] User input validated?
- [ ] No SQL injection or XSS risks?
- [ ] No sensitive info in logs?

{
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended",
    "prettier"
  ],
  "rules": {
    "max-lines": ["warn", { "max": 400 }],
    "max-lines-per-function": ["warn", { "max": 50 }],
    "max-params": ["warn", { "max": 3 }],
    "max-depth": ["warn", { "max": 3 }],
    "complexity": ["warn", { "max": 10 }],
    "no-else-return": "error",
    "prefer-const": "error",
    "no-var": "error"
  }
}

sonar.qualitygate.conditions:
  - metric: cognitive_complexity
    operator: GT
    error: 15
  - metric: duplicated_lines_density
    operator: GT
    error: 3
  - metric: coverage
    operator: LT
    error: 80