Тесты как промпт: подход TDD при работе с ИИ-агентом. ai.. ai. Go.. ai. Go. llm.. ai. Go. llm. TDD.. ai. Go. llm. TDD. Блог компании МТС.. ai. Go. llm. TDD. Блог компании МТС. искусственный интеллект.. ai. Go. llm. TDD. Блог компании МТС. искусственный интеллект. Программирование.. ai. Go. llm. TDD. Блог компании МТС. искусственный интеллект. Программирование. разработка.. ai. Go. llm. TDD. Блог компании МТС. искусственный интеллект. Программирование. разработка. Тестирование IT-систем.

Всем привет. Меня зовут Егор Гурин, я Go-разработчик из МТС Web Services. В предыдущем тексте я рассказывал о Document Driven Development. Если коротко, эта методология предлагает проектировать контракты до того, как начинается разработка. 

В этот раз хочу развить тему и рассказать о TDD (Test Driven Development) — разработке через тестирование. Для меня это логичное дополнение первого подхода. В Document Driven Development мы до разработки пишем контракты, то есть описываем форматы входных и выходных данных, с которыми работает сервер. Потом делимся ими с командой и по ним реализуем серверы и клиенты. В TDD перед реализацией конкретных методов и функций сначала пишутся тесты, а уже потом код. 

Тесты как промпт: подход TDD при работе с ИИ-агентом - 1

Зачем это нужно

Часто по TDD работают в режиме светофора Red-Green-Refactor: red — тесты падают, потому что проверяемый код еще не реализован; green — тесты прошли; refactor — написанный код оптимизируют. 

По моим наблюдениям, среди тех, кто использует LLM в работе, есть как минимум два лагеря. Одни полностью перекладывают ответственность на модель и не особенно проверяют результаты генерации. Другие дробят задачу на мелкие и решают ее пошагово вместе с агентом. 

TDD может помочь и тем, и другим: ИИ довольно хорошо следует четким правилам и паттернам, которые уже заложены в проекте. Тесты здесь становятся одновременно и промптом, и условием приемки работы агента. Бывает, что желаемый результат по каким-то причинам не получается четко сформулировать словами, но его можно показать через ожидаемые выходные данные в тестах.

Давайте рассмотрим подход на конкретных примерах. Я буду писать на самом привычном для меня языке — Go.

Пример 1. Бизнес-правило для статуса заказа 

В нашей предметной области есть сущность Order (заказ) с набором бизнес-атрибутов: 

var ErrInvalidTransition = errors.New("invalid order status transition")


type Status int


const (
    Created Status = iota
    Paid
    InProgress
    Cancelled
    Dispatched
    Delivered
)




type Order struct {
    id         uuid.UUID
    createdAt  time.Time
    items      []OrderItem
    status     Status
    scheduleID *string
    deliveryID *string
}

Бизнес-правило такое: заказ может перейти в статус Paid (оплачен), только если сейчас у него статус Created (создан). Давайте напишем тест, который проверяет это правило. 

Для удобства я обычно сразу определяю API тестируемых методов: 

func (o *Order) Pay() error {
    return errors.New(“Not Implemented”)
}

Теперь пишем тест по бизнес-правилу:

func TestOrder_Pay(t *testing.T) {
    data := []struct {
       name    string
       order   *Order
       wantErr bool
       err     error
    }{
       {
          name:    "pay created order",
          order:   &Order{status: Created},
          wantErr: false,
       },
       {
          name:    "pay paid order",
          order:   &Order{status: Paid},
          wantErr: true,
          err:     ErrInvalidTransition,
       },
       {
          name:    "pay cancelled order",
          order:   &Order{status: Cancelled},
          wantErr: true,
          err:     ErrInvalidTransition,
       },
    }
    for _, d := range data {
       t.Run(d.name, func(t *testing.T) {
          t.Parallel()
          err := d.order.Pay()
          if !d.wantErr {
             assert.NoError(t, err)
          }
          if d.wantErr {
             assert.ErrorIs(t, err, d.err)
          }
       })
    }
}

Запускаем тесты и получаем красную фазу: тесты падают, потому что логика метода еще не реализована. Просим агента написать код, при котором тесты этого метода проходят, и получаем реализацию:

