PunchUK pardons women convicted of abortion offencesThe Jerusalem PostIDF blocks Area A road to new Jewish outpost near Jericho, confiscates residents' army weaponsInquirer3 top fugitives nabbed in Caraga police opsDaily MaverickHISTORY MAKERS: Wales’ shock victory over All Blacks gives Springboks Nations Championship lifeline한겨레서산·충주·예천 주민들 “광주 군 공항 이전 군용기 잠정 배치 반대”CNN Türkİslam Memiş kritik seviyeyi açıkladı: Altın bu rakamın altına inerse düşüş sürebilirZDF heuteAktuelle Pressemitteilungen des ZDFالنهارالكنيست يعيّن عربيين في منصب نائب رئيس الكنيست للمرّة الأولى!Wirtualna PolskaABW zatrzymała nastolatków. Szykowali zamachy w PolsceCBS NewsIran rules out inspections of damaged nuclear sites until war endsFotogramasGary Oldman, actor: "Me he dedicado a emborracharme hasta caer inconsciente en mi habitación del hotel estando en alguno de los lugares más bellos del planeta"GIGAZINEChatGPTのチャット内でクレカ決済できる「ChatGPT Wallet」が登場
The Daily Newsstand · Free, Always
Monday, November 16, 2026

AI-агент + Proxyman MCP: автоматизируем API-моки при разработке iOS-приложений

Translate

Допустим, вы закончили разработку экрана, на котором нужно отображать несколько состояний подписки. Осталось проверить, что всё работает правильно.

Открываете приложение, а на тестовом окружении есть только одна активная подписка. Ни пробного периода, ни приостановленных подписок. Feature flag, который включает новую логику, тоже выключен.

Можно попросить бэкенд подготовить данные. Можно попробовать самостоятельно изменить состояние подписки через API. А можно открыть Proxyman и подменить ответ.

Я обычно предпочитаю последний вариант, если задача сводится к проверке интерфейса.

С одним состоянием проблем нет. Находишь запрос, сохраняешь ответ в JSON, меняешь пару полей и подключаешь Map Local.

Но когда нужно проверить десяток комбинаций, процесс начинает раздражать. Особенно если для одного сценария приходится подменять несколько запросов.

При этом почти все действия довольно механические. Нужно найти модель в проекте, понять, какие поля влияют на отображение, сопоставить их с API и подготовить нужный ответ.

Возникла идея поручить эту работу AI-агенту.

В статье разберём, как организовать такую автоматизацию с помощью OpenCode, Xcode MCP и Proxyman MCP. Заодно посмотрим, что агенту действительно можно доверить, а что пока лучше контролировать самостоятельно.

Сразу оговорюсь: ниже не отчёт о результатах проведённого эксперимента, а пример реализации подхода. Конкретные возможности автоматизации зависят от подключённых MCP-серверов.

Задача: проверить экран подписок

Для примера возьмём небольшое iOS-приложение, в котором пользователь управляет своими подписками.

На экране отображаются название подписки, её статус и информация о следующем списании.

Логика следующая:

  • У обычной подписки показываем дату из next_billing_date.

  • У пробной подписки используем trial_end_date.

  • Если подписка приостановлена, вместо даты выводим соответствующее сообщение.

Дополнительно есть feature flag enableNewSubscriptionDetails, который переключает старую и новую реализацию блока.

Получается шесть основных комбинаций:

Подписка

Feature flag

Что проверяем

Обычная

OFF

Старое отображение

Обычная

ON

Дату следующего списания

Пробная

OFF

Старое отображение

Пробная

ON

Дату окончания пробного периода

Приостановленная

OFF

Старое отображение

Приостановленная

ON

Сообщение о приостановке

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

Это только основные сценарии. Отдельно стоило бы проверить отсутствие даты, некорректный формат, пустой список и ошибки сервера.

Но начнём с шести комбинаций.

Предположим, тестовое окружение возвращает такой ответ:

GET /api/v1/subscriptions

