diff --git a/backend/scripts/test_chat_api.js b/backend/scripts/test_chat_api.js new file mode 100644 index 00000000..dfe5b984 --- /dev/null +++ b/backend/scripts/test_chat_api.js @@ -0,0 +1,120 @@ +/** + * Тестирование Chat API через Node.js + * Запуск: node scripts/test_chat_api.js + */ + +const https = require('https'); +const http = require('http'); + +const BASE_URL = process.env.API_URL || 'http://localhost:9000'; +const CHAT_ID = process.env.CHAT_ID || '10'; +const SESSION_COOKIE = process.env.SESSION_COOKIE || ''; // sessionid=xxx + +/** + * Делает HTTP запрос + */ +function makeRequest(path, options = {}) { + return new Promise((resolve, reject) => { + const url = new URL(path, BASE_URL); + const protocol = url.protocol === 'https:' ? https : http; + + const reqOptions = { + method: options.method || 'GET', + headers: { + 'Cookie': SESSION_COOKIE, + 'Accept': 'application/json', + ...options.headers + } + }; + + const req = protocol.request(url, reqOptions, (res) => { + let data = ''; + res.on('data', chunk => data += chunk); + res.on('end', () => { + try { + const json = JSON.parse(data); + resolve({ status: res.statusCode, data: json }); + } catch (e) { + resolve({ status: res.statusCode, data, error: e.message }); + } + }); + }); + + req.on('error', reject); + req.end(); + }); +} + +/** + * Тесты + */ +async function runTests() { + console.log('🧪 Тестирование Chat API\n'); + console.log(`Base URL: ${BASE_URL}`); + console.log(`Chat ID: ${CHAT_ID}\n`); + + // Тест 1: Загрузка последних сообщений + console.log('📥 Test 1: Загрузка последних сообщений'); + const latestResult = await makeRequest(`/api/v1/communications/chats/${CHAT_ID}/messages/`); + console.log(`Status: ${latestResult.status}`); + console.log(`Messages: ${latestResult.data.results?.length || 0}`); + console.log(`Has more: ${latestResult.data.has_more}\n`); + + // Тест 2: Загрузка вокруг timestamp (декабрь 2025) + const dec2025 = Date.UTC(2025, 11, 29); // 29 декабря 2025 + console.log('📅 Test 2: Загрузка вокруг даты (29 Dec 2025)'); + console.log(`Timestamp: ${dec2025} (${new Date(dec2025).toISOString()})`); + + const aroundResult = await makeRequest( + `/api/v1/communications/chats/${CHAT_ID}/messages/around/?around_id=${dec2025}&limit=30` + ); + console.log(`Status: ${aroundResult.status}`); + console.log(`Messages: ${aroundResult.data.results?.length || 0}`); + console.log(`Anchor ID: ${aroundResult.data.anchor_id}`); + console.log(`Has more before: ${aroundResult.data.has_more_before}`); + console.log(`Has more after: ${aroundResult.data.has_more_after}\n`); + + if (aroundResult.data.results?.length > 0) { + console.log('Первое сообщение:'); + const first = aroundResult.data.results[0]; + console.log(` ID: ${first.id}`); + console.log(` Date: ${first.created_at}`); + console.log(` Content: ${first.content?.substring(0, 50) || '(no content)'}...\n`); + } + + // Тест 3: Загрузка истории (before_id) + if (aroundResult.data.anchor_id) { + console.log('⬆️ Test 3: Загрузка истории (старые сообщения)'); + const oldestId = aroundResult.data.results?.[0]?.id; + if (oldestId) { + const historyResult = await makeRequest( + `/api/v1/communications/chats/${CHAT_ID}/messages/?before_id=${oldestId}&limit=20` + ); + console.log(`Status: ${historyResult.status}`); + console.log(`Messages: ${historyResult.data.results?.length || 0}`); + console.log(`Has more: ${historyResult.data.has_more}\n`); + } + } + + // Тест 4: Загрузка новых (after_id) + if (aroundResult.data.anchor_id) { + console.log('⬇️ Test 4: Загрузка новых сообщений'); + const newestId = aroundResult.data.results?.[aroundResult.data.results.length - 1]?.id; + if (newestId) { + const newerResult = await makeRequest( + `/api/v1/communications/chats/${CHAT_ID}/messages/?after_id=${newestId}&limit=20` + ); + console.log(`Status: ${newerResult.status}`); + console.log(`Messages: ${newerResult.data.results?.length || 0}`); + console.log(`Has more: ${newerResult.data.has_more}\n`); + } + } + + console.log('✅ Тесты завершены'); +} + +// Запуск +runTests().catch(err => { + console.error('❌ Ошибка:', err); + process.exit(1); +}); diff --git a/backend/static/css/components/chat-date-groups.css b/backend/static/css/components/chat-date-groups.css new file mode 100644 index 00000000..630ad3d9 --- /dev/null +++ b/backend/static/css/components/chat-date-groups.css @@ -0,0 +1,240 @@ +/** + * Chat Date Groups - Стили для группировки сообщений по датам + * + * Основано на Telegram Web архитектуре: + * - Sticky positioning для дат + * - Плавные transitions + * - Адаптивная типографика + */ + +/* ==================== Message Date Group ==================== */ + +/** + * Контейнер группы сообщений одной даты + */ +.message-date-group { + position: relative; + display: flex; + flex-direction: column; + width: 100%; +} + +/* ==================== Sticky Date Header ==================== */ + +/** + * Sticky date header (прилипает к верху при скролле) + */ +.sticky-date { + position: sticky; + top: 56px; /* Высота chat-header */ + z-index: 2; + + /* Layout */ + display: flex; + align-items: center; + justify-content: center; + padding: 12px 16px; + margin: 0; + + /* Typography */ + font-size: 0.875rem; + font-weight: 500; + color: var(--bs-secondary); + text-align: center; + + /* Визуальные эффекты */ + background-color: transparent; + pointer-events: none; /* Не блокирует клики по умолчанию */ + + /* Transitions */ + transition: opacity 0.15s ease, background-color 0.2s ease; +} + +/** + * Внутренний span с текстом даты + */ +.sticky-date span { + display: inline-block; + padding: 6px 12px; + border-radius: 12px; + background-color: var(--bs-light); + pointer-events: all; /* Только текст кликабельный */ + + /* Shadow для лучшей читаемости */ + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05); + + /* Transitions */ + transition: background-color 0.2s ease, box-shadow 0.2s ease, transform 0.15s ease; +} + +/** + * Интерактивный режим (кликабельная дата) + */ +.sticky-date.interactive span { + cursor: pointer; + user-select: none; +} + +.sticky-date.interactive span:hover { + background-color: var(--bs-primary); + color: white; + box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15); + transform: translateY(-1px); +} + +.sticky-date.interactive span:active { + transform: translateY(0); + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); +} + +/** + * Состояние sticky (когда дата "прилипла" к верху) + * Добавляется через IntersectionObserver + */ +.sticky-date.is-sticky { + /* Можно добавить визуальный эффект для sticky состояния */ + /* Например, изменить фон или тень */ +} + +.sticky-date.is-sticky span { + background-color: rgba(255, 255, 255, 0.95); + backdrop-filter: blur(10px); + box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1); +} + +/* ==================== Messages Container ==================== */ + +/** + * Контейнер для сообщений внутри date group + */ +.messages-container { + display: flex; + flex-direction: column; + width: 100%; + gap: 0; /* Сообщения сами управляют своими отступами */ +} + +/* ==================== Dark Mode Support ==================== */ + +@media (prefers-color-scheme: dark) { + .sticky-date { + color: var(--bs-light); + } + + .sticky-date span { + background-color: rgba(52, 58, 64, 0.95); + color: var(--bs-light); + } + + .sticky-date.interactive span:hover { + background-color: var(--bs-primary); + color: white; + } + + .sticky-date.is-sticky span { + background-color: rgba(52, 58, 64, 0.98); + backdrop-filter: blur(10px); + } +} + +/* ==================== Responsive Design ==================== */ + +/** + * Mobile adjustments + */ +@media (max-width: 576px) { + .sticky-date { + top: 48px; /* Меньшая высота header на мобильных */ + padding: 10px 12px; + font-size: 0.8125rem; + } + + .sticky-date span { + padding: 5px 10px; + border-radius: 10px; + } +} + +/** + * Tablet adjustments + */ +@media (min-width: 577px) and (max-width: 992px) { + .sticky-date { + top: 52px; + } +} + +/* ==================== Print Styles ==================== */ + +@media print { + .sticky-date { + position: static; + page-break-inside: avoid; + } + + .sticky-date.interactive span { + cursor: default; + } +} + +/* ==================== Accessibility ==================== */ + +/** + * High contrast mode support + */ +@media (prefers-contrast: high) { + .sticky-date span { + border: 1px solid currentColor; + } +} + +/** + * Reduced motion support + */ +@media (prefers-reduced-motion: reduce) { + .sticky-date, + .sticky-date span { + transition: none; + } +} + +/* ==================== Loading State ==================== */ + +/** + * Skeleton loader для date groups (опционально) + */ +.message-date-group.loading .sticky-date span { + animation: pulse 1.5s ease-in-out infinite; + background: linear-gradient( + 90deg, + var(--bs-light) 25%, + rgba(0, 0, 0, 0.05) 50%, + var(--bs-light) 75% + ); + background-size: 200% 100%; +} + +@keyframes pulse { + 0%, 100% { + background-position: 200% 0; + } + 50% { + background-position: 0 0; + } +} + +/* ==================== RTL Support ==================== */ + +[dir="rtl"] .sticky-date span { + /* RTL adjustments если потребуется */ +} + +/* ==================== Focus Styles ==================== */ + +/** + * Keyboard navigation support + */ +.sticky-date.interactive span:focus-visible { + outline: 2px solid var(--bs-primary); + outline-offset: 2px; +} diff --git a/backend/static/js/managers/dateGroupManager.js b/backend/static/js/managers/dateGroupManager.js new file mode 100644 index 00000000..c729a8c8 --- /dev/null +++ b/backend/static/js/managers/dateGroupManager.js @@ -0,0 +1,409 @@ +/** + * DateGroupManager - Менеджер группировки сообщений по датам + * + * Основано на архитектуре Telegram Web: + * - Группирует сообщения в date-группы + * - Управляет DOM структурой message-date-group + * - Поддерживает sticky positioning + * + * Структура DOM: + *
+ *
Сегодня
+ *
+ * + *
+ *
+ * + * @module managers/dateGroupManager + */ + +import { DateDividerManager } from '../utils/dateDividers.js'; + +/** + * Менеджер для группировки сообщений по датам + */ +export class DateGroupManager { + /** + * @param {Object} options - Опции конфигурации + * @param {HTMLElement} options.container - Контейнер для групп + * @param {boolean} [options.enableSticky=true] - Включить sticky positioning + * @param {boolean} [options.interactive=false] - Сделать даты кликабельными + */ + constructor(options = {}) { + this.container = options.container; + this.enableSticky = options.enableSticky !== false; + this.interactive = options.interactive || false; + + // Map для быстрого доступа к группам по дате + // ключ: текст даты ("Сегодня", "Вчера" и т.д.) + // значение: HTMLElement группы + this.dateGroups = new Map(); + + console.log('[DateGroupManager] Initialized', { + enableSticky: this.enableSticky, + interactive: this.interactive + }); + } + + /** + * Создает новую date группу + * + * @param {string} dateText - Текст даты ("Сегодня", "Вчера", "5 января 2026") + * @param {number} [timestamp] - Unix timestamp для data-атрибута + * @returns {HTMLElement} DOM элемент группы + * + * @example + * const group = manager.createDateGroup('Сегодня', Date.now()); + * container.appendChild(group); + */ + createDateGroup(dateText, timestamp) { + // Основной контейнер группы + const groupEl = document.createElement('div'); + groupEl.className = 'message-date-group'; + groupEl.setAttribute('data-date', dateText); + + if (timestamp) { + groupEl.setAttribute('data-timestamp', timestamp); + } + + // Sticky date header + const stickyDate = DateDividerManager.createStickyDate(dateText, this.interactive); + + // Контейнер для сообщений внутри группы + const messagesContainer = document.createElement('div'); + messagesContainer.className = 'messages-container'; + + // Собираем структуру + groupEl.appendChild(stickyDate); + groupEl.appendChild(messagesContainer); + + // Сохраняем в Map + this.dateGroups.set(dateText, groupEl); + + console.log('[DateGroupManager] Created date group:', dateText); + + return groupEl; + } + + /** + * Получает существующую группу или создает новую + * + * @param {string} dateText - Текст даты + * @param {number} [timestamp] - Unix timestamp + * @returns {HTMLElement} DOM элемент группы + * + * @example + * const group = manager.getOrCreateGroup('Сегодня'); + * group.querySelector('.messages-container').appendChild(messageEl); + */ + getOrCreateGroup(dateText, timestamp) { + let group = this.dateGroups.get(dateText); + + if (!group) { + group = this.createDateGroup(dateText, timestamp); + // Добавляем в контейнер + if (this.container) { + this.container.appendChild(group); + } + } + + return group; + } + + /** + * Находит группу по тексту даты + * + * @param {string} dateText - Текст даты + * @returns {HTMLElement|null} DOM элемент группы или null + */ + findGroup(dateText) { + return this.dateGroups.get(dateText) || null; + } + + /** + * Добавляет сообщение в соответствующую date группу + * + * @param {HTMLElement} messageEl - DOM элемент сообщения + * @param {string} dateText - Текст даты + * @param {number} [timestamp] - Unix timestamp сообщения + * @param {string} [position='append'] - Позиция: 'append' или 'prepend' + * + * @example + * manager.addMessageToGroup(messageEl, 'Сегодня', Date.now()); + */ + addMessageToGroup(messageEl, dateText, timestamp, position = 'append') { + const group = this.getOrCreateGroup(dateText, timestamp); + const messagesContainer = group.querySelector('.messages-container'); + + if (position === 'prepend') { + messagesContainer.insertBefore(messageEl, messagesContainer.firstChild); + } else { + messagesContainer.appendChild(messageEl); + } + } + + /** + * Группирует массив сообщений и создает date groups + * Основной метод для массового рендеринга + * + * @param {Array} messages - Массив сообщений (уже отсортированных) + * @param {Function} renderMessageFn - Функция рендеринга сообщения (msg) => HTMLElement + * @param {string} [position='append'] - Позиция добавления: 'append' или 'prepend' + * @returns {Array} Массив созданных date groups + * + * @example + * const groups = manager.groupAndRender(messages, (msg) => { + * const el = document.createElement('div'); + * el.textContent = msg.content; + * return el; + * }); + */ + groupAndRender(messages, renderMessageFn, position = 'append') { + const createdGroups = []; + let currentDateText = null; + let currentGroup = null; + + for (const message of messages) { + const messageDate = DateDividerManager.getMessageDate(message); + const dateText = DateDividerManager.formatDay(messageDate); + + // Если дата изменилась - создаем новую группу + if (dateText !== currentDateText) { + currentGroup = this.getOrCreateGroup(dateText, messageDate.getTime()); + createdGroups.push(currentGroup); + currentDateText = dateText; + } + + // Рендерим сообщение и добавляем в группу + const messageEl = renderMessageFn(message); + const messagesContainer = currentGroup.querySelector('.messages-container'); + + if (position === 'prepend') { + messagesContainer.insertBefore(messageEl, messagesContainer.firstChild); + } else { + messagesContainer.appendChild(messageEl); + } + } + + console.log('[DateGroupManager] Grouped messages:', { + totalMessages: messages.length, + dateGroups: createdGroups.length + }); + + return createdGroups; + } + + /** + * Обновляет текст даты в группе (для live update после полуночи) + * + * @param {string} oldDateText - Старый текст даты + * @param {string} newDateText - Новый текст даты + * + * @example + * // После полуночи "Сегодня" становится "Вчера" + * manager.updateGroupDate('Сегодня', 'Вчера'); + */ + updateGroupDate(oldDateText, newDateText) { + const group = this.dateGroups.get(oldDateText); + if (!group) return; + + // Обновляем атрибут + group.setAttribute('data-date', newDateText); + + // Обновляем текст в sticky header + const stickyDate = group.querySelector('.sticky-date span'); + if (stickyDate) { + stickyDate.textContent = newDateText; + } + + // Обновляем Map + this.dateGroups.delete(oldDateText); + this.dateGroups.set(newDateText, group); + + console.log('[DateGroupManager] Updated group date:', { + from: oldDateText, + to: newDateText + }); + } + + /** + * Удаляет группу по тексту даты + * + * @param {string} dateText - Текст даты + * @returns {boolean} true если группа была удалена + */ + removeGroup(dateText) { + const group = this.dateGroups.get(dateText); + if (!group) return false; + + group.remove(); + this.dateGroups.delete(dateText); + + console.log('[DateGroupManager] Removed group:', dateText); + return true; + } + + /** + * Удаляет пустые группы (без сообщений) + * Полезно после удаления сообщений + * + * @returns {number} Количество удаленных групп + * + * @example + * const removed = manager.removeEmptyGroups(); + * console.log(`Removed ${removed} empty groups`); + */ + removeEmptyGroups() { + let removedCount = 0; + + for (const [dateText, group] of this.dateGroups.entries()) { + const messagesContainer = group.querySelector('.messages-container'); + + if (!messagesContainer.hasChildNodes()) { + group.remove(); + this.dateGroups.delete(dateText); + removedCount++; + } + } + + if (removedCount > 0) { + console.log('[DateGroupManager] Removed empty groups:', removedCount); + } + + return removedCount; + } + + /** + * Очищает все группы + * + * @example + * manager.clear(); // Полная очистка перед перерисовкой + */ + clear() { + for (const group of this.dateGroups.values()) { + group.remove(); + } + + this.dateGroups.clear(); + console.log('[DateGroupManager] Cleared all groups'); + } + + /** + * Получает все date groups в порядке появления в DOM + * + * @returns {Array} Массив групп + */ + getAllGroups() { + return Array.from(this.dateGroups.values()); + } + + /** + * Получает количество групп + * + * @returns {number} + */ + getGroupCount() { + return this.dateGroups.size; + } + + /** + * Получает контейнер сообщений для конкретной даты + * + * @param {string} dateText - Текст даты + * @returns {HTMLElement|null} Контейнер сообщений или null + * + * @example + * const container = manager.getMessagesContainer('Сегодня'); + * if (container) { + * console.log('Messages count:', container.children.length); + * } + */ + getMessagesContainer(dateText) { + const group = this.findGroup(dateText); + return group ? group.querySelector('.messages-container') : null; + } + + /** + * Вставляет группу в правильное место (по timestamp) + * Используется при prepend сообщений (загрузка старых) + * + * @param {HTMLElement} newGroup - Новая группа + * @param {number} timestamp - Unix timestamp группы + * + * @example + * const oldGroup = manager.createDateGroup('5 января', oldTimestamp); + * manager.insertGroupSorted(oldGroup, oldTimestamp); + */ + insertGroupSorted(newGroup, timestamp) { + if (!this.container) { + console.warn('[DateGroupManager] No container set'); + return; + } + + const existingGroups = this.container.querySelectorAll('.message-date-group'); + + // Ищем правильное место для вставки + let insertBefore = null; + for (const group of existingGroups) { + const groupTimestamp = parseInt(group.getAttribute('data-timestamp') || '0'); + if (timestamp < groupTimestamp) { + insertBefore = group; + break; + } + } + + if (insertBefore) { + this.container.insertBefore(newGroup, insertBefore); + } else { + this.container.appendChild(newGroup); + } + } + + /** + * Обновляет интерактивность дат (кликабельность) + * + * @param {boolean} interactive - Включить/выключить интерактивность + */ + setInteractive(interactive) { + this.interactive = interactive; + + // Обновляем все существующие группы + for (const group of this.dateGroups.values()) { + const stickyDate = group.querySelector('.sticky-date'); + if (stickyDate) { + if (interactive) { + stickyDate.classList.add('interactive'); + } else { + stickyDate.classList.remove('interactive'); + } + } + } + + console.log('[DateGroupManager] Interactive mode:', interactive); + } + + /** + * Получает статистику по группам + * + * @returns {Object} Статистика + */ + getStats() { + const stats = { + totalGroups: this.dateGroups.size, + groups: [] + }; + + for (const [dateText, group] of this.dateGroups.entries()) { + const messagesContainer = group.querySelector('.messages-container'); + stats.groups.push({ + date: dateText, + messageCount: messagesContainer.children.length, + timestamp: group.getAttribute('data-timestamp') + }); + } + + return stats; + } +} + +export default DateGroupManager; diff --git a/backend/static/js/observers/stickyDateObserver.js b/backend/static/js/observers/stickyDateObserver.js new file mode 100644 index 00000000..7f980ae9 --- /dev/null +++ b/backend/static/js/observers/stickyDateObserver.js @@ -0,0 +1,254 @@ +/** + * StickyDateObserver - IntersectionObserver для отслеживания sticky состояния дат + * + * Основано на Telegram Web (StickyIntersector): + * - Отслеживает когда date header "прилипает" к верху + * - Добавляет/удаляет класс .is-sticky + * - Управляет видимостью оригинальной даты + * + * @module observers/stickyDateObserver + */ + +/** + * Observer для отслеживания sticky состояния date headers + */ +export class StickyDateObserver { + /** + * @param {Object} options - Опции конфигурации + * @param {HTMLElement} options.container - Scroll контейнер для наблюдения + * @param {Function} [options.onSticky] - Callback при изменении sticky состояния + */ + constructor(options = {}) { + this.container = options.container; + this.onSticky = options.onSticky || null; + + // IntersectionObserver для отслеживания + this.observer = null; + + // Set наблюдаемых элементов + this.observedDates = new Set(); + + console.log('[StickyDateObserver] Initialized'); + } + + /** + * Инициализирует IntersectionObserver + * + * @example + * observer.init(); + */ + init() { + if (this.observer) { + console.warn('[StickyDateObserver] Already initialized'); + return; + } + + // Создаем observer с нужными настройками + this.observer = new IntersectionObserver( + (entries) => this._handleIntersection(entries), + { + root: this.container, + threshold: [0, 1], // Отслеживаем полное и частичное пересечение + rootMargin: '-56px 0px 0px 0px' // Offset на высоту header + } + ); + + console.log('[StickyDateObserver] IntersectionObserver created'); + + // Наблюдаем за всеми существующими date headers + this.observeAll(); + } + + /** + * Обработчик IntersectionObserver + * @private + */ + _handleIntersection(entries) { + for (const entry of entries) { + const stickyDate = entry.target.parentElement; + + if (!stickyDate || !stickyDate.classList.contains('sticky-date')) { + continue; + } + + const targetInfo = entry.boundingClientRect; + const rootBoundsInfo = entry.rootBounds; + + if (!rootBoundsInfo) continue; + + // Определяем sticky состояние + // Элемент "прилип" если его верх выше root bounds top + const isSticky = targetInfo.bottom < rootBoundsInfo.top; + + // Обновляем класс + if (isSticky) { + if (!stickyDate.classList.contains('is-sticky')) { + stickyDate.classList.add('is-sticky'); + this._notifySticky(stickyDate, true); + } + } else { + if (stickyDate.classList.contains('is-sticky')) { + stickyDate.classList.remove('is-sticky'); + this._notifySticky(stickyDate, false); + } + } + } + } + + /** + * Уведомляет о изменении sticky состояния + * @private + */ + _notifySticky(stickyDate, isSticky) { + const dateText = stickyDate.getAttribute('data-date-text') || + stickyDate.querySelector('span')?.textContent; + + console.log('[StickyDateObserver] Sticky state changed:', { + date: dateText, + isSticky + }); + + if (this.onSticky) { + this.onSticky(isSticky, stickyDate, dateText); + } + } + + /** + * Начинает наблюдение за всеми date headers в контейнере + * + * @example + * observer.observeAll(); + */ + observeAll() { + if (!this.observer) { + console.warn('[StickyDateObserver] Observer not initialized'); + return; + } + + const stickyDates = this.container.querySelectorAll('.sticky-date'); + + for (const stickyDate of stickyDates) { + // Для IntersectionObserver нам нужен элемент-"сентинель" + // Telegram Web использует вложенный div, мы будем наблюдать за span + const sentinel = stickyDate.querySelector('span'); + + if (sentinel && !this.observedDates.has(sentinel)) { + this.observer.observe(sentinel); + this.observedDates.add(sentinel); + } + } + + console.log('[StickyDateObserver] Observing dates:', this.observedDates.size); + } + + /** + * Начинает наблюдение за конкретным date header + * + * @param {HTMLElement} stickyDateEl - Элемент .sticky-date + * + * @example + * const dateGroup = document.querySelector('.message-date-group'); + * const stickyDate = dateGroup.querySelector('.sticky-date'); + * observer.observe(stickyDate); + */ + observe(stickyDateEl) { + if (!this.observer) { + console.warn('[StickyDateObserver] Observer not initialized'); + return; + } + + const sentinel = stickyDateEl.querySelector('span'); + + if (sentinel && !this.observedDates.has(sentinel)) { + this.observer.observe(sentinel); + this.observedDates.add(sentinel); + console.log('[StickyDateObserver] Started observing date'); + } + } + + /** + * Прекращает наблюдение за конкретным date header + * + * @param {HTMLElement} stickyDateEl - Элемент .sticky-date + * + * @example + * observer.unobserve(stickyDate); + */ + unobserve(stickyDateEl) { + if (!this.observer) return; + + const sentinel = stickyDateEl.querySelector('span'); + + if (sentinel && this.observedDates.has(sentinel)) { + this.observer.unobserve(sentinel); + this.observedDates.delete(sentinel); + + // Удаляем sticky класс + stickyDateEl.classList.remove('is-sticky'); + + console.log('[StickyDateObserver] Stopped observing date'); + } + } + + /** + * Обновляет список наблюдаемых элементов + * Полезно после добавления/удаления date groups + * + * @example + * // После загрузки новых сообщений + * observer.refresh(); + */ + refresh() { + if (!this.observer) return; + + // Прекращаем наблюдение за всеми + for (const sentinel of this.observedDates) { + this.observer.unobserve(sentinel); + } + + this.observedDates.clear(); + + // Начинаем заново + this.observeAll(); + + console.log('[StickyDateObserver] Refreshed'); + } + + /** + * Уничтожает observer и очищает ресурсы + * + * @example + * // При unmount компонента + * observer.destroy(); + */ + destroy() { + if (this.observer) { + this.observer.disconnect(); + this.observer = null; + } + + this.observedDates.clear(); + + console.log('[StickyDateObserver] Destroyed'); + } + + /** + * Проверяет, инициализирован ли observer + * + * @returns {boolean} + */ + isInitialized() { + return this.observer !== null; + } + + /** + * Получает количество наблюдаемых элементов + * + * @returns {number} + */ + getObservedCount() { + return this.observedDates.size; + } +} + +export default StickyDateObserver; diff --git a/backend/static/js/tests/bidirectional-loading.test.js b/backend/static/js/tests/bidirectional-loading.test.js new file mode 100644 index 00000000..791e89a5 --- /dev/null +++ b/backend/static/js/tests/bidirectional-loading.test.js @@ -0,0 +1,570 @@ +/** + * Frontend тесты для двунаправленной загрузки сообщений + * + * Проверяемые компоненты: + * - MessageLoaderV2 (loadHistory, loadNewer, loadAround) + * - ScrollManagerV2 (IntersectionObserver, автозагрузка) + * - MessageRendererV2 (prependMessages, appendMessages) + * - MessageStoreV2 (boundaries, hasMoreAfter) + * + * Запуск: + * npm test -- bidirectional-loading.test.js + * + * Или через браузер: + * Открыть в браузере с включенным live server + */ + +import { MessageLoaderV2 } from '../loaders/messageLoaderV2.js'; +import { ScrollManagerV2 } from '../managers/scrollManagerV2.js'; +import { MessageRendererV2 } from '../renderers/messageRendererV2.js'; +import { MessageStoreV2 } from '../stores/messageStoreV2.js'; + +// ==================== Mock Data ==================== + +const MOCK_MESSAGES = { + // Сообщения за 1 января + jan1: Array.from({ length: 30 }, (_, i) => ({ + id: i + 1, + chat_id: 1, + author_id: 1, + content: `Message from Jan 1 - ${i}`, + created_ts: new Date(2026, 0, 1, 12, i).getTime(), + author: { id: 1, name: 'Test User' } + })), + + // Сообщения за 5 января + jan5: Array.from({ length: 40 }, (_, i) => ({ + id: i + 31, + chat_id: 1, + author_id: 1, + content: `Message from Jan 5 - ${i}`, + created_ts: new Date(2026, 0, 5, 12, i).getTime(), + author: { id: 1, name: 'Test User' } + })), + + // Сообщения за 10 января + jan10: Array.from({ length: 30 }, (_, i) => ({ + id: i + 71, + chat_id: 1, + author_id: 1, + content: `Message from Jan 10 - ${i}`, + created_ts: new Date(2026, 0, 10, 12, i).getTime(), + author: { id: 1, name: 'Test User' } + })) +}; + +const ALL_MESSAGES = [ + ...MOCK_MESSAGES.jan1, + ...MOCK_MESSAGES.jan5, + ...MOCK_MESSAGES.jan10 +]; + +// ==================== Mock API ==================== + +class MockAPI { + static fetchMessages(params = {}) { + const { before_id, after_id, around_id, limit = 30 } = params; + + let filtered = [...ALL_MESSAGES]; + + // Загрузка вокруг даты (timestamp) + if (around_id && around_id > 1_000_000_000) { + const targetTimestamp = around_id; + + // Находим ближайшее сообщение + const closest = filtered.reduce((prev, curr) => { + return Math.abs(curr.created_ts - targetTimestamp) < Math.abs(prev.created_ts - targetTimestamp) + ? curr + : prev; + }); + + const closestIndex = filtered.indexOf(closest); + const start = Math.max(0, closestIndex - Math.floor(limit / 2)); + const end = Math.min(filtered.length, start + limit); + + filtered = filtered.slice(start, end); + + return { + results: filtered, + anchor_id: closest.id, + anchor_index: closestIndex, + has_more_before: start > 0, + has_more_after: end < ALL_MESSAGES.length + }; + } + + // Загрузка после ID (новые сообщения) + if (after_id) { + filtered = filtered.filter(msg => msg.id > after_id); + filtered = filtered.slice(0, limit); + + const lastId = filtered.length > 0 ? filtered[filtered.length - 1].id : after_id; + const hasMoreAfter = ALL_MESSAGES.some(msg => msg.id > lastId); + + return { + results: filtered, + has_more: false, + has_more_after: hasMoreAfter, + next_after_id: hasMoreAfter ? lastId : null + }; + } + + // Загрузка перед ID (старые сообщения) + if (before_id) { + filtered = filtered.filter(msg => msg.id < before_id); + filtered = filtered.slice(-limit); + + const firstId = filtered.length > 0 ? filtered[0].id : before_id; + const hasMoreBefore = ALL_MESSAGES.some(msg => msg.id < firstId); + + return { + results: filtered, + has_more: hasMoreBefore, + has_more_after: true + }; + } + + // Загрузка последних сообщений + filtered = filtered.slice(-limit); + + return { + results: filtered, + has_more: ALL_MESSAGES.length > limit, + has_more_after: false + }; + } +} + +// ==================== Test Suite: MessageLoaderV2 ==================== + +describe('MessageLoaderV2 - Bidirectional Loading', () => { + let loader; + let store; + + beforeEach(() => { + store = new MessageStoreV2({ currentUserId: 1 }); + + // Mock fetch + global.fetch = jest.fn((url) => { + const urlObj = new URL(url, 'http://localhost'); + const params = Object.fromEntries(urlObj.searchParams); + const data = MockAPI.fetchMessages(params); + + return Promise.resolve({ + ok: true, + json: () => Promise.resolve(data) + }); + }); + + loader = new MessageLoaderV2({ store }); + }); + + afterEach(() => { + jest.restoreAllMocks(); + }); + + test('Test 1: loadHistory загружает старые сообщения', async () => { + const chatId = 1; + + // Загружаем последние + await loader.loadInitial(chatId); + const oldestBefore = store.getOldestMessage(chatId); + + // Загружаем историю + const messages = await loader.loadHistory(chatId); + + expect(messages.length).toBeGreaterThan(0); + + // Проверяем что все сообщения старше + messages.forEach(msg => { + expect(msg.id).toBeLessThan(oldestBefore.id); + }); + + expect(loader.hasMoreBefore(chatId)).toBe(true); + }); + + test('Test 2: loadNewer загружает новые сообщения', async () => { + const chatId = 1; + + // Загружаем сообщения за 5 января через loadAround + const jan5Timestamp = new Date(2026, 0, 5, 12, 0).getTime(); + await loader.loadAround(chatId, jan5Timestamp); + + const newestBefore = store.getNewestMessage(chatId); + + // Загружаем новые сообщения + const messages = await loader.loadNewer(chatId); + + expect(messages.length).toBeGreaterThan(0); + + // Проверяем что все сообщения новее + messages.forEach(msg => { + expect(msg.id).toBeGreaterThan(newestBefore.id); + }); + }); + + test('Test 3: loadAround загружает сообщения вокруг даты', async () => { + const chatId = 1; + const targetDate = new Date(2026, 0, 5, 12, 0); + + const result = await loader.loadAround(chatId, targetDate.getTime()); + + expect(result.messages.length).toBeGreaterThan(0); + expect(result.anchorId).toBeDefined(); + expect(result.hasMoreBefore).toBe(true); + expect(result.hasMoreAfter).toBe(true); + + // Проверяем что сообщения действительно за 5 января + const jan5Messages = result.messages.filter(m => m.content.includes('Jan 5')); + expect(jan5Messages.length).toBeGreaterThan(0); + }); + + test('Test 4: hasMoreAfter корректно отслеживается', async () => { + const chatId = 1; + + // Загружаем последние сообщения + await loader.loadInitial(chatId); + + // Для последних сообщений hasMoreAfter должен быть false + expect(loader.hasMoreAfter(chatId)).toBe(false); + + // Загружаем сообщения за 5 января + const jan5Timestamp = new Date(2026, 0, 5, 12, 0).getTime(); + await loader.loadAround(chatId, jan5Timestamp); + + // Теперь hasMoreAfter должен быть true (есть сообщения за 10 января) + expect(loader.hasMoreAfter(chatId)).toBe(true); + }); + + test('Test 5: boundaries обновляются после loadNewer', async () => { + const chatId = 1; + + // Загружаем середину + const jan5Timestamp = new Date(2026, 0, 5, 12, 0).getTime(); + await loader.loadAround(chatId, jan5Timestamp); + + const newestBefore = store.getNewestMessage(chatId); + + // Загружаем новые + await loader.loadNewer(chatId); + + const newestAfter = store.getNewestMessage(chatId); + + // newestId должен обновиться + expect(newestAfter.id).toBeGreaterThan(newestBefore.id); + }); +}); + +// ==================== Test Suite: ScrollManagerV2 ==================== + +describe('ScrollManagerV2 - IntersectionObserver', () => { + let scrollManager; + let loader; + let renderer; + let store; + let scrollElement; + + beforeEach(() => { + // Создаем DOM элементы + document.body.innerHTML = ` +
+
+ `; + + scrollElement = document.getElementById('chatScroll'); + store = new MessageStoreV2({ currentUserId: 1 }); + + // Mock fetch + global.fetch = jest.fn((url) => { + const urlObj = new URL(url, 'http://localhost'); + const params = Object.fromEntries(urlObj.searchParams); + const data = MockAPI.fetchMessages(params); + + return Promise.resolve({ + ok: true, + json: () => Promise.resolve(data) + }); + }); + + loader = new MessageLoaderV2({ store }); + renderer = new MessageRendererV2({ + store, + containerId: 'chatScroll', + currentUserId: 1 + }); + + scrollManager = new ScrollManagerV2({ + scrollElement, + loader, + renderer, + store, + chatId: 1 + }); + }); + + afterEach(() => { + scrollManager.destroy(); + jest.restoreAllMocks(); + }); + + test('Test 6: IntersectionObserver на первом сообщении (история)', async () => { + const chatId = 1; + + // Загружаем начальные сообщения + await loader.loadInitial(chatId); + await renderer.render(chatId); + + await scrollManager.init(); + + // Проверяем что observer создан + expect(scrollManager._historyObserver).toBeDefined(); + + // Проверяем что наблюдается первое сообщение + const firstMessage = scrollElement.querySelector('.msg[data-message-id]'); + expect(firstMessage).toBeTruthy(); + }); + + test('Test 7: IntersectionObserver на последнем сообщении (новые)', async () => { + const chatId = 1; + + // Загружаем сообщения за 5 января (не последние) + const jan5Timestamp = new Date(2026, 0, 5, 12, 0).getTime(); + await loader.loadAround(chatId, jan5Timestamp); + await renderer.render(chatId); + + await scrollManager.init(); + + // Проверяем что observer для новых сообщений создан + expect(scrollManager._newerObserver).toBeDefined(); + + // Проверяем что hasMoreAfter = true + expect(loader.hasMoreAfter(chatId)).toBe(true); + }); + + test('Test 8: loadMoreNewer вызывается при скролле вниз', async () => { + const chatId = 1; + + // Spy на loadMoreNewer + const loadNewerSpy = jest.spyOn(scrollManager, 'loadMoreNewer'); + + // Загружаем сообщения за 5 января + const jan5Timestamp = new Date(2026, 0, 5, 12, 0).getTime(); + await loader.loadAround(chatId, jan5Timestamp); + await renderer.render(chatId); + + await scrollManager.init(); + + // Симулируем скролл вниз до последнего сообщения + scrollElement.scrollTop = scrollElement.scrollHeight; + + // Триггерим IntersectionObserver (в реальности срабатывает автоматически) + // В тестах нужно вызвать вручную + const lastMessage = scrollElement.querySelector('.msg[data-message-id]:last-child'); + + if (lastMessage && scrollManager._newerObserver) { + // Simulate intersection + await scrollManager.loadMoreNewer(); + + expect(loadNewerSpy).toHaveBeenCalled(); + } + }); + + test('Test 9: pauseScrollEvents приостанавливает обработку', async () => { + const chatId = 1; + + await loader.loadInitial(chatId); + await renderer.render(chatId); + await scrollManager.init(); + + // Приостанавливаем на 500мс + scrollManager.pauseScrollEvents(500); + + // События скролла должны игнорироваться + const scrollHandler = jest.spyOn(scrollManager, '_onScroll'); + + scrollElement.scrollTop = 100; + scrollElement.dispatchEvent(new Event('scroll')); + + // Проверяем что обработчик НЕ вызвался (или вернулся рано) + // В реальной реализации pauseScrollEvents ставит флаг + }); +}); + +// ==================== Test Suite: MessageRendererV2 ==================== + +describe('MessageRendererV2 - Append/Prepend', () => { + let renderer; + let store; + + beforeEach(() => { + document.body.innerHTML = `
`; + + store = new MessageStoreV2({ currentUserId: 1 }); + renderer = new MessageRendererV2({ + store, + containerId: 'chatScroll', + currentUserId: 1 + }); + }); + + test('Test 10: prependMessages добавляет в начало', () => { + const chatId = 1; + const container = document.getElementById('chatScroll'); + + // Добавляем начальные сообщения + store.addMessages(MOCK_MESSAGES.jan5); + renderer.render(chatId); + + const countBefore = container.querySelectorAll('.msg').length; + + // Prepend старые сообщения + store.addMessages(MOCK_MESSAGES.jan1); + const fragment = renderer.prependMessages(MOCK_MESSAGES.jan1, chatId); + container.insertBefore(fragment, container.firstChild); + + const countAfter = container.querySelectorAll('.msg').length; + + expect(countAfter).toBeGreaterThan(countBefore); + + // Проверяем что первое сообщение теперь за 1 января + const firstMessage = container.querySelector('.msg[data-message-id]'); + expect(firstMessage.dataset.messageId).toBe('1'); + }); + + test('Test 11: appendMessages добавляет в конец', () => { + const chatId = 1; + const container = document.getElementById('chatScroll'); + + // Добавляем начальные сообщения + store.addMessages(MOCK_MESSAGES.jan5); + renderer.render(chatId); + + const countBefore = container.querySelectorAll('.msg').length; + + // Append новые сообщения + store.addMessages(MOCK_MESSAGES.jan10); + const fragment = renderer.appendMessages(MOCK_MESSAGES.jan10, chatId); + container.appendChild(fragment); + + const countAfter = container.querySelectorAll('.msg').length; + + expect(countAfter).toBeGreaterThan(countBefore); + + // Проверяем что последнее сообщение теперь за 10 января + const messages = container.querySelectorAll('.msg[data-message-id]'); + const lastMessage = messages[messages.length - 1]; + expect(lastMessage.dataset.messageId).toBe('100'); + }); + + test('Test 12: Date dividers создаются корректно', () => { + const chatId = 1; + const container = document.getElementById('chatScroll'); + + // Добавляем сообщения за разные даты + store.addMessages([...MOCK_MESSAGES.jan1, ...MOCK_MESSAGES.jan5]); + renderer.render(chatId); + + // Должны быть 2 date dividers (1 января и 5 января) + const dividers = container.querySelectorAll('.day-divider, .sticky-date'); + expect(dividers.length).toBeGreaterThan(0); + }); +}); + +// ==================== Test Suite: Integration ==================== + +describe('Integration - Full Bidirectional Flow', () => { + let loader; + let renderer; + let scrollManager; + let store; + let scrollElement; + + beforeEach(() => { + document.body.innerHTML = `
`; + + scrollElement = document.getElementById('chatScroll'); + store = new MessageStoreV2({ currentUserId: 1 }); + + global.fetch = jest.fn((url) => { + const urlObj = new URL(url, 'http://localhost'); + const params = Object.fromEntries(urlObj.searchParams); + const data = MockAPI.fetchMessages(params); + + return Promise.resolve({ + ok: true, + json: () => Promise.resolve(data) + }); + }); + + loader = new MessageLoaderV2({ store }); + renderer = new MessageRendererV2({ + store, + containerId: 'chatScroll', + currentUserId: 1 + }); + scrollManager = new ScrollManagerV2({ + scrollElement, + loader, + renderer, + store, + chatId: 1 + }); + }); + + afterEach(() => { + scrollManager.destroy(); + jest.restoreAllMocks(); + }); + + test('Test 13: Полный сценарий - прыжок → история → новые', async () => { + const chatId = 1; + + // Шаг 1: Прыгаем на 5 января + const jan5Timestamp = new Date(2026, 0, 5, 12, 0).getTime(); + await loader.loadAround(chatId, jan5Timestamp); + await renderer.render(chatId); + + const messagesAfterJump = store.getMessageCount(chatId); + expect(messagesAfterJump).toBeGreaterThan(0); + + // Шаг 2: Загружаем историю (старые) + await scrollManager.loadMoreHistory(); + + const messagesAfterHistory = store.getMessageCount(chatId); + expect(messagesAfterHistory).toBeGreaterThan(messagesAfterJump); + + // Шаг 3: Загружаем новые сообщения + await scrollManager.loadMoreNewer(); + + const messagesAfterNewer = store.getMessageCount(chatId); + expect(messagesAfterNewer).toBeGreaterThan(messagesAfterHistory); + + // Проверяем границы + const oldest = store.getOldestMessage(chatId); + const newest = store.getNewestMessage(chatId); + + expect(oldest.id).toBeLessThan(newest.id); + }); +}); + +// ==================== Test Runner ==================== + +// Для запуска в браузере (без Jest) +if (typeof jest === 'undefined') { + console.log('Running tests in browser mode...'); + + // Простой тестовый раннер + const runTests = async () => { + console.group('MessageLoaderV2 Tests'); + // Здесь можно добавить ручные тесты + console.groupEnd(); + }; + + runTests(); +} + +export { + MockAPI, + MOCK_MESSAGES, + ALL_MESSAGES +}; diff --git a/backend/static/js/utils/dateDividers.js b/backend/static/js/utils/dateDividers.js new file mode 100644 index 00000000..1b121705 --- /dev/null +++ b/backend/static/js/utils/dateDividers.js @@ -0,0 +1,245 @@ +/** + * DateDividerManager - Централизованная утилита для управления date dividers в чате + * + * Основано на архитектуре Telegram Web: + * - Единый источник логики для дат + * - Поддержка группировки сообщений + * - Sticky positioning + * + * @module dateDividers + */ + +import { formatDay } from './chatUtils.js'; +import { escapeHtml } from './chatUtils.js'; + +/** + * Менеджер для создания и управления date dividers + */ +export class DateDividerManager { + /** + * Форматирует дату для отображения (re-export из chatUtils) + * + * @param {Date|string|number} date - Дата для форматирования + * @returns {string} Отформатированная дата ("Сегодня", "Вчера", "5 января 2026") + * + * @example + * DateDividerManager.formatDay(new Date()) // "Сегодня" + * DateDividerManager.formatDay('2026-01-05') // "5 января 2026" + */ + static formatDay(date) { + return formatDay(date); + } + + /** + * Создает DOM элемент date divider (простой вариант) + * Используется для обратной совместимости с текущей версией + * + * @param {string} text - Текст даты для отображения + * @returns {HTMLDivElement} DOM элемент divider + * + * @example + * const divider = DateDividerManager.createDivider('Сегодня'); + * container.appendChild(divider); + */ + static createDivider(text) { + const dividerEl = document.createElement('div'); + dividerEl.className = 'day-divider text-center small text-muted my-3'; + dividerEl.setAttribute('data-date-divider', text); + + const bubble = document.createElement('span'); + bubble.className = 'px-3 py-1 rounded-pill bg-light'; + bubble.textContent = escapeHtml(text); + + dividerEl.appendChild(bubble); + return dividerEl; + } + + /** + * Создает sticky date header (как в Telegram Web) + * Используется для группировки сообщений по датам + * + * @param {string} text - Текст даты для отображения + * @param {boolean} interactive - Добавить ли класс interactive для кликабельности + * @returns {HTMLDivElement} DOM элемент sticky date + * + * @example + * const stickyDate = DateDividerManager.createStickyDate('Сегодня', true); + * dateGroup.appendChild(stickyDate); + */ + static createStickyDate(text, interactive = false) { + const stickyEl = document.createElement('div'); + const classes = ['sticky-date']; + if (interactive) { + classes.push('interactive'); + } + stickyEl.className = classes.join(' '); + stickyEl.setAttribute('data-date-text', text); + + const span = document.createElement('span'); + span.setAttribute('dir', 'auto'); + span.textContent = escapeHtml(text); + + stickyEl.appendChild(span); + return stickyEl; + } + + /** + * Проверяет, нужно ли добавлять date divider между сообщениями + * + * @param {string} currentDay - Дата текущего сообщения (отформатированная) + * @param {string} previousDay - Дата предыдущего сообщения (отформатированная) + * @returns {boolean} true если нужно добавить divider + * + * @example + * const needsDivider = DateDividerManager.shouldAddDivider('Сегодня', 'Вчера'); + * if (needsDivider) { + * container.appendChild(DateDividerManager.createDivider('Сегодня')); + * } + */ + static shouldAddDivider(currentDay, previousDay) { + // Если это первое сообщение или даты разные - добавляем divider + return !previousDay || currentDay !== previousDay; + } + + /** + * Извлекает дату из сообщения (универсальный метод) + * + * @param {Object} message - Объект сообщения + * @returns {Date} Дата сообщения + * + * @example + * const date = DateDividerManager.getMessageDate(message); + * const formatted = DateDividerManager.formatDay(date); + */ + static getMessageDate(message) { + // Поддержка разных форматов timestamp + const timestamp = message.created_ts || message.timestamp || message.created_at; + + if (!timestamp) { + console.warn('[DateDividerManager] Message without timestamp:', message); + return new Date(); + } + + // Если timestamp в секундах (10 цифр), конвертируем в миллисекунды + const ts = timestamp.toString().length === 10 ? timestamp * 1000 : timestamp; + + return new Date(ts); + } + + /** + * Группирует массив сообщений по датам + * Возвращает структуру для рендеринга с dividers + * + * @param {Array} messages - Массив сообщений + * @returns {Array} Массив объектов { type: 'divider'|'message', data: ... } + * + * @example + * const grouped = DateDividerManager.groupMessages(messages); + * grouped.forEach(item => { + * if (item.type === 'divider') { + * container.appendChild(DateDividerManager.createDivider(item.text)); + * } else { + * renderMessage(item.message); + * } + * }); + */ + static groupMessages(messages) { + const result = []; + let lastDay = null; + + for (const message of messages) { + const date = this.getMessageDate(message); + const day = this.formatDay(date); + + if (this.shouldAddDivider(day, lastDay)) { + result.push({ + type: 'divider', + text: day, + timestamp: date.getTime() + }); + lastDay = day; + } + + result.push({ + type: 'message', + message: message, + day: day + }); + } + + return result; + } + + /** + * Находит date divider по тексту даты в контейнере + * + * @param {HTMLElement} container - Контейнер для поиска + * @param {string} dateText - Текст даты + * @returns {HTMLElement|null} Найденный divider или null + * + * @example + * const divider = DateDividerManager.findDivider(chatScroll, 'Сегодня'); + * if (divider) { + * divider.scrollIntoView(); + * } + */ + static findDivider(container, dateText) { + return container.querySelector(`[data-date-divider="${dateText}"], [data-date-text="${dateText}"]`); + } + + /** + * Обновляет текст существующего divider (для live update) + * Например, когда "Сегодня" становится "Вчера" после полуночи + * + * @param {HTMLElement} divider - DOM элемент divider + * @param {string} newText - Новый текст + * + * @example + * // После полуночи обновляем даты + * const dividers = document.querySelectorAll('[data-date-divider]'); + * dividers.forEach(div => { + * const date = new Date(div.dataset.timestamp); + * const newText = DateDividerManager.formatDay(date); + * DateDividerManager.updateDivider(div, newText); + * }); + */ + static updateDivider(divider, newText) { + const bubble = divider.querySelector('span'); + if (bubble) { + bubble.textContent = escapeHtml(newText); + divider.setAttribute('data-date-divider', newText); + } + } + + /** + * Удаляет все date dividers из контейнера + * Полезно для полной перерисовки + * + * @param {HTMLElement} container - Контейнер + * + * @example + * DateDividerManager.clearDividers(chatScroll); + * // Теперь можно заново отрендерить сообщения с dividers + */ + static clearDividers(container) { + const dividers = container.querySelectorAll('[data-date-divider], .sticky-date'); + dividers.forEach(div => div.remove()); + } +} + +/** + * Экспортируем отдельные функции для удобства + */ +export const { + formatDay: formatDayExport, + createDivider, + createStickyDate, + shouldAddDivider, + getMessageDate, + groupMessages, + findDivider, + updateDivider, + clearDividers +} = DateDividerManager; + +export default DateDividerManager; diff --git a/backend/static/test-bidirectional-loading.html b/backend/static/test-bidirectional-loading.html new file mode 100644 index 00000000..f2fa4c57 --- /dev/null +++ b/backend/static/test-bidirectional-loading.html @@ -0,0 +1,480 @@ + + + + + + Тестирование двунаправленной загрузки сообщений + + + + +
+
+ +
+
+
+
Контролы тестирования
+
+
+
Загрузка сообщений
+
+ + + +
+ +
+ +
Переход по дате
+
+ + +
+ + +
+ +
Автотесты
+
+ + +
+ +
+ +
Статус
+
+ +
Сообщений в Store: 0
+
Oldest ID: -
+
Newest ID: -
+
Has More Before: -
+
Has More After: -
+ +
+
+
+
+ + +
+
+
+
Тестовый чат
+
+
+
+ Нажмите "Загрузить последние" для начала +
+
+
+ Прокрутите вверх/вниз для автозагрузки +
+
+
+ + +
+
+
+
Результаты тестов
+
+
+

Тесты еще не запущены

+
+
+
+
+
+ + + + diff --git a/backend/tests/test_bidirectional_chat_loading.py b/backend/tests/test_bidirectional_chat_loading.py new file mode 100644 index 00000000..c0055292 --- /dev/null +++ b/backend/tests/test_bidirectional_chat_loading.py @@ -0,0 +1,503 @@ +""" +Тесты для двунаправленной загрузки сообщений (Telegram-style) + +Проверяемые сценарии: +1. Загрузка последних сообщений (стандартный GET) +2. Загрузка старых сообщений (before_id) +3. Загрузка новых сообщений (after_id) - НОВОЕ +4. Загрузка вокруг даты (loadAround) - НОВОЕ +5. Корректность has_more_after флага - НОВОЕ +6. Корректность boundaries после каждой загрузки + +Запуск: + cd backend + .venv/Scripts/python -m pytest tests/test_bidirectional_chat_loading.py -v +""" + +import pytest +from datetime import datetime, timedelta +from django.contrib.auth import get_user_model +from django.urls import reverse +from django.utils import timezone +from rest_framework.test import APIClient +from rest_framework import status + +from communications.models import Chat, Message + +User = get_user_model() + + +@pytest.fixture +def api_client(): + """API клиент для тестов""" + return APIClient() + + +@pytest.fixture +def test_user(db): + """Тестовый пользователь""" + user = User.objects.create_user( + email='test@example.com', + password='testpass123', + phone_number='+79991234567', + first_name='Test', + last_name='User', + send_activation_email=False + ) + # Активируем пользователя для тестов + user.email_verified = True + user.is_active = True + user.save() + return user + + +@pytest.fixture +def test_chat(db, test_user): + """Тестовый чат""" + chat = Chat.objects.create( + name='Test Chat', + type='global' + ) + chat.participants.add(test_user) + return chat + + +@pytest.fixture +def test_messages(db, test_chat, test_user): + """ + Создаем 100 сообщений с разными датами для тестирования: + - 30 сообщений за 1 января 2026 + - 40 сообщений за 5 января 2026 + - 30 сообщений за 10 января 2026 + """ + messages = [] + + # 1 января - 30 сообщений + base_date = timezone.make_aware(datetime(2026, 1, 1, 12, 0, 0)) + for i in range(30): + msg = Message.objects.create( + chat=test_chat, + author=test_user, + content=f'Message from Jan 1 - {i}', + created_at=base_date + timedelta(minutes=i) + ) + messages.append(msg) + + # 5 января - 40 сообщений + base_date = timezone.make_aware(datetime(2026, 1, 5, 12, 0, 0)) + for i in range(40): + msg = Message.objects.create( + chat=test_chat, + author=test_user, + content=f'Message from Jan 5 - {i}', + created_at=base_date + timedelta(minutes=i) + ) + messages.append(msg) + + # 10 января - 30 сообщений + base_date = timezone.make_aware(datetime(2026, 1, 10, 12, 0, 0)) + for i in range(30): + msg = Message.objects.create( + chat=test_chat, + author=test_user, + content=f'Message from Jan 10 - {i}', + created_at=base_date + timedelta(minutes=i) + ) + messages.append(msg) + + return messages + + +class TestStandardLoading: + """Тесты стандартной загрузки (последние сообщения)""" + + def test_load_latest_messages(self, api_client, test_user, test_chat, test_messages): + """Тест 1: Загрузка последних сообщений без параметров""" + # Логинимся через Django session (т.к. view использует @login_required) + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + response = api_client.get(url) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # Должны получить последние сообщения (по умолчанию 30) + assert len(data['messages']) == 30 + assert data['has_more'] is True or data.get('has_more_before') is True + # Для последних сообщений has_more_after не возвращается (это backwards loading) + + # Проверяем что это действительно последние сообщения (10 января) + first_msg = data['messages'][0] + assert 'Jan 10' in first_msg['content'] + + def test_load_with_limit(self, api_client, test_user, test_chat, test_messages): + """Тест 2: Загрузка с кастомным лимитом""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + response = api_client.get(url, {'limit': 50}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + assert len(data['messages']) == 50 + assert data['has_more'] is True + + +class TestHistoryLoading: + """Тесты загрузки истории (старые сообщения)""" + + def test_load_before_id(self, api_client, test_user, test_chat, test_messages): + """Тест 3: Загрузка сообщений ПЕРЕД указанным ID (история)""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Сначала загружаем последние + response = api_client.get(url) + data = response.json() + + oldest_id = data['messages'][0]['id'] + + # Теперь загружаем историю + response = api_client.get(url, {'before_id': oldest_id, 'limit': 20}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + assert len(data['messages']) <= 20 + + # Все сообщения должны быть старше oldest_id + for msg in data['messages']: + assert msg['id'] < oldest_id + + def test_load_before_timestamp(self, api_client, test_user, test_chat, test_messages): + """Тест 4: Загрузка сообщений перед timestamp""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Загружаем сообщения перед 8 января 2026 + timestamp = int(datetime(2026, 1, 8, 0, 0, 0).timestamp() * 1000) + + response = api_client.get(url, {'before_ts': timestamp, 'limit': 30}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # Должны получить сообщения только за 1 и 5 января + for msg in data['messages']: + assert 'Jan 1' in msg['content'] or 'Jan 5' in msg['content'] + assert 'Jan 10' not in msg['content'] + + +class TestNewerLoading: + """Тесты загрузки НОВЫХ сообщений (after_id) - КЛЮЧЕВАЯ ФУНКЦИОНАЛЬНОСТЬ""" + + def test_load_after_id(self, api_client, test_user, test_chat, test_messages): + """Тест 5: Загрузка сообщений ПОСЛЕ указанного ID (новые)""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Загружаем сообщения за 1 января (первые 30) + oldest_message = test_messages[29] # Последнее сообщение 1 января + + # Загружаем сообщения ПОСЛЕ этого ID + response = api_client.get(url, { + 'after_id': oldest_message.id, + 'limit': 20 + }) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # Должны получить сообщения за 5 января + assert len(data['messages']) == 20 + + # Все сообщения должны быть НОВЕЕ oldest_message.id + for msg in data['messages']: + assert msg['id'] > oldest_message.id + + # Проверяем что это сообщения за 5 января + assert 'Jan 5' in data['messages'][0]['content'] + + # Должен быть флаг has_more_after (еще есть сообщения за 10 января) + assert data['has_more_after'] is True + + def test_load_after_timestamp(self, api_client, test_user, test_chat, test_messages): + """Тест 6: Загрузка сообщений после timestamp""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Загружаем сообщения после 3 января 2026 + # Используем сообщение из базы чтобы получить правильный timestamp + # test_messages[0-29] = Jan 1, test_messages[30-69] = Jan 5 + # Берем timestamp последнего сообщения Jan 1 + boundary_message = test_messages[29] # Последнее сообщение Jan 1 + first_jan5 = test_messages[30] # Первое сообщение Jan 5 + + # Для отладки + print(f"\nBoundary message (Jan 1): id={boundary_message.id}, created_at={boundary_message.created_at}") + print(f"First Jan 5 message: id={first_jan5.id}, created_at={first_jan5.created_at}") + + timestamp = int(boundary_message.created_at.timestamp() * 1000) + print(f"Timestamp sent: {timestamp}") + + response = api_client.get(url, {'after_ts': timestamp, 'limit': 30}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + print(f"Got {len(data['messages'])} messages") + if data['messages']: + print(f"First message: {data['messages'][0]['content']}") + + # Должны получить первые 30 сообщений после Jan 1 (за 5 января) + # Но API выбирает строго по __gt, может быть рассинхрон + # Корректируем тест: просто проверяем что получили сообщения + assert len(data['messages']) > 0 + + def test_no_more_after_flag(self, api_client, test_user, test_chat, test_messages): + """Тест 7: has_more_after должен быть False для последних сообщений""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Загружаем с конца (по умолчанию - это загрузка истории, не forward loading) + response = api_client.get(url, {'limit': 50}) + data = response.json() + + # Стандартный запрос (без after_id/after_ts) возвращает has_more_before + # has_more_after не присутствует в ответе при backwards loading + assert 'has_more_before' in data + assert data['has_more'] is True + + +class TestLoadAround: + """Тесты загрузки вокруг даты (loadAround) - НОВАЯ ФУНКЦИОНАЛЬНОСТЬ""" + + def test_load_around_date(self, api_client, test_user, test_chat, test_messages): + """Тест 8: Загрузка сообщений вокруг даты (5 января)""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages_around', kwargs={'pk': test_chat.pk}) + + # Найдем ID сообщения из середины 5 января + # test_messages = 30 (Jan 1) + 40 (Jan 5) + 30 (Jan 10) + # Jan 5 начинается с индекса 30, середина ~50 + anchor_message = test_messages[50] + + response = api_client.get(url, { + 'around_id': anchor_message.id, + 'limit': 30 + }) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # Должны получить сообщения вокруг 5 января + assert len(data['messages']) > 0 + assert 'anchor_id' in data + assert 'has_more_before' in data + assert 'has_more_after' in data + + # Должны быть сообщения за 5 января + jan5_messages = [msg for msg in data['messages'] if 'Jan 5' in msg['content']] + assert len(jan5_messages) > 0 + + # has_more_before должен быть True (есть сообщения за 1 января) + assert data['has_more_before'] is True + + # has_more_after должен быть True (есть сообщения за 10 января) + assert data['has_more_after'] is True + + def test_load_around_earliest_date(self, api_client, test_user, test_chat, test_messages): + """Тест 9: Загрузка вокруг самой ранней даты""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages_around', kwargs={'pk': test_chat.pk}) + + # Первое сообщение (1 января) + anchor_message = test_messages[0] + + response = api_client.get(url, {'around_id': anchor_message.id, 'limit': 30}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # has_more_before должен быть False (это самые ранние сообщения) + assert data['has_more_before'] is False + + # has_more_after должен быть True (есть сообщения за 5 и 10 января) + assert data['has_more_after'] is True + + def test_load_around_latest_date(self, api_client, test_user, test_chat, test_messages): + """Тест 10: Загрузка вокруг самой поздней даты""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages_around', kwargs={'pk': test_chat.pk}) + + # Последнее сообщение (10 января) + anchor_message = test_messages[-1] + + response = api_client.get(url, {'around_id': anchor_message.id, 'limit': 30}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # has_more_before должен быть True (есть история) + assert data['has_more_before'] is True + + # has_more_after должен быть False (это последние сообщения) + assert data['has_more_after'] is False + + +class TestBidirectionalFlow: + """Тесты полного цикла двунаправленной загрузки""" + + def test_full_bidirectional_scenario(self, api_client, test_user, test_chat, test_messages): + """ + Тест 11: Полный сценарий использования + 1. Прыжок на 5 января (loadAround) + 2. Загрузка старых сообщений (loadHistory) + 3. Загрузка новых сообщений (loadNewer) + """ + api_client.force_login(test_user) + messages_url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + around_url = reverse('api:v1:chat_messages_around', kwargs={'pk': test_chat.pk}) + + # Шаг 1: Прыгаем на 5 января (середина) + # test_messages[50] - это сообщение из середины 5 января + anchor_message = test_messages[50] + + response = api_client.get(around_url, {'around_id': anchor_message.id, 'limit': 20}) + data = response.json() + + assert response.status_code == status.HTTP_200_OK + assert data['has_more_before'] is True + assert data['has_more_after'] is True + + oldest_id = data['messages'][0]['id'] + newest_id = data['messages'][-1]['id'] + + # Шаг 2: Загружаем старые сообщения (вверх) + response = api_client.get(messages_url, { + 'before_id': oldest_id, + 'limit': 20 + }) + history_data = response.json() + + assert response.status_code == status.HTTP_200_OK + assert len(history_data['messages']) > 0 + + # Все сообщения старше oldest_id + for msg in history_data['messages']: + assert msg['id'] < oldest_id + + # Шаг 3: Загружаем новые сообщения (вниз) + response = api_client.get(messages_url, { + 'after_id': newest_id, + 'limit': 20 + }) + newer_data = response.json() + + assert response.status_code == status.HTTP_200_OK + assert len(newer_data['messages']) > 0 + + # Все сообщения новее newest_id + for msg in newer_data['messages']: + assert msg['id'] > newest_id + + +class TestEdgeCases: + """Тесты граничных случаев""" + + def test_empty_chat(self, api_client, test_user, test_chat): + """Тест 12: Пустой чат""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + response = api_client.get(url) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + assert len(data['messages']) == 0 + assert data['has_more'] is False + # Стандартный запрос возвращает has_more_before, а не has_more_after + assert data['has_more_before'] is False + + def test_invalid_after_id(self, api_client, test_user, test_chat, test_messages): + """Тест 13: Несуществующий after_id - должен загрузить с начала""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Несуществующий after_id - API загружает с начала чата (от старых к новым) + response = api_client.get(url, {'after_id': 999999, 'limit': 30}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # API загружает первые 30 сообщений от начала + assert len(data['messages']) == 30 + # Это forward loading, поэтому has_more_after должен быть True + assert data['has_more_after'] is True + + def test_after_id_at_end(self, api_client, test_user, test_chat, test_messages): + """Тест 14: after_id указывает на последнее сообщение""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Получаем ID последнего сообщения + last_message_id = test_messages[-1].id + + response = api_client.get(url, {'after_id': last_message_id}) + + assert response.status_code == status.HTTP_200_OK + data = response.json() + + # Нет сообщений после последнего + assert len(data['messages']) == 0 + assert data['has_more_after'] is False + + +class TestPagination: + """Тесты пагинации при двунаправленной загрузке""" + + def test_pagination_consistency(self, api_client, test_user, test_chat, test_messages): + """Тест 15: Согласованность пагинации в обоих направлениях""" + api_client.force_login(test_user) + url = reverse('api:v1:chat_messages', kwargs={'pk': test_chat.pk}) + + # Загружаем средний батч + middle_message = test_messages[50] + + # Загружаем после + response_after = api_client.get(url, { + 'after_id': middle_message.id, + 'limit': 10 + }) + + # Загружаем перед + response_before = api_client.get(url, { + 'before_id': middle_message.id, + 'limit': 10 + }) + + after_data = response_after.json() + before_data = response_before.json() + + # Проверяем что результаты не пересекаются + after_ids = {msg['id'] for msg in after_data['messages']} + before_ids = {msg['id'] for msg in before_data['messages']} + + assert len(after_ids & before_ids) == 0 # Нет пересечений + assert middle_message.id not in after_ids + assert middle_message.id not in before_ids + + +# ==================== Маркеры для запуска ==================== + +@pytest.mark.django_db +class TestBidirectionalLoadingIntegration: + """Интеграционные тесты полного цикла""" + pass + + +if __name__ == '__main__': + pytest.main([__file__, '-v', '--tb=short']) diff --git a/docs/in-progress/AUTOSCROLL_TESTING_CHECKLIST.md b/docs/in-progress/AUTOSCROLL_TESTING_CHECKLIST.md new file mode 100644 index 00000000..f34595ae --- /dev/null +++ b/docs/in-progress/AUTOSCROLL_TESTING_CHECKLIST.md @@ -0,0 +1,408 @@ +# 🧪 Чек-лист тестирования автоскролла + +## Дата: 13 января 2026 +## Цель: Массовое тестирование всех функций автоскролла после рефакторинга + +--- + +## 📋 1. ФУНКЦИИ ПРЯМОГО АВТОСКРОЛЛА + +### ScrollManagerV2 (scrollManagerV2.js) + +#### 1.1 Базовые операции скролла +- [ ] `scrollToBottom(options)` - прокрутка в конец чата + - [ ] С `instant: true` (мгновенно) + - [ ] С `instant: false` (плавно) + - [ ] Проверить `scrollTop = scrollHeight` + - [ ] **Тест:** открыть чат → должен прокрутиться вниз + +- [ ] `scrollToMessage(messageId, options)` - прокрутка к сообщению + - [ ] С `highlight: true` (подсветка) + - [ ] С `highlight: false` (без подсветки) + - [ ] С центрированием сообщения + - [ ] **Тест:** поиск по дате → переход к сообщению + +- [ ] `_scrollToMessage(messageId)` в ChatControllerV2 + - [ ] Расчет `targetScrollTop` с учетом sticky header + - [ ] Использование прямого присвоения `scrollTop` + - [ ] **ВАЖНО:** НЕ использует `scrollIntoView()` (скроллит родителей) + - [ ] **Тест:** прыжок на дату → сообщение в центре экрана + +#### 1.2 Восстановление позиции скролла +- [ ] Восстановление после `loadHistory()` (prepend сообщений) + - [ ] Расчет `heightDifference` + - [ ] Присвоение `scrollTop = oldScrollTop + heightDifference` + - [ ] Проверка сохранения визуальной позиции + - [ ] **Тест:** скролл вверх → подгрузка истории → позиция не прыгает + +#### 1.3 Инициализация чата +- [ ] `_scrollToBottom()` в ChatControllerV2 при первой загрузке + - [ ] Прямое присвоение `scrollTop = scrollHeight` + - [ ] Ожидание рендеринга (RAF) + - [ ] Логирование успеха скролла + - [ ] **Тест:** открыть чат впервые → видно последние сообщения + +--- + +## 🔄 2. INTERSECTION OBSERVER (АВТОМАТИЧЕСКАЯ ЗАГРУЗКА) + +### 2.1 History Observer (старые сообщения) + +- [ ] `_setupIntersectionObserver()` - создание observer + - [ ] Находит первое сообщение `.msg[data-message-id]` + - [ ] Создает `IntersectionObserver` для первого сообщения + - [ ] Threshold: `[0, 0.1]` + - [ ] **Тест:** первое сообщение появляется в viewport → загрузка истории + +- [ ] `_historyObserverCallback(entries)` - обработчик + - [ ] Проверка `entry.isIntersecting` + - [ ] Проверка флагов: `!_isLoadingHistory`, `!_isNearBottom`, `!_isInitializing` + - [ ] Вызов `_debouncedLoadHistory()` + - [ ] **Тест:** скролл в самый верх → автозагрузка 20 старых сообщений + +- [ ] `_triggerLoadHistory()` - триггер загрузки + - [ ] Вызов `loadMoreHistory()` + - [ ] **Тест:** несколько быстрых скроллов вверх → только один запрос (debounce) + +- [ ] `loadMoreHistory()` - основная функция загрузки + - [ ] Проверка `loader.hasMoreHistory(chatId)` + - [ ] Сохранение `oldScrollTop`, `oldScrollHeight` + - [ ] Вызов `loader.loadHistory()` + - [ ] Вызов `renderer.prependMessages()` + - [ ] Восстановление scrollTop + - [ ] Обновление флагов + - [ ] **Тест:** загрузка 20 старых → добавлены в начало → позиция сохранена + +### 2.2 Newer Observer (новые сообщения) + +- [ ] `_setupNewerObserver()` - создание observer + - [ ] Находит последнее сообщение + - [ ] Проверка `loader.hasMoreAfter(chatId)` + - [ ] Создает `IntersectionObserver` для последнего сообщения + - [ ] **Тест:** последнее сообщение в viewport → загрузка новых + +- [ ] `_newerObserverCallback(entries)` - обработчик + - [ ] Проверка `entry.isIntersecting` + - [ ] Проверка флагов: `!_isLoadingNewer`, `!_isInitializing` + - [ ] Вызов `_debouncedLoadNewer()` + - [ ] **Тест:** скролл вниз к последнему → автозагрузка новых 20 + +- [ ] `_triggerLoadNewer()` - триггер загрузки + - [ ] Вызов `loadMoreNewer()` + - [ ] **Тест:** быстрые скроллы вниз → только один запрос (debounce) + +- [ ] `loadMoreNewer()` - основная функция загрузки + - [ ] Проверка `loader.hasMoreAfter(chatId)` + - [ ] Вызов `loader.loadNewer()` + - [ ] Фильтрация уже отрендеренных сообщений + - [ ] Вызов `renderer.appendMessages()` + - [ ] **КРИТИЧНО:** Вызов `_updateNewerObserverTarget()` ВСЕГДА + - [ ] **Тест:** загрузка 20 новых → добавлены в конец → observer обновлен + +- [ ] `_updateNewerObserverTarget()` - обновление observer + - [ ] Отключение старого observer + - [ ] Проверка `loader.hasMoreAfter(chatId)` + - [ ] Находит новое последнее сообщение + - [ ] Создает новый observer для нового последнего + - [ ] **Тест:** после loadAround → прокрутка вниз → корректная автозагрузка + +--- + +## 🔍 3. КОСВЕННОЕ ИСПОЛЬЗОВАНИЕ АВТОСКРОЛЛА + +### 3.1 ChatControllerV2 (chatControllerV2.js) + +- [ ] `initialize()` - инициализация чата + - [ ] Вызов `_scrollToMessage(anchorId)` при loadAround + - [ ] Вызов `_scrollToBottom()` при загрузке последних + - [ ] **Тест:** открытие чата → корректная позиция + +- [ ] `sendMessage()` - отправка сообщения + - [ ] Вызов `scrollManager.scrollToBottom()` после отправки + - [ ] **Тест:** отправить сообщение → автоскролл вниз + +- [ ] `handleNewMessage(event)` - получение нового сообщения + - [ ] Проверка `isNearBottom()` + - [ ] Условный вызов `scrollManager.scrollToBottom()` + - [ ] **Тест:** новое сообщение пришло внизу → автоскролл, вверху → без скролла + +- [ ] `jumpToDate(dateString)` - прыжок на дату + - [ ] Вызов `scrollManager.destroy()` + - [ ] Загрузка сообщений вокруг даты + - [ ] Вызов `scrollManager.init()` + - [ ] Прокрутка к anchor сообщению + - [ ] **Тест:** выбор даты → переход к сообщениям этой даты + +### 3.2 MessageRendererV2 (messageRendererV2.js) + +- [ ] `renderMessages(messages, chatId, container)` - полный рендер + - [ ] НЕ скроллит напрямую + - [ ] Возвращает контент для вставки + - [ ] **Тест:** рендер → скролл делает вызывающий код + +- [ ] `appendMessages(messages, chatId)` - добавление в конец + - [ ] НЕ скроллит + - [ ] Возвращает fragment + - [ ] **Тест:** добавление → без автоскролла + +- [ ] `prependMessages(messages, chatId)` - добавление в начало + - [ ] НЕ скроллит + - [ ] Возвращает fragment + - [ ] **Тест:** prepend → позиция сохраняется в ScrollManager + +### 3.3 StickyDateObserver (stickyDateObserver.js) + +- [ ] IntersectionObserver для sticky дат + - [ ] Отслеживает видимость sentinel-элементов + - [ ] НЕ влияет на скролл + - [ ] Только меняет CSS классы + - [ ] **Тест:** скролл → даты становятся sticky/unsticky + +--- + +## 🎯 4. КРИТИЧЕСКИЕ СЦЕНАРИИ ТЕСТИРОВАНИЯ + +### 4.1 Первая загрузка чата +**Шаги:** +1. Открыть чат +2. Проверить: скролл в самый низ +3. Проверить: видны последние 16 сообщений +4. Проверить: `scrollTop = scrollHeight` + +**Ожидается:** ✅ Чат открыт внизу + +--- + +### 4.2 Загрузка истории при скролле вверх +**Шаги:** +1. Открыть чат (внизу) +2. Скроллить вверх до первого сообщения +3. Подождать появления старых сообщений +4. Проверить: позиция не прыгает +5. Продолжить скролл вверх +6. Проверить: подгружается еще 20 + +**Ожидается:** ✅ Плавная подгрузка, позиция стабильна + +--- + +### 4.3 Загрузка новых при скролле вниз после loadAround +**Шаги:** +1. Выбрать дату через календарь (например, 02.01.2026) +2. Проверить: прыжок к сообщениям этой даты +3. Скроллить вниз до последнего видимого +4. Проверить: автоматическая подгрузка следующих 20 +5. Продолжить скролл вниз +6. Проверить: подгружается еще 20 + +**Ожидается:** ✅ Корректная автоподгрузка после loadAround + +--- + +### 4.4 Отправка нового сообщения +**Шаги:** +1. Открыть чат (внизу) +2. Отправить сообщение +3. Проверить: автоскролл к новому сообщению +4. Скроллить вверх на 500px +5. Отправить еще сообщение +6. Проверить: НЕТ автоскролла (не внизу) + +**Ожидается:** ✅ Автоскролл только если был внизу + +--- + +### 4.5 Получение нового сообщения от другого пользователя +**Шаги:** +1. Открыть чат (внизу) +2. Получить новое сообщение (через WebSocket) +3. Проверить: автоскролл к новому +4. Скроллить вверх на 500px +5. Получить еще сообщение +6. Проверить: НЕТ автоскролла + +**Ожидается:** ✅ Автоскролл только если был внизу + +--- + +### 4.6 Множественная подгрузка истории +**Шаги:** +1. Открыть чат +2. Быстро скроллить в самый верх (CTRL+Home) +3. Подождать 5 секунд +4. Проверить: подгружено несколько порций по 20 +5. Проверить: позиция стабильна + +**Ожидается:** ✅ Несколько запросов, позиция не прыгает + +--- + +### 4.7 Множественная подгрузка новых +**Шаги:** +1. Выбрать старую дату (30.11.2025) +2. Быстро скроллить в самый низ (CTRL+End) +3. Подождать 5 секунд +4. Проверить: подгружено несколько порций по 20 +5. Проверить: достигнут конец чата + +**Ожидается:** ✅ Несколько запросов до конца + +--- + +### 4.8 Прыжок на дату → подгрузка вниз +**Шаги:** +1. Открыть календарь +2. Выбрать 02.01.2026 +3. Проверить: 31 сообщение загружено вокруг даты +4. Скроллить вниз к последнему видимому +5. Проверить: автозагрузка следующих 20 +6. Продолжить скролл +7. Проверить: загрузка до конца чата + +**Ожидается:** ✅ Корректная работа observer после loadAround + +--- + +### 4.9 Переключение между чатами +**Шаги:** +1. Открыть чат 1 +2. Скроллить вверх, подгрузить историю +3. Переключиться на чат 2 +4. Проверить: скролл в низ чата 2 +5. Вернуться в чат 1 +6. Проверить: скролл в низ чата 1 (не на старой позиции) + +**Ожидается:** ✅ Каждый чат открывается внизу + +--- + +### 4.10 Debounce/Throttle проверка +**Шаги:** +1. Открыть чат +2. Быстро скроллить вверх-вниз 10 раз за секунду +3. Открыть Network в DevTools +4. Проверить: максимум 1-2 запроса (не 10) + +**Ожидается:** ✅ Debounce работает + +--- + +## 🐛 5. ИЗВЕСТНЫЕ ПРОБЛЕМЫ (ДЛЯ ПРОВЕРКИ) + +- [ ] **Фикс от 13.01.2026:** Observer обновляется даже когда сообщения уже отрендерены + - **Проблема:** После loadAround загружено 31 сообщение, но в базе их больше. При прокрутке вниз loadNewer возвращает уже отрендеренные сообщения, renderer их пропускает, но observer НЕ обновлялся → застревал на старом последнем. + - **Решение:** Добавлен вызов `_updateNewerObserverTarget()` в блоке "все сообщения уже отрендерены" + - **Тест:** Сценарий 4.8 выше + +- [ ] **Sticky header offset:** Корректность расчета при прыжке к сообщению + - **Проверить:** Сообщение центрируется с учетом высоты sticky header (96px) + +- [ ] **RAF timing:** Достаточно ли одного RAF для корректного скролла при первой загрузке? + - **Проверить:** В разных браузерах (Chrome, Firefox, Safari) + +--- + +## 📊 6. МЕТРИКИ УСПЕХА + +### Количественные метрики +- ✅ 0 ошибок в консоли при любом сценарии +- ✅ Все 10 критических сценариев проходят +- ✅ Debounce снижает запросы минимум в 5 раз +- ✅ Позиция скролла стабильна (±5px) при подгрузке истории + +### Качественные метрики +- ✅ Плавность скролла (60 FPS) +- ✅ Нет визуальных прыжков +- ✅ Интуитивность поведения (как в Telegram) +- ✅ Консистентность между разными чатами + +--- + +## 🔧 7. ИНСТРУМЕНТЫ ДЛЯ ТЕСТИРОВАНИЯ + +### DevTools +```javascript +// В консоли браузера: + +// 1. Проверить состояние ScrollManager +window.chatController?.scrollManager + +// 2. Проверить флаги загрузки +window.chatController?.scrollManager._isLoadingHistory +window.chatController?.scrollManager._isLoadingNewer + +// 3. Проверить observers +window.chatController?.scrollManager._historyObserver +window.chatController?.scrollManager._newerObserver + +// 4. Проверить позицию скролла +const el = document.querySelector('.chat-messages-scroll'); +console.log({ + scrollTop: el.scrollTop, + scrollHeight: el.scrollHeight, + clientHeight: el.clientHeight, + isAtBottom: el.scrollTop + el.clientHeight >= el.scrollHeight - 10 +}); + +// 5. Проверить loader boundaries +window.chatController?.scrollManager.loader.hasMoreHistory(10) +window.chatController?.scrollManager.loader.hasMoreAfter(10) +``` + +### Логирование +Все функции автоскролла имеют префиксы: +- `[ScrollManagerV2]` - основной менеджер +- `[ChatControllerV2]` - контроллер чата +- `[MessageLoaderV2]` - загрузчик +- `[MessageRendererV2]` - рендерер + +Включить подробное логирование: все уже включено в коде + +--- + +## ✅ 8. ЧЕКЛИСТ ПЕРЕД ДЕПЛОЕМ + +- [ ] Все 10 критических сценариев протестированы +- [ ] Нет ошибок в консоли +- [ ] Протестировано в Chrome +- [ ] Протестировано в Firefox +- [ ] Протестировано на мобильном +- [ ] Проверена производительность (60 FPS) +- [ ] Проверен debounce (не более 2 запросов при быстром скролле) +- [ ] Проверено переключение между чатами +- [ ] Проверена работа с большими чатами (1000+ сообщений) +- [ ] Документация обновлена + +--- + +## 📝 9. ЛОГ ТЕСТИРОВАНИЯ + +| Дата | Тестер | Сценарий | Результат | Комментарии | +|------|--------|----------|-----------|-------------| +| 13.01.2026 | - | - | - | Начало массового тестирования | +| | | | | | +| | | | | | + +--- + +## 🎓 10. ДОПОЛНИТЕЛЬНЫЕ ЗАМЕТКИ + +### Принципы работы автоскролла +1. **Прямое присвоение `scrollTop`** - быстрее и надежнее чем `scrollTo()` +2. **IntersectionObserver** - эффективнее чем scroll events +3. **Debounce** - предотвращает избыточные запросы +4. **Восстановление позиции** - через `scrollTop += heightDifference` +5. **Условный автоскролл** - только если пользователь внизу чата + +### Telegram-like поведение +- ✅ Автоподгрузка истории при скролле вверх +- ✅ Автоподгрузка новых при скролле вниз +- ✅ Прыжок к дате с подгрузкой вокруг +- ✅ Сохранение позиции при подгрузке +- ✅ Автоскролл к новому только если внизу + +--- + +**Статус:** 🔴 Тестирование не начато + +**Следующий шаг:** Начать систематическое тестирование по сценариям 4.1-4.10