collavre 0.24.0 → 0.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9658b35d00bfa088037c3bc4ff2720913c69f43746e924545805f08482b091e9
-  data.tar.gz: e614bb81be4080199ee4dbf9ae248ce43ca1f88cbff11678514ecde1d66d69f6
+  metadata.gz: '080f4e1eadfbbb142d360670a3477f3c19f191d586ea47200b95e6566b63d64d'
+  data.tar.gz: 593a65708b18711b54283e4390af4b7b39267a0e20f9a98b2d3df3c3aede0a5e
 SHA512:
-  metadata.gz: be8a6c28498c6878c9eb1ae6287bdd97adfb395452b1a0296e1a7cce5e159763b904f93926bfff8c1ad3b4db077abfd0b5c77f2aa1fada447e65d291cc0bab24
-  data.tar.gz: a6fde45bf58c0707916f3f02e0d2293244b2c8598de2f8913555183d77c88590df29ec67f00a2a3c093378a3f2c7b0995975aaf61fb5f9d95a6c345b0fc85568
+  metadata.gz: 57e481a2c4284f2f705cd363f7417c6803d47af951a8e37bea75ef45366142442aec2231f572b2e021319d85283fba78ce613ae96df4e536e16188a5873fe8f3
+  data.tar.gz: aefdf3ea1327707b3e230089d5fe8787b428b92ba86d80ba32d244037be9aad82f5c1f36de99ccff779ec323210a1394bfc076e623d99ff46c44645f9bfc8330

data/app/assets/stylesheets/collavre/comments_popup.css

@@ -1452,23 +1452,6 @@ body.chat-fullscreen {
     fill-opacity: 0.2;
 }
 
-.comment-topics-list {
-    display: flex;
-    flex-wrap: nowrap;
-    align-items: center;
-    gap: 0.5em;
-    padding: var(--space-1) 0;
-    overflow-x: auto;
-    overflow-y: hidden;
-    scrollbar-width: none; /* Firefox */
-    -ms-overflow-style: none; /* IE/Edge */
-    min-height: 36px; /* Prevent height collapse during scroll */
-}
-
-.comment-topics-list::-webkit-scrollbar {
-    display: none; /* Chrome/Safari */
-}
-
 .topic-tag {
     display: inline-flex;
     align-items: center;
@@ -1651,6 +1634,11 @@ body.chat-fullscreen {
     flex-shrink: 0;
 }
 
+/* Class rule above outranks the UA [hidden] rule, so restate it. */
+.topic-creation-container[hidden] {
+    display: none;
+}
+
 .add-topic-btn {
     display: inline-flex;
     align-items: center;

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

@@ -343,4 +343,30 @@ describe('FormController - Review Quote Chips', () => {
       expect(controller.textareaTarget.value).toBe('fb2')
     })
   })
+
+  describe('active chip re-click - programmatic scroll', () => {
+    // Re-clicking the active chip scrolls its quoted comment into view. That is a
+    // programmatic list scroll, so it must drop the prev-message anchor the same way
+    // scrollToBottom/highlightComment do — otherwise a stale anchor inside the corridor
+    // survives and the next previous-message click skips the comment now in view.
+    test('re-clicking the active chip notifies the list of a programmatic scroll', () => {
+      const commentEl = document.createElement('div')
+      commentEl.setAttribute('data-comment-id', '1')
+      commentEl.scrollIntoView = jest.fn() // jsdom has no scrollIntoView
+      document.body.appendChild(commentEl)
+
+      const notifyProgrammaticScroll = jest.fn()
+      jest
+        .spyOn(controller, 'listController', 'get')
+        .mockReturnValue({ notifyProgrammaticScroll })
+
+      controller.appendReviewQuote(1, 'first') // freshly appended quote is active
+      container.querySelector('.review-quote-chip-text').click()
+
+      expect(commentEl.scrollIntoView).toHaveBeenCalled()
+      expect(notifyProgrammaticScroll).toHaveBeenCalled()
+
+      commentEl.remove()
+    })
+  })
 })

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

