import { expect, test, type Browser, type Page } from '@playwright/test'

import { strToU8, zipSync } from 'fflate'

import {

ANONYMOUS_STATE,

OWNER,

completeStepUp,

createPage,

login,

loginAs,

openLayersPanel,

openSiteEditor,

saveDraft,

setPropValue,

canvasFrame,

insertNotchModule,

} from './helpers'

const PNG_1X1 = Buffer.from(

'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',

'base64',

)

interface PersonaAccount {

roleName: string

email: string

password: string

}

test.describe.serial('capability boundaries', () => {

test.use({ storageState: ANONYMOUS_STATE })

test.setTimeout(180_000)

const suffix = Date.now().toString(36)

const seededText = `Capability seed ${suffix}`

const secondText = `Capability spare ${suffix}`

const contentText = `Content persona copy ${suffix}`

const styleClass = `cap-style-${suffix}`

let pageName = ''

const personas: Record<'content' | 'style' | 'structure', PersonaAccount> = {

content: {

roleName: `CAP Content ${suffix}`,

email: `cap-content-${suffix}@example.com`,

password: 'cap-content-pass-12345',

},

style: {

roleName: `CAP Style ${suffix}`,

email: `cap-style-${suffix}@example.com`,

password: 'cap-style-pass-12345',

},

structure: {

roleName: `CAP Structure ${suffix}`,

email: `cap-structure-${suffix}@example.com`,

password: 'cap-structure-pass-12345',

},

}

test.beforeAll(async ({ browser }, testInfo) => {

testInfo.setTimeout(180_000)

const context = await browser.newContext()

const ownerPage = await context.newPage()

try {

await login(ownerPage)

pageName = await seedCapabilityPage(ownerPage, suffix, seededText, secondText)

await createRole(ownerPage, personas.content.roleName, [

'View site',

'Edit site content',

])

await createRole(ownerPage, personas.style.roleName, [

'View site',

'Edit site styles',

])

await createRole(ownerPage, personas.structure.roleName, [

'View site',

'Edit site structure',

'Edit pages',

])

for (const persona of Object.values(personas)) {

await createUser(ownerPage, {

email: persona.email,

displayName: persona.roleName,

password: persona.password,

role: persona.roleName,

})

}

} finally {

await context.close()

}

})

test('content editor can edit copy but not style or structure (CAP-002)', async ({

browser,

}) => {

await withPersona(browser, personas.content, async (personaPage) => {

await openNamedPage(personaPage, pageName)

await canvasFrame(personaPage).getByText(seededText, { exact: true }).click()

await setPropValue(personaPage, 'text', contentText)

await expectAbsentOrDisabled(personaPage.getByTestId('canvas-notch-text-btn'))

await expect(

personaPage.getByText('Styles are read-only for your role'),

).toBeVisible()

await saveDraft(personaPage)

await personaPage.reload()

await openNamedPage(personaPage, pageName)

await expect(

canvasFrame(personaPage).getByText(contentText, { exact: true }),

).toBeVisible()

})

})

test('style editor can edit CSS but not copy (CAP-002)', async ({ browser }) => {

await withPersona(browser, personas.style, async (personaPage) => {

await openNamedPage(personaPage, pageName)

const editableText = canvasFrame(personaPage).getByText(contentText, { exact: true })

await editableText.click()

await expect(personaPage.getByTestId('property-control-text')).toHaveAttribute(

'data-disabled',

'true',

)

await personaPage.getByTestId('class-picker-input').fill(styleClass)

await personaPage.getByTestId('class-picker-submit').click()

await expect(personaPage.getByTestId(`class-chip-${styleClass}`)).toBeVisible()

await personaPage.getByLabel('Search class style properties to add').fill('font size')

const fontSizeInput = personaPage

.getByTestId('css-property-row-fontSize')

.getByLabel('Font size')

await fontSizeInput.fill('23px')

await fontSizeInput.blur()

await expect(editableText).toHaveCSS('font-size', '23px')

await saveDraft(personaPage)

await personaPage.reload()

await openNamedPage(personaPage, pageName)

const reloadedText = canvasFrame(personaPage).getByText(contentText, { exact: true })

await reloadedText.click()

await expect(reloadedText).toHaveCSS('font-size', '23px')

})

})

test('structure editor can insert layers but not edit copy (CAP-002)', async ({

browser,

}) => {

await withPersona(browser, personas.structure, async (personaPage) => {

await openNamedPage(personaPage, pageName)

await canvasFrame(personaPage).getByText(contentText, { exact: true }).click()

await expect(personaPage.getByTestId('property-control-text')).toHaveAttribute(

'data-disabled',

'true',

)

await openLayersPanel(personaPage)

const tree = personaPage.getByRole('tree', { name: 'Page element tree' })

await expect(tree.getByRole('treeitem', { name: 'Text' })).toHaveCount(2)

await insertNotchModule(personaPage, 'text')

await expect(tree.getByRole('treeitem', { name: 'Text' })).toHaveCount(3)

await saveDraft(personaPage)

await personaPage.reload()

await openNamedPage(personaPage, pageName)

await openLayersPanel(personaPage)

await expect(

personaPage

.getByRole('tree', { name: 'Page element tree' })

.getByRole('treeitem', { name: 'Text' }),

).toHaveCount(3)

})

})

})

