dify/e2e/features/step-definitions/agent-v2/publish.steps.ts

import type { DifyWorld } from '../../support/world'
import { Then, When } from '@cucumber/cucumber'
import { expect } from '@playwright/test'
import { waitForAgentConfigureAutosaved } from '../../../support/agent-configure'
import { getAgentVersionDetail, getTestAgent } from '../../agent-v2/support/agent'
import { normalAgentPrompt } from '../../agent-v2/support/agent-soul'
import { expectAgentModelRequiredFeedback, getCurrentAgentId } from './configure-helpers'

When('I publish the Agent v2 draft', async function (this: DifyWorld) {
  const page = this.getPage()
  const publishButton = page.getByRole('button', { name: /^Publish(?: update)?$/ })

  await expect(publishButton).toBeEnabled({ timeout: 30_000 })
  await publishButton.click()
})

When('I try to publish the Agent v2 draft without a model', async function (this: DifyWorld) {
  const page = this.getPage()
  const publishButton = page.getByRole('button', { name: /^Publish(?: update)?$/ })

  await expect(publishButton).toBeEnabled({ timeout: 30_000 })
  await publishButton.click()
})

Then('Agent v2 publish should be blocked until a model is configured', async function (this: DifyWorld) {
  await expectAgentModelRequiredFeedback(this.getPage())
})

Then('the Agent v2 draft should remain unpublished', async function (this: DifyWorld) {
  await expect.poll(
    async () => (await getTestAgent(getCurrentAgentId(this))).active_config_is_published,
    { timeout: 30_000 },
  ).toBe(false)
})

Then('the Agent v2 configuration should be saved automatically', async function (this: DifyWorld) {
  await waitForAgentConfigureAutosaved(this.getPage())
})

Then('the Agent v2 draft should be published and up to date', async function (this: DifyWorld) {
  const page = this.getPage()
  const agentId = getCurrentAgentId(this)

  await expect(page.getByRole('button', { name: 'Published' })).toBeVisible({ timeout: 30_000 })
  await expect(page.getByRole('status', { name: /^Up to date\./ })).toBeVisible()
  await expect(page.getByText('Up to date')).toBeVisible()
  await expect.poll(async () => (await getTestAgent(agentId)).active_config_is_published).toBe(true)
})

Then(
  'the Agent v2 publish action should be available for unpublished changes',
  async function (this: DifyWorld) {
    const page = this.getPage()
    const agentId = getCurrentAgentId(this)

    await expect(page.getByRole('status', { name: /^(?:Draft|Unpublished changes)\./ }))
      .toBeVisible({ timeout: 30_000 })
    await expect(page.getByRole('button', { name: /^Publish(?: update)?$/ }))
      .toBeEnabled()
    await expect.poll(async () => (await getTestAgent(agentId)).active_config_is_published)
      .toBe(false)
  },
)

Then('the Agent v2 publish action should be unavailable while up to date', async function (this: DifyWorld) {
  const page = this.getPage()

  await expect(page.getByRole('status', { name: /^Up to date\./ })).toBeVisible({ timeout: 30_000 })
  await expect(page.getByRole('button', { name: 'Published' })).toBeDisabled()
})

When('I open the Agent v2 version history', async function (this: DifyWorld) {
  const page = this.getPage()

  await page.getByRole('button', { name: 'Open version history' }).click()
  await expect(page.getByRole('heading', { name: 'Versions' })).toBeVisible({ timeout: 30_000 })
})

When('I select Agent v2 published version {int}', async function (this: DifyWorld, versionNumber: number) {
  const page = this.getPage()
  const versionButton = page.getByRole('button', { name: new RegExp(`\\bVersion ${versionNumber}\\b`) })

  await expect(versionButton).toBeVisible({ timeout: 30_000 })
  await versionButton.click()
})

Then('the selected Agent v2 version should be displayed in view-only mode', async function (this: DifyWorld) {
  const page = this.getPage()

  await expect(page.getByText('View Only')).toBeVisible({ timeout: 30_000 })
  await expect(page.getByRole('button', { name: 'Restore' })).toBeEnabled()
})

When('I restore the selected Agent v2 version', async function (this: DifyWorld) {
  const page = this.getPage()
  const agentId = getCurrentAgentId(this)
  const restoreResponse = page.waitForResponse(response =>
    response.request().method() === 'POST'
    && response.url().includes(`/console/api/agent/${agentId}/versions/`)
    && response.url().endsWith('/restore'),
  )

  await page.getByRole('button', { name: 'Restore' }).click()
  const response = await restoreResponse
  expect(response.ok()).toBe(true)
})

Then(
  'the active published Agent v2 version should still use the normal E2E prompt',
  async function (this: DifyWorld) {
    const agentId = getCurrentAgentId(this)

    await expect.poll(async () => (await getTestAgent(agentId)).active_config_is_published, {
      timeout: 30_000,
    }).toBe(false)

    const agent = await getTestAgent(agentId)
    const activeSnapshotId = agent?.active_config_snapshot_id
    if (!activeSnapshotId)
      throw new Error(`Agent v2 ${agentId} does not have an active published snapshot.`)

    const version = await getAgentVersionDetail(agentId, activeSnapshotId)

    expect(version.config_snapshot.prompt).toEqual({ system_prompt: normalAgentPrompt })
  },
)