L - Liskov Substitution: подтипы без сюрпризов

LSP: объекты подкласса должны заменять объекты базового класса без поломки логики.

Если ты подставил наследника и всё сломалось - это нарушение LSP.

Классический провал: квадрат и прямоугольник

«Квадрат - это частный случай прямоугольника» - звучит математически безупречно. На бумаге Square идеально наследует Rectangle. На практике LSP ломается:

type Rectangle struct{ Width, Height int }
func (r *Rectangle) SetWidth(w int)  { r.Width = w }
func (r *Rectangle) SetHeight(h int) { r.Height = h }
func (r *Rectangle) Area() int       { return r.Width * r.Height }

type Square struct{ Rectangle } // встроили - методы Rectangle продвинуты в Square

// Чтобы сохранить инвариант «у квадрата стороны равны», объявляем свои методы:
func (s *Square) SetWidth(w int)  { s.Width = w; s.Height = w }
func (s *Square) SetHeight(h int) { s.Width = h; s.Height = h }

// Embedding не делает Square подтипом Rectangle: *Square нельзя передать
// туда, где ждут *Rectangle. Подтипирование в Go - только через интерфейс:
type Shape interface {
    SetWidth(w int)
    SetHeight(h int)
    Area() int
}
<?php
declare(strict_types=1);

class Rectangle
{
    public function __construct(protected int $width, protected int $height) {}

    public function setWidth(int $w): void  { $this->width = $w; }
    public function setHeight(int $h): void { $this->height = $h; }
    public function area(): int             { return $this->width * $this->height; }
}

final class Square extends Rectangle
{
    // Чтобы сохранить инвариант «у квадрата стороны равны», переопределяем:
    public function setWidth(int $w): void  { $this->width = $w; $this->height = $w; }
    public function setHeight(int $h): void { $this->width = $h; $this->height = $h; }
}
from dataclasses import dataclass


@dataclass
class Rectangle:
    width: int
    height: int

    def set_width(self, w: int) -> None:
        self.width = w

    def set_height(self, h: int) -> None:
        self.height = h

    def area(self) -> int:
        return self.width * self.height


class Square(Rectangle):  # унаследовали - теперь Square имеет set_width/set_height
    # Чтобы сохранить инвариант «у квадрата стороны равны», переопределяем:
    def set_width(self, w: int) -> None:
        self.width = w
        self.height = w

    def set_height(self, h: int) -> None:
        self.width = h
        self.height = h

А теперь функция, которая написана для Rectangle и не знает про Square:

func GrowToFit(r Shape, w, h int) int {
    r.SetWidth(w)
    r.SetHeight(h)
    return r.Area() // ожидаем w*h
}

// GrowToFit(&Rectangle{}, 2, 3) == 6
// GrowToFit(&Square{}, 2, 3)    == 9 - а ждали 6
<?php
declare(strict_types=1);

function growToFit(Rectangle $r, int $w, int $h): int
{
    $r->setWidth($w);
    $r->setHeight($h);
    return $r->area(); // ожидаем w*h
}
def grow_to_fit(r: Rectangle, w: int, h: int) -> int:
    r.set_width(w)
    r.set_height(h)
    return r.area()  # ожидаем w*h

Подставляем Square вместо Rectangle - получаем h*h вместо w*h. Код, корректный для базового типа, ломается на подтипе. Это и есть нарушение LSP: подтип не сохранил наблюдаемое поведение базы.

Урок: наследование «is-a» в реальном мире и наследование контракта в коде - не одно и то же. В Go embedding выглядит как наследование, но лишь продвигает методы и не делает Square подтипом Rectangle. Подтипирование в Go возможно только через интерфейсы - и как только Square и Rectangle подставляются под общий интерфейс Shape, та же ловушка возвращается.

Практичный пример: «репозиторий» без сюрпризов

// Доменная ошибка - часть контракта UserRepo.
// Postgres-реализация оборачивает в неё sql.ErrNoRows, а не отдаёт ошибку драйвера наружу.
var ErrUserNotFound = errors.New("user not found")