{
  "subscriptions": [
    {
      "id": "sub_101",
      "type": "standard",
      "status": "active",
      "next_billing_date": "2026-12-01"
    },
    {
      "id": "sub_102",
      "type": "trial",
      "status": "active",
      "trial_end_date": "2026-11-20"
    }
  ]
}

Здесь я намеренно оставил только поля, которые понадобятся в примере. В настоящем API структура, скорее всего, будет сложнее.

Конфигурация приходит отдельным запросом:

GET /api/v1/config

{
  "features": {
    "enableNewSubscriptionDetails": false
  }
}

Чтобы проверить все комбинации, придётся управлять двумя ответами.

Именно эту работу попробуем передать агенту.

Как устроена связка

Используем четыре инструмента:

OpenCode отвечает за работу AI-агента. Он исследует проект, вызывает доступные инструменты и подготавливает тестовые данные.

Xcode MCP предоставляет агенту доступ к операциям с проектом. Нам понадобится чтение исходников и поиск связанных моделей, сервисов и логики отображения. Конкретный набор операций зависит от MCP-сервера.

Proxyman MCP нужен для работы с сетевым трафиком. Через него агент может получать информацию о запросах и ответах. Возможность создавать и переключать моки зависит от реализации сервера.

Proxyman перехватывает трафик приложения и подменяет ответы с помощью Map Local или Scripting.

iOS Simulator используем для запуска приложения и проверки интерфейса.

Общая схема получается такой:

                 OpenCode
                 AI Agent
                    |
          +---------+---------+
          |                   |
          v                   v
       Xcode MCP         Proxyman MCP
          |                   |
          v                   v
      Исходный код        HTTP-трафик
          |                   |
          +---------+---------+
                    |
                    v
             Анализ сценария
                    |
                    v
             Подготовка JSON
                    |
                    v
                Proxyman
                    |
                    v
              iOS Simulator
                    |
                    v
               Проверка UI

От обычной генерации моков этот подход отличается тем, что агент работает не только с описанием задачи.

Он может посмотреть, как приложение декодирует ответ, какие поля использует ViewModel и какие данные фактически возвращает сервер.

Например, если в модели есть обязательное поле currency, а в нашем описании сценария оно не упоминается, агент должен сохранить его в итоговом JSON.

Это не гарантирует отсутствие ошибок, но позволяет избежать части проблем, которые возникают при генерации ответов с нуля.

Подключаем MCP

Предположим, OpenCode уже установлен, а MCP-серверы настроены.

Проверяем доступные подключения:

opencode mcp list

В списке должны появиться серверы для работы с Xcode и Proxyman.

Названия зависят от конфигурации. Например, они могут называться xcode и proxyman.

Здесь стоит остановиться на возможностях Proxyman MCP.

Подключённый сервер не обязательно умеет всё, что доступно в самом Proxyman.

Нам нужны операции для чтения запросов, получения тела ответа, поиска по URL и HTTP-методу. Для полной автоматизации дополнительно понадобятся создание правил Map Local и управление их состоянием.

Если MCP предоставляет только чтение трафика, ничего страшного. Агент всё равно сможет анализировать ответы и готовить JSON-файлы.

Просто подключать их к Proxyman придётся вручную.

Перед работой я бы попросил агента перечислить доступные инструменты Proxyman MCP и отдельно указать, какие операции изменения правил действительно поддерживаются.

Это лучше, чем выяснить после генерации всех сценариев, что переключать их автоматически нечем.

Ещё один момент касается самого прокси.

Приложение в симуляторе должно отправлять запросы через Proxyman. Для HTTPS необходимо корректно настроить сертификат и доверие к нему.

Если приложение использует certificate pinning, стандартного подключения прокси может оказаться недостаточно. Для тестовой сборки понадобится предусмотренный проектом способ работы с прокси.

Иначе агент будет искать запросы, которых Proxyman просто не видит.

Создаём отдельного агента

Постоянно объяснять OpenCode, как нужно исследовать проект и готовить моки, неудобно.

Поэтому я бы вынес правила в отдельного агента ios-mock-qa.

