cozy-client 60.31.0 → 60.32.0

package/dist/models/banner.spec.js

@@ -1,47 +1,42 @@
 import {
   BANNERS_DOCTYPE,
-  BANNERS_QUERY_NAME,
-  getActiveBanner,
-  getActiveBanners,
-  byPriority,
   dismiss,
-  getCta,
-  getSeverity,
-  getSurface,
-  getVisibleBanners,
-  isDismissed,
-  isInWindow,
-  isSupported,
-  isTrusted
+  getActiveBanner,
+  getActiveBanners
 } from './banner'
 import vectors from './__fixtures__/io.cozy.banners.json'
-import MockDate from 'mockdate'
+
+/** A client that answers a collection read with the given documents. */
+const clientListing = docs => ({
+  query: jest.fn().mockResolvedValue({ data: docs })
+})
 
 /**
- * The fixtures are the shared contract vectors published with the doctype in
- * cozy-doctypes (fixtures/io.cozy.banners.json). Every client implementing
- * io.cozy.banners runs the same cases, so the implementations are checked
- * against one specification rather than against each other.
+ * The fixtures are the contract vectors published with the doctype in
+ * cozy-doctypes. Every client implementing io.cozy.banners runs the same cases,
+ * so the implementations are checked against one specification rather than
+ * against each other.
+ *
+ * They run through getActiveBanners, the entry point a consumer calls, rather
+ * than against the internals: what matters is what an application ends up
+ * displaying.
  */
 describe('io.cozy.banners contract vectors', () => {
   const now = new Date(vectors.now)
 
   it.each(vectors.cases.map(testCase => [testCase.name, testCase]))(
     '%s',
-    (name, testCase) => {
-      const visible = getVisibleBanners(testCase.input, {
-        now,
-        supportedDoctypeVersion:
-          testCase.supportedDoctypeVersion ?? vectors.supportedDoctypeVersion
+    async (name, testCase) => {
+      const banners = await getActiveBanners(clientListing(testCase.input), {
+        now
       })
 
-      // No helper calls: getVisibleBanners returns banners ready to render,
-      // with every fallback already applied.
-      const rendered = visible.map(banner => ({
+      const rendered = banners.map(banner => ({
         bannerId: banner.bannerId,
         severity: banner.severity,
         surface: banner.surface,
-        cta: banner.cta !== null
+        cta: Boolean(banner.cta),
+        secondaryCta: Boolean(banner.secondaryCta)
       }))
 
       expect(rendered).toEqual(testCase.expected)
@@ -49,348 +44,131 @@ describe('io.cozy.banners contract vectors', () => {
   )
 })
 
-describe('isTrusted', () => {
-  it('should reject a document written by an application', () => {
-    expect(isTrusted({ cozyMetadata: { createdByApp: 'drive' } })).toBe(false)
-  })
-
-  it('should reject a document with no metadata', () => {
-    expect(isTrusted({})).toBe(false)
-    expect(isTrusted(undefined)).toBe(false)
-  })
-})
-
-const stackBanner = attributes => ({
-  bannerId: 'quota.exceeded',
-  category: 'quota',
-  severity: 'info',
-  surface: 'banner',
-  text: 'Message.',
-  lang: 'en',
-  dismissible: true,
-  dismissedAt: null,
-  priority: 50,
-  startsAt: '2026-07-01T00:00:00Z',
-  endsAt: null,
-  cozyMetadata: {
-    createdByApp: 'stack',
-    doctypeVersion: 1,
-    metadataVersion: 1
-  },
-  ...attributes
-})
-
-const now = new Date('2026-07-22T12:00:00Z')
-const idsOf = banners => banners.map(banner => banner.bannerId)
-
-describe('getSurface', () => {
-  it('should keep every surface the doctype defines', () => {
-    expect(getSurface({ surface: 'banner' })).toBe('banner')
-    expect(getSurface({ surface: 'modal' })).toBe('modal')
-  })
-
-  it('should fall back for a surface the doctype no longer defines', () => {
-    expect(getSurface({ surface: 'inline' })).toBe('banner')
-  })
-})
+describe('getActiveBanners', () => {
+  const stored = {
+    _id: 'abc',
+    bannerId: 'quota.almost-full',
+    category: 'quota',
+    severity: 'critical',
+    surface: 'inline',
+    text: 'hi',
+    lang: 'en',
+    cta: { label: 'Go', url: 'http://example.org' },
+    dismissible: true,
+    dismissedAt: null,
+    priority: 10,
+    startsAt: '2020-01-01T00:00:00Z',
+    endsAt: null,
+    cozyMetadata: { createdByApp: 'stack', doctypeVersion: '1' }
+  }
 
-describe('getSeverity', () => {
-  it('should keep every severity the doctype defines', () => {
-    expect(getSeverity({ severity: 'info' })).toBe('info')
-    expect(getSeverity({ severity: 'warning' })).toBe('warning')
-    expect(getSeverity({ severity: 'error' })).toBe('error')
-  })
-})
+  it('should return banners ready to render, with every fallback applied', async () => {
+    const banners = await getActiveBanners(clientListing([stored]))
 
-describe('getCta', () => {
-  it('should drop a call to action with no readable label', () => {
-    expect(getCta({ cta: { url: 'https://example.org' } })).toBe(null)
-    expect(getCta({ cta: { label: '', url: 'https://example.org' } })).toBe(
-      null
-    )
-    // Whitespace and a zero width space render as a button with nothing on it.
-    expect(getCta({ cta: { label: '  ', url: 'https://example.org' } })).toBe(
-      null
-    )
-    expect(
-      getCta({ cta: { label: '\u200B', url: 'https://example.org' } })
-    ).toBe(null)
+    expect(banners).toHaveLength(1)
+    // a severity or surface this client does not know is rendered with the
+    // fallback rather than dropped, so a new value needs no client release
+    expect(banners[0].severity).toBe('warning')
+    expect(banners[0].surface).toBe('banner')
   })
 
-  it('should accept a scheme written in any case', () => {
-    const cta = { label: 'Upgrade', url: 'HTTPS://example.org' }
-    expect(getCta({ cta })).toBe(cta)
+  it('should query the doctype, not a wrapper around it', async () => {
+    const client = clientListing([])
+    await getActiveBanners(client)
+    const [definition] = client.query.mock.calls[0]
+    expect(definition.doctype).toBe(BANNERS_DOCTYPE)
   })
-})
 
-describe('isInWindow', () => {
-  it('should hide a banner whose window cannot be read', () => {
-    expect(isInWindow(stackBanner({ endsAt: 'not-a-date' }), now)).toBe(false)
-    expect(isInWindow(stackBanner({ startsAt: '2026-13-45' }), now)).toBe(false)
+  it('should cope with an empty or missing collection', async () => {
+    for (const data of [[], null, undefined]) {
+      await expect(getActiveBanners(clientListing(data))).resolves.toEqual([])
+    }
   })
 
-  it('should hide a banner with no start bound rather than treat it as open', () => {
-    // startsAt is not one of the fields the doctype allows to be missing, so an
-    // absent one is an unreadable window. Treating it as "no lower bound" would
-    // make deleting the field enough to turn a scheduled banner into a
-    // permanent one, which anything able to rewrite the document could do.
-    expect(isInWindow(stackBanner({ startsAt: undefined }), now)).toBe(false)
-    expect(isInWindow(stackBanner({ startsAt: null }), now)).toBe(false)
-    expect(
-      idsOf(
-        getVisibleBanners(
-          [stackBanner({ startsAt: undefined, endsAt: null })],
-          {
-            now
-          }
-        )
+  it('should not hide a failed read behind an empty list', async () => {
+    // client.query resolves undefined when the client carries an onError
+    // callback, which would otherwise read as "no banners apply"
+    const client = { query: jest.fn().mockResolvedValue(undefined) }
+    await expect(getActiveBanners(client)).rejects.toThrow(BANNERS_DOCTYPE)
+  })
+
+  it('should drop a call to action that is not an absolute https URL', async () => {
+    // the documents live in a database the applications can write, and a
+    // client renders this straight into an href
+    const urls = [
+      'javascript' + ':alert(document.cookie)',
+      'data:text/html,<script>alert(1)</script>',
+      'http://example.org/plans',
+      '/plans'
+    ]
+
+    for (const url of urls) {
+      const [banner] = await getActiveBanners(
+        clientListing([{ ...stored, cta: { label: 'Go', url } }])
       )
-    ).toEqual([])
-  })
-
-  it('should default to the current time', () => {
-    MockDate.set('2026-07-22T12:00:00Z')
-    try {
-      expect(
-        isInWindow(stackBanner({ startsAt: '2026-08-01T00:00:00Z' }))
-      ).toBe(false)
-      expect(isInWindow(stackBanner())).toBe(true)
-    } finally {
-      MockDate.reset()
+      expect(banner.cta).toBeUndefined()
     }
-  })
-})
 
-describe('isDismissed', () => {
-  it('should read an absent value as not dismissed', () => {
-    expect(isDismissed({ dismissedAt: null })).toBe(false)
-    expect(isDismissed({})).toBe(false)
-    expect(isDismissed(undefined)).toBe(false)
-  })
-})
-
-describe('isSupported', () => {
-  it('should default to the version this client was written against', () => {
-    expect(isSupported(stackBanner())).toBe(true)
-  })
-})
-
-describe('byPriority', () => {
-  it('should order equal priorities by code unit rather than by locale', () => {
-    const banners = [{ bannerId: 'a.x' }, { bannerId: 'B.x' }]
-    expect(idsOf([...banners].sort(byPriority))).toEqual(['B.x', 'a.x'])
-  })
-
-  it('should stay transitive when a priority is missing', () => {
-    const high = { bannerId: 'z.high', priority: 100 }
-    const none = { bannerId: 'm.none' }
-    const low = { bannerId: 'a.low', priority: 10 }
-
-    expect(byPriority(high, none)).toBeLessThan(0)
-    expect(byPriority(none, low)).toBeGreaterThan(0)
-    expect(byPriority(high, low)).toBeLessThan(0)
-  })
-})
-
-describe('getVisibleBanners', () => {
-  it('should not let an out of window version hide a live one', () => {
-    const live = stackBanner({ _id: 'v1' })
-    const future = stackBanner({
-      _id: 'v2',
-      startsAt: '2026-08-01T00:00:00Z',
-      cozyMetadata: { createdByApp: 'stack', doctypeVersion: 2 }
-    })
-
-    const visible = getVisibleBanners([live, future], {
-      now,
-      supportedDoctypeVersion: 2
-    })
-
-    expect(idsOf(visible)).toEqual(['quota.exceeded'])
-  })
-
-  it('should keep a bannerId hidden once any of its versions is dismissed', () => {
-    const dismissed = stackBanner({
-      _id: 'v1',
-      dismissedAt: '2026-07-20T00:00:00Z'
-    })
-    const upgraded = stackBanner({
-      _id: 'v2',
-      cozyMetadata: { createdByApp: 'stack', doctypeVersion: 2 }
-    })
-
-    const visible = getVisibleBanners([dismissed, upgraded], {
-      now,
-      supportedDoctypeVersion: 2
-    })
-
-    expect(visible).toEqual([])
-  })
-
-  it('should not depend on the order the documents came back in', () => {
-    const older = stackBanner({
-      _id: 'a',
-      priority: 10,
-      cozyMetadata: {
-        createdByApp: 'stack',
-        doctypeVersion: 1,
-        updatedAt: '2026-07-01T00:00:00Z'
-      }
-    })
-    const newer = stackBanner({
-      _id: 'b',
-      priority: 90,
-      cozyMetadata: {
-        createdByApp: 'stack',
-        doctypeVersion: 1,
-        updatedAt: '2026-07-10T00:00:00Z'
-      }
-    })
-
-    const one = getVisibleBanners([older, newer], { now })
-    const other = getVisibleBanners([newer, older], { now })
-
-    expect(one).toEqual(other)
-    expect(one[0]._id).toBe('b')
-  })
-
-  it('should keep documents that lost their bannerId apart', () => {
-    const first = stackBanner({ _id: 'a', bannerId: undefined })
-    const second = stackBanner({ _id: 'b', bannerId: undefined })
-
-    expect(getVisibleBanners([first, second], { now })).toHaveLength(2)
-  })
-
-  it('should ignore a dismissal recorded by anything but the stack', () => {
-    // An application holding write permission on the doctype could otherwise
-    // suppress a platform message by authoring a dismissed document of its own,
-    // without touching the one the stack wrote.
-    const live = stackBanner({ _id: 'stack' })
-    const forged = stackBanner({
-      _id: 'forged',
-      dismissedAt: '2026-07-20T00:00:00Z',
-      cozyMetadata: { createdByApp: 'drive', doctypeVersion: 1 }
-    })
-
-    expect(idsOf(getVisibleBanners([forged, live], { now }))).toEqual([
-      'quota.exceeded'
-    ])
-  })
-
-  it('should not leave a blocking modal without a way out', () => {
-    // The doctype guarantees a non dismissible modal carries a call to action.
-    // Dropping an unusable one must not paint a dialog with no dismiss control
-    // and no button.
-    const trapped = stackBanner({
-      surface: 'modal',
-      dismissible: false,
-      cta: { label: 'Upgrade', url: 'http://example.org/plans' }
-    })
-
-    const [visible] = getVisibleBanners([trapped], { now })
-
-    expect(visible.cta).toBeNull()
-    expect(visible.surface).toBe('banner')
+    const [kept] = await getActiveBanners(
+      clientListing([
+        { ...stored, cta: { label: 'Go', url: 'https://example.org/plans' } }
+      ])
+    )
+    expect(kept.cta.url).toBe('https://example.org/plans')
   })
 
-  it('should keep a modal whose call to action survived', () => {
-    const usable = stackBanner({
-      surface: 'modal',
-      dismissible: false,
-      cta: { label: 'Upgrade', url: 'https://example.org/plans' }
-    })
-
-    expect(getVisibleBanners([usable], { now })[0].surface).toBe('modal')
-  })
+  it('should hide a banner whose window bound is not the timestamp the doctype writes', async () => {
+    // Date.parse falls back to an engine specific parser for everything else,
+    // so the same document would be visible in one browser and hidden in
+    // another, and the contract vectors could no longer describe both
+    const bounds = ['2020-01-01', 'Jan 1 2020', '2020/01/01', 0, ['2020-01-01']]
 
-  it('should not let a version written as null lose to its older sibling', () => {
-    // Number(null) is a finite 0, so an unusable version must not be read as a
-    // real one: it would lose the version comparison outright and render the
-    // stale document.
-    const fresher = stackBanner({
-      _id: 'fresher',
-      surface: 'modal',
-      cozyMetadata: {
-        createdByApp: 'stack',
-        doctypeVersion: null,
-        updatedAt: '2026-07-20T00:00:00Z'
-      }
-    })
-    const stale = stackBanner({
-      _id: 'stale',
-      cozyMetadata: {
-        createdByApp: 'stack',
-        doctypeVersion: '1',
-        updatedAt: '2026-07-01T00:00:00Z'
-      }
-    })
-
-    expect(getVisibleBanners([fresher, stale], { now })[0]._id).toBe('fresher')
+    for (const startsAt of bounds) {
+      await expect(
+        getActiveBanners(clientListing([{ ...stored, startsAt }]))
+      ).resolves.toEqual([])
+    }
   })
 
-  it('should fall back on the supported version when the option is unusable', () => {
-    // ?? would let NaN through, and every `version <= NaN` is false, so the
-    // whole feature would go dark with no error.
-    expect(
-      idsOf(
-        getVisibleBanners([stackBanner()], {
-          now,
-          supportedDoctypeVersion: Number('nope')
-        })
-      )
-    ).toEqual(['quota.exceeded'])
-  })
+  it('should rank a banner carrying no priority below one that does', async () => {
+    // b.priority - a.priority is NaN without this, and a NaN comparator makes
+    // sort keep insertion order and never reach the bannerId tiebreak
+    const ranked = { ...stored, _id: 'a', bannerId: 'a.ranked', priority: 50 }
+    const unranked = { ...stored, _id: 'b', bannerId: 'b.unranked' }
+    delete unranked.priority
 
-  it('should keep bannerId and _id in separate identities', () => {
-    // A document that lost its bannerId keys on its _id, which must not collide
-    // with another document whose bannerId happens to be that same string.
-    const dismissedNoId = stackBanner({
-      _id: 'quota.exceeded',
-      bannerId: undefined,
-      dismissedAt: '2026-07-20T00:00:00Z'
-    })
-    const live = stackBanner({ _id: 'other' })
+    const banners = await getActiveBanners(clientListing([unranked, ranked]))
 
-    expect(idsOf(getVisibleBanners([dismissedNoId, live], { now }))).toEqual([
-      'quota.exceeded'
+    expect(banners.map(banner => banner.bannerId)).toEqual([
+      'a.ranked',
+      'b.unranked'
     ])
   })
+})
 
-  it('should order documents that lost their bannerId deterministically', () => {
-    const first = stackBanner({ _id: 'zzz', bannerId: undefined })
-    const second = stackBanner({ _id: 'aaa', bannerId: undefined })
-
-    const one = getVisibleBanners([first, second], { now }).map(b => b._id)
-    const other = getVisibleBanners([second, first], { now }).map(b => b._id)
+describe('getActiveBanner', () => {
+  const base = {
+    bannerId: 'low',
+    severity: 'info',
+    surface: 'banner',
+    priority: 1,
+    dismissedAt: null,
+    startsAt: '2020-01-01T00:00:00Z',
+    endsAt: null,
+    cozyMetadata: { createdByApp: 'stack', doctypeVersion: '1' }
+  }
 
-    expect(one).toEqual(['aaa', 'zzz'])
-    expect(one).toEqual(other)
-  })
+  it('should return the highest priority banner', async () => {
+    const low = { ...base, _id: 'a' }
+    const high = { ...base, _id: 'b', bannerId: 'high', priority: 99 }
 
-  it('should return the stored document when no fallback applied', () => {
-    // The store relies on referential equality, so an untouched banner must not
-    // be copied on every read.
-    const clean = stackBanner({ cta: null })
+    const banner = await getActiveBanner(clientListing([low, high]))
 
-    expect(getVisibleBanners([clean], { now })[0]).toBe(clean)
+    expect(banner.bannerId).toBe('high')
   })
 
-  it('should fall back on the clock when now is unusable', () => {
-    // The banner is live at the frozen clock, so this separates the guard from
-    // isInWindow's own rejection of a NaN time, which would hide it instead.
-    const live = stackBanner()
-
-    MockDate.set('2026-07-22T12:00:00Z')
-    try {
-      expect(
-        idsOf(getVisibleBanners([live], { now: new Date('nope') }))
-      ).toEqual(['quota.exceeded'])
-      expect(
-        idsOf(getVisibleBanners([live], { now: '2026-07-22T12:00:00Z' }))
-      ).toEqual(['quota.exceeded'])
-    } finally {
-      MockDate.reset()
-    }
+  it('should return null when nothing applies', async () => {
+    await expect(getActiveBanner(clientListing([]))).resolves.toBeNull()
   })
 })
 
@@ -435,19 +213,21 @@ describe('dismiss', () => {
     // A caller holds a resolved banner, whose severity, surface and cta have
     // had the client fallbacks applied. Persisting those would overwrite the
     // values the stack wrote, and nothing server side prevents it.
-    const [resolved] = getVisibleBanners([
-      {
-        ...stored,
-        category: 'quota',
-        text: 'hi',
-        lang: 'en',
-        dismissible: true,
-        priority: 1,
-        startsAt: '2020-01-01T00:00:00Z',
-        endsAt: null,
-        cozyMetadata: { createdByApp: 'stack', doctypeVersion: 1 }
-      }
-    ])
+    const [resolved] = await getActiveBanners(
+      clientListing([
+        {
+          ...stored,
+          category: 'quota',
+          text: 'hi',
+          lang: 'en',
+          dismissible: true,
+          priority: 1,
+          startsAt: '2020-01-01T00:00:00Z',
+          endsAt: null,
+          cozyMetadata: { createdByApp: 'stack', doctypeVersion: '1' }
+        }
+      ])
+    )
     const client = clientReturning(stored)
 
     await dismiss(client, resolved, { dismissedAt: at })
@@ -499,8 +279,6 @@ describe('dismiss', () => {
     const client = {
       query: jest
         .fn()
-        // the collection lookup for every version of the bannerId
-        .mockResolvedValueOnce({ data: [stored] })
         // the read by id, then the re-read after the conflict
         .mockResolvedValueOnce({ data: stored })
         .mockResolvedValue({ data: fresh }),
@@ -512,7 +290,8 @@ describe('dismiss', () => {
 
     await dismiss(client, stored, { dismissedAt: at })
 
-    expect(client.query).toHaveBeenCalledTimes(3)
+    // the read by id, then the re-read after the conflict
+    expect(client.query).toHaveBeenCalledTimes(2)
     expect(client.save).toHaveBeenLastCalledWith({
       ...fresh,
       _type: BANNERS_DOCTYPE,
@@ -600,162 +379,3 @@ describe('dismiss', () => {
     await expect(dismiss(client, stored)).rejects.toThrow('Server error')
   })
 })
-
-describe('getCta url validation', () => {
-  const withUrl = url => ({ cta: { label: 'Go', url } })
-
-  it('should keep an absolute https URL', () => {
-    expect(getCta(withUrl('https://example.org/plans'))).not.toBeNull()
-  })
-
-  it.each([
-    ['https://', 'a scheme with no host'],
-    ['http://example.org', 'plain http'],
-    ['javascript:alert(1)', 'a script scheme'],
-    ['//example.org', 'a protocol relative URL'],
-    ['/plans', 'a relative path']
-  ])('should drop %s (%s)', url => {
-    expect(getCta(withUrl(url))).toBeNull()
-  })
-})
-
-describe('getActiveBanners', () => {
-  const stored = {
-    _id: 'abc',
-    bannerId: 'quota.almost-full',
-    category: 'quota',
-    severity: 'critical',
-    surface: 'inline',
-    text: 'hi',
-    lang: 'en',
-    dismissible: true,
-    dismissedAt: null,
-    priority: 10,
-    startsAt: '2020-01-01T00:00:00Z',
-    endsAt: null,
-    cozyMetadata: { createdByApp: 'stack', doctypeVersion: '1' }
-  }
-
-  it('should query and return banners ready to render', async () => {
-    const client = { query: jest.fn().mockResolvedValue({ data: [stored] }) }
-
-    const banners = await getActiveBanners(client)
-
-    // asserted precisely: passing the { definition, options } wrapper instead
-    // of the definition itself throws "Cannot init query with no doctype" at
-    // runtime, which a permissive mock hides.
-    const [definition, queryOptions] = client.query.mock.calls[0]
-    expect(definition.doctype).toBe(BANNERS_DOCTYPE)
-    // Named under its own key rather than the bare doctype: client.query keys
-    // the store entry on the name but the in flight promise on the definition,
-    // so sharing the name with another query makes this one resolve nothing.
-    expect(queryOptions.as).toBe(BANNERS_QUERY_NAME)
-    expect(BANNERS_QUERY_NAME).not.toBe(BANNERS_DOCTYPE)
-    expect(banners).toHaveLength(1)
-    // fallbacks already applied, so the caller renders what it is given
-    expect(banners[0].severity).toBe('warning')
-    expect(banners[0].surface).toBe('banner')
-  })
-
-  it('should cope with an empty or missing collection', async () => {
-    for (const data of [[], null, undefined]) {
-      const client = { query: jest.fn().mockResolvedValue({ data }) }
-      await expect(getActiveBanners(client)).resolves.toEqual([])
-    }
-  })
-
-  it('should read a collection the pouch link resolves as a bare object', async () => {
-    const client = { query: jest.fn().mockResolvedValue({ data: stored }) }
-    await expect(getActiveBanners(client)).resolves.toEqual([])
-  })
-
-  it('should not report a query that resolved nothing as an empty instance', async () => {
-    const client = { query: jest.fn().mockResolvedValue(undefined) }
-    await expect(getActiveBanners(client)).rejects.toThrow('resolved nothing')
-  })
-})
-
-describe('getActiveBanner', () => {
-  it('should return the highest priority banner', async () => {
-    const low = {
-      _id: 'a',
-      bannerId: 'low',
-      severity: 'info',
-      surface: 'banner',
-      priority: 1,
-      dismissedAt: null,
-      startsAt: '2020-01-01T00:00:00Z',
-      endsAt: null,
-      cozyMetadata: { createdByApp: 'stack', doctypeVersion: '1' }
-    }
-    const high = { ...low, _id: 'b', bannerId: 'high', priority: 99 }
-    const client = { query: jest.fn().mockResolvedValue({ data: [low, high] }) }
-
-    const banner = await getActiveBanner(client)
-
-    expect(banner.bannerId).toBe('high')
-  })
-
-  it('should return null when nothing applies', async () => {
-    const client = { query: jest.fn().mockResolvedValue({ data: [] }) }
-    await expect(getActiveBanner(client)).resolves.toBeNull()
-  })
-})
-
-describe('dismiss across versions', () => {
-  const at = '2026-08-28T10:00:00Z'
-  const v1 = {
-    _id: 'v1doc',
-    bannerId: 'quota.exceeded',
-    dismissedAt: null,
-    cozyMetadata: { createdByApp: 'stack', doctypeVersion: '1' }
-  }
-  const v2 = {
-    ...v1,
-    _id: 'v2doc',
-    cozyMetadata: { ...v1.cozyMetadata, doctypeVersion: '2' }
-  }
-  const other = { ...v1, _id: 'otherdoc', bannerId: 'billing.failed' }
-
-  it('should write the dismissal to every version of the bannerId', async () => {
-    const byId = { v1doc: v1, v2doc: v2, otherdoc: other }
-    const client = {
-      query: jest
-        .fn()
-        .mockImplementation(definition =>
-          Promise.resolve(
-            definition?.id
-              ? { data: byId[definition.id] }
-              : { data: [v1, v2, other] }
-          )
-        ),
-      save: jest.fn().mockImplementation(doc => Promise.resolve({ data: doc }))
-    }
-
-    await dismiss(client, v1, { dismissedAt: at })
-
-    const written = client.save.mock.calls.map(([doc]) => doc._id).sort()
-    expect(written).toEqual(['v1doc', 'v2doc'])
-    // the sibling under a different bannerId is left alone
-    expect(written).not.toContain('otherdoc')
-  })
-
-  it('should answer with the document the caller asked about', async () => {
-    const client = {
-      query: jest
-        .fn()
-        .mockImplementation(definition =>
-          Promise.resolve(
-            definition?.id
-              ? { data: definition.id === 'v1doc' ? v1 : v2 }
-              : { data: [v1, v2] }
-          )
-        ),
-      save: jest.fn().mockImplementation(doc => Promise.resolve({ data: doc }))
-    }
-
-    const result = await dismiss(client, v2, { dismissedAt: at })
-
-    expect(result.data._id).toBe('v2doc')
-  })
-})