func (o *Order) Pay() error {
    if o.status != Created {
       return fmt.Errorf("%w: pay is allowed only for created orders", ErrInvalidTransition)
    }
    o.status = Paid
    return nil
}

Тесты проходят, задача выполнена. Полученный код удовлетворяет бизнес-правилу.

Пример 2. Поиск по номеру телефона в разных форматах 

Другой пример — прямо с работы. Чтобы найти взаимодействия оператора с клиентом, пользователь вводит в текстовое поле номер телефона. Номер может начинаться с +7, 7, 8, 08 или 9. То есть +7 (900) 123-45-67 можно ввести как 79001234567, 9001234567, 89001234567 и так далее.

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

Тесты выглядят так:

func TestGetNumberMutations(t *testing.T) {
    tests := []struct {
       name        string
       input       *string
       wantNumbers []string
    }{
       {
          name:        "number_starts_plus",
          input:       new("+79001234567"),
          wantNumbers: []string{"+79001234567", "79001234567", "9001234567", "89001234567", "089001234567"},
       },
       {
          name:        "number_starts_seven",
          input:       new("79001234567"),
          wantNumbers: []string{"+79001234567", "79001234567", "9001234567", "89001234567", "089001234567"},
       },
       {
          name:        "number_starts_nine",
          input:       new("9001234567"),
          wantNumbers: []string{"+79001234567", "79001234567", "9001234567", "89001234567", "089001234567"},
       },
       {
          name:        "number_starts_eight",
          input:       new("89001234567"),
          wantNumbers: []string{"+79001234567", "79001234567", "9001234567", "89001234567", "089001234567"},
       },
       {
          name:        "number_starts_zero",
          input:       new("089001234567"),
          wantNumbers: []string{"+79001234567", "79001234567", "9001234567", "89001234567", "089001234567"},
       },
       {
          name:        "service_number",
          input:       new("12345"),
          wantNumbers: []string{"12345"},
       },
       {
          name:        "another_number_type",
          input:       new("5050343244224"),
          wantNumbers: []string{"5050343244224"},
       },
       {
          name:        "number_nil",
          input:       nil,
          wantNumbers: []string{},
       },
    }
    for _, tt := range tests {
       t.Run(tt.name, func(t *testing.T) {
          numbers := getNumberMutations(tt.input)
          assert.Empty(t, cmp.Diff(numbers, tt.wantNumbers, cmpopts.SortSlices(func(x, y string) bool {
             return x < y
          })))
       })
    }
}

Реализация, которую агент сгенерировал по тестам:

var rePhoneNumberMask = regexp.MustCompile(`^(?:+7|7|8|08)?(?P<phone>d{10})$`)


// getNumberMutations возвращает все возможные варианты номера телефона с разными префиксами.
func getNumberMutations(number *string) []string {
    if number == nil {
       return []string{}
    }

    match := rePhoneNumberMask.FindStringSubmatch(*number)

    if match == nil {
       return []string{*number}
    }

    index := rePhoneNumberMask.SubexpIndex(phoneNumberMaskGroup)
    if index < 0 || index >= len(match) {
       return []string{*number}
    }

    rawNumber := match[index]

    phonePrefixes := []string{"+7", "7", "8", "08"}
    numberMutations := make([]string, 0, len(phonePrefixes)+1)

    for _, prefix := range phonePrefixes {
       numberMutations = append(numberMutations, prefix+rawNumber)
    }
    numberMutations = append(numberMutations, rawNumber)
    return numberMutations
}

Тесты прошли. Здесь полученный код меня устроил, и рефакторинг я не делал.

Что имеем в итоге

Как и Document Driven Development, TDD позволяет загнать ИИ-агента в определенные рамки и ограничить его вольность строго заданными контрактами, которые одновременно служат условиями приемки сгенерированного кода. С обоими подходами мы возвращаем себе вожжи проектировщика решений, а LLM становится исполнителем с ясным заданием. Приятный бонус TDD — качественное покрытие кода тестами, особенно в слое приложения, который реализует бизнес-правила продукта.

А вы уже пробовали работать в этой парадигме?

Автор: jdrzz

Источник