Его задача: получить описание состояния приложения, определить необходимые изменения API и подготовить соответствующие ответы.

При этом агенту не нужен доступ на изменение исходников.

Мы проверяем существующую функциональность, а не просим его исправлять приложение.

Пример инструкции:

# iOS Mock QA

Ты отвечаешь за подготовку API-моков
для тестирования iOS-приложения.

## Порядок работы

1. Найди реализацию указанной функциональности.
2. Определи модели, API и зависимости UI.
3. Получи реальные ответы через Proxyman MCP.
4. Проверь структуру и обязательные поля.
5. Подготовь отдельный мок для каждого сценария.
6. Изменяй только поля, необходимые для сценария.
7. Проверь существующие правила Proxyman.
8. Покажи diff перед применением.
9. Активируй моки только после подтверждения.
10. Проверь результат доступными инструментами.

## Ограничения

- Не изменяй исходный код приложения.
- Не придумывай API-контракты.
- Не удаляй обязательные поля.
- Не изменяй посторонние объекты.
- Не создавай конфликтующие правила.
- Не используй production-трафик.
- Не сохраняй токены и персональные данные в моках.
- Не считай создание JSON успешной проверкой UI.

## Отчёт

Для каждого сценария укажи:

- Endpoint и HTTP-метод.
- Изменённые поля.
- Путь к подготовленному JSON.
- Состояние правила Proxyman.
- Подтверждение получения подменённого ответа.
- Результат проверки UI.

Если операция недоступна через MCP,
сообщи об ограничении.

Эту инструкцию можно использовать как основу для кастомного агента OpenCode. Конкретный формат файла и настройки доступа к инструментам нужно адаптировать под установленную версию.

Я намеренно разделил подготовку данных, активацию правил и проверку интерфейса.

Создать корректный JSON ещё не значит проверить функциональность. Даже если Proxyman успешно подменил ответ, приложение могло взять данные из кеша.

Поэтому агент не должен сообщать об успешном тестировании, пока нет подтверждения результата.

Просим агента разобраться в реализации

Теперь можно переходить к самому сценарию.

В OpenCode отправляем задачу:

Исследуй экран подписок. Найди модели, API и логику отображения даты следующего списания. Определи, какие поля влияют на обычную и пробную подписку.

Используй реальные ответы через Proxyman MCP. Подготовь отдельные моки для обоих состояний. Исходный код не изменяй. Перед активацией покажи diff.

Допустим, агент находит такую модель:

struct Subscription: Decodable {
    let id: String
    let type: SubscriptionType
    let status: SubscriptionStatus
    let nextBillingDate: Date?
    let trialEndDate: Date?

    enum CodingKeys: String, CodingKey {
        case id
        case type
        case status
        case nextBillingDate = "next_billing_date"
        case trialEndDate = "trial_end_date"
    }
}

И функцию, которая определяет отображаемую дату:

func displayDate(
    for subscription: Subscription
) -> Date? {
    guard subscription.status == .active else {
        return nil
    }

    switch subscription.type {
    case .standard:
        return subscription.nextBillingDate

    case .trial:
        return subscription.trialEndDate
    }
}

Из этого кода можно сделать несколько выводов.

Для обычной подписки используется next_billing_date, для пробной trial_end_date. Если статус отличается от active, функция возвращает nil.

Но последнего недостаточно, чтобы утверждать, что на экране появится сообщение о приостановке.

Для этого агенту нужно найти код, который формирует текст или состояние соответствующего UI-компонента.

Это важная деталь: отсутствие даты и отображение сообщения о приостановке являются разными требованиями.

Также агент должен проверить, как декодируются даты.

В примере API возвращает строки формата yyyy-MM-dd, а в Swift-модели используется Date. Значит, где-то должен быть настроен соответствующий JSONDecoder.

Если он ожидает ISO 8601 с временем, а сервер возвращает только дату, проблема возникнет ещё до отображения экрана.

Хорошо, если агент обнаружит это на этапе анализа, а не после подключения мока.

Находим API и готовим ответы

