collavre 0.24.0 → 0.25.0

data/app/javascript/controllers/comments/__tests__/prev_message_navigator.test.js

@@ -0,0 +1,129 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import PrevMessageNavigator from '../prev_message_navigator'
+
+// Items are ordered oldest -> newest, matching DOM order of `.comment-item`.
+// `top` is the item's viewport-relative top, as measured by the controller.
+function items(...tops) {
+  return tops.map((top, i) => ({ id: String(i), top }))
+}
+
+describe('PrevMessageNavigator', () => {
+  const VIEWPORT_TOP = 100
+
+  let nav
+
+  beforeEach(() => {
+    nav = new PrevMessageNavigator()
+  })
+
+  describe('without an anchor (geometry fallback)', () => {
+    test('steps to the previous item when the current one is flush with the top', () => {
+      // item 2 is exactly at the viewport top -> previous message is item 1
+      expect(nav.resolveTargetIndex(items(-200, -100, 100, 300), VIEWPORT_TOP)).toBe(1)
+    })
+
+    test('scrolls the partially visible item to the top first', () => {
+      // item 2 is cut off above the fold -> bring item 2 fully into view
+      expect(nav.resolveTargetIndex(items(-200, -100, 130, 330), VIEWPORT_TOP)).toBe(2)
+    })
+
+    test('starts from the last item when everything is scrolled above the fold', () => {
+      expect(nav.resolveTargetIndex(items(-300, -200, -100), VIEWPORT_TOP)).toBe(2)
+    })
+
+    test('returns -1 at the oldest item so the caller can load older comments', () => {
+      expect(nav.resolveTargetIndex(items(100, 300), VIEWPORT_TOP)).toBe(-1)
+    })
+
+    test('returns -1 for an empty list', () => {
+      expect(nav.resolveTargetIndex([], VIEWPORT_TOP)).toBe(-1)
+    })
+  })
+
+  describe('with an anchor (rapid clicks)', () => {
+    test('keeps stepping backwards while the smooth scroll is still in flight', () => {
+      // First click: item 2 is flush with the top, so we head for item 1.
+      expect(nav.resolveTargetIndex(items(-200, -100, 100, 300), VIEWPORT_TOP)).toBe(1)
+      nav.commit('1', -100)
+
+      // Second click lands mid-animation: item 1 has not reached the top yet, so
+      // geometry alone would send us back down to item 1. The anchor must win.
+      expect(nav.resolveTargetIndex(items(-150, -50, 150, 350), VIEWPORT_TOP)).toBe(0)
+    })
+
+    test('keeps stepping when the first click started from a partially visible item', () => {
+      // First click from between messages: item 2 is cut off *below* the top, so
+      // we scroll it up into place and the anchor starts below the viewport top.
+      expect(nav.resolveTargetIndex(items(-200, -100, 130, 330), VIEWPORT_TOP)).toBe(2)
+      nav.commit('2', 130)
+
+      // Second click mid-animation: item 2 is on its way down to the top. The
+      // anchor must still win, otherwise we re-target item 2 and stall.
+      expect(nav.resolveTargetIndex(items(-215, -115, 115, 315), VIEWPORT_TOP)).toBe(1)
+    })
+
+    test('survives older comments being prepended (anchor is id based)', () => {
+      // Prepending shifts scrollTop but leaves the anchor where it is on screen,
+      // so it is still on its way from -300 up to the viewport top.
+      nav.commit('c5', -300)
+      const prepended = [
+        { id: 'c3', top: -500 },
+        { id: 'c4', top: -300 },
+        { id: 'c5', top: -100 },
+      ]
+      expect(nav.resolveTargetIndex(prepended, VIEWPORT_TOP)).toBe(1)
+    })
+
+    test('falls back to geometry when the anchored comment is gone', () => {
+      nav.commit('deleted-comment', -100)
+      expect(nav.resolveTargetIndex(items(-200, -100, 100, 300), VIEWPORT_TOP)).toBe(1)
+    })
+
+    test('returns -1 when the anchor is already the oldest item', () => {
+      nav.commit('0', -100)
+      expect(nav.resolveTargetIndex(items(100, 300), VIEWPORT_TOP)).toBe(-1)
+    })
+
+    test('ignores an anchor the list has scrolled away from', () => {
+      // A programmatic jump (new message arriving, permalink highlight) moves the
+      // list without any user gesture, so nothing drops the anchor. It is now far
+      // above where it started, which our own animation can never produce - that
+      // only ever walks the anchor down towards the viewport top.
+      nav.commit('0', -100)
+      expect(nav.resolveTargetIndex(items(-900, -700, 100, 300), VIEWPORT_TOP)).toBe(1)
+    })
+
+    test('a stale anchor stops wedging the button at the oldest message', () => {
+      // Regression: anchored on the oldest item, every later click returned -1
+      // forever once there was nothing more to load, so the button went dead.
+      nav.commit('0', -100)
+      nav.resolveTargetIndex(items(100, 300), VIEWPORT_TOP)
+
+      // The list is jumped back to the bottom; clicking must resume stepping.
+      expect(nav.resolveTargetIndex(items(-900, -700, 100, 300), VIEWPORT_TOP)).toBe(1)
+    })
+  })
+
+  describe('anchor invalidation', () => {
+    test('drops the anchor when the user moves the list', () => {
+      nav.commit('1', -100)
+      nav.notifyUserInput()
+      expect(nav.anchorId).toBeNull()
+    })
+
+    test('reset clears the anchor', () => {
+      nav.commit('1', -100)
+      nav.reset()
+      expect(nav.anchorId).toBeNull()
+    })
+
+    test('after a user scroll, geometry drives the next click again', () => {
+      nav.commit('1', -100)
+      nav.notifyUserInput()
+      expect(nav.resolveTargetIndex(items(-200, -100, 130, 330), VIEWPORT_TOP)).toBe(2)
+    })
+  })
+})

