Typescript, react-scripts. Веб-приложение получает через url флажок isComplexMode=true…
- User
Typescript, react-scripts.
Веб-приложение получает через url флажок isComplexMode=true или не получает. Один из пакетов используется только тогда, когда isComplexMode=true.
Как можно сделать, чтобы он был в отдельном chunk и его не было бы, если бы флажок isComplexMode не был бы выставлен?
Assistant
Для достижения цели разделения кода (code splitting) и ленивой загрузки (lazy loading) пакета, который используется только в
isComplexMode=true, можно воспользоваться динамическим импортом (dynamic import) и React.lazy.Вот шаги и пример кода:
1. Создайте отдельный модуль для "сложного" компонента/функциональности:
Пусть у вас есть компонент, который вы хотите загружать только в
complexMode. Создайте для него отдельный файл, например,ComplexComponent.tsx:// ComplexComponent.tsx import React from 'react'; const ComplexComponent = () => { return ( <div> <h1>Complex Component</h1> <p>Этот компонент загружается только в Complex Mode.</p> </div> ); }; export default ComplexComponent;2. Используйте динамический импорт и
React.lazy:В вашем основном компоненте используйте динамический импорт и
React.lazyдля ленивой загрузкиComplexComponent.tsx.// App.tsx import React, { useState, useEffect, Suspense } from 'react'; const App: React.FC = () => { const [isComplexMode, setIsComplexMode] = useState(false); useEffect(() => { const params = new URLSearchParams(window.location.search); const complexParam = params.get('isComplexMode'); setIsComplexMode(complexParam === 'true'); }, []); // Ленивая загрузка компонента const LazyComplexComponent = React.lazy(() => import('./ComplexComponent')); return ( <div> <h1>My App</h1> {isComplexMode ? ( <Suspense fallback={<div>Загрузка...</div>}> <LazyComplexComponent /> </Suspense> ) : ( <p>Обычный режим</p> )} </div> ); }; export default App;Пояснения:
useEffect: Получает параметрisComplexModeиз URL при монтировании компонента.React.lazy(() => import('./ComplexComponent')):React.lazyпринимает функцию, которая должна возвращатьPromise.import('./ComplexComponent')- это динамический импорт, который возвращает Promise, разрешающийся в модульComplexComponent. Это говорит React о том, чтоComplexComponentнужно загружать лениво, только когда он понадобится. Webpack (или Parcel, если вы его используете) автоматически создаст отдельный chunk дляComplexComponent.tsx.Suspense:Suspenseнужен для обработки состояния загрузки лениво загружаемых компонентов. Атрибутfallbackуказывает, что нужно отображать во время загрузки компонента.
3. Проверьте работу:
- Запустите ваше React-приложение.
- Откройте инструменты разработчика (Developer Tools) в браузере (обычно F12).
- Перейдите на вкладку "Network" (Сеть).
- Загрузите страницу без параметра
isComplexModeв URL (например,http://localhost:3000). Убедитесь, что chunk сComplexComponentне загружается. - Загрузите страницу с параметром
isComplexMode=trueв URL (например,http://localhost:3000?isComplexMode=true). Убедитесь, что chunk сComplexComponentзагружается только тогда, когдаisComplexModeустановлен в true. Обратите внимание на имя chunk'а – оно должно отличаться от основного bundle.
Дополнительные замечания:
-
Имена чанков (Chunk Names): Вы можете управлять именами чанков с помощью
webpackChunkNameв динамическом импорте:const LazyComplexComponent = React.lazy(() => import(/* webpackChunkName: "complex-component" */ './ComplexComponent'));Это облегчит отслеживание чанков в инструментах разработчика.
-
Ошибка при загрузке: Обработайте возможные ошибки при загрузке компонента с помощью
Suspense. Можно обернутьLazyComplexComponentвtry...catchвнутриSuspensefallback, или создать ErrorBoundary. -
Оптимизация: После внедрения разделения кода, проверьте размер и структуру ваших чанков с помощью инструментов анализа bundle, таких как
webpack-bundle-analyzer. Это поможет выявить области для дальнейшей оптимизации. -
Типизация динамического импорта: Иногда TypeScript может ругаться на отсутствие типизации динамического импорта. Можно объявить
import()как функцию с правильным типом. Вtsconfig.jsonубедитесь, чтоmoduleResolutionустановлено вnodeилиnode16+, аmoduleвesnextили что-то подобное, поддерживающее динамический импорт. Если проблемы остаются, можно добавить объявление в*.d.tsфайл:// global.d.ts declare global { interface ImportMeta { env: { [key: string]: string | undefined; }; } function __non_webpack_require__(request: string): any; } export {};
Этот подход позволит загружать "сложный" компонент только тогда, когда это необходимо, улучшая производительность вашего приложения за счет уменьшения размера начального bundle. Он также позволяет избежать загрузки ненужного кода для пользователей, которые не используют complex mode.
- User
Хочу узнать про способ динамическим импортом. У меня вызов только в middleware. Вызов обусловил проверкой флага. Теперь только useEffect добавить?
Assistant
Если вы уже используете динамический импорт в middleware, обусловленный флагом, то
useEffectдобавлять, скорее всего, не нужно, по крайней мере, не в том виде, как это было предложено в предыдущем ответе.useEffectнужен для того, чтобы React компонент знал, когда нужно лениво загрузить компонент. В вашем случае, middleware занимается загрузкой, поэтому React компонент не нуждается в этой логике.Понимание контекста:
- Middleware: Похоже, что вы используете Redux middleware (или middleware в другом контексте, но суть остается той же) для выполнения побочных эффектов и, вероятно, для загрузки данных или инициализации чего-то.
- Динамический импорт в middleware: Вы уже делаете
import(...)в middleware, основываясь на значении флагаisComplexMode. Это означает, что сам процесс загрузки модуля и его использование происходит в middleware, вне React компонентов.
Что нужно сделать (если необходимо):
Вам может понадобиться использовать
useEffectдля триггера middleware, но не для динамического импорта. Основная идея заключается в том, чтобы middleware запускалось только тогда, когдаisComplexModeравноtrue.Вот пример (предполагая, что вы используете Redux):
// middleware.ts import { Middleware } from 'redux'; // Типизируйте Action и State соответственно вашему приложению type RootState = { complexData: any; }; type Action = { type: string; payload?: any; }; const complexMiddleware: Middleware<{}, RootState> = (store) => (next) => async (action: Action) => { if (action.type === 'INIT_COMPLEX_MODE') { try { // Динамический импорт const { complexFunction } = await import('./complexModule'); // Замените на правильный путь // Вызываем функцию и, например, сохраняем данные в store const data = complexFunction(action.payload); store.dispatch({ type: 'SET_COMPLEX_DATA', payload: data }); } catch (error) { console.error('Ошибка при загрузке complexModule:', error); // Обработайте ошибку } } return next(action); }; export default complexMiddleware; // complexModule.ts export function complexFunction(data: any) { //Тут тяжелая логика return data + " - Обработано в complexFunction"; }// App.tsx import React, { useEffect, useState } from 'react'; import { useDispatch, useSelector } from 'react-redux'; // Или как вы используете Redux import {configureStore} from '@reduxjs/toolkit' import complexMiddleware from './middleware'; type RootState = { complexData: any; }; const store = configureStore({ reducer: (state: RootState = { complexData: null }, action: any) => { switch (action.type) { case 'SET_COMPLEX_DATA': return { ...state, complexData: action.payload }; default: return state; } }, middleware: [complexMiddleware] }); const App: React.FC = () => { const [isComplexMode, setIsComplexMode] = useState(false); const dispatch = useDispatch(); const complexData = useSelector((state: RootState) => state.complexData); useEffect(() => { const params = new URLSearchParams(window.location.search); const complexParam = params.get('isComplexMode'); const isComplex = complexParam === 'true'; setIsComplexMode(isComplex); if (isComplex) { // Запускаем middleware только когда isComplexMode = true dispatch({ type: 'INIT_COMPLEX_MODE', payload: { someData: 'данные' } }); // Передайте необходимые данные } }, [dispatch]); return ( <div> <h1>My App</h1> {isComplexMode ? ( <div> <p>Complex Mode Enabled!</p> {complexData && <p>Complex Data: {complexData}</p>} </div> ) : ( <p>Обычный режим</p> )} </div> ); }; export default App;Пояснения:
complexMiddleware: Функция middleware, которая будет перехватывать определенные действия (INIT_COMPLEX_MODE).- Динамический импорт в middleware: Внутри middleware происходит динамический импорт
complexModule.ts. useEffectдля запуска middleware:useEffectвApp.tsxопределяет, включен лиcomplexMode. Если да, то диспатчится действиеINIT_COMPLEX_MODE, которое перехватывается middleware. Это триггер для запуска логики в middleware, включая динамический импорт.dispatchdependency: Обязательно добавьтеdispatchв массив зависимостейuseEffect, чтобы гарантировать, что эффект будет повторно выполняться при измененииdispatch. Это важно для правильной работы с Redux.
Преимущества этого подхода:
- Четкое разделение ответственности: Компоненты React отвечают только за отображение UI и запуск действий. Middleware занимается загрузкой модулей и выполнением побочных эффектов.
- Контроль над временем загрузки: Вы точно знаете, когда загружается модуль, поскольку это происходит только при dispatch соответствующего действия.
- Легче тестировать: Middleware можно легко протестировать, имитируя действия и проверяя, что динамический импорт выполняется и что данные обрабатываются правильно.
Когда все-таки нужен
React.lazy?React.lazyиSuspenseполезны, когда вы хотите лениво загружать React компоненты. ЕслиcomplexModuleсодержит только функции, а не React компоненты, то использованиеReact.lazyне нужно. ЕслиcomplexModuleсодержит React компонент, и вы хотите его рендерить вApp.tsx, тогда стоит подумать проReact.lazy, как было указано в предыдущем примере.- User
await import(/* webpackChunkName: "complex-middleware" */ 'your-middleware-package');
jest. Как лучше всего мокать?
Assistant
Мокирование динамически импортируемых модулей в Jest требует немного больше усилий, чем мокирование обычных модулей. Вот несколько подходов, от простых к более сложным, в зависимости от вашей конкретной ситуации:
1.
jest.mock()с явным моком:Это самый простой и часто достаточный способ. Он предполагает, что вы заранее знаете, какой модуль нужно мокнуть.
// __mocks__/your-middleware-package.ts // Создайте файл мока в директории __mocks__ (должна быть на том же уровне, что и node_modules) module.exports = { yourMiddlewareFunction: jest.fn().mockImplementation(() => 'mockedValue'), // Пример мока функции // Другие моки для экспортов из модуля }; // your-test.test.ts jest.mock('your-middleware-package'); // Автоматически подменяет модуль моком из __mocks__ import { yourMiddlewareFunction } from 'your-middleware-package'; describe('Your Component', () => { it('должен корректно мокать middleware', () => { // Проверки с использованием mockedFunction yourMiddlewareFunction.mockReturnValue('new mocked value'); // Измените возвращаемое значение при необходимости expect(yourMiddlewareFunction()).toBe('new mocked value'); }); });Объяснение:
__mocks__директория: Jest автоматически ищет моки в директориях__mocks__, расположенных рядом с мокируемыми модулями или в корне проекта.jest.mock('your-middleware-package'): Эта строка сообщает Jest, что всякий раз, когда код импортирует'your-middleware-package', он должен использовать мок из__mocks__/your-middleware-package.ts.- Модуль мока: В
__mocks__/your-middleware-package.tsвы создаете объект с моками для всего, что вы экспортируете из исходного модуля.jest.fn()создает mock function, которую вы можете проверять и контролировать.
Когда это работает хорошо:
- Когда вы знаете заранее, какой модуль нужно мокнуть.
- Когда структура мокируемого модуля относительно простая.
Недостатки:
- Не работает с динамическими импортами "из коробки", т.к.
jest.mockвыполняется синхронно в начале теста. - Если структура модуля сильно изменится, вам придется обновить мок.
2.
jest.spyOn+mockImplementation:Более гибкий подход, особенно когда вам нужно мокнуть только часть модуля или когда вам нужно мокнуть динамический импорт. Он использует
jest.spyOnдля слежки за импортируемой функцией иmockImplementationдля замены ее реализации.// your-test.test.ts describe('Your Component', () => { it('должен корректно мокать динамический импорт', async () => { const yourMiddlewarePackage = await import('your-middleware-package'); // Получаем доступ к модулю const yourMiddlewareFunctionSpy = jest.spyOn(yourMiddlewarePackage, 'yourMiddlewareFunction'); yourMiddlewareFunctionSpy.mockImplementation(() => 'mockedValue'); // ... (Ваш код, который использует yourMiddlewareFunction) ... expect(yourMiddlewareFunctionSpy).toHaveBeenCalled(); // Проверка, что функция была вызвана yourMiddlewareFunctionSpy.mockRestore(); // Восстанавливаем оригинальную реализацию }); });Объяснение:
await import('your-middleware-package'): Сначала вы импортируете модуль, чтобы получить доступ к его экспортам.jest.spyOn(yourMiddlewarePackage, 'yourMiddlewareFunction'): Создает spy на конкретную функцию в импортированном модуле.mockImplementation(() => 'mockedValue'): Заменяет оригинальную реализацию функции на вашу мокнутую.mockRestore(): Очень важно! Восстанавливает оригинальную реализацию функции после теста. Это предотвращает влияние мока на другие тесты.
Когда это работает хорошо:
- Для мокирования только части модуля.
- Для мокирования динамически импортируемых модулей.
- Когда нужно временно изменить поведение функции только для одного теста.
3.
jest.mockсmockImplementationи resolve:Этот подход позволяет мокнуть динамически импортируемый модуль целиком, используя
jest.mockиmockImplementation. Это более сложный способ, но он предоставляет полный контроль над моком.// your-test.test.ts jest.mock('your-middleware-package', () => { return { __esModule: true, // Важно для корректной работы ES modules yourMiddlewareFunction: jest.fn().mockImplementation(() => 'mockedValue'), }; }); import { yourMiddlewareFunction } from 'your-middleware-package'; describe('Your Component', () => { it('должен корректно мокать динамический импорт', async () => { // ... (Ваш код, который использует yourMiddlewareFunction) ... expect(yourMiddlewareFunction).toHaveBeenCalled(); // Проверка, что функция была вызвана }); });Объяснение:
jest.mock('your-middleware-package', () => { ... }): Второй аргументjest.mock- это функция-фабрика, которая должна возвращать мок.__esModule: true: Важно указать__esModule: true, чтобы Jest правильно обрабатывал ES modules.- Внутри фабрики вы создаете объект с моками для всего, что экспортируется из модуля.
4. Использование
jest.unmock(редко, но полезно):Если вам нужно отключить мок, который вы ранее установили с помощью
jest.mock, вы можете использоватьjest.unmock('your-middleware-package'). Это может быть полезно, если у вас есть глобальные моки, и вы хотите отключить их для конкретного теста.5. Мокирование на уровне сети (network mocking):
Если
your-middleware-packageвыполняет сетевые запросы (например, API calls), вместо мокирования самого модуля, вы можете мокировать сетевые запросы с помощью библиотек, таких какnockилиjest-fetch-mock. Это более реалистичный способ тестирования, поскольку он проверяет, как ваше приложение взаимодействует с сетью.Как выбрать правильный подход:
- Простота: Начните с самого простого подхода (
jest.mockс явным моком). Если он работает, используйте его. - Гибкость: Если вам нужна большая гибкость или вы работаете с динамическими импортами, используйте
jest.spyOn+mockImplementation. - Контроль: Если вам нужен полный контроль над моком или вы хотите мокнуть весь модуль, используйте
jest.mockс фабрикой. - Реализм: Если модуль выполняет сетевые запросы, рассмотрите возможность мокирования на уровне сети.
Общие советы:
- Всегда восстанавливайте моки: После каждого теста восстанавливайте оригинальные реализации функций, которые вы мокировали, чтобы избежать побочных эффектов. Используйте
mockRestore()илиjest.resetAllMocks(). - Пишите хорошие комментарии: Объясните, что вы мокируете и почему. Это облегчит понимание и поддержку ваших тестов.
- Используйте типизацию: Используйте TypeScript для типизации мокируемых модулей. Это поможет вам избежать ошибок и улучшить поддержку кода.
- Избегайте избыточного мокирования: Мокируйте только то, что действительно необходимо для тестирования конкретной части вашего приложения. Избегайте мокирования всего подряд, так как это может сделать ваши тесты хрупкими и трудными для поддержки.
Пример использования мокирования на уровне сети с
jest-fetch-mock:// your-test.test.ts import fetchMock from 'jest-fetch-mock'; fetchMock.enableMocks(); describe('Your Component', () => { beforeEach(() => { fetchMock.resetMocks(); }); it('должен корректно мокать сетевой запрос', async () => { fetchMock.mockResponseOnce(JSON.stringify({ data: 'mocked data' })); // ... (Ваш код, который делает fetch запрос) ... expect(fetchMock).toHaveBeenCalledTimes(1); expect(fetchMock.mock.calls[0][0]).toEqual('https://example.com/api'); // Проверьте URL }); });Помните, что цель мокирования - изолировать тестируемый код и убедиться, что он работает правильно, не полагаясь на внешние зависимости. Выбор правильного подхода зависит от сложности вашего кода и ваших конкретных требований.
- User
const abc = new ModuleToMock().withSmthHandle({ onEvent: function (_a, b) { return new Promise(resolve => { return resolve({}); }); }, });
await abc.connect();Используя jest, замокай ModuleToMock
Assistant
Учитывая, что у вас есть цепочка вызовов методов (
new ModuleToMock().withSmthHandle(...).connect()), мокированиеModuleToMockтребует особого внимания, чтобы правильно мокнуть все части этой цепочки. Вот несколько подходов, от более простых к более сложным, с учетом динамического импорта (хотя в вашем примере динамический импорт не виден, я предполагаю, чтоModuleToMockимпортируется динамически, как обсуждалось ранее).1. Мокирование с использованием
jest.mockи фабрики:Этот подход хорошо работает, если вы хотите контролировать всю цепочку вызовов и вернуть мокнутые объекты для каждого шага.
// your-test.test.ts jest.mock('./ModuleToMock', () => { const mockConnect = jest.fn().mockResolvedValue(undefined); // Мокаем connect const mockWithSmthHandle = jest.fn().mockReturnValue({ // Мокаем withSmthHandle connect: mockConnect, }); const MockModuleToMock = jest.fn().mockImplementation(() => { return { withSmthHandle: mockWithSmthHandle, }; }); return { __esModule: true, // Обязательно для ES modules default: MockModuleToMock, // Мокаем конструктор }; }); import ModuleToMock from './ModuleToMock'; describe('Your Component', () => { it('должен корректно мокать ModuleToMock', async () => { const mockedModuleToMock = new ModuleToMock(); // Создаем экземпляр мока await mockedModuleToMock.withSmthHandle({ onEvent: jest.fn() }).connect(); // Проверки expect(ModuleToMock).toHaveBeenCalled(); // Проверяем, что конструктор был вызван expect(mockedModuleToMock.withSmthHandle).toHaveBeenCalled(); expect(mockedModuleToMock.withSmthHandle().connect).toHaveBeenCalled(); }); });Объяснение:
jest.mock('./ModuleToMock', () => { ... }): Мы предоставляем фабрику для создания мока.MockModuleToMock: Мокнутый конструкторModuleToMock.jest.fn().mockImplementation(() => { ... })позволяет нам указать, что будет возвращать конструктор.mockWithSmthHandle: Мокнутая функцияwithSmthHandle. Она возвращает объект с мокнутой функциейconnect.mockConnect: Мокнутая функцияconnect.mockResolvedValue(undefined)говорит, чтоconnectвозвращает Promise, который разрешается сundefined.__esModule: true: Не забудьте добавить это, если вы используете ES modules.
Преимущества:
- Полный контроль над мокнутыми значениями и поведением.
- Может мокнуть любые методы и свойства.
Недостатки:
- Более сложный код мока.
- Требует знания внутренней структуры
ModuleToMock.
2. Мокирование с использованием
jest.spyOn(частичное мокирование):Этот подход позволяет мокнуть только часть цепочки вызовов, оставляя остальную часть нетронутой. Это может быть полезно, если вы хотите протестировать только определенную часть логики.
// your-test.test.ts import ModuleToMock from './ModuleToMock'; describe('Your Component', () => { it('должен корректно мокать withSmthHandle и connect', async () => { const mockConnect = jest.fn().mockResolvedValue(undefined); const mockWithSmthHandle = jest.fn().mockReturnValue({ connect: mockConnect }); const moduleInstance = new ModuleToMock(); const withSmthHandleSpy = jest.spyOn(moduleInstance, 'withSmthHandle').mockImplementation(mockWithSmthHandle); const connectSpy = jest.spyOn(moduleInstance.withSmthHandle({onEvent: jest.fn()}), 'connect').mockImplementation(mockConnect); const abc = moduleInstance.withSmthHandle({ onEvent: function (_a, b) { return new Promise(resolve => { return resolve({}); }); }, }); await abc.connect(); expect(withSmthHandleSpy).toHaveBeenCalled(); expect(connectSpy).toHaveBeenCalled(); }); });Объяснение:
jest.spyOn(moduleInstance, 'withSmthHandle'): Создаем spy на методwithSmthHandleконкретного экземпляраModuleToMock.mockImplementation(mockWithSmthHandle): Заменяем реализациюwithSmthHandleна наш мок.- Повторяем ту же процедуру для мокирования connect, создавая spy на уже мокнутый объект.
Преимущества:
- Более гибкий, чем полное мокирование.
- Позволяет тестировать интеграцию между реальным и мокнутым кодом.
Недостатки:
- Требует создания экземпляра реального
ModuleToMock.
3. Комбинирование подходов (лучший контроль, сложнее):
Можно комбинировать
jest.mockдля мокирования конструктора иjest.spyOnдля мокирования конкретных методов экземпляра. Это дает вам лучший контроль над тем, что мокируется, а что нет.// your-test.test.ts jest.mock('./ModuleToMock', () => { const MockModuleToMock = jest.fn().mockImplementation(() => { return { withSmthHandle: jest.fn(), // Заглушка для withSmthHandle }; }); return { __esModule: true, default: MockModuleToMock, }; }); import ModuleToMock from './ModuleToMock'; describe('Your Component', () => { it('должен корректно мокать ModuleToMock', async () => { const moduleInstance = new ModuleToMock(); // Создаем экземпляр мока const mockConnect = jest.fn().mockResolvedValue(undefined); const mockWithSmthHandle = jest.fn().mockReturnValue({ connect: mockConnect }); (moduleInstance.withSmthHandle as jest.Mock).mockImplementation(mockWithSmthHandle); const abc = moduleInstance.withSmthHandle({ onEvent: function (_a, b) { return new Promise(resolve => { return resolve({}); }); }, }); await abc.connect(); expect(ModuleToMock).toHaveBeenCalled(); expect(moduleInstance.withSmthHandle).toHaveBeenCalled(); expect(mockConnect).toHaveBeenCalled(); }); });Объяснение:
jest.mock('./ModuleToMock', ...): Мокируем конструкторModuleToMock, но оставляем заглушку дляwithSmthHandle.(moduleInstance.withSmthHandle as jest.Mock).mockImplementation(mockWithSmthHandle);: Получаем доступ к мокнутой функцииwithSmthHandleи заменяем ее реализацию.
Выбор правильного подхода:
- Если вы хотите полностью изолировать код и контролировать все аспекты
ModuleToMock, используйте подход сjest.mockи фабрикой. - Если вам нужно протестировать интеграцию между реальным и мокнутым кодом, используйте подход с
jest.spyOn. - Комбинированный подход дает вам наибольший контроль, но и требует больше кода.
Важные советы:
- Типизация: Используйте TypeScript для типизации мокнутых модулей и функций. Это поможет вам избежать ошибок и улучшить поддержку кода.
mockRestoreилиjest.clearAllMocks()/jest.resetAllMocks(): Убедитесь, что вы восстанавливаете моки после каждого теста, чтобы избежать побочных эффектов. Лучше всего использоватьjest.clearAllMocks()илиjest.resetAllMocks()вafterEach.mockRestoreработает, только если использовалсяjest.spyOn- Асинхронный код: При мокировании асинхронных функций используйте
mockResolvedValueилиmockRejectedValue, чтобы указать, как Promise должен разрешиться или отклониться. - Читаемость: Пишите код моков так, чтобы он был легким для понимания. Добавьте комментарии, чтобы объяснить, что вы мокируете и почему.
- Динамические импорты: Убедитесь, что jest правильно настроен для работы с динамическими импортами (например,
transformIgnorePatternsв jest.config.js).
В конечном итоге, лучший способ мокирования
ModuleToMockзависит от ваших конкретных потребностей и от того, что вы хотите протестировать. Начните с простого подхода и переходите к более сложным только тогда, когда это необходимо.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.