После изучения модели агент должен найти сервис, который загружает подписки, и сопоставить его с запросом в Proxyman.

Предположим, это:

GET /api/v1/subscriptions

Дальше нужно взять реальный ответ и подготовить несколько вариантов.

Я бы не стал просить агента создавать JSON с нуля.

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

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

Например, хотим проверить дату следующего списания у sub_101.

Агент должен найти объект по id и подготовить изменение:

{
  "id": "sub_101",
  "type": "standard",
  "status": "active",
- "next_billing_date": "2026-11-15"
+ "next_billing_date": "2026-12-01"
}

Это иллюстрация diff относительно исходного ответа, в котором дата была 2026-11-15.

Здесь важно искать объект именно по идентификатору.

Если API возвращает массив из десяти подписок, изменение первого элемента может затронуть совсем не ту подписку, которую мы собирались проверить.

Для приостановленной подписки потребуется другое изменение:

{
  "id": "sub_101",
  "type": "standard",
- "status": "active"
+ "status": "paused"
}

Остальные поля можно оставить без изменений, если контракт это допускает.

Если сервер обычно удаляет next_billing_date для приостановленных подписок, стоит подготовить отдельный сценарий с отсутствующим полем.

Так мы сможем проверить не только отображение статуса, но и корректность обработки необязательных данных.

Организуем файлы моков

Для начала достаточно обычной структуры каталогов:

mocks/
└── subscriptions/
    ├── standard.json
    ├── trial.json
    └── paused.json

Каждый файл содержит полный ответ /api/v1/subscriptions, а не отдельный объект подписки.

Это важно, поскольку приложение ожидает объект с массивом subscriptions.

Файлы можно подключить через Map Local.

MCP позволяет агенту включать и выключать правила - это нам и поможет

При переключении сценариев нужно учитывать уже существующие правила. Несколько активных подмен для одного URL могут привести к неожиданному результату.

Я бы использовал одно управляемое правило для каждого endpoint, а не создавал новое при каждом запросе к агенту.

Так проще понять, какой мок сейчас активен.

Добавляем feature flag

Пока мы управляли только подписками.

Теперь подключим второй запрос:

GET /api/v1/config

Ответ:

{
  "features": {
    "enableNewSubscriptionDetails": false
  }
}

Задача немного усложняется.

Для проверки одной комбинации нужно подготовить согласованные ответы сразу для двух endpoint.

Например, чтобы проверить приостановленную подписку с новой логикой, необходимо:

  1. Установить status = paused для нужной подписки.

  2. Включить enableNewSubscriptionDetails.

  3. Убедиться, что оба ответа подменяются.

  4. Перезагрузить данные приложения.

  5. Проверить состояние экрана.

Вручную это несложно. Но при переключении между шестью сценариями легко забыть поменять один из ответов.

Поэтому агенту можно поставить задачу:

Подготовь шесть комбинаций для обычной, пробной и приостановленной подписки с включённым и выключенным enableNewSubscriptionDetails.

Не изменяй остальные подписки и feature flags. Для каждого сценария подготовь полный набор ответов. Перед переключением проверь существующие правила.

Для хранения комбинаций можно использовать такую структуру:

mocks/
└── subscriptions/
    ├── standard-off/
    │   ├── subscriptions.json
    │   └── config.json
    ├── standard-on/
    │   ├── subscriptions.json
    │   └── config.json
    ├── trial-off/
    │   ├── subscriptions.json
    │   └── config.json
    ├── trial-on/
    │   ├── subscriptions.json
    │   └── config.json
    ├── paused-off/
    │   ├── subscriptions.json
    │   └── config.json
    └── paused-on/
        ├── subscriptions.json
        └── config.json

Файлов стало больше, зато каждый сценарий полностью описывает необходимое состояние API.

Можно переключать комбинации, не вспоминая, какой ответ был активен до этого.

Есть одна техническая тонкость.

Proxyman не обеспечивает атомарное переключение нескольких независимых правил как единую транзакцию.

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