test.describe.serial('media capability boundaries', () => {

test.use({ storageState: ANONYMOUS_STATE })

test.setTimeout(180_000)

const suffix = Date.now().toString(36)

const seededFilename = `cap-media-seed-${suffix}.png`

const writerFilename = `cap-media-writer-${suffix}.png`

const replaceOriginalFilename = `cap-media-replace-original-${suffix}.png`

const replaceNextFilename = `cap-media-replace-next-${suffix}.png`

const deleteFilename = `cap-media-delete-${suffix}.png`

const personas: Record<'reader' | 'writer' | 'replacer' | 'deleter', PersonaAccount> = {

reader: {

roleName: `CAP Media Reader ${suffix}`,

email: `cap-media-reader-${suffix}@example.com`,

password: 'cap-media-reader-pass-12345',

},

writer: {

roleName: `CAP Media Writer ${suffix}`,

email: `cap-media-writer-${suffix}@example.com`,

password: 'cap-media-writer-pass-12345',

},

replacer: {

roleName: `CAP Media Replacer ${suffix}`,

email: `cap-media-replacer-${suffix}@example.com`,

password: 'cap-media-replacer-pass-12345',

},

deleter: {

roleName: `CAP Media Deleter ${suffix}`,

email: `cap-media-deleter-${suffix}@example.com`,

password: 'cap-media-deleter-pass-12345',

},

}

test.beforeAll(async ({ browser }, testInfo) => {

testInfo.setTimeout(180_000)

const context = await browser.newContext()

const ownerPage = await context.newPage()

try {

await login(ownerPage)

await ownerPage.goto('/admin/media')

await uploadMediaFile(ownerPage, seededFilename)

await uploadMediaFile(ownerPage, replaceOriginalFilename)

await uploadMediaFile(ownerPage, deleteFilename)

await createRole(ownerPage, personas.reader.roleName, ['Browse media library'])

await createRole(ownerPage, personas.writer.roleName, [

'Browse media library',

'Upload and edit media',

])

await createRole(ownerPage, personas.replacer.roleName, [

'Browse media library',

'Replace media bytes',

])

await createRole(ownerPage, personas.deleter.roleName, [

'Browse media library',

'Delete media',

])

for (const persona of Object.values(personas)) {

await createUser(ownerPage, {

email: persona.email,

displayName: persona.roleName,

password: persona.password,

role: persona.roleName,

})

}

} finally {

await context.close()

}

})

test('media reader can browse without write/replace/delete controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.reader, async (personaPage) => {

await openMediaWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload media' })).toHaveCount(0)

const asset = personaPage.getByRole('button', { name: `Open ${seededFilename}` })

await expect(asset).toBeVisible()

await asset.click({ button: 'right' })

const menu = personaPage.getByRole('menu', { name: 'Media item options' })

await expect(menu.getByText('Copy URL')).toBeVisible()

await expect(menu.getByText('Rename')).toHaveCount(0)

await expect(menu.getByText('Delete')).toHaveCount(0)

await personaPage.keyboard.press('Escape')

await asset.click()

const viewer = personaPage.getByTestId('media-viewer-window')

await expect(viewer).toBeVisible()

await expect(viewer.getByLabel('Title')).toBeDisabled()

await expect(viewer.getByLabel('Filename')).toBeDisabled()

await expect(viewer.getByRole('button', { name: 'Replace file' })).toHaveCount(0)

})

})