data/app/javascript/controllers/comments/__tests__/topics_controller_action_errors.test.js

@@ -0,0 +1,184 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+
+// Every topic mutation used to alert a hardcoded English literal on failure.
+// These tests pin that each failure path reaches the user through the localized
+// string handed down by the ERB partial, and that the English literals survive
+// only as the last-resort fallback when the partial supplied nothing.
+jest.unstable_mockModule('../../../lib/utils/dialog', () => ({
+  confirmDialog: jest.fn(),
+  alertDialog: jest.fn(),
+}))
+
+const { Application } = await import('@hotwired/stimulus')
+const TopicsController = (await import('../topics_controller')).default
+const { alertDialog, confirmDialog } = await import('../../../lib/utils/dialog')
+
+// Mirrors the data attributes emitted by _comments_popup.html.erb.
+const LOCALIZED = {
+  topicSetAgentError: '에이전트를 지정할 수 없습니다.',
+  topicCreateError: '토픽을 만들 수 없습니다.',
+  topicUpdateError: '토픽을 수정할 수 없습니다.',
+  topicDeleteError: '토픽을 삭제할 수 없습니다.',
+  topicArchiveError: '토픽을 보관할 수 없습니다.',
+  topicRestoreError: '토픽을 복원할 수 없습니다.',
+}
+
+const ENGLISH_FALLBACK = {
+  set_agent_error: 'Unable to assign the agent to this topic.',
+  create_error: 'Unable to create the topic.',
+  update_error: 'Unable to update the topic.',
+  delete_error: 'Unable to delete the topic.',
+  archive_error: 'Unable to archive the topic.',
+  restore_error: 'Unable to restore the topic.',
+}
+
+describe('TopicsController topic action failures', () => {
+  let application
+  let controller
+  let element
+
+  const mount = async (dataset = LOCALIZED) => {
+    const container = document.createElement('div')
+    container.innerHTML = `
+      <div id="topics" data-controller="comments--topics">
+        <div data-comments--topics-target="list"></div>
+      </div>
+    `
+    document.body.appendChild(container)
+
+    element = document.getElementById('topics')
+    Object.assign(element.dataset, dataset)
+
+    application = Application.start()
+    application.register('comments--topics', TopicsController)
+
+    const meta = document.createElement('meta')
+    meta.name = 'csrf-token'
+    meta.content = 'test-csrf'
+    document.head.appendChild(meta)
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    controller = application.getControllerForElementAndIdentifier(element, 'comments--topics')
+    controller.creativeIdValue = '42'
+    controller.loadTopics = jest.fn()
+    controller.renderTopics = jest.fn()
+    controller.restoreSelection = jest.fn()
+    controller.flushSaveLastTopic = jest.fn()
+    controller.topics = [{ id: 1, name: 'Main' }]
+    return controller
+  }
+
+  // deleteTopic/archiveTopic/unarchiveTopic read the id off event.currentTarget.
+  const eventFor = (id) => ({
+    stopPropagation: jest.fn(),
+    currentTarget: { dataset: { id: String(id) } },
+  })
+
+  const failingFetch = () => jest.fn().mockResolvedValue({ ok: false, json: async () => ({}) })
+
+  afterEach(() => {
+    document.body.innerHTML = ''
+    document.head.innerHTML = ''
+    application.stop()
+    jest.clearAllMocks()
+  })
+
+  describe('with localized strings from the partial', () => {
+    beforeEach(async () => {
+      await mount()
+      confirmDialog.mockResolvedValue(true)
+    })
+
+    test('deleteTopic surfaces the localized delete error', async () => {
+      global.fetch = failingFetch()
+      controller.serverLastTopicId = '1'
+      controller._topicScrollInterrupted = true
+
+      await controller.deleteTopic(eventFor(1))
+
+      expect(alertDialog).toHaveBeenCalledWith(LOCALIZED.topicDeleteError)
+      expect(controller._topicScrollInterrupted).toBe(true)
+    })
+
+    test('archiveTopic surfaces the localized archive error', async () => {
+      global.fetch = failingFetch()
+      controller.serverLastTopicId = '1'
+      controller._topicScrollInterrupted = true
+
+      await controller.archiveTopic(eventFor(1))
+
+      expect(alertDialog).toHaveBeenCalledWith(LOCALIZED.topicArchiveError)
+      expect(controller._topicScrollInterrupted).toBe(true)
+    })
+
+    test('unarchiveTopic surfaces the localized restore error', async () => {
+      global.fetch = failingFetch()
+
+      await controller.unarchiveTopic(eventFor(1))
+
+      expect(alertDialog).toHaveBeenCalledWith(LOCALIZED.topicRestoreError)
+    })
+
+    // updateTopic additionally reloads to discard the optimistic rename.
+    test('updateTopic surfaces the localized update error and reloads', async () => {
+      global.fetch = failingFetch()
+
+      await controller.updateTopic('1', 'Renamed')
+
+      expect(alertDialog).toHaveBeenCalledWith(LOCALIZED.topicUpdateError)
+      expect(controller.loadTopics).toHaveBeenCalled()
+    })
+
+    test('createTopic surfaces the localized create error', async () => {
+      global.fetch = failingFetch()
+
+      await controller.createTopic('New topic')
+
+      expect(alertDialog).toHaveBeenCalledWith(LOCALIZED.topicCreateError)
+      // The `finally` block must clear the guard even on the failure path,
+      // otherwise blur handling stays wedged after one failed create.
+      expect(controller.creating).toBe(false)
+    })
+  })
+
+  describe('without localized strings (controller mounted bare)', () => {
+    beforeEach(async () => {
+      await mount({})
+      confirmDialog.mockResolvedValue(true)
+    })
+
+    test.each(Object.entries(ENGLISH_FALLBACK))(
+      '_i18n("%s") falls back to the English literal',
+      (key, expected) => {
+        expect(controller._i18n(key)).toBe(expected)
+      }
+    )
+
+    // An unknown key must not render as `undefined` in a dialog; returning the
+    // key itself keeps the failure legible.
+    test('_i18n returns the key itself when it is unknown', () => {
+      expect(controller._i18n('no_such_key')).toBe('no_such_key')
+    })
+  })
+
+  describe('_i18n with localized strings', () => {
+    beforeEach(async () => {
+      await mount()
+    })
+
+    test.each([
+      ['set_agent_error', LOCALIZED.topicSetAgentError],
+      ['create_error', LOCALIZED.topicCreateError],
+      ['update_error', LOCALIZED.topicUpdateError],
+      ['delete_error', LOCALIZED.topicDeleteError],
+      ['archive_error', LOCALIZED.topicArchiveError],
+      ['restore_error', LOCALIZED.topicRestoreError],
+    ])('_i18n("%s") prefers the value from the partial', (key, expected) => {
+      expect(controller._i18n(key)).toBe(expected)
+    })
+  })
+})