@@ -0,0 +1,230 @@
+/**
+ * @jest-environment jsdom
+ */
+
+/**
+ * Covers the previous-message wiring in list_controller: anchor lifecycle across
+ * connect/disconnect, list reloads, and the scroll action itself.
+ *
+ * jsdom has no layout engine, so item geometry is stubbed. `scrollTo` records
+ * the request without moving `scrollTop` — that models the smooth-scroll
+ * animation still being in flight, which is the state the original bug needed.
+ */
+
+import { jest } from '@jest/globals'
+import ListController from '../list_controller'
+
+const ITEM_HEIGHT = 100
+
+function buildController({ itemCount = 5 } = {}) {
+  const state = { scrollTop: 0 }
+
+  const element = document.createElement('div')
+  const list = document.createElement('div')
+  element.appendChild(list)
+  document.body.appendChild(element)
+
+  for (let i = 0; i < itemCount; i++) {
+    const item = document.createElement('div')
+    item.className = 'comment-item'
+    item.dataset.commentId = `c${i}`
+    Object.defineProperty(item, 'offsetTop', { get: () => i * ITEM_HEIGHT })
+    item.getBoundingClientRect = () => ({ top: i * ITEM_HEIGHT - state.scrollTop })
+    list.appendChild(item)
+  }
+
+  list.getBoundingClientRect = () => ({ top: 0 })
+  Object.defineProperty(list, 'offsetTop', { get: () => 0 })
+  list.scrollTo = jest.fn()
+
+  // Stand the controller up without a Stimulus application: `element` is a
+  // getter on Controller.prototype, so it has to be shadowed rather than set.
+  const controller = Object.create(ListController.prototype)
+  Object.defineProperty(controller, 'element', { value: element })
+  Object.defineProperty(controller, 'listTarget', { value: list })
+  controller.connect()
+
+  return {
+    controller,
+    list,
+    element,
+    // Apply the last requested scroll, i.e. let the smooth animation finish.
+    settle() {
+      const call = list.scrollTo.mock.calls.at(-1)
+      if (call) state.scrollTop = call[0].top
+    },
+    // Move the list without going through the button, as a user gesture would.
+    scrollTo(top) {
+      state.scrollTop = top
+    },
+    lastScrollTop() {
+      return list.scrollTo.mock.calls.at(-1)?.[0].top
+    },
+  }
+}
+
+describe('list_controller previous-message navigation', () => {
+  afterEach(() => {
+    document.body.innerHTML = ''
+  })
+
+  test('connect installs a navigator', () => {
+    const { controller } = buildController()
+    expect(controller.prevMsgNavigator).toBeTruthy()
+  })
+
+  test('walks backwards one message per click when settled', () => {
+    const h = buildController()
+    h.scrollTo(4 * ITEM_HEIGHT) // parked on the last item
+
+    h.controller.scrollToPreviousMessage()
+    expect(h.lastScrollTop()).toBe(3 * ITEM_HEIGHT)
+    h.settle()
+
+    h.controller.scrollToPreviousMessage()
+    expect(h.lastScrollTop()).toBe(2 * ITEM_HEIGHT)
+  })
+
+  test('keeps stepping back when clicked mid-animation', () => {
+    const h = buildController()
+    h.scrollTo(4 * ITEM_HEIGHT)
+
+    // Three clicks with no settle between them: the list never reaches the
+    // requested offset, which is exactly when the old geometry-only code
+    // bounced back to the item it had just left.
+    h.controller.scrollToPreviousMessage()
+    expect(h.lastScrollTop()).toBe(3 * ITEM_HEIGHT)
+    h.controller.scrollToPreviousMessage()
+    expect(h.lastScrollTop()).toBe(2 * ITEM_HEIGHT)
+    h.controller.scrollToPreviousMessage()
+    expect(h.lastScrollTop()).toBe(1 * ITEM_HEIGHT)
+  })
+
+  test('releases stick-to-bottom so incoming comments do not yank the view', () => {
+    const h = buildController()
+    h.controller.stickToBottom = true
+    h.scrollTo(4 * ITEM_HEIGHT)
+
+    h.controller.scrollToPreviousMessage()
+
+    expect(h.controller.stickToBottom).toBe(false)
+  })
+
+  test('does nothing when the list is empty', () => {
+    const h = buildController({ itemCount: 0 })
+
+    h.controller.scrollToPreviousMessage()
+
+    expect(h.list.scrollTo).not.toHaveBeenCalled()
+  })
+
+  test('loads older comments once past the oldest message', () => {
+    const h = buildController()
+    h.controller.allOlderLoaded = false
+    h.controller.loadOlderComments = jest.fn()
+
+    h.controller.scrollToPreviousMessage() // lands on the oldest item
+    h.settle()
+    h.controller.scrollToPreviousMessage() // nothing older in the DOM
+
+    expect(h.controller.loadOlderComments).toHaveBeenCalled()
+  })
+
+  test('stops at the oldest message when everything is already loaded', () => {
+    const h = buildController()
+    h.controller.allOlderLoaded = true
+    h.controller.loadOlderComments = jest.fn()
+
+    h.controller.scrollToPreviousMessage()
+    h.settle()
+    const before = h.list.scrollTo.mock.calls.length
+    h.controller.scrollToPreviousMessage()
+
+    expect(h.controller.loadOlderComments).not.toHaveBeenCalled()
+    expect(h.list.scrollTo.mock.calls.length).toBe(before)
+  })
+
+  describe.each(['wheel', 'touchstart', 'keydown', 'pointerdown'])(
+    'user input via %s',
+    (eventName) => {
+      test('drops the anchor so the next click resolves from where the user landed', () => {
+        const h = buildController()
+        h.scrollTo(4 * ITEM_HEIGHT)
+
+        h.controller.scrollToPreviousMessage() // anchor = c3
+        h.settle()
+
+        // User scrolls back down to the bottom themselves.
+        h.list.dispatchEvent(new Event(eventName))
+        h.scrollTo(4 * ITEM_HEIGHT)
+
+        h.controller.scrollToPreviousMessage()
+
+        // Resolved from geometry (c4 at top -> c3), not from the stale anchor.
+        expect(h.lastScrollTop()).toBe(3 * ITEM_HEIGHT)
+      })
+    }
+  )
+
+  test('a programmatic jump to the bottom drops the anchor', () => {
+    // form_controller (after sending) and the fullscreen handlers call
+    // scrollToBottom() with no user gesture. A small jump can leave the anchor
+    // inside the corridor, where geometry cannot tell it from our own in-flight
+    // scroll, so the next click would step off the stale anchor (c3 -> c2)
+    // instead of resolving from where the list actually is (c4 -> c3).
+    const h = buildController()
+    h.scrollTo(4 * ITEM_HEIGHT)
+
+    h.controller.scrollToPreviousMessage() // anchor = c3, in flight
+    expect(h.controller.prevMsgNavigator.anchorId).toBe('c3')
+
+    h.controller.scrollToBottom()
+    expect(h.controller.prevMsgNavigator.anchorId).toBeNull()
+
+    h.controller.scrollToPreviousMessage()
+    expect(h.lastScrollTop()).toBe(3 * ITEM_HEIGHT) // c3 from geometry, not c2
+  })
+
+  test('a permalink highlight jump drops the anchor', () => {
+    const h = buildController()
+    h.scrollTo(4 * ITEM_HEIGHT)
+
+    h.controller.scrollToPreviousMessage() // anchor = c3
+    expect(h.controller.prevMsgNavigator.anchorId).toBe('c3')
+
+    // highlightComment looks the target up by DOM id and scrolls it into view
+    // (jsdom has no scrollIntoView, so stub it).
+    const target = h.list.querySelector('[data-comment-id="c1"]')
+    target.id = 'comment_c1'
+    target.scrollIntoView = () => {}
+    h.controller.highlightComment('c1')
+
+    expect(h.controller.prevMsgNavigator.anchorId).toBeNull()
+  })
+
+  test('disconnect unhooks the user-input listeners', () => {
+    const h = buildController()
+    h.scrollTo(4 * ITEM_HEIGHT)
+    h.controller.scrollToPreviousMessage() // anchor = c3
+    h.settle()
+
+    h.controller.disconnect()
+    h.list.dispatchEvent(new Event('wheel'))
+
+    // Anchor survived because the listener is gone.
+    expect(h.controller.prevMsgNavigator.anchorId).toBe('c3')
+  })
+
+  test('reloading the list drops the anchor', () => {
+    const h = buildController()
+    h.scrollTo(4 * ITEM_HEIGHT)
+    h.controller.scrollToPreviousMessage()
+    expect(h.controller.prevMsgNavigator.anchorId).toBe('c3')
+
+    h.controller.creativeId = '1'
+    h.controller.fetchComments = jest.fn(() => new Promise(() => {}))
+    h.controller.loadInitialComments()
+
+    expect(h.controller.prevMsgNavigator.anchorId).toBeNull()
+  })
+})

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,178 @@
+/**
+ * @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()
+
+      await controller.deleteTopic(eventFor(1))
+
+      expect(alertDialog).toHaveBeenCalledWith(LOCALIZED.topicDeleteError)
+    })
+
+    test('archiveTopic surfaces the localized archive error', async () => {
+      global.fetch = failingFetch()
+
+      await controller.archiveTopic(eventFor(1))
+
+      expect(alertDialog).toHaveBeenCalledWith(LOCALIZED.topicArchiveError)
+    })
+
+    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)
+    })
+  })
+})