test('media writer can upload and edit metadata without replace/delete controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.writer, async (personaPage) => {

await openMediaWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload media' })).toBeVisible()

await uploadMediaFile(personaPage, writerFilename)

const asset = personaPage.getByRole('button', { name: `Open ${writerFilename}` })

await expect(asset).toBeVisible()

await asset.click({ button: 'right' })

const menu = personaPage.getByRole('menu', { name: 'Media item options' })

await expect(menu.getByText('Rename')).toBeVisible()

await expect(menu.getByText('Delete')).toHaveCount(0)

await personaPage.keyboard.press('Escape')

await asset.click()

const viewer = personaPage.getByTestId('media-viewer-window')

await expect(viewer).toBeVisible()

await expect(viewer.getByLabel('Title')).toBeEnabled()

await expect(viewer.getByLabel('Filename')).toBeEnabled()

await expect(viewer.getByRole('button', { name: 'Replace file' })).toHaveCount(0)

})

})

test('media replacer can replace bytes without metadata or delete controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.replacer, async (personaPage) => {

await openMediaWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload media' })).toHaveCount(0)

const asset = personaPage.getByRole('button', { name: `Open ${replaceOriginalFilename}` })

await expect(asset).toBeVisible()

await asset.click({ button: 'right' })

const menu = personaPage.getByRole('menu', { name: 'Media item options' })

await expect(menu.getByText('Copy URL')).toBeVisible()

await expect(menu.getByText('Rename')).toHaveCount(0)

await expect(menu.getByText('Delete')).toHaveCount(0)

await personaPage.keyboard.press('Escape')

await asset.click()

const viewer = personaPage.getByRole('dialog', { name: `Viewer: ${replaceOriginalFilename}` })

await expect(viewer).toBeVisible()

await expect(viewer.getByLabel('Title')).toBeDisabled()

await expect(viewer.getByLabel('Filename')).toBeDisabled()

await viewer.getByRole('button', { name: 'Replace file' }).click()

const replaceDialog = personaPage.getByRole('dialog', { name: 'Replace file' })

await expect(replaceDialog).toBeVisible()

await replaceDialog

.locator('input[type="file"]')

.setInputFiles({ name: replaceNextFilename, mimeType: 'image/png', buffer: PNG_1X1 })

await expect(replaceDialog.getByRole('status')).toContainText(replaceNextFilename)

await Promise.all([

waitForMediaReplace(personaPage),

replaceDialog.getByRole('button', { name: 'Replace file' }).click(),

])

await expect(replaceDialog).toBeHidden()

const replacedViewer = personaPage.getByRole('dialog', { name: `Viewer: ${replaceNextFilename}` })

await expect(replacedViewer).toBeVisible()

await expect(replacedViewer).toContainText('Replaced')

await expect(personaPage.getByRole('button', { name: `Open ${replaceNextFilename}` })).toBeVisible()

})

})

test('media deleter can trash and purge without upload or replace controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.deleter, async (personaPage) => {

await openMediaWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload media' })).toHaveCount(0)

const asset = personaPage.getByRole('button', { name: `Open ${deleteFilename}` })

await expect(asset).toBeVisible()

await asset.click()

const viewer = personaPage.getByRole('dialog', { name: `Viewer: ${deleteFilename}` })

await expect(viewer).toBeVisible()

await expect(viewer.getByLabel('Title')).toBeDisabled()

await expect(viewer.getByLabel('Filename')).toBeDisabled()

await expect(viewer.getByRole('button', { name: 'Replace file' })).toHaveCount(0)

await viewer.getByRole('button', { name: `Close ${deleteFilename} panel` }).click()

await asset.click({ button: 'right' })

const activeMenu = personaPage.getByRole('menu', { name: 'Media item options' })

await expect(activeMenu.getByText('Rename')).toHaveCount(0)

await expect(activeMenu.getByRole('menuitem', { name: 'Delete' })).toBeVisible()

await Promise.all([

waitForMediaDelete(personaPage),

activeMenu.getByRole('menuitem', { name: 'Delete' }).click(),

])

await expect(personaPage.getByRole('button', { name: `Open ${deleteFilename}` })).toHaveCount(0)

await personaPage.getByTestId('media-folder-row-trash').click()

const trashedAsset = personaPage.getByRole('button', { name: `Open ${deleteFilename}` })

await expect(trashedAsset).toBeVisible()

await trashedAsset.click({ button: 'right' })

const trashMenu = personaPage.getByRole('menu', { name: 'Media item options' })

await expect(trashMenu.getByText('Restore')).toHaveCount(0)

await expect(trashMenu.getByRole('menuitem', { name: 'Delete' })).toBeVisible()

await Promise.all([

waitForMediaDelete(personaPage),

trashMenu.getByRole('menuitem', { name: 'Delete' }).click(),

])

await expect(personaPage.getByRole('button', { name: `Open ${deleteFilename}` })).toHaveCount(0)

await expect(personaPage.getByText('Trash is empty')).toBeVisible()

})

})

})