type UserRepo interface {
  Get(id int64) (User, error)
}

type PgUserRepo struct{}
func (PgUserRepo) Get(id int64) (User, error) { /* ok */ return User{}, nil }

type FakeUserRepo struct{}
func (FakeUserRepo) Get(id int64) (User, error) {
  // Должно вести себя так же: либо User, либо ErrUserNotFound.
  return User{}, ErrUserNotFound
}
interface UserRepo
{
    public function get(int $id): array;
}

final class PgUserRepo implements UserRepo
{
    public function get(int $id): array
    {
        return ['id' => $id];
    }
}

final class FakeUserRepo implements UserRepo
{
    public function get(int $id): array
    {
        // Контракт: либо массив пользователя, либо UserNotFoundException - придерживаемся.
        throw new UserNotFoundException("user {$id} not found");
    }
}
from dataclasses import dataclass
from typing import Protocol


@dataclass
class User:
    id: int


class UserNotFoundError(Exception):
    pass


# Контракт UserRepo: get() вернёт User или бросит UserNotFoundError.
# Protocol - структурная типизация: наследоваться от него не нужно,
# достаточно совпадения сигнатур (как с неявной реализацией интерфейса в Go).
class UserRepo(Protocol):
    def get(self, user_id: int) -> User: ...


class PgUserRepo:
    def get(self, user_id: int) -> User:
        # ok - возвращает User
        return User(id=user_id)


class FakeUserRepo:
    def get(self, user_id: int) -> User:
        # Должно вести себя так же: либо User, либо UserNotFoundError - не None, не другое исключение.
        raise UserNotFoundError(f"user {user_id} not found")

⚠️ Пример нарушения LSP

Если FakeUserRepo.Get() вдруг начнёт паниковать вместо ошибки/исключения - код, ожидающий стандартное поведение, развалится.

Контракт интерфейса = preconditions + postconditions + инварианты

LSP формализуется через design-by-contract:

  • preconditions - что обязан гарантировать вызывающий код перед вызовом метода (валидный id, ненулевой контекст)
  • postconditions - что обязан гарантировать метод после успешного выполнения (вернёт User или error, не оставит мусор в БД)
  • инварианты - что справедливо для типа в целом (UserRepo не должен паниковать)

Правило Барбары Лисков: подтип может ослабить preconditions (принимать больше) и усилить postconditions (возвращать конкретнее), но никогда наоборот. Если фейк начинает требовать заполненный RequestID в контексте, а Postgres-реализация - нет, фейк ужесточил precondition и нарушил LSP.

LSP в Go: интерфейсы - это контракты

В Go нет наследования классов, и иногда возникает соблазн думать, что LSP здесь не нужен. Это заблуждение. LSP - это про подтипирование, а не про конкретный механизм наследования. В Go механизм подтипирования один - интерфейсы и их реализации:

type UserRepo interface { // базовый «тип» (контракт)
    Get(ctx context.Context, id int64) (User, error)
}

// Каждая реализация - это «подтип» в смысле LSP
type PgUserRepo struct{ db *sql.DB }       // реализация-подтип
type RedisUserRepo struct{ rdb *redis.Client } // ещё один подтип
type FakeUserRepo struct{ users map[int64]User } // и ещё один
<?php
declare(strict_types=1);

interface UserRepo // базовый «тип» (контракт)
{
    public function get(int $id): User;
}

// Каждая реализация - это «подтип» в смысле LSP
final class PdoUserRepo implements UserRepo
{
    public function __construct(private readonly PDO $db) {}
    public function get(int $id): User { /* ... */ throw new LogicException(); }
}

final class RedisUserRepo implements UserRepo
{
    public function __construct(private readonly Redis $redis) {}
    public function get(int $id): User { /* ... */ throw new LogicException(); }
}