Например, сначала остановить тестовый сценарий, обновить оба правила, проверить их состояние и только потом перезапустить загрузку данных.

Это не настоящая атомарность на уровне Proxyman, но для контролируемого тестового окружения такой порядок позволяет избежать смешивания ответов от разных сценариев.

Что делать с кешированием

Допустим, агент подготовил оба ответа, правила активны, но экран продолжает показывать старые данные.

Первое, что нужно проверить: выполнило ли приложение новый запрос.

Между Proxyman и интерфейсом может находиться несколько уровней кеширования:

  • Сетевой кеш.

  • Локальная база данных.

  • Состояние ViewModel.

  • Загруженная ранее конфигурация feature flags.

Последний случай особенно неприятен.

Если приложение получает конфигурацию только при запуске, переключение мока не изменит уже загруженные значения.

Понадобится перезапуск приложения или предусмотренный механизм обновления конфигурации.

Поэтому для каждого сценария я бы фиксировал три отдельных результата.

Мок подготовлен. JSON создан и прошёл проверку структуры.

Мок применён. В Proxyman зафиксирован запрос с подменённым ответом, и есть основания считать, что именно этот ответ получил сетевой слой приложения.

UI проверен. На экране отображается ожидаемое состояние.

Для последнего этапа можно использовать UI-автоматизацию или проверять интерфейс вручную.

Сам по себе Proxyman MCP не подтверждает, что приложение правильно отобразило данные.

И ещё: если запрос был перехвачен прокси, это не всегда означает, что данные успешно декодировались и дошли до ViewModel.

Поэтому для полноценной проверки полезно иметь доступ к логам приложения.

Когда Map Local недостаточно

Map Local удобен, когда нужно полностью заменить ответ заранее подготовленным JSON.

Но для небольших изменений иногда проще использовать Proxyman Scripting.

Например, у нас большой конфигурационный ответ с десятками feature flags, а изменить нужно только один.

Вместо хранения нескольких почти одинаковых файлов можно модифицировать ответ на лету.

Сама логика изменения выглядит примерно так:

function enableSubscriptionDetails(body) {
    if (
        !body ||
        typeof body !== "object" ||
        !body.features ||
        typeof body.features !== "object"
    ) {
        return body;
    }

    return {
        ...body,
        features: {
            ...body.features,
            enableNewSubscriptionDetails: true
        }
    };
}

Это обычная JavaScript-функция преобразования объекта, а не готовый обработчик Proxyman Scripting.

Чтобы использовать её в Proxyman, нужно встроить вызов в поддерживаемый обработчик ответа и учесть фактический формат response.body.

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

Но у Scripting есть и недостаток.

Когда сценариев становится много, логика подмены постепенно превращается в отдельную систему условий.

В таком случае набор явно названных JSON-файлов может оказаться удобнее.

Я бы использовал Scripting для небольших независимых изменений, а Map Local для воспроизведения конкретных состояний API.

Где агент может ошибиться

Пожалуй, это самая интересная часть всей автоматизации.

Проблема не в том, что AI может неправильно написать JSON. Ошибки возникают и в более неожиданных местах.

Изменение не того объекта

API возвращает массив подписок, агент меняет первый элемент, а нужная подписка находится на третьей позиции.

JSON остаётся валидным, приложение работает, но проверяется другой сценарий.

Решение простое: искать объекты по устойчивым идентификаторам и проверять, что найден ровно один подходящий элемент.

Если объект не найден, лучше остановить подготовку мока, чем менять что-то приблизительно подходящее.

Несоответствие API-контракту

Агент удаляет поле, которое считает ненужным, но декодер ожидает его как обязательное.

В результате экран не загружается.

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

При этом Swift-модель не всегда описывает полный контракт сервера. Если есть OpenAPI-спецификация, её тоже стоит учитывать.

Конфликтующие правила

Для одного endpoint уже существует Map Local, а агент создаёт ещё одно правило.

В итоге сложно понять, какая подмена сработала.

Перед созданием новых правил нужно проверить существующие и определить, какие из них будут затронуты.