test.describe.serial('data capability boundaries', () => {

test.use({ storageState: ANONYMOUS_STATE })

test.setTimeout(180_000)

const suffix = Date.now().toString(36)

const tableName = `Capability Records ${suffix}`

const personas: Record<'reader' | 'manager' | 'exporter' | 'importer', PersonaAccount> = {

reader: {

roleName: `CAP Data Reader ${suffix}`,

email: `cap-data-reader-${suffix}@example.com`,

password: 'cap-data-reader-pass-12345',

},

manager: {

roleName: `CAP Data Manager ${suffix}`,

email: `cap-data-manager-${suffix}@example.com`,

password: 'cap-data-manager-pass-12345',

},

exporter: {

roleName: `CAP Data Exporter ${suffix}`,

email: `cap-data-exporter-${suffix}@example.com`,

password: 'cap-data-exporter-pass-12345',

},

importer: {

roleName: `CAP Data Importer ${suffix}`,

email: `cap-data-importer-${suffix}@example.com`,

password: 'cap-data-importer-pass-12345',

},

}

test.beforeAll(async ({ browser }, testInfo) => {

testInfo.setTimeout(180_000)

const context = await browser.newContext()

const ownerPage = await context.newPage()

try {

await login(ownerPage)

await createCustomDataTable(ownerPage, tableName)

await createRole(ownerPage, personas.reader.roleName, ['Browse custom tables'])

await createRole(ownerPage, personas.manager.roleName, ['Manage custom tables'])

await createRole(ownerPage, personas.exporter.roleName, [

'Browse custom tables',

'Export data bundles',

])

await createRole(ownerPage, personas.importer.roleName, [

'Browse custom tables',

'Import data bundles',

])

for (const persona of Object.values(personas)) {

await createUser(ownerPage, {

email: persona.email,

displayName: persona.roleName,

password: persona.password,

role: persona.roleName,

})

}

} finally {

await context.close()

}

})

test('custom table reader can browse without manage or transfer controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.reader, async (personaPage) => {

await openDataWorkspace(personaPage)

await expectDataTableVisible(personaPage, tableName)

await expect(personaPage.getByText('System', { exact: true })).toHaveCount(0)

await expect(personaPage.getByRole('alert')).toHaveCount(0)

await expect(personaPage.getByRole('button', { name: 'New table' })).toHaveCount(0)

await expect(personaPage.getByRole('button', { name: 'Export site' })).toHaveCount(0)

await expect(personaPage.getByRole('button', { name: 'Import site' })).toHaveCount(0)

})

})

test('custom table manager can create tables without import/export controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.manager, async (personaPage) => {

await openDataWorkspace(personaPage)

await expectDataTableVisible(personaPage, tableName)

await expect(personaPage.getByRole('button', { name: 'New table' })).toBeVisible()

await expect(personaPage.getByRole('button', { name: 'Export site' })).toHaveCount(0)

await expect(personaPage.getByRole('button', { name: 'Import site' })).toHaveCount(0)

})

})

test('data exporter sees export but not import or schema creation controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.exporter, async (personaPage) => {

await openDataWorkspace(personaPage)

await expectDataTableVisible(personaPage, tableName)

await expect(personaPage.getByRole('button', { name: 'New table' })).toHaveCount(0)

await expect(personaPage.getByRole('button', { name: 'Import site' })).toHaveCount(0)

await personaPage.getByRole('button', { name: 'Export site' }).click()

await expect(personaPage.getByRole('dialog', { name: 'Export site' })).toBeVisible()

})

})

test('data importer sees import but not export or schema creation controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.importer, async (personaPage) => {

await openDataWorkspace(personaPage)

await expectDataTableVisible(personaPage, tableName)

await expect(personaPage.getByRole('button', { name: 'New table' })).toHaveCount(0)

await expect(personaPage.getByRole('button', { name: 'Export site' })).toHaveCount(0)

await personaPage.getByRole('button', { name: 'Import site' }).click()

await expect(personaPage.getByRole('dialog', { name: 'Import site' })).toBeVisible()

})

})

})

