admin/apps/backend/tests/functional/web_manager/web_revalidation_service.spec.ts

import { test } from '@japa/runner'
import WebRevalidationService, {
  blogCacheTag,
  flushPendingRevalidations,
  pageCacheTag,
  REVALIDATION_MAX_ATTEMPTS,
  settingsCacheTag,
  WEB_MANAGER_CACHE_TAG,
  type RevalidationResult,
} from '#base_modules/WebManager/services/web_revalidation_service'

/** Captures the tags instead of posting them to the web app. */
class RecordingRevalidationService extends WebRevalidationService {
  readonly purged: string[][] = []

  override async revalidate(tags: string[]): Promise<RevalidationResult> {
    this.purged.push(tags)
    return { status: 'purged', tags }
  }

  get lastPurge() {
    return this.purged.at(-1) ?? []
  }
}

/**
 * Exercises the delivery path itself: counts attempts and fails the first `failures` of
 * them, with the backoff collapsed so the retries do not slow the suite down.
 */
class FlakyRevalidationService extends WebRevalidationService {
  attempts = 0

  constructor(private failures: number) {
    super()
  }

  protected override resolveTarget() {
    return { webAppUrl: 'http://web.test', secret: 'secret' }
  }

  protected override async attempt() {
    this.attempts++
    return this.attempts <= this.failures ? 'connection refused' : null
  }

  protected override backoffFor() {
    return 0
  }
}

test.group('Web Manager revalidation tags', () => {
  /**
   * These literals are duplicated in `apps/web/web-runtime/api/cache-tags.ts`; a change
   * here without a matching change there silently stops purging cached content.
   */
  test('builds the tag names the web app labels its fetches with', ({ assert }) => {
    assert.equal(pageCacheTag('en', 'pricing'), 'web-manager:page:en:pricing')
    assert.equal(settingsCacheTag('uk'), 'web-manager:settings:uk')
    assert.equal(blogCacheTag('de'), 'web-manager:blog:de')
  })

  test('gives the home page a tag that cannot collide with a real path', ({ assert }) => {
    assert.equal(pageCacheTag('en', ''), 'web-manager:page:en:/')
    assert.notEqual(pageCacheTag('en', ''), pageCacheTag('en', 'index'))
  })

  test('purges the page and its sibling translations', async ({ assert }) => {
    const service = new RecordingRevalidationService()

    await service.revalidatePage({
      locale: 'en',
      path: 'pricing',
      pageType: 'landing',
      translations: [
        { locale: 'uk', path: 'tsiny' },
        { locale: 'de', path: 'preise' },
      ],
    })

    assert.deepEqual(service.lastPurge, [
      'web-manager:page:en:pricing',
      'web-manager:page:uk:tsiny',
      'web-manager:page:de:preise',
    ])
    assert.notInclude(service.lastPurge, WEB_MANAGER_CACHE_TAG)
  })

  test('purges the blog listing only when a post changed', async ({ assert }) => {
    const service = new RecordingRevalidationService()
    const target = { locale: 'en', path: 'blog/hello', translations: [] }

    await service.revalidatePage({ ...target, pageType: 'blog-item' })
    assert.include(service.lastPurge, 'web-manager:blog:en')

    await service.revalidatePage({ ...target, pageType: 'landing' })
    assert.notInclude(service.lastPurge, 'web-manager:blog:en')
  })

  test('deduplicates when a translation repeats the page itself', async ({ assert }) => {
    const service = new RecordingRevalidationService()

    await service.revalidatePage({
      locale: 'en',
      path: 'pricing',
      pageType: 'landing',
      translations: [{ locale: 'en', path: 'pricing' }],
    })

    assert.deepEqual(service.lastPurge, ['web-manager:page:en:pricing'])
  })

  test('settings purge is scoped to its locale', async ({ assert }) => {
    const service = new RecordingRevalidationService()

    await service.revalidateSettings('uk')

    assert.deepEqual(service.lastPurge, ['web-manager:settings:uk'])
  })

  test('structural changes still purge everything', async ({ assert }) => {
    const service = new RecordingRevalidationService()

    await service.revalidatePublicContent()

    assert.deepEqual(service.lastPurge, [WEB_MANAGER_CACHE_TAG])
  })
})

test.group('Web Manager revalidation delivery', (group) => {
  group.each.teardown(() => flushPendingRevalidations())

  test('reports a purge the web app confirmed', async ({ assert }) => {
    const service = new FlakyRevalidationService(0)

    const result = await service.revalidate([WEB_MANAGER_CACHE_TAG])

    assert.equal(result.status, 'purged')
    assert.equal(service.attempts, 1)
  })

  test('does not keep the caller waiting when the first attempt fails', async ({ assert }) => {
    const service = new FlakyRevalidationService(1)

    const result = await service.revalidate([WEB_MANAGER_CACHE_TAG])

    assert.equal(result.status, 'retrying')
    assert.equal(service.attempts, 1, 'retries must not run on the request path')

    await flushPendingRevalidations()
    assert.equal(service.attempts, 2, 'the background retry recovers the purge')
  })

  test('gives up after the attempt budget', async ({ assert }) => {
    const service = new FlakyRevalidationService(Number.POSITIVE_INFINITY)

    await service.revalidate([WEB_MANAGER_CACHE_TAG])
    await flushPendingRevalidations()

    assert.equal(service.attempts, REVALIDATION_MAX_ATTEMPTS)
  })

  test('the last retry still counts', async ({ assert }) => {
    const service = new FlakyRevalidationService(REVALIDATION_MAX_ATTEMPTS - 1)

    await service.revalidate([WEB_MANAGER_CACHE_TAG])
    await flushPendingRevalidations()

    assert.equal(service.attempts, REVALIDATION_MAX_ATTEMPTS)
  })
})