Причём я бы не разрешал агенту без подтверждения удалять чужие правила.

Некорректная проверка результата

Агент создал файлы, активировал правила и сообщил, что сценарии успешно протестированы.

При этом приложение даже не запускалось.

Такой результат нельзя считать тестированием.

В отчёте должно быть видно, какие действия действительно выполнены и какие результаты подтверждены.

Работа с чувствительными даннымиЕсли у вас корпоративная модель в контуре компании текст ниже не пригодиться

Есть ещё одна проблема, которую легко пропустить. Реальный ответ API может содержать персональные данные, токены или другую информацию, которую не стоит сохранять в репозитории и передавать модели. Поэтому перед использованием ответов в качестве моков нужно проверить их содержимое. Для локального тестирования лучше использовать обезличенные данные. Если моки планируется коммитить, стоит дополнительно убедиться, что в файлах нет чувствительной информации.

Как должен выглядеть результат работы агента

Мне кажется, здесь полезнее всего не длинный рассказ о выполненных действиях, а короткий отчёт с конкретными статусами.

Например:

Scenario: paused-on

Endpoints:
  GET /api/v1/subscriptions
  GET /api/v1/config

Changes:
  sub_101.status:
    active -> paused

  enableNewSubscriptionDetails:
    false -> true

Files:
  mocks/subscriptions/paused-on/subscriptions.json
  mocks/subscriptions/paused-on/config.json

Validation:
  JSON syntax: OK
  Required fields: OK
  Other subscriptions: unchanged

Proxyman:
  Rules prepared: YES
  Rules activated: NO

Runtime:
  Mock response received: NOT CHECKED
  UI verified: NOT CHECKED

Здесь сразу понятно, что готово, а что ещё предстоит сделать.

После активации правил и проверки приложения статусы можно обновить.

Такой формат особенно удобен, когда сценариев много и нужно быстро переключаться между ними.

Что в итоге можно автоматизировать

Если собрать весь процесс, получится примерно следующее:

Действие

Можно поручить агенту

Поиск моделей и логики UI

Да, при наличии доступа к проекту

Поиск связанных API

Да

Анализ сетевых ответов

Да, если MCP предоставляет нужные данные

Подготовка JSON-моков

Да

Проверка структуры JSON

Да

Сравнение изменений

Да

Создание правил Proxyman

Зависит от MCP

Переключение сценариев

Зависит от MCP

Проверка получения ответа

При наличии доступа к трафику и логам

Проверка интерфейса

При наличии UI-автоматизации

Главное преимущество здесь не в генерации JSON.

Это как раз самая простая часть.

Гораздо полезнее, что агент может связать требования к интерфейсу с конкретными полями API.

Разработчику не нужно каждый раз вспоминать, в каком сервисе находится нужный endpoint, как называется поле и какие дополнительные условия влияют на отображение.

Можно описать необходимое состояние приложения:

Подготовь приостановленную подписку с включённой новой логикой. Остальные подписки не изменяй.

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

Если MCP поддерживает управление правилами, часть действий в Proxyman тоже можно автоматизировать.

Но окончательная проверка поведения приложения всё равно остаётся отдельным этапом.

Вместо заключения

Proxyman и без AI отлично справляется с подменой сетевых ответов.

Проблема не в сложности изменения одного поля JSON. Проблема в количестве подготовительных действий, особенно когда состояние экрана зависит от нескольких API и feature flags.

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

OpenCode с подключёнными MCP-серверами позволяет переложить значительную часть этой работы на агента.

При этом я бы не стремился сразу полностью автоматизировать тестирование.

Для начала достаточно научить агента находить нужные API, готовить корректные моки и показывать изменения перед применением.

Уже это убирает немало ручной работы.

А когда подготовка сценариев станет предсказуемой, можно постепенно добавлять управление правилами Proxyman и проверку интерфейса.

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

Без очередного ручного редактирования нескольких JSON-файлов.

View the original on Хабр →

KioskNews shows a cleaned-up reading view extracted from the publisher’s page — the original always lives on their site, not ours.