test.describe.serial('content row move capability boundaries', () => {

test.use({ storageState: ANONYMOUS_STATE })

test.setTimeout(180_000)

const suffix = Date.now().toString(36)

const sourceCollectionName = `CAP Source ${suffix}`

const targetCollectionName = `CAP Target ${suffix}`

const entryTitle = `CAP movable entry ${suffix}`

const personas: Record<'editor' | 'mover', PersonaAccount> = {

editor: {

roleName: `CAP Content Editor ${suffix}`,

email: `cap-content-editor-${suffix}@example.com`,

password: 'cap-content-editor-pass-12345',

},

mover: {

roleName: `CAP Content Mover ${suffix}`,

email: `cap-content-mover-${suffix}@example.com`,

password: 'cap-content-mover-pass-12345',

},

}

test.beforeAll(async ({ browser }, testInfo) => {

testInfo.setTimeout(180_000)

const context = await browser.newContext()

const ownerPage = await context.newPage()

try {

await login(ownerPage)

await createContentCollection(ownerPage, sourceCollectionName, 'Source item')

await createContentCollection(ownerPage, targetCollectionName, 'Target item')

await createContentEntry(ownerPage, sourceCollectionName, 'Source item', entryTitle)

await createRole(ownerPage, personas.editor.roleName, ['Edit any content'])

await createRole(ownerPage, personas.mover.roleName, [

'Edit any content',

'Move rows between tables',

])

for (const persona of Object.values(personas)) {

await createUser(ownerPage, {

email: persona.email,

displayName: persona.roleName,

password: persona.password,

role: persona.roleName,

})

}

} finally {

await context.close()

}

})

test('content editor without row-move capability cannot see move controls (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.editor, async (personaPage) => {

await openContentWorkspace(personaPage)

await selectContentCollection(personaPage, sourceCollectionName)

const entry = contentEntryRow(personaPage, entryTitle)

await expect(entry).toBeVisible()

await entry.click({ button: 'right' })

const menu = personaPage.getByRole('menu', { name: 'Content item options' })

await expect(menu).toBeVisible()

await expect(

menu.getByRole('menuitem', { name: 'Move to collection' }),

).toHaveCount(0)

})

})

test('content mover can move an entry between collections (CAP-004)', async ({

browser,

}) => {

await withPersona(browser, personas.mover, async (personaPage) => {

await openContentWorkspace(personaPage)

await selectContentCollection(personaPage, sourceCollectionName)

const entry = contentEntryRow(personaPage, entryTitle)

await expect(entry).toBeVisible()

await entry.click({ button: 'right' })

const menu = personaPage.getByRole('menu', { name: 'Content item options' })

await menu.getByRole('menuitem', { name: 'Move to collection' }).hover()

await personaPage.getByRole('menuitem', { name: targetCollectionName }).click()

await expect(menu).toBeHidden()

await expect(contentEntryRow(personaPage, entryTitle)).toHaveCount(0)

await selectContentCollection(personaPage, targetCollectionName)

await expect(contentEntryRow(personaPage, entryTitle)).toBeVisible({

timeout: 20_000,

})

})

})

})

test.describe.serial('site import step-up boundaries', () => {

test.use({ storageState: ANONYMOUS_STATE })

test.setTimeout(180_000)

test('destructive site import requires successful step-up before mutating (CAP-003)', async ({

browser,

}) => {

const suffix = Date.now().toString(36)

const bundledTableName = `CAP Imported Bundle ${suffix}`

const localTableName = `CAP Local Table ${suffix}`

let bundle: unknown

const setupContext = await browser.newContext()

const setupPage = await setupContext.newPage()

try {

await login(setupPage)

await createCustomDataTable(setupPage, bundledTableName)

bundle = await exportCmsBundle(setupPage)

await createCustomDataTable(setupPage, localTableName)

} finally {

await setupContext.close()

}

const context = await browser.newContext()

const page = await context.newPage()

try {

await login(page)

await openDataWorkspace(page)

await expectDataTableVisible(page, bundledTableName)

await expectDataTableVisible(page, localTableName)

await openReplaceImportReview(page, bundle, `cap-replace-${suffix}.json`)

await page.getByRole('button', { name: 'Replace site' }).click()

const stepUpDialog = page.getByTestId('step-up-dialog')

await expect(stepUpDialog).toBeVisible()

await stepUpDialog.getByRole('button', { name: 'Cancel' }).click()

await expect(stepUpDialog).toBeHidden()

await closeImportReview(page)

await expectDataTablePresence(page, localTableName, true)

await openReplaceImportReview(page, bundle, `cap-replace-retry-${suffix}.json`)

await page.getByRole('button', { name: 'Replace site' }).click()

await expect(stepUpDialog).toBeVisible()

await page.getByTestId('step-up-password').fill('wrong-password-12345')

await page.getByTestId('step-up-confirm').click()

await expect(stepUpDialog.getByRole('alert')).toBeVisible()

await expectDataTablePresence(page, localTableName, true)

await page.getByTestId('step-up-password').fill(OWNER.password)

await page.getByTestId('step-up-confirm').click()

await expect(stepUpDialog).toBeHidden({ timeout: 20_000 })

await expect(siteImportDialog(page, 'Review bundle')).toHaveCount(0)

await expectDataTablePresence(page, bundledTableName, true)

await expectDataTablePresence(page, localTableName, false)

} finally {

await context.close()

}

})

})

