) => {
+ postMessage(compareMarkdownSourceLines(data))
+})
diff --git a/src/comparison/markdownSourceComparisonProtocol.ts b/src/comparison/markdownSourceComparisonProtocol.ts
new file mode 100644
index 00000000000..a6e4883993b
--- /dev/null
+++ b/src/comparison/markdownSourceComparisonProtocol.ts
@@ -0,0 +1,26 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Change } from 'diff'
+
+import { diffLines } from 'diff'
+
+export interface SourceComparisonWorkerRequest {
+ before: string
+ after: string
+ maximumEditLength: number
+ timeoutMilliseconds: number
+}
+
+export type SourceComparisonWorkerResponse = { status: 'ready', changes: Change[] } | { status: 'limited' }
+
+export function compareMarkdownSourceLines(request: SourceComparisonWorkerRequest): SourceComparisonWorkerResponse {
+ const changes = diffLines(request.before, request.after, {
+ stripTrailingCr: false,
+ maxEditLength: request.maximumEditLength,
+ timeout: request.timeoutMilliseconds,
+ })
+ return changes ? { status: 'ready', changes } : { status: 'limited' }
+}
diff --git a/src/components/MarkdownContentComparison.vue b/src/components/MarkdownContentComparison.vue
index 1a26137c968..a7ed89846fa 100644
--- a/src/components/MarkdownContentComparison.vue
+++ b/src/components/MarkdownContentComparison.vue
@@ -104,6 +104,13 @@
t('text', 'No rendered differences — Markdown syntax differs.')
}}
+
+ {{ t('text', 'Open Markdown source') }}
+
{{ t('text', 'No differences.') }}
@@ -157,17 +164,35 @@
+
+
+
+ {{
+ t(
+ 'text',
+ 'Source compares literal Markdown, so its change groups can differ from rendered changes.',
+ )
+ }}
+
+
+
+
+
+
diff --git a/src/tests/comparison/MarkdownSourceComponent.spec.ts b/src/tests/comparison/MarkdownSourceComponent.spec.ts
index daecc93ceaf..f095354e1e1 100644
--- a/src/tests/comparison/MarkdownSourceComponent.spec.ts
+++ b/src/tests/comparison/MarkdownSourceComponent.spec.ts
@@ -3,7 +3,10 @@
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
-import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceComparison from '../../components/MarkdownSourceComparison.vue'
+import { SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
import {
COMPLETE_SOURCE_DISPLAY_LIMITS,
displayBoundedMarkdownSource,
@@ -64,4 +67,121 @@ describe('Markdown source component', () => {
expect(result.text.isWellFormed()).toBe(true)
expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
})
+
+ it('shows complete fallback immediately, then enhanced literal hunks', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: 'old\t \n', afterContent: 'new\u200B\n', layoutMode: 'paired' },
+ })
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+ expect(wrapper.text()).toContain('old')
+ expect(wrapper.text()).toContain('new⟦ZWSP⟧')
+ })
+
+ it('AUD-05 exposes side, operation, whitespace, EOL, and missing-newline semantics', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: `old${String.fromCharCode(9)}\r\ntrail `,
+ afterContent: 'new\ntrail\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.find('[data-source-side="before"]').text()).toBe('Before')
+ expect(wrapper.find('[data-source-side="after"]').text()).toBe('After')
+ expect(wrapper.find('[data-source-operation="removed"]').attributes('aria-label')).toContain('Removed line')
+ expect(wrapper.find('[data-source-operation="added"]').attributes('aria-label')).toContain('Added line')
+ expect(wrapper.find('[data-source-operation="removed"] [data-source-cue]').text()).toBe('−')
+ expect(wrapper.find('[data-source-operation="added"] [data-source-cue]').text()).toBe('+')
+ for (const token of ['TAB', 'CRLF', 'LF', '2 TRAILING SPACES', 'No newline at end of file']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ })
+
+ it('omits per-line badges when paired line endings match', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: 'old\nunchanged\n',
+ afterContent: 'new\nunchanged\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.findAll('[data-source-eol]')).toHaveLength(0)
+ })
+
+ it('AUD-13 renders the audited bidi and control set as visible inert source tokens', async () => {
+ const controls = '\u061C\u00AD\u200E\u200F\u0085\u2028\u2029'
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: controls, afterContent: '', layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ for (const token of ['ALM', 'SHY', 'LRM', 'RLM', 'NEL', 'LS', 'PS']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ for (const control of controls) {
+ expect(wrapper.text()).not.toContain(control)
+ }
+ })
+
+ it('AUD-08 expands a large unchanged gap incrementally with observable source ranges', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('.text-source-comparison__gap button')).toHaveLength(2))
+
+ await wrapper.findAll('[data-source-gap-toggle]')[0]!.trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows + 7)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}`)
+ expect(wrapper.text()).not.toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 + 7)
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+ })
+
+ it('AUD-08 never expands gaps beyond the shared displayed-row ceiling', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('[data-source-gap-toggle]')).toHaveLength(2))
+
+ for (const toggle of wrapper.findAll('[data-source-gap-toggle]')) {
+ await toggle.trigger('click')
+ while (wrapper.find('[data-source-gap-more]').exists()) {
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+ }
+ }
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumDisplayedRows)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain('suffix-3')
+ expect(wrapper.text()).not.toContain('suffix-2999')
+ expect(wrapper.find('[data-source-gap-limited]').exists()).toBe(true)
+ }, 15_000)
+
+ it('V11 preserves bounded complete fallback when source enhancement is limited', async () => {
+ const beforeContent = 'x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1)
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent: 'after', layoutMode: 'single' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-limited]').exists()).toBe(true))
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ expect(wrapper.find('pre code').text()).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(wrapper.findAll('[role="status"]').map((status) => status.text()).join(' ')).toContain('truncated')
+ })
})
diff --git a/src/tests/comparison/createMarkdownContentComparison.spec.ts b/src/tests/comparison/createMarkdownContentComparison.spec.ts
index 6f996066ae5..53c3fd57479 100644
--- a/src/tests/comparison/createMarkdownContentComparison.spec.ts
+++ b/src/tests/comparison/createMarkdownContentComparison.spec.ts
@@ -30,6 +30,26 @@ afterAll(() => {
afterEach(() => vi.restoreAllMocks())
describe('Markdown comparison factory fallback and lifecycle', () => {
+ it('V09 reports syntax-only Markdown as no semantic edit and opens Source', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '*same rendered text*',
+ afterContent: '_same rendered text_',
+ el,
+ })
+
+ expect(el.querySelectorAll('[data-comparison-change]')).toHaveLength(0)
+ expect(el.querySelector('[role="status"]')?.textContent).toContain('No rendered differences')
+ const openSource = el.querySelector('[data-comparison-empty-action]')
+ expect(openSource).not.toBeNull()
+ openSource!.click()
+ await nextTick()
+ expect([...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Markdown source')
+ ?.getAttribute('aria-selected')).toBe('true')
+ instance.destroy()
+ })
+
it('F05 remounts complete Source when rendered editor initialization fails', async () => {
vi.spyOn(Editor.prototype, 'mount').mockImplementation(() => {
throw new Error('forced mount failure')
diff --git a/src/tests/comparison/markdownSourceComparison.spec.ts b/src/tests/comparison/markdownSourceComparison.spec.ts
new file mode 100644
index 00000000000..3af9ec62b96
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparison.spec.ts
@@ -0,0 +1,214 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceDiffHunk, SourceDiffLine } from '../../comparison/markdownSourceComparison.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createMarkdownSourceComparison, materializeSourceDiffGap, SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import { compareMarkdownSourceLines } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('literal Markdown source comparison', () => {
+ const lines = (hunks: readonly SourceDiffHunk[], side: 'before' | 'after') => hunks
+ .flatMap(({ rows }) => rows.flatMap((row) => row[side] ? [row[side]] : []))
+
+ it('V10 normalizes EOL only for matching while retaining literal line facts', async () => {
+ const model = await createMarkdownSourceComparison('tab\tvalue \r\nzero\u200Bwidth\nlast', 'tab value \nzero width\nlast\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const before = lines(model.hunks, 'before')
+ const after = lines(model.hunks, 'after')
+ expect(before[0]).toMatchObject({ text: 'tab\tvalue ', eol: 'crlf' })
+ expect(before.some(({ text }) => text.includes('\u200b'))).toBe(true)
+ expect(before.at(-1)?.eol).toBe('none')
+ expect(after.at(-1)?.eol).toBe('lf')
+ })
+
+ it('AUD-14 materializes stable paired row records with the source model', async () => {
+ const model = await createMarkdownSourceComparison('old\nsame\n', 'new\nsame\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const hunk = model.hunks[0]!
+
+ expect(hunk.rows.map(({ before, after }) => [before?.text, after?.text])).toEqual([['old', 'new'], ['same', 'same']])
+ expect(hunk.rows).toBe(hunk.rows)
+ })
+
+ it('AUD-08 represents large collapsed gaps without retained line clones', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+
+ expect(model.gaps).toEqual([{
+ id: 'source-gap-0',
+ slot: 0,
+ beforeFrom: 0,
+ beforeTo: 10_000,
+ afterFrom: 0,
+ afterTo: 10_000,
+ count: 10_000,
+ }])
+ })
+
+ it('AUD-08 materializes large gaps in bounded observable pages', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const gap = model.gaps[0]!
+
+ const firstPage = materializeSourceDiffGap(source, source, gap, Number.POSITIVE_INFINITY)
+ const secondPage = materializeSourceDiffGap(source, source, gap, SOURCE_DIFF_LIMITS.maximumGapPageRows, SOURCE_DIFF_LIMITS.maximumGapPageRows)
+
+ expect(firstPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(firstPage[0]?.before).toMatchObject({ number: 1, text: 'line 0' })
+ expect(firstPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}` })
+ expect(secondPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(secondPage[0]?.before).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows + 1, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows}` })
+ expect(secondPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows * 2, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 - 1}` })
+ })
+
+ it('falls back when visible controls exceed the source display limit', async () => {
+ const source = `${'\t'.repeat(200_000)}😀`
+
+ await expect(createMarkdownSourceComparison(source, source)).resolves.toEqual({
+ status: 'limited',
+ reason: 'size',
+ })
+ })
+
+ it('retains complete literal lines when only line endings differ', async () => {
+ const beforeSource = 'same\r\nbytes\r\n'
+ const afterSource = 'same\nbytes\n'
+ const model = await createMarkdownSourceComparison(beforeSource, afterSource)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(model.hunks).toEqual([])
+ expect(model.gaps).toHaveLength(1)
+ const rows = materializeSourceDiffGap(beforeSource, afterSource, model.gaps[0]!)
+ expect(rows.map(({ before }: { before?: SourceDiffLine }) => ({ text: before?.text, eol: before?.eol }))).toEqual([
+ { text: 'same', eol: 'crlf' },
+ { text: 'bytes', eol: 'crlf' },
+ ])
+ expect(rows.map(({ after }: { after?: SourceDiffLine }) => ({ text: after?.text, eol: after?.eol }))).toEqual([
+ { text: 'same', eol: 'lf' },
+ { text: 'bytes', eol: 'lf' },
+ ])
+ })
+
+ it('keeps syntax-only and HTML-like changes as literal text', async () => {
+ const model = await createMarkdownSourceComparison('# Heading\n', '# Heading #\n![]()
')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(lines(model.hunks, 'before').map(({ text }) => text)).toContain('')
+ expect(lines(model.hunks, 'after').map(({ text }) => text)).toContain('![]()
')
+ })
+
+ it('reports limits and aborts without losing the caller fallback contract', async () => {
+ await expect(createMarkdownSourceComparison('x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1), ''))
+ .resolves.toEqual({ status: 'limited', reason: 'size' })
+ const controller = new AbortController()
+ controller.abort()
+ await expect(createMarkdownSourceComparison('before', 'after', controller.signal)).rejects.toMatchObject({ name: 'AbortError' })
+ })
+
+ it('V11 terminates an in-flight worker when the caller aborts', async () => {
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {}
+ terminate() { terminate() }
+ })
+ const controller = new AbortController()
+ const comparison = createMarkdownSourceComparison('before', 'after', controller.signal)
+ controller.abort()
+ await expect(comparison).rejects.toMatchObject({ name: 'AbortError' })
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('terminates the worker when posting the comparison request throws', async () => {
+ const failure = new Error('post failure')
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {
+ throw failure
+ }
+
+ terminate() { terminate() }
+ })
+
+ await expect(createMarkdownSourceComparison('before', 'after')).rejects.toBe(failure)
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects message decoding errors once and ignores a late success', async () => {
+ const workers: Array<{ onmessage?: EventListener, onmessageerror?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ onmessageerror?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ expect(workers[0]!.onmessageerror).toBeTypeOf('function')
+ workers[0]!.onmessageerror!(new MessageEvent('messageerror'))
+ workers[0]!.onmessage!(new MessageEvent('message', { data: { status: 'ready', changes: [] } }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects malformed worker responses after cleanup', async () => {
+ const workers: Array<{ onmessage?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ workers[0]!.onmessage!(new MessageEvent('message', { data: null }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('uses the same bounded line protocol for main-thread and worker paths', () => {
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 }))
+ .toMatchObject({ status: 'ready' })
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 }))
+ .toEqual({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparisonWorker.spec.ts b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
new file mode 100644
index 00000000000..031caf28ae2
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceComparisonWorkerRequest } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+afterEach(() => {
+ vi.resetModules()
+ vi.unstubAllGlobals()
+})
+
+describe('Markdown source comparison worker', () => {
+ it('delegates ready and limited messages to the shared protocol', async () => {
+ let listener: ((event: MessageEvent) => void) | undefined
+ const postMessage = vi.fn()
+ vi.stubGlobal('addEventListener', vi.fn((_type, callback) => {
+ listener = callback
+ }))
+ vi.stubGlobal('postMessage', postMessage)
+ await import('../../comparison/markdownSourceComparison.worker.ts')
+ expect(listener).toBeTypeOf('function')
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ready' }))
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith({ status: 'limited' })
+ })
+})
diff --git a/src/tests/playwrightConfig.spec.ts b/src/tests/playwrightConfig.spec.ts
new file mode 100644
index 00000000000..3811aa2248e
--- /dev/null
+++ b/src/tests/playwrightConfig.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const originalComparisonBaseURL = process.env.TEXT_COMPARISON_BASE_URL
+const originalComparisonE2E = process.env.TEXT_COMPARISON_E2E
+const originalBaseURL = process.env.baseURL
+
+afterEach(() => {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', originalComparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', originalComparisonE2E)
+ setEnvironment('baseURL', originalBaseURL)
+})
+
+function setEnvironment(name: string, value: string | undefined) {
+ if (value === undefined) {
+ delete process.env[name]
+ } else {
+ process.env[name] = value
+ }
+}
+
+async function loadConfig(comparisonBaseURL: string | undefined, baseURL: string | undefined, comparisonE2E?: string) {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', comparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', comparisonE2E)
+ setEnvironment('baseURL', baseURL)
+ vi.resetModules()
+ return (await import('../../playwright.config.ts')).default
+}
+
+describe('Playwright comparison server selection', () => {
+ it.each([
+ { name: 'unset values', comparisonBaseURL: undefined, baseURL: undefined, expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'empty values', comparisonBaseURL: '', baseURL: '', expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'generic external URL', comparisonBaseURL: '', baseURL: 'https://generic.example/index.php/', expected: 'https://generic.example/index.php/', managed: false },
+ { name: 'dedicated external URL', comparisonBaseURL: 'https://text.example/index.php/', baseURL: '', expected: 'https://text.example/index.php/', managed: false },
+ { name: 'dedicated precedence', comparisonBaseURL: 'https://text.example/index.php/', baseURL: 'https://generic.example/index.php/', expected: 'https://text.example/index.php/', managed: false },
+ ])('uses the selected URL for $name', async ({ comparisonBaseURL, baseURL, expected, managed }) => {
+ const config = await loadConfig(comparisonBaseURL, baseURL)
+
+ expect(config.use?.baseURL).toBe(expected)
+ expect(config.webServer === undefined).toBe(!managed)
+ })
+
+ it('routes comparison and memory tests to their dedicated projects', async () => {
+ const config = await loadConfig(undefined, undefined, '1')
+ const projects = config.projects ?? []
+ const byName = new Map(projects.map((project) => [project.name, project]))
+ const comparisonNames = [
+ 'comparison-chromium',
+ 'comparison-webkit',
+ 'comparison-chromium-memory',
+ ]
+
+ expect(projects.map(({ name }) => name)).toEqual(['chromium', ...comparisonNames])
+ for (const name of comparisonNames) {
+ const match = byName.get(name)?.testMatch
+ expect(match).toBeInstanceOf(RegExp)
+ expect((match as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((match as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ }
+ for (const name of comparisonNames.slice(0, 2)) {
+ expect(byName.get(name)?.grepInvert).toEqual(/@memory/)
+ expect(byName.get(name)?.grep).toBeUndefined()
+ }
+ expect(byName.get('comparison-chromium-memory')?.grep).toEqual(/@memory/)
+ expect(byName.get('comparison-chromium-memory')?.grepInvert).toBeUndefined()
+ const ordinaryIgnore = byName.get('chromium')?.testIgnore
+ expect(ordinaryIgnore).toBeInstanceOf(RegExp)
+ expect((ordinaryIgnore as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((ordinaryIgnore as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ })
+})
diff --git a/vite.config.ts b/vite.config.ts
index 1830d335ca4..5d930dd6f08 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -50,6 +50,15 @@ const config = createAppConfig(
},
config: {
base: process.env.BASE,
+ worker: {
+ rollupOptions: {
+ output: {
+ assetFileNames: 'js/[name]-[hash][extname]',
+ chunkFileNames: 'js/[name]-[hash].worker.chunk.mjs',
+ entryFileNames: 'js/[name]-[hash].worker.mjs',
+ },
+ },
+ },
resolve: {
dedupe: ['vue'],
},