TASKS-1823 WebManager module

2026-08-28 08:35:58 +00:00
parent fdb2cf3837
commit c93d8c025b
654 changed files with 26232 additions and 6075 deletions
@@ -0,0 +1,170 @@
+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)
+  })
+})