test.describe.serial('plugin capability boundaries', () => {

test.use({ storageState: ANONYMOUS_STATE })

test.setTimeout(180_000)

const suffix = Date.now().toString(36)

const actionPluginName = `CAP Plugin Actions ${suffix}`

const automationPluginId = `cap.automation-${suffix}`

const automationPluginName = `CAP Plugin Automation ${suffix}`

const automationScheduleId = `${automationPluginId}.heartbeat`

const actionPluginManifest = {

id: `cap.actions-${suffix}`,

name: actionPluginName,

version: '1.0.0',

apiVersion: 1,

description: 'Capability fixture for plugin action visibility.',

permissions: [],

settings: [

{

id: 'mode',

label: 'Mode',

type: 'text',

default: 'draft',

},

],

}

const personas: Record<'reader' | 'installer' | 'configurator' | 'lifecycle', PersonaAccount> = {

reader: {

roleName: `CAP Plugin Reader ${suffix}`,

email: `cap-plugin-reader-${suffix}@example.com`,

password: 'cap-plugin-reader-pass-12345',

},

installer: {

roleName: `CAP Plugin Installer ${suffix}`,

email: `cap-plugin-installer-${suffix}@example.com`,

password: 'cap-plugin-installer-pass-12345',

},

configurator: {

roleName: `CAP Plugin Configurator ${suffix}`,

email: `cap-plugin-configurator-${suffix}@example.com`,

password: 'cap-plugin-configurator-pass-12345',

},

lifecycle: {

roleName: `CAP Plugin Lifecycle ${suffix}`,

email: `cap-plugin-lifecycle-${suffix}@example.com`,

password: 'cap-plugin-lifecycle-pass-12345',

},

}

test.beforeAll(async ({ browser }, testInfo) => {

testInfo.setTimeout(180_000)

const context = await browser.newContext()

const ownerPage = await context.newPage()

try {

await login(ownerPage)

await openPluginsWorkspace(ownerPage)

await installReviewedPlugin(ownerPage, actionPluginManifest, OWNER.password)

await installReviewedPluginPackage(

ownerPage,

automationPluginId,

automationPluginName,

pluginAutomationPackageFiles(automationPluginId, automationPluginName),

OWNER.password,

)

await createRole(ownerPage, personas.reader.roleName, ['Browse installed plugins'])

await createRole(ownerPage, personas.installer.roleName, [

'Browse installed plugins',

'Install or uninstall plugins',

])

await createRole(ownerPage, personas.configurator.roleName, [

'Browse installed plugins',

'Configure plugins',

])

await createRole(ownerPage, personas.lifecycle.roleName, [

'Browse installed plugins',

'Plugin lifecycle control',

])

for (const persona of Object.values(personas)) {

await createUser(ownerPage, {

email: persona.email,

displayName: persona.roleName,

password: persona.password,

role: persona.roleName,

})

}

} finally {

await context.close()

}

})

test('plugin reader can browse without install controls (CAP-005)', async ({

browser,

}) => {

await withPersona(browser, personas.reader, async (personaPage) => {

await openPluginsWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload Plugin' })).toHaveCount(0)

const pluginCard = installedPluginCard(personaPage, actionPluginName)

await expect(pluginCard).toBeVisible()

await expect(

pluginCard.getByRole('button', { name: `Edit settings for ${actionPluginName}` }),

).toHaveCount(0)

await expect(

pluginCard.getByRole('button', { name: `Disable ${actionPluginName}` }),

).toHaveCount(0)

await expect(

pluginCard.getByRole('button', { name: `Remove ${actionPluginName}` }),

).toHaveCount(0)

const automationCard = installedPluginCard(personaPage, automationPluginName)

await expect(automationCard).toBeVisible()

await expectPackResyncButton(automationCard, automationPluginName, false)

await expectScheduleControls(

personaPage,

automationCard,

automationPluginName,

automationScheduleId,

false,

)

})

})

test('plugin installer can access upload controls (CAP-005)', async ({

browser,

}) => {

await withPersona(browser, personas.installer, async (personaPage) => {

await openPluginsWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload Plugin' })).toBeVisible()

const pluginCard = installedPluginCard(personaPage, actionPluginName)

await expect(

pluginCard.getByRole('button', { name: `Remove ${actionPluginName}` }),

).toBeVisible()

await expect(

pluginCard.getByRole('button', { name: `Edit settings for ${actionPluginName}` }),

).toHaveCount(0)

await expect(

pluginCard.getByRole('button', { name: `Disable ${actionPluginName}` }),

).toHaveCount(0)

const automationCard = installedPluginCard(personaPage, automationPluginName)

await expect(automationCard).toBeVisible()

await expectPackResyncButton(automationCard, automationPluginName, true)

await expect(

automationCard.getByRole('button', { name: `View schedules for ${automationPluginName}` }),

).toBeVisible()

})

})

test('plugin configurator can open settings without install or lifecycle controls (CAP-005)', async ({

browser,

}) => {

await withPersona(browser, personas.configurator, async (personaPage) => {

await openPluginsWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload Plugin' })).toHaveCount(0)

const pluginCard = installedPluginCard(personaPage, actionPluginName)

await expect(

pluginCard.getByRole('button', { name: `Edit settings for ${actionPluginName}` }),

).toBeVisible()

await expect(

pluginCard.getByRole('button', { name: `Disable ${actionPluginName}` }),

).toHaveCount(0)

await expect(

pluginCard.getByRole('button', { name: `Remove ${actionPluginName}` }),

).toHaveCount(0)

await pluginCard

.getByRole('button', { name: `Edit settings for ${actionPluginName}` })

.click()

const dialog = personaPage.getByRole('dialog', { name: actionPluginName })

await expect(dialog).toBeVisible()

await expect(dialog.getByLabel('Mode')).toHaveValue('draft')

await dialog.getByRole('button', { name: 'Cancel' }).click()

const automationCard = installedPluginCard(personaPage, automationPluginName)

await expect(automationCard).toBeVisible()

await expectPackResyncButton(automationCard, automationPluginName, false)

await expect(

automationCard.getByRole('button', { name: `View schedules for ${automationPluginName}` }),

).toBeVisible()

})

})

test('plugin lifecycle operator can toggle without install or settings controls (CAP-005)', async ({

browser,

}) => {

await withPersona(browser, personas.lifecycle, async (personaPage) => {

await openPluginsWorkspace(personaPage)

await expect(personaPage.getByRole('button', { name: 'Upload Plugin' })).toHaveCount(0)

const pluginCard = installedPluginCard(personaPage, actionPluginName)

await expect(

pluginCard.getByRole('button', { name: `Disable ${actionPluginName}` }),

).toBeVisible()

await expect(

pluginCard.getByRole('button', { name: `Edit settings for ${actionPluginName}` }),

).toHaveCount(0)

await expect(

pluginCard.getByRole('button', { name: `Remove ${actionPluginName}` }),

).toHaveCount(0)

const automationCard = installedPluginCard(personaPage, automationPluginName)

await expect(automationCard).toBeVisible()

await expectPackResyncButton(automationCard, automationPluginName, false)

await expectScheduleControls(

personaPage,

automationCard,

automationPluginName,

automationScheduleId,

true,

)

})

})

test('plugin install requires successful step-up before mutating (CAP-003)', async ({

browser,

}) => {

await withPersona(browser, personas.installer, async (personaPage) => {

await openPluginsWorkspace(personaPage)

const pluginName = `CAP Step-Up Plugin ${suffix}`

await uploadPluginManifest(personaPage, {

id: `cap.stepup-${suffix}`,

name: pluginName,

version: '1.0.0',

apiVersion: 1,

permissions: [],

})

await expect(

personaPage.getByRole('heading', { name: `Review ${pluginName}` }),

).toBeVisible()

await expect(installedPluginHeading(personaPage, pluginName)).toHaveCount(0)

await personaPage.getByRole('button', { name: 'Approve and Install' }).click()

const stepUpDialog = personaPage.getByTestId('step-up-dialog')

await expect(stepUpDialog).toBeVisible()

await stepUpDialog.getByRole('button', { name: 'Cancel' }).click()

await expect(stepUpDialog).toBeHidden()

await expect(installedPluginHeading(personaPage, pluginName)).toHaveCount(0)

await personaPage.getByRole('button', { name: 'Approve and Install' }).click()

await expect(stepUpDialog).toBeVisible()

await personaPage.getByTestId('step-up-password').fill('wrong-password-12345')

await personaPage.getByTestId('step-up-confirm').click()

await expect(stepUpDialog.getByRole('alert')).toBeVisible()

await expect(installedPluginHeading(personaPage, pluginName)).toHaveCount(0)

await personaPage.getByTestId('step-up-password').fill(personas.installer.password)

await personaPage.getByTestId('step-up-confirm').click()

await expect(stepUpDialog).toBeHidden({ timeout: 20_000 })

await expect(

personaPage.getByRole('heading', { name: `Review ${pluginName}` }),

).toHaveCount(0)

await expect(installedPluginHeading(personaPage, pluginName)).toBeVisible()

})

})

test('plugin uninstall requires successful step-up before mutating (CAP-003)', async ({

browser,

}) => {

const pluginName = `CAP Remove Plugin ${suffix}`

const manifest = {

id: `cap.remove-${suffix}`,

name: pluginName,

version: '1.0.0',

apiVersion: 1,

permissions: [],

}

await withPersona(browser, personas.installer, async (personaPage) => {

await openPluginsWorkspace(personaPage)

await installReviewedPlugin(personaPage, manifest, personas.installer.password)

await expect(installedPluginHeading(personaPage, pluginName)).toBeVisible()

})

await withPersona(browser, personas.installer, async (personaPage) => {

await openPluginsWorkspace(personaPage)

await expect(installedPluginHeading(personaPage, pluginName)).toBeVisible()

await openRemovePluginDialog(personaPage, pluginName)

const stepUpDialog = personaPage.getByTestId('step-up-dialog')

await expect(stepUpDialog).toBeVisible()

await stepUpDialog.getByRole('button', { name: 'Cancel' }).click()

await expect(stepUpDialog).toBeHidden()

await expect(installedPluginHeading(personaPage, pluginName)).toBeVisible()

await openRemovePluginDialog(personaPage, pluginName)

await expect(stepUpDialog).toBeVisible()

await personaPage.getByTestId('step-up-password').fill('wrong-password-12345')

await personaPage.getByTestId('step-up-confirm').click()

await expect(stepUpDialog.getByRole('alert')).toBeVisible()

await expect(installedPluginHeading(personaPage, pluginName)).toBeVisible()

await personaPage.getByTestId('step-up-password').fill(personas.installer.password)

await personaPage.getByTestId('step-up-confirm').click()

await expect(stepUpDialog).toBeHidden({ timeout: 20_000 })

await expect(installedPluginHeading(personaPage, pluginName)).toHaveCount(0)

})

})

})