final class FakeUserRepo implements UserRepo
{
    /** @var array<int, User> */
    private array $users = [];
    public function get(int $id): User { /* ... */ throw new LogicException(); }
}
from dataclasses import dataclass, field
from typing import Protocol

from psycopg import Connection
from redis import Redis


class UserRepo(Protocol):  # базовый «тип» (контракт)
    def get(self, user_id: int) -> User: ...


# Каждая реализация - это «подтип» в смысле LSP.
# Ни один класс не наследует UserRepo: Protocol сверяет форму, а не родословную.
class PgUserRepo:  # реализация-подтип
    def __init__(self, db: Connection) -> None:
        self._db = db

    def get(self, user_id: int) -> User: ...


class RedisUserRepo:  # ещё один подтип
    def __init__(self, rdb: Redis) -> None:
        self._rdb = rdb

    def get(self, user_id: int) -> User: ...


@dataclass
class FakeUserRepo:  # и ещё один
    users: dict[int, User] = field(default_factory=dict)

    def get(self, user_id: int) -> User: ...

Любой код, написанный против UserRepo, должен корректно работать с любой из этих реализаций. Это и есть LSP, переведённый на язык Go: подтип = реализация интерфейса, контракт = интерфейс.

Поэтому LSP в Go проявляется везде, где есть полиморфизм через интерфейсы - а это практически весь идиоматический Go-код. Если фейк ведёт себя иначе, чем Postgres-реализация, клиентский код, написанный на тестах с фейком, рассыплется в проде. Это и есть нарушение принципа подстановки.

Embedding gotchas в Go

Go не имеет наследования, но embedding создаёт похожую иллюзию - и те же ловушки:

type Base struct{}
func (Base) Save(ctx context.Context) error { return nil }

type Cached struct {
    Base
    cache map[string]string
}
// Если переопределить Save и забыть про инвариант базового типа -
// код, который ожидал поведение Base, сломается на Cached.
func (c *Cached) Save(ctx context.Context) error {
    c.cache = nil // делаем что-то ещё
    return nil
}
<?php
declare(strict_types=1);

// В PHP та же ловушка возникает при extends + переопределении метода:
// если потомок ломает постусловие родителя, клиентский код, ожидающий
// поведение Base, развалится на Cached.

class Base
{
    public function save(): void { /* persist */ }
}

final class Cached extends Base
{
    /** @var array<string, string> */
    private array $cache = [];

    public function save(): void
    {
        $this->cache = []; // делаем что-то ещё
        // забыли вызвать parent::save() - данные не сохранятся
    }
}
class Base:
    def save(self) -> None:
        ...  # persist


class Cached(Base):
    def __init__(self) -> None:
        super().__init__()
        self._cache: dict[str, str] = {}

    # Если переопределить save и забыть про инвариант базового типа -
    # код, который ожидал поведение Base, сломается на Cached.
    def save(self) -> None:
        self._cache.clear()  # делаем что-то ещё
        # забыли super().save() - данные не сохранятся

Это меньшая проблема, чем классическое наследование, потому что Go-код обычно работает с интерфейсами, а не с конкретными типами. Но как только клиент начинает делать type assertion (if cached, ok := r.(*Cached); ok) - иерархия даёт о себе знать.

Как проверить LSP

  • прочитай контракт интерфейса (включая «как я веду себя при ошибке»)
  • подставь каждую реализацию в уме: «а сломает ли это ожидающее поведение?»
  • лучше - напиши общий тестовый пакет, прогоняющий один и тот же набор сценариев на всех реализациях
// Один тест на все реализации UserRepo - гарантия LSP по построению
func RunUserRepoContract(t *testing.T, makeRepo func() UserRepo) {
    t.Run("Get несуществующего возвращает ErrUserNotFound", func(t *testing.T) {
        repo := makeRepo()
        _, err := repo.Get(context.Background(), -1)
        if !errors.Is(err, ErrUserNotFound) {
            t.Fatalf("want ErrUserNotFound, got %v", err)
        }
    })
    // ... другие инварианты контракта
}

func TestPgUserRepo(t *testing.T)   { RunUserRepoContract(t, func() UserRepo { return NewPgRepo(testDB) }) }
func TestFakeUserRepo(t *testing.T) { RunUserRepoContract(t, func() UserRepo { return NewFakeRepo() }) }
<?php
declare(strict_types=1);

// Один абстрактный тест на все реализации UserRepo - гарантия LSP по построению.
// В PHPUnit это базовый abstract класс с реальными тестами + потомки,
// возвращающие конкретную реализацию.

namespace App\Tests\User;

use App\User\UserNotFoundException;
use App\User\UserRepo;
use PHPUnit\Framework\TestCase;

abstract class UserRepoContractTest extends TestCase
{
    abstract protected function makeRepo(): UserRepo;

    public function testGetMissingThrowsUserNotFound(): void
    {
        $this->expectException(UserNotFoundException::class);
        $this->makeRepo()->get(-1);
    }
    // ... другие инварианты контракта
}

final class PdoUserRepoTest extends UserRepoContractTest
{
    protected function makeRepo(): UserRepo { return new PdoUserRepo(self::testPdo()); }
}

final class FakeUserRepoTest extends UserRepoContractTest
{
    protected function makeRepo(): UserRepo { return new FakeUserRepo(); }
}
# Один набор тестов на все реализации UserRepo - гарантия LSP по построению.
# В pytest это класс-контракт с реальными тестами + потомки Test*,
# возвращающие конкретную реализацию (базовый класс без префикса Test не собирается).
import pytest


class UserRepoContract:
    def make_repo(self) -> UserRepo:
        raise NotImplementedError

    def test_get_missing_raises_user_not_found(self) -> None:
        repo = self.make_repo()
        with pytest.raises(UserNotFoundError):
            repo.get(-1)

    # ... другие инварианты контракта


class TestPgUserRepo(UserRepoContract):
    def make_repo(self) -> UserRepo:
        return PgUserRepo(test_db)


class TestFakeUserRepo(UserRepoContract):
    def make_repo(self) -> UserRepo:
        return FakeUserRepo()

Если фейк перестаёт проходить контрактный тест, значит его клиенты тоже сломаются в реальной интеграции. Это самый дешёвый способ ловить LSP-нарушения автоматически.

Где LSP проявляется в реальном Go-коде

Самые частые места, где нарушается LSP в живых проектах:

  • Фейковые репозитории, которые паникуют там, где Postgres-реализация возвращает ошибку
  • Декорированные клиенты (например, кеширующая обёртка), которые молча проглатывают ошибки сети, считая «нет данных в кеше = нет данных вообще»
  • Тестовые HTTP-клиенты, не соблюдающие тайм-ауты, которые гарантирует прод-реализация
  • Адаптеры для разных БД, по-разному ведущие себя при race conditions (один блокирует, другой возвращает специфическую ошибку)
  • «Гибкие» реализации, которые принимают nil там, где базовый контракт требовал ненулевой указатель
  • Кеширующие декораторы, у которых TTL ломает гарантии свежести данных, заявленные в основном интерфейсе
  • In-memory имплементации, которые игнорируют контекст и не отменяют операции по ctx.Done()
  • Метричные обёртки, которые добавляют побочные эффекты (записи в Prometheus) и блокируются, если метрик-сервер недоступен

В каждом случае подтип формально удовлетворяет интерфейсу (методы те же), но наблюдаемое поведение отличается - и это отличие проявляется только под нагрузкой или на граничных случаях.

Мини‑задание

  • Проверь свои реализации интерфейсов: одинаково ли они ведут себя при ошибках?
  • Заведи общий контрактный тест для одного интерфейса с двумя+ реализациями - все ли они его проходят?
  • Найди случай embedding-а с переопределённым методом и оцени, не нарушает ли он ожидания базового типа

Зарегистрируйтесь бесплатно, чтобы пройти квиз, решить задание с автопроверкой, вести прогресс.