test.describe.serial('AI capability boundaries', () => {

test.use({ storageState: ANONYMOUS_STATE })

test.setTimeout(180_000)

const suffix = Date.now().toString(36)

const personas: Record<'siteReader' | 'chatReader' | 'providerManager' | 'auditor', PersonaAccount> = {

siteReader: {

roleName: `CAP AI Site Reader ${suffix}`,

email: `cap-ai-site-reader-${suffix}@example.com`,

password: 'cap-ai-site-reader-pass-12345',

},

chatReader: {

roleName: `CAP AI Chat Reader ${suffix}`,

email: `cap-ai-chat-reader-${suffix}@example.com`,

password: 'cap-ai-chat-reader-pass-12345',

},

providerManager: {

roleName: `CAP AI Provider Manager ${suffix}`,

email: `cap-ai-provider-manager-${suffix}@example.com`,

password: 'cap-ai-provider-manager-pass-12345',

},

auditor: {

roleName: `CAP AI Auditor ${suffix}`,

email: `cap-ai-auditor-${suffix}@example.com`,

password: 'cap-ai-auditor-pass-12345',

},

}

test.beforeAll(async ({ browser }, testInfo) => {

testInfo.setTimeout(180_000)

const context = await browser.newContext()

const ownerPage = await context.newPage()

try {

await login(ownerPage)

await createRole(ownerPage, personas.siteReader.roleName, ['View site'])

await createRole(ownerPage, personas.chatReader.roleName, [

'View site',

'Use AI chat',

])

await createRole(ownerPage, personas.providerManager.roleName, [

'Manage AI providers',

])

await createRole(ownerPage, personas.auditor.roleName, [

'Read AI audit log',

])

for (const persona of Object.values(personas)) {

await createUser(ownerPage, {

email: persona.email,

displayName: persona.roleName,

password: persona.password,

role: persona.roleName,

})

}

} finally {

await context.close()

}

})