Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test(web): replace AP29/AP32 form and settings doubles with behavior (#45068)

Stephen Zhoubda335a0aca2
diff --git a/web/app/components/app/access-point/__tests__/mcp-card.spec.tsx b/web/app/components/app/access-point/__tests__/mcp-card.spec.tsx
index fd297f76669..ddce6f4a338 100644
--- a/web/app/components/app/access-point/__tests__/mcp-card.spec.tsx
+++ b/web/app/components/app/access-point/__tests__/mcp-card.spec.tsx
@@ -17,7 +17,6 @@ const mocks = vi.hoisted(() => ({
data: undefined as undefined | { id: string; server_code: string; status: string },
isPending: false,
},
- modalProps: vi.fn(),
refreshServerCode: vi.fn(),
updateServer: vi.fn(),
}))
@@ -52,13 +51,6 @@ vi.mock('@/service/console', async (importOriginal) => {
}
})
-vi.mock('@/app/components/tools/mcp/mcp-server-modal', () => ({
- default: (props: Record<string, unknown>) => {
- mocks.modalProps(props)
- return <div role="dialog" aria-label="MCP server settings" />
- },
-}))
-
const appInfo = createAppDetailFixture({
api_base_url: 'https://api.example.test/v1',
id: 'app-1',
@@ -124,8 +116,6 @@ function renderCard(cardAppInfo: AppDetailWithSite = appInfo, workflow?: Publish
...mocks.serverDetail.data,
}),
)
- const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries')
-
const view = render(
<QueryClientProvider client={queryClient}>
<MCPAccessPointCard
@@ -136,7 +126,7 @@ function renderCard(cardAppInfo: AppDetailWithSite = appInfo, workflow?: Publish
/>
</QueryClientProvider>,
)
- return { ...view, invalidateQueries }
+ return { ...view, queryClient }
}
describe('MCPAccessPointCard', () => {
@@ -147,34 +137,19 @@ describe('MCPAccessPointCard', () => {
mocks.updateServer.mockResolvedValue(undefined)
})
- afterEach(() => {
- vi.restoreAllMocks()
- })
-
- it('uses the provided basic app model config without refetching app detail', async () => {
+ it('opens settings with the provided basic app model config', async () => {
const user = userEvent.setup()
- const fetchSpy = vi
- .spyOn(globalThis, 'fetch')
- .mockResolvedValue(new Response('{}', { status: 200 }))
renderCard()
await user.click(screen.getByRole('button', { name: /addDescription/ }))
- expect(screen.getByRole('dialog', { name: 'MCP server settings' })).toBeInTheDocument()
- expect(mocks.modalProps).toHaveBeenCalledWith(
- expect.objectContaining({
- latestParams: [
- {
- label: 'Question',
- required: true,
- type: 'text-input',
- variable: 'question',
- },
- ],
- }),
- )
- expect(fetchSpy).not.toHaveBeenCalled()
+ expect(
+ screen.getByRole('dialog', { name: 'tools.mcp.server.modal.addTitle' }),
+ ).toBeInTheDocument()
+ expect(screen.getByRole('textbox', { name: 'Question' })).toBeInTheDocument()
+ expect(screen.getByText('question')).toBeInTheDocument()
+ expect(screen.getByText('text-input')).toBeInTheDocument()
})
it('uses workflow inputs when the app model config is null', async () => {
@@ -184,11 +159,11 @@ describe('MCPAccessPointCard', () => {
await user.click(screen.getByRole('button', { name: /addDescription/ }))
- expect(mocks.modalProps).toHaveBeenCalledWith(
- expect.objectContaining({
- latestParams: [{ label: 'Query', variable: 'query' }],
- }),
- )
+ expect(
+ screen.getByRole('dialog', { name: 'tools.mcp.server.modal.addTitle' }),
+ ).toBeInTheDocument()
+ expect(screen.getByRole('textbox', { name: 'Query' })).toBeInTheDocument()
+ expect(screen.getByText('query')).toBeInTheDocument()
})
it('shows loading without reporting an environment failure', () => {
@@ -241,7 +216,7 @@ describe('MCPAccessPointCard', () => {
mocks.updateServer
.mockReturnValueOnce(firstToggle.promise)
.mockReturnValueOnce(secondToggle.promise)
- const { invalidateQueries } = renderCard()
+ const { queryClient } = renderCard()
const accessSwitch = screen.getByRole('switch')
await user.click(accessSwitch)
@@ -259,17 +234,32 @@ describe('MCPAccessPointCard', () => {
await waitFor(() => {
expect(mocks.updateServer).toHaveBeenCalledTimes(2)
})
+ expect(mocks.updateServer.mock.calls.map(([input]) => input.body.status)).toEqual([
+ 'inactive',
+ 'active',
+ ])
+ await waitFor(() => {
+ expect(
+ queryClient.getQueryData(
+ consoleQuery.apps.byAppId.server.get.queryKey({
+ input: { params: { app_id: 'app-1' } },
+ }),
+ ),
+ ).toEqual(expect.objectContaining({ status: 'inactive' }))
+ })
secondToggle.resolve()
await waitFor(() => {
- expect(invalidateQueries).toHaveBeenCalledTimes(2)
- expect(invalidateQueries).toHaveBeenLastCalledWith({
- queryKey: consoleQuery.apps.byAppId.server.get.queryKey({
- input: { params: { app_id: 'app-1' } },
- }),
- })
+ expect(
+ queryClient.getQueryData(
+ consoleQuery.apps.byAppId.server.get.queryKey({
+ input: { params: { app_id: 'app-1' } },
+ }),
+ ),
+ ).toEqual(expect.objectContaining({ status: 'active' }))
})
expect(accessSwitch).toHaveAttribute('aria-checked', 'true')
+ expect(screen.getByText('agentV2.agentDetail.access.status.inService')).toBeInTheDocument()
})
})
diff --git a/web/app/components/app/configuration/config-var/config-modal/__tests__/form-fields.spec.tsx b/web/app/components/app/configuration/config-var/config-modal/__tests__/form-fields.spec.tsx
index c5313047b1a..3bf038edbfa 100644
--- a/web/app/components/app/configuration/config-var/config-modal/__tests__/form-fields.spec.tsx
+++ b/web/app/components/app/configuration/config-var/config-modal/__tests__/form-fields.spec.tsx
@@ -1,11 +1,15 @@
import type { TFunction } from 'i18next'
-import type { ReactNode } from 'react'
-import type { InputVar } from '@/app/components/workflow/types'
-import { screen } from '@testing-library/react'
+import type { ChangeEvent, ReactNode } from 'react'
+import type { FileEntity } from '@/app/components/base/file-uploader/types'
+import type { InputVar, UploadFileSetting } from '@/app/components/workflow/types'
+import type { consoleClient } from '@/service/console'
+import { screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
+import { useState } from 'react'
import { InputVarType } from '@/app/components/workflow/types'
import { renderWithConsoleQuery as render } from '@/test/console/query-data'
import { withSelectorKey } from '@/test/i18n-mock'
+import { TransferMethod } from '@/types/app'
import ConfigModalFormFields from '../form-fields'
vi.mock('react-i18next', async () => {
@@ -33,113 +37,171 @@ vi.mock('@/context/i18n', () => ({
useDocLink: () => (path?: string) => `https://docs.example.com${path || ''}`,
}))
-vi.mock('@/app/components/base/file-uploader', async (importOriginal) => ({
- ...(await importOriginal<typeof import('@/app/components/base/file-uploader')>()),
- FileUploaderInAttachmentWrapper: ({
- onChange,
- value,
- fileConfig,
- }: {
- onChange: (files?: Array<Record<string, unknown>>) => void
- value: Array<Record<string, unknown>>
- fileConfig: Record<string, unknown>
- }) => (
- <div>
- <span data-testid="file-uploader-value">{JSON.stringify(value)}</span>
- <span data-testid="file-uploader-config">{JSON.stringify(fileConfig)}</span>
- <button
- type="button"
- onClick={() =>
- onChange([
- { fileId: 'file-1', type: 'local_file', url: 'https://example.com/file.png' },
- { fileId: 'file-2', type: 'remote_url', url: 'https://example.com/file-2.png' },
- ])
- }
- >
- upload-file
- </button>
- <button type="button" data-testid="upload-empty-file" onClick={() => onChange(undefined)}>
- upload-empty-file
- </button>
- </div>
- ),
+vi.mock('@/next/navigation', () => ({
+ useParams: () => ({}),
+ usePathname: () => '/',
}))
+const remoteUpload = vi.hoisted(() =>
+ vi.fn<
+ (url: string) => Promise<{
+ id: string
+ name: string
+ size: number
+ mime_type: string
+ url: string
+ created_at: null
+ created_by: null
+ extension: string
+ }>
+ >(),
+)
+
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleResponses } = await import('@/test/console/service-responses')
+ const { createFileUploadConfigFixture } = await import('@/test/fixtures/file-upload-config')
+ return {
+ ...actual,
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'files.upload.get': async () => createFileUploadConfigFixture(),
+ 'remoteFiles.upload.post': ({
+ body,
+ }: Parameters<typeof consoleClient.remoteFiles.upload.post>[0]) => remoteUpload(body.url),
+ }),
+ }
+})
+
const t = withSelectorKey((key: string) => key) as TFunction<['appDebug']>
-const createPayloadChangeHandler = () => vi.fn<(value: unknown) => void>()
+const basePayload: InputVar = {
+ type: InputVarType.textInput,
+ label: 'Question',
+ variable: 'question',
+ required: false,
+ hide: false,
+}
+
+const selectOptions = [
+ { value: InputVarType.textInput, name: 'Text' },
+ { value: InputVarType.select, name: 'Select' },
+ { value: InputVarType.checkbox, name: 'Checkbox' },
+]
+
+type ControlledFieldsProps = {
+ initialPayload?: InputVar
+ options?: string[]
+ showHiddenField?: boolean
+}
+
+function ControlledFields({
+ initialPayload = basePayload,
+ options,
+ showHiddenField,
+}: ControlledFieldsProps) {
+ const [tempPayload, setTempPayload] = useState(initialPayload)
-const createBaseProps = () => {
- const payloadChangeHandlers: Record<string, ReturnType<typeof createPayloadChangeHandler>> = {
- default: createPayloadChangeHandler(),
- hide: createPayloadChangeHandler(),
- label: createPayloadChangeHandler(),
- max_length: createPayloadChangeHandler(),
- options: createPayloadChangeHandler(),
- required: createPayloadChangeHandler(),
+ const setPayloadValue = (key: string) => (value: unknown) => {
+ setTempPayload((payload) => ({ ...payload, [key]: value }) as InputVar)
}
- return {
- checkboxDefaultSelectValue: 'false',
- isStringInput: false,
- jsonSchemaStr: '',
- maxLength: 32,
- modelId: 'gpt-4o',
- onFilePayloadChange: vi.fn(),
- onJSONSchemaChange: vi.fn(),
- onPayloadChange: (key: string) => {
- if (!payloadChangeHandlers[key]) payloadChangeHandlers[key] = createPayloadChangeHandler()
- return payloadChangeHandlers[key]
- },
- onTypeChange: vi.fn(),
- onVarKeyBlur: vi.fn(),
- onVarNameChange: vi.fn(),
- options: undefined as string[] | undefined,
- selectOptions: [
- { value: InputVarType.textInput, name: 'Text' },
- { value: InputVarType.select, name: 'Select' },
- { value: InputVarType.checkbox, name: 'Checkbox' },
- ],
- tempPayload: {
- type: InputVarType.textInput,
- label: 'Question',
- variable: 'question',
- required: false,
- hide: false,
- } as InputVar,
- t,
- payloadChangeHandlers,
+ return (
+ <>
+ <ConfigModalFormFields
+ checkboxDefaultSelectValue={tempPayload.default === true ? 'true' : 'false'}
+ isStringInput={false}
+ jsonSchemaStr=""
+ maxLength={32}
+ modelId="gpt-4o"
+ onFilePayloadChange={(payload: UploadFileSetting) =>
+ setTempPayload((current) => ({ ...current, ...payload }))
+ }
+ onJSONSchemaChange={() => undefined}
+ onPayloadChange={setPayloadValue}
+ onTypeChange={(item) => setTempPayload((payload) => ({ ...payload, type: item.value }))}
+ onVarKeyBlur={() => undefined}
+ onVarNameChange={(event: ChangeEvent<HTMLInputElement>) =>
+ setTempPayload((payload) => ({ ...payload, variable: event.target.value }))
+ }
+ options={options}
+ selectOptions={selectOptions}
+ showHiddenField={showHiddenField}
+ tempPayload={tempPayload}
+ t={t}
+ />
+ <output aria-label="Saved variable">{JSON.stringify(tempPayload)}</output>
+ </>
+ )
+}
+
+function getSavedVariable() {
+ return JSON.parse(screen.getByLabelText('Saved variable').textContent || '{}') as InputVar
+}
+
+const createFile = (overrides: Partial<FileEntity> = {}): FileEntity => ({
+ id: 'file-1',
+ name: 'report.txt',
+ size: 1024,
+ type: 'text/plain',
+ progress: 100,
+ transferMethod: TransferMethod.remote_url,
+ supportFileType: 'document',
+ uploadedId: 'uploaded-file-1',
+ url: 'https://example.com/report.txt',
+ isRemote: true,
+ ...overrides,
+})
+
+async function uploadRemoteFile(user: ReturnType<typeof userEvent.setup>, url: string) {
+ let input = screen.queryByPlaceholderText('common.fileUploader.pasteFileLinkInputPlaceholder')
+ if (!input) {
+ await user.click(screen.getByRole('button', { name: /fileUploader.pasteFileLink/ }))
+ input = screen.getByPlaceholderText('common.fileUploader.pasteFileLinkInputPlaceholder')
}
+ await user.type(input, url)
+ await user.click(screen.getByRole('button', { name: 'common.operation.ok' }))
}
describe('ConfigModalFormFields', () => {
+ beforeEach(() => {
+ remoteUpload.mockImplementation(async (url) => ({
+ id: url.includes('second') ? 'uploaded-file-2' : 'uploaded-file-1',
+ name: url.split('/').at(-1) || 'report.txt',
+ size: 1024,
+ mime_type: 'text/plain',
+ url,
+ created_at: null,
+ created_by: null,
+ extension: 'txt',
+ }))
+ })
+
it.each([
{
type: InputVarType.textInput,
label: 'variableConfig.fieldType',
option: 'Select',
- value: InputVarType.select,
+ expected: 'Select',
},
{
type: InputVarType.checkbox,
label: 'variableConfig.defaultValue',
option: 'variableConfig.startChecked',
- value: true,
+ expected: 'true',
},
{
type: InputVarType.select,
label: 'variableConfig.defaultValue',
option: 'beta',
- value: 'beta',
+ expected: 'beta',
},
])(
'should focus the $type selector from its label and select an option',
- async ({ type, label, option, value }) => {
+ async ({ type, label, option, expected }) => {
const user = userEvent.setup()
- const props = createBaseProps()
- props.tempPayload.type = type
- props.options = ['alpha', 'beta']
- render(<ConfigModalFormFields {...props} />)
+ render(
+ <ControlledFields initialPayload={{ ...basePayload, type }} options={['alpha', 'beta']} />,
+ )
await user.click(screen.getByText(label))
const trigger = screen.getByRole('combobox', { name: label })
@@ -148,219 +210,162 @@ describe('ConfigModalFormFields', () => {
await user.click(await screen.findByRole('option', { name: new RegExp(`^${option}`) }))
if (type === InputVarType.textInput)
- expect(props.onTypeChange).toHaveBeenCalledWith({ value, name: option })
- else expect(props.payloadChangeHandlers.default).toHaveBeenCalledWith(value)
+ expect(screen.getByText('variableConfig.options')).toBeInTheDocument()
+ else expect(screen.getByRole('combobox', { name: label })).toHaveTextContent(expected)
},
)
- it('should hide visibility controls for file inputs and adapt uploaded defaults for single and multiple files', async () => {
+ it('should hide visibility controls for file inputs and save scalar and list defaults', async () => {
const user = userEvent.setup()
- const textInputProps = createBaseProps()
- const textInputView = render(<ConfigModalFormFields {...textInputProps} />)
+ const textInputView = render(<ControlledFields />)
expect(screen.getByText('variableConfig.hidden')).toBeInTheDocument()
await user.click(screen.getByRole('button', { name: 'variableConfig.hidden' }))
expect(await screen.findByText('variableConfig.hiddenDescription')).toBeInTheDocument()
- const docLink = await screen.findByRole('link')
- expect(docLink).toHaveAttribute(
+ expect(await screen.findByRole('link')).toHaveAttribute(
'href',
'https://docs.example.com/use-dify/nodes/user-input#hide-and-pre-fill-input-fields',
)
- expect(docLink).toHaveAttribute('target', '_blank')
- expect(docLink).toHaveAttribute('rel', 'noopener noreferrer')
textInputView.unmount()
- const hiddenFieldDisabledProps = createBaseProps()
- const hiddenFieldDisabledView = render(
- <ConfigModalFormFields {...hiddenFieldDisabledProps} showHiddenField={false} />,
- )
+ const hiddenFieldDisabledView = render(<ControlledFields showHiddenField={false} />)
expect(screen.queryByText('variableConfig.hidden')).not.toBeInTheDocument()
- expect(screen.queryByText('variableConfig.hiddenDescription')).not.toBeInTheDocument()
hiddenFieldDisabledView.unmount()
- const singleFileProps = createBaseProps()
- singleFileProps.tempPayload = {
- ...singleFileProps.tempPayload,
- type: InputVarType.singleFile,
- allowed_file_types: ['document'],
- allowed_file_extensions: [],
- allowed_file_upload_methods: ['remote_url'],
- }
- const singleFileView = render(<ConfigModalFormFields {...singleFileProps} />)
+ const singleFileView = render(
+ <ControlledFields
+ initialPayload={{
+ ...basePayload,
+ type: InputVarType.singleFile,
+ allowed_file_types: ['document'],
+ allowed_file_extensions: [],
+ allowed_file_upload_methods: [TransferMethod.remote_url],
+ }}
+ />,
+ )
expect(screen.queryByText('variableConfig.hidden')).not.toBeInTheDocument()
- expect(screen.queryByText('variableConfig.hiddenDescription')).not.toBeInTheDocument()
- await user.click(screen.getByText('upload-file'))
- await user.click(screen.getByRole('checkbox', { name: 'variableConfig.required' }))
-
- expect(singleFileProps.payloadChangeHandlers.default).toHaveBeenCalledWith(
- expect.objectContaining({
- fileId: 'file-1',
- }),
+ await uploadRemoteFile(user, 'https://example.com/first.txt')
+ await waitFor(() =>
+ expect(getSavedVariable().default).toEqual(
+ expect.objectContaining({ uploadedId: 'uploaded-file-1' }),
+ ),
)
- expect(singleFileProps.payloadChangeHandlers.required).toHaveBeenCalledWith(true)
- expect(singleFileProps.payloadChangeHandlers.hide).not.toHaveBeenCalled()
+ expect(Array.isArray(getSavedVariable().default)).toBe(false)
+ expect(screen.getByText('https://example.com/first.txt')).toBeInTheDocument()
+ await user.click(screen.getByRole('checkbox', { name: 'variableConfig.required' }))
+ expect(screen.getByRole('checkbox', { name: 'variableConfig.required' })).toBeChecked()
singleFileView.unmount()
- const multiFileProps = createBaseProps()
- multiFileProps.tempPayload = {
- ...multiFileProps.tempPayload,
- type: InputVarType.multiFiles,
- allowed_file_types: ['document'],
- allowed_file_extensions: [],
- allowed_file_upload_methods: ['remote_url'],
- }
- render(<ConfigModalFormFields {...multiFileProps} />)
- expect(screen.queryByText('variableConfig.hidden')).not.toBeInTheDocument()
- await user.click(screen.getAllByText('upload-file')[0]!)
- expect(multiFileProps.payloadChangeHandlers.default).toHaveBeenCalledWith([
- expect.objectContaining({ fileId: 'file-1' }),
- expect.objectContaining({ fileId: 'file-2' }),
- ])
+ render(
+ <ControlledFields
+ initialPayload={{
+ ...basePayload,
+ type: InputVarType.multiFiles,
+ allowed_file_types: ['document'],
+ allowed_file_extensions: [],
+ allowed_file_upload_methods: [TransferMethod.remote_url],
+ }}
+ />,
+ )
+ await uploadRemoteFile(user, 'https://example.com/first.txt')
+ await waitFor(() =>
+ expect(getSavedVariable().default).toEqual([
+ expect.objectContaining({ uploadedId: 'uploaded-file-1' }),
+ ]),
+ )
+ await uploadRemoteFile(user, 'https://example.com/second.txt')
+ await waitFor(() =>
+ expect(getSavedVariable().default).toEqual([
+ expect.objectContaining({ uploadedId: 'uploaded-file-1' }),
+ expect.objectContaining({ uploadedId: 'uploaded-file-2' }),
+ ]),
+ )
+ expect(screen.getByText('https://example.com/first.txt')).toBeInTheDocument()
+ expect(screen.getByText('https://example.com/second.txt')).toBeInTheDocument()
})
- it('should clear select defaults and apply uploader fallback values', async () => {
+ it('should clear select defaults and show an empty real uploader', async () => {
const user = userEvent.setup()
- const selectProps = createBaseProps()
- selectProps.tempPayload = {
- ...selectProps.tempPayload,
- type: InputVarType.select,
- default: 'alpha',
- }
- selectProps.options = ['alpha', ' ', 'beta']
- const selectView = render(<ConfigModalFormFields {...selectProps} />)
+ const selectView = render(
+ <ControlledFields
+ initialPayload={{ ...basePayload, type: InputVarType.select, default: 'alpha' }}
+ options={['alpha', ' ', 'beta']}
+ />,
+ )
await user.click(screen.getByRole('combobox', { name: 'variableConfig.defaultValue' }))
- const selectOptions = await screen.findAllByRole('option')
- await user.click(selectOptions[0]!)
- expect(selectProps.payloadChangeHandlers.default).toHaveBeenCalledWith(undefined)
+ await user.click(await screen.findByRole('option', { name: 'variableConfig.noDefaultValue' }))
+ expect(getSavedVariable()).not.toHaveProperty('default')
selectView.unmount()
- const singleFallbackProps = createBaseProps()
- singleFallbackProps.tempPayload = {
- ...singleFallbackProps.tempPayload,
- type: InputVarType.singleFile,
- default: undefined,
- }
- render(<ConfigModalFormFields {...singleFallbackProps} />)
-
- expect(screen.getAllByTestId('file-uploader-value')[0]).toHaveTextContent('[]')
- expect(screen.getAllByTestId('file-uploader-config')[0]).toHaveTextContent(
- '"allowed_file_types":["document"]',
+ render(
+ <ControlledFields
+ initialPayload={{ ...basePayload, type: InputVarType.singleFile, default: undefined }}
+ />,
)
- expect(screen.getAllByTestId('file-uploader-config')[0]).toHaveTextContent(
- '"allowed_file_upload_methods":["remote_url"]',
- )
- expect(screen.getAllByTestId('file-uploader-config')[0]).toHaveTextContent('"number_limits":1')
- await user.click(screen.getAllByTestId('upload-empty-file')[0]!)
- expect(singleFallbackProps.payloadChangeHandlers.default).toHaveBeenCalledWith(undefined)
-
- const multiFallbackProps = createBaseProps()
- multiFallbackProps.tempPayload = {
- ...multiFallbackProps.tempPayload,
- type: InputVarType.multiFiles,
- default: undefined,
- max_length: undefined,
- }
- render(<ConfigModalFormFields {...multiFallbackProps} />)
-
- expect(screen.getAllByTestId('file-uploader-value')[1]).toHaveTextContent('[]')
- expect(screen.getAllByTestId('file-uploader-config')[1]).toHaveTextContent('"number_limits":5')
- await user.click(screen.getAllByTestId('upload-empty-file')[1]!)
- expect(multiFallbackProps.payloadChangeHandlers.default).toHaveBeenCalledWith(undefined)
+ expect(screen.getByRole('button', { name: /fileUploader.pasteFileLink/ })).toBeEnabled()
+ expect(
+ screen.queryByRole('button', { name: /common.operation.remove/ }),
+ ).not.toBeInTheDocument()
})
it('should skip rendering the default selector when options are missing', () => {
- const selectWithoutOptionsProps = createBaseProps()
- selectWithoutOptionsProps.tempPayload = {
- ...selectWithoutOptionsProps.tempPayload,
- type: InputVarType.select,
- }
- selectWithoutOptionsProps.options = undefined
- render(<ConfigModalFormFields {...selectWithoutOptionsProps} />)
+ render(<ControlledFields initialPayload={{ ...basePayload, type: InputVarType.select }} />)
expect(
screen.queryByRole('combobox', { name: 'variableConfig.defaultValue' }),
).not.toBeInTheDocument()
})
- it('should preserve existing file defaults when present', () => {
- const existingFile = {
- fileId: 'existing-file',
- type: 'local_file',
- url: 'https://example.com/existing.png',
- }
- const singleFileProps = createBaseProps()
- singleFileProps.tempPayload = {
- ...singleFileProps.tempPayload,
- type: InputVarType.singleFile,
- default: existingFile as unknown as InputVar['default'],
- }
- render(<ConfigModalFormFields {...singleFileProps} />)
-
- expect(screen.getAllByTestId('file-uploader-value')[0]).toHaveTextContent(
- '"fileId":"existing-file"',
+ it('should preserve supported file defaults when present', () => {
+ const singleFile = createFile({ id: 'existing-file', name: 'existing.txt' })
+ const singleFileView = render(
+ <ControlledFields
+ initialPayload={{
+ ...basePayload,
+ type: InputVarType.singleFile,
+ default: singleFile,
+ }}
+ />,
)
+ expect(screen.getByText('existing.txt')).toBeInTheDocument()
+ expect(screen.getByRole('button', { name: /fileUploader.pasteFileLink/ })).toBeDisabled()
+ singleFileView.unmount()
const existingFiles = [
- { fileId: 'file-1', type: 'local_file', url: 'https://example.com/1.png' },
- { fileId: 'file-2', type: 'remote_url', url: 'https://example.com/2.png' },
+ createFile({ id: 'file-1', name: 'first.txt' }),
+ createFile({ id: 'file-2', name: 'second.txt', uploadedId: 'uploaded-file-2' }),
]
- const multiFileProps = createBaseProps()
- multiFileProps.tempPayload = {
- ...multiFileProps.tempPayload,
- type: InputVarType.multiFiles,
- default: existingFiles as unknown as InputVar['default'],
- max_length: 2,
- }
- render(<ConfigModalFormFields {...multiFileProps} />)
-
- expect(screen.getAllByTestId('file-uploader-value')[1]).toHaveTextContent('"fileId":"file-1"')
- expect(screen.getAllByTestId('file-uploader-config')[1]).toHaveTextContent('"number_limits":2')
+ render(
+ <ControlledFields
+ initialPayload={{
+ ...basePayload,
+ type: InputVarType.multiFiles,
+ default: existingFiles,
+ max_length: 2,
+ }}
+ />,
+ )
+ expect(screen.getByText('first.txt')).toBeInTheDocument()
+ expect(screen.getByText('second.txt')).toBeInTheDocument()
+ expect(screen.getByRole('button', { name: /fileUploader.pasteFileLink/ })).toBeDisabled()
})
- it('should disable hide checkbox when required is true and disable required when hide is true', () => {
- const requiredProps = createBaseProps()
- requiredProps.tempPayload = {
- ...requiredProps.tempPayload,
- type: InputVarType.textInput,
- required: true,
- hide: false,
- }
- const { unmount } = render(<ConfigModalFormFields {...requiredProps} />)
-
+ it('should disable hide when required becomes true and disable required when hidden', async () => {
+ const user = userEvent.setup()
+ const requiredView = render(<ControlledFields />)
+ await user.click(screen.getByRole('checkbox', { name: 'variableConfig.required' }))
+ expect(screen.getByRole('checkbox', { name: 'variableConfig.required' })).toBeChecked()
expect(screen.getByRole('checkbox', { name: 'variableConfig.hidden' })).toHaveAttribute(
'aria-disabled',
'true',
)
- unmount()
-
- const hideProps = createBaseProps()
- hideProps.tempPayload = {
- ...hideProps.tempPayload,
- type: InputVarType.textInput,
- required: false,
- hide: true,
- }
- render(<ConfigModalFormFields {...hideProps} />)
+ requiredView.unmount()
+ render(<ControlledFields initialPayload={{ ...basePayload, hide: true }} />)
expect(screen.getByRole('checkbox', { name: 'variableConfig.required' })).toHaveAttribute(
'aria-disabled',
'true',
)
- expect(screen.getByRole('checkbox', { name: 'variableConfig.hidden' })).toHaveAttribute(
- 'aria-checked',
- 'true',
- )
+ expect(screen.getByRole('checkbox', { name: 'variableConfig.hidden' })).toBeChecked()
})
})
-
-vi.mock('@/service/console', async (importOriginal) => {
- const actual = await importOriginal<typeof import('@/service/console')>()
- const { withConsoleResponses } = await import('@/test/console/service-responses')
- const { createFileUploadConfigFixture } = await import('@/test/fixtures/file-upload-config')
- return {
- ...actual,
- consoleQuery: withConsoleResponses(actual.consoleQuery, {
- 'files.upload.get': async () => createFileUploadConfigFixture(),
- }),
- }
-})
diff --git a/web/app/components/workflow/nodes/llm/components/__tests__/panel-output-section.spec.tsx b/web/app/components/workflow/nodes/llm/components/__tests__/panel-output-section.spec.tsx
index 81b3e0a0908..685060562ed 100644
--- a/web/app/components/workflow/nodes/llm/components/__tests__/panel-output-section.spec.tsx
+++ b/web/app/components/workflow/nodes/llm/components/__tests__/panel-output-section.spec.tsx
@@ -1,4 +1,4 @@
-import type { LLMNodeType, StructuredOutput } from '../../types'
+import type { LLMNodeType } from '../../types'
import { render, screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { useState } from 'react'
@@ -6,21 +6,6 @@ import { BlockEnum } from '@/app/components/workflow/types'
import { Type } from '../../types'
import PanelOutputSection from '../panel-output-section'
-const mockStructureOutput = vi.fn()
-
-vi.mock('../structure-output', () => ({
- __esModule: true,
- StructureOutput: (props: {
- className?: string
- readOnly: boolean
- value?: StructuredOutput
- onChange: (value: StructuredOutput) => void
- }) => {
- mockStructureOutput(props)
- return <div data-testid="structure-output">structured-output</div>
- },
-}))
-
const createInputs = (overrides: Partial<LLMNodeType> = {}): LLMNodeType => ({
title: 'LLM',
desc: '',
@@ -44,10 +29,6 @@ const createInputs = (overrides: Partial<LLMNodeType> = {}): LLMNodeType => ({
})
describe('llm/panel-output-section', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- })
-
it('expands output details through the real section control', async () => {
const user = userEvent.setup()
const Harness = () => {
@@ -69,10 +50,10 @@ describe('llm/panel-output-section', () => {
await user.click(screen.getByRole('button', { name: 'workflow.nodes.common.outputVars' }))
expect(screen.getByText('reasoning_content')).toBeInTheDocument()
expect(screen.getByText('usage')).toBeInTheDocument()
- expect(screen.queryByTestId('structure-output')).not.toBeInTheDocument()
+ expect(screen.queryByText('structured_output')).not.toBeInTheDocument()
})
- it('passes the read-only permission to configured output', () => {
+ it('shows configured output as read-only and disables its switch', () => {
render(
<PanelOutputSection
readOnly={true}
@@ -81,7 +62,19 @@ describe('llm/panel-output-section', () => {
structured_output: {
schema: {
type: Type.object,
- properties: {},
+ properties: {
+ result: {
+ type: Type.object,
+ description: 'Result details',
+ properties: {
+ answer: {
+ type: Type.string,
+ description: 'Final answer',
+ },
+ },
+ required: ['answer'],
+ },
+ },
additionalProperties: false,
},
},
@@ -94,29 +87,38 @@ describe('llm/panel-output-section', () => {
/>,
)
- expect(screen.getByTestId('structure-output')).toBeInTheDocument()
+ expect(screen.getByText('structured_output')).toBeInTheDocument()
+ expect(screen.getByText('result')).toBeInTheDocument()
+ expect(screen.getByText('Final answer')).toBeInTheDocument()
+ expect(screen.getByText('app.structOutput.required')).toBeInTheDocument()
+ expect(
+ screen.queryByRole('button', { name: 'app.structOutput.configure' }),
+ ).not.toBeInTheDocument()
expect(screen.getByRole('switch')).toHaveAttribute('aria-disabled', 'true')
- expect(mockStructureOutput).toHaveBeenCalledWith(expect.objectContaining({ readOnly: true }))
})
it('opens the model warning with the keyboard without changing structured output', async () => {
const user = userEvent.setup()
- const onEnable = vi.fn()
- render(
- <PanelOutputSection
- readOnly={false}
- inputs={createInputs({ structured_output_enabled: true })}
- isModelSupportStructuredOutput={false}
- structuredOutputCollapsed={false}
- setStructuredOutputCollapsed={vi.fn()}
- handleStructureOutputEnableChange={onEnable}
- handleStructureOutputChange={vi.fn()}
- />,
- )
+ const Harness = () => {
+ const [enabled, setEnabled] = useState(true)
+ return (
+ <PanelOutputSection
+ readOnly={false}
+ inputs={createInputs({ structured_output_enabled: enabled })}
+ isModelSupportStructuredOutput={false}
+ structuredOutputCollapsed={false}
+ setStructuredOutputCollapsed={() => undefined}
+ handleStructureOutputEnableChange={setEnabled}
+ handleStructureOutputChange={() => undefined}
+ />
+ )
+ }
+ render(<Harness />)
+ expect(screen.getByRole('switch')).toBeChecked()
screen.getByRole('button', { name: 'app.structOutput.modelNotSupported' }).focus()
await user.keyboard('{Enter}')
expect(await screen.findByRole('dialog')).toHaveTextContent(
'app.structOutput.modelNotSupportedTip',
)
- expect(onEnable).not.toHaveBeenCalled()
+ expect(screen.getByRole('switch')).toBeChecked()
})
})
diff --git a/web/app/components/workflow/panel/env-panel/__tests__/index.spec.tsx b/web/app/components/workflow/panel/env-panel/__tests__/index.spec.tsx
index ae3396ce074..364825a2a7d 100644
--- a/web/app/components/workflow/panel/env-panel/__tests__/index.spec.tsx
+++ b/web/app/components/workflow/panel/env-panel/__tests__/index.spec.tsx
@@ -1,4 +1,4 @@
-import type { ReactElement } from 'react'
+import type { ReactFlowInstance } from 'reactflow'
import type { ModelParameterRule } from '@/app/components/header/account-setting/model-provider-page/declarations'
import type { EditorResource } from '@/app/components/workflow/editor-resource/resource'
import type { SyncDraftCallback } from '@/app/components/workflow/hooks-store'
@@ -8,14 +8,14 @@ import type { Shape } from '@/app/components/workflow/store/workflow'
import type { EnvironmentVariable, Node } from '@/app/components/workflow/types'
import type { consoleClient } from '@/service/console'
import { zGetWorkspacesCurrentModelProvidersByProviderModelsParameterRulesResponse } from '@dify/contracts/api/console/workspaces/zod.gen'
-import { act, screen, waitFor } from '@testing-library/react'
+import { act, screen, waitFor, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
-import { useLayoutEffect } from 'react'
-import { useStoreApi } from 'reactflow'
import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { collaborationManager } from '@/app/components/workflow/collaboration/core/collaboration-manager'
+import { isLLMEnvironmentVariableValue } from '@/app/components/workflow/llm-environment-variable'
import { CodeLanguage } from '@/app/components/workflow/nodes/code/types'
import { BlockEnum } from '@/app/components/workflow/types'
+import { consoleQuery } from '@/service/console'
import {
createCatalogModelFixture,
createModelCatalogFixture,
@@ -23,25 +23,9 @@ import {
} from '@/test/console/model-provider'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
import { createWorkflowResponseFixture } from '@/test/fixtures/workflow-response'
+import { createNuqsTestRenderer } from '@/test/nuqs-testing'
import EnvPanel from '../index'
-let initialNodes: Node[] = []
-let graph: ReturnType<typeof useStoreApi> | undefined
-
-function GraphProbe() {
- const store = useStoreApi()
- useLayoutEffect(() => {
- graph = store
- }, [store])
- return null
-}
-
-const getNodes = () => graph!.getState().getNodes()
-const setNodes = (nodes: Node[]) => {
- if (graph) act(() => graph!.getState().setNodes(nodes))
- else initialNodes = nodes
-}
-
const createLLMNode = ({
id = 'llm-node',
data,
@@ -63,6 +47,7 @@ const createLLMNode = ({
...data,
},
})
+
const createCodeNode = (
id: string,
variables: CodeNodeType['variables'] = [],
@@ -83,7 +68,6 @@ const createCodeNode = (
const {
mockDoSyncWorkflowDraft,
- mockVariableTriggerState,
mockUpdateEnvironmentVariables,
mockFetchWorkflowDraft,
mockGetSocket,
@@ -100,28 +84,20 @@ const {
}
},
) => Promise<void>
- >(async (_notRefresh, callback) => {
- callback?.onSuccess?.()
- }),
- mockVariableTriggerState: {
- savePayload: undefined as EnvironmentVariable | undefined,
- },
- mockUpdateEnvironmentVariables: vi.fn<
- (payload: {
- appId: string
- environmentVariables: EnvironmentVariable[]
- deletedEnvironmentVariableIds: string[]
- }) => Promise<unknown>
- >(() => Promise.resolve({})),
- mockFetchWorkflowDraft: vi.fn<() => Promise<{ environment_variables: EnvironmentVariable[] }>>(
- () => Promise.reject(new Error('draft refresh unavailable')),
- ),
- mockGetSocket: vi.fn<
- (appId: string) => { emit: (event: string, payload: unknown) => void } | null
- >(() => null),
- mockFetchModelParameterRulesForModel: vi.fn<
- (provider: string, modelId: string) => Promise<ModelParameterRule[]>
- >(() => Promise.resolve([])),
+ >(),
+ mockUpdateEnvironmentVariables:
+ vi.fn<
+ (payload: {
+ appId: string
+ environmentVariables: EnvironmentVariable[]
+ deletedEnvironmentVariableIds: string[]
+ }) => Promise<unknown>
+ >(),
+ mockFetchWorkflowDraft: vi.fn<() => Promise<{ environment_variables: EnvironmentVariable[] }>>(),
+ mockGetSocket:
+ vi.fn<(appId: string) => { emit: (event: string, payload: unknown) => void } | null>(),
+ mockFetchModelParameterRulesForModel:
+ vi.fn<(provider: string, modelId: string) => Promise<ModelParameterRule[]>>(),
}))
vi.mock('@/service/console', async (importOriginal) => {
@@ -160,50 +136,6 @@ vi.mock('@/app/components/workflow/collaboration/core/websocket-manager', () =>
},
}))
-// The form is independently tested; keep its submission boundary small while the
-// container owns the real popover, variable rows, confirmation, queue and persistence.
-vi.mock('@/app/components/workflow/panel/env-panel/variable-modal', () => ({
- default: ({
- env,
- onClose,
- onSave,
- }: {
- env?: EnvironmentVariable
- onClose: () => void
- onSave: (env: EnvironmentVariable) => Promise<void>
- }) => (
- <div>
- <input aria-label="Variable being edited" readOnly value={env?.name ?? ''} />
- <button
- type="button"
- onClick={() =>
- onSave(
- mockVariableTriggerState.savePayload ??
- env ?? {
- id: 'env-created',
- name: 'created_name',
- value: 'created-value',
- value_type: 'string',
- description: 'created',
- },
- )
- }
- >
- Save variable
- </button>
- <button type="button" onClick={onClose}>
- Close variable modal
- </button>
- </div>
- ),
-}))
-
-async function saveVariable(user: ReturnType<typeof userEvent.setup>) {
- if (!screen.queryByRole('button', { name: 'Save variable' }))
- await user.click(screen.getByRole('button', { name: 'workflow.env.envPanelButton' }))
- await user.click(await screen.findByRole('button', { name: 'Save variable' }))
-}
-
const createEnv = (overrides: Partial<EnvironmentVariable> = {}): EnvironmentVariable => ({
id: 'env-1',
name: 'api_key',
@@ -213,50 +145,192 @@ const createEnv = (overrides: Partial<EnvironmentVariable> = {}): EnvironmentVar
...overrides,
})
-const renderWithProviders = (
- ui: ReactElement,
- storeState: Partial<Shape> = {},
- resource: EditorResource = { kind: 'app', appId: 'app-1', mode: 'workflow' },
-) => {
- const { queryClient } = createConsoleQueryWrapper({
- systemFeatures: { enable_collaboration_mode: false },
+const oldModelEnv = (overrides: Partial<EnvironmentVariable> = {}) =>
+ createEnv({
+ name: 'shared_model',
+ value_type: 'llm',
+ value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
+ description: '',
+ ...overrides,
})
- seedModelProviderQueries(queryClient, [
- createModelCatalogFixture({
- provider: 'new-provider',
- models: [createCatalogModelFixture({ model: 'new-model', features: [] })],
- }),
- ])
- return renderWorkflowFlowComponent(
- <>
- <GraphProbe />
- {ui}
- </>,
+
+const modelRule: ModelParameterRule = {
+ name: 'temperature',
+ type: 'float',
+ min: 0,
+ max: 2,
+ label: { en_US: 'Temperature', zh_Hans: 'Temperature' },
+ required: false,
+}
+
+type RenderPanelOptions = {
+ initialStoreState?: Partial<Shape>
+ nodes?: Node[]
+ resource?: EditorResource
+}
+
+const renderPanelWithNuqs = createNuqsTestRenderer(
+ (
+ ui,
{
+ initialStoreState = {},
+ nodes = [],
+ resource = { kind: 'app', appId: 'app-1', mode: 'workflow' },
+ }: RenderPanelOptions = {},
+ ) => {
+ const { queryClient } = createConsoleQueryWrapper({
+ systemFeatures: { enable_collaboration_mode: false },
+ })
+ seedModelProviderQueries(queryClient, [
+ createModelCatalogFixture({
+ provider: 'old-provider',
+ models: [
+ createCatalogModelFixture({
+ model: 'old-model',
+ label: { en_US: 'old-model' },
+ model_properties: { mode: 'chat' },
+ }),
+ ],
+ }),
+ createModelCatalogFixture({
+ provider: 'new-provider',
+ models: [
+ createCatalogModelFixture({
+ model: 'new-model',
+ label: { en_US: 'new-model' },
+ model_properties: { mode: 'chat' },
+ features: [],
+ }),
+ createCatalogModelFixture({
+ model: 'newest-model',
+ label: { en_US: 'newest-model' },
+ model_properties: { mode: 'chat' },
+ features: [],
+ }),
+ ],
+ }),
+ ])
+ queryClient.setQueryDefaults(
+ consoleQuery.workspaces.current.modelProviders.byProvider.models.parameterRules.get.key(),
+ { initialData: { data: [modelRule] } },
+ )
+ let flow: ReactFlowInstance | undefined
+ const result = renderWorkflowFlowComponent(ui, {
resource,
queryClient,
- nodes: initialNodes,
- initialStoreState: storeState,
+ nodes,
+ initialStoreState,
hooksStoreProps: { doSyncWorkflowDraft: mockDoSyncWorkflowDraft },
- // Node rendering is outside this panel's contract; the React Flow graph stays real.
- reactFlowProps: { nodeTypes: { custom: () => null } },
- },
+ reactFlowProps: {
+ nodeTypes: { custom: () => null },
+ onInit: (instance) => {
+ flow = instance
+ },
+ },
+ })
+
+ return {
+ ...result,
+ getNodes: () => {
+ if (!flow) throw new Error('React Flow was not initialized')
+ return flow.getNodes()
+ },
+ }
+ },
+)
+
+function renderPanel(options: RenderPanelOptions = {}) {
+ return renderPanelWithNuqs(<EnvPanel />, options)
+}
+
+async function openCreateVariable(user: ReturnType<typeof userEvent.setup>) {
+ await user.click(screen.getByRole('button', { name: 'workflow.env.envPanelButton' }))
+ await screen.findByRole('textbox', { name: 'workflow.env.modal.name' })
+}
+
+async function openEditVariable(user: ReturnType<typeof userEvent.setup>, name: string) {
+ await user.click(screen.getByRole('button', { name: `common.operation.edit ${name}` }))
+ await screen.findByRole('textbox', { name: 'workflow.env.modal.name' })
+}
+
+async function setTextField(name: string, value: string, user: ReturnType<typeof userEvent.setup>) {
+ const field = screen.getByRole('textbox', { name })
+ await user.clear(field)
+ if (value) await user.type(field, value)
+}
+
+async function selectModel(
+ user: ReturnType<typeof userEvent.setup>,
+ currentModel: string | undefined,
+ nextModel: string,
+) {
+ await user.click(
+ screen.getByRole('button', {
+ name: currentModel ? new RegExp(`^${currentModel}`) : 'plugin.detailPanel.configureModel',
+ }),
+ )
+ const picker = within(
+ await screen.findByRole('dialog', { name: 'plugin.detailPanel.configureModel' }),
+ )
+ await user.click(picker.getByRole('button', { name: new RegExp(`^${nextModel}`) }))
+}
+
+async function saveForm(user: ReturnType<typeof userEvent.setup>) {
+ await user.click(screen.getByRole('button', { name: 'common.operation.save' }))
+ await waitFor(() =>
+ expect(
+ screen.queryByRole('textbox', { name: 'workflow.env.modal.name' }),
+ ).not.toBeInTheDocument(),
)
}
+async function createTextVariable(
+ user: ReturnType<typeof userEvent.setup>,
+ { name, value, description = '' }: { name: string; value: string; description?: string },
+) {
+ await openCreateVariable(user)
+ await user.type(screen.getByRole('textbox', { name: 'workflow.env.modal.name' }), name)
+ await user.type(screen.getByRole('textbox', { name: 'workflow.env.modal.value' }), value)
+ if (description)
+ await user.type(
+ screen.getByRole('textbox', { name: 'workflow.env.modal.description' }),
+ description,
+ )
+ await saveForm(user)
+}
+
+async function createSecretVariable(
+ user: ReturnType<typeof userEvent.setup>,
+ { name, value }: { name: string; value: string },
+) {
+ await openCreateVariable(user)
+ await user.click(screen.getByRole('button', { name: 'Secret', pressed: false }))
+ await user.type(screen.getByRole('textbox', { name: 'workflow.env.modal.name' }), name)
+ await user.type(screen.getByRole('textbox', { name: 'workflow.env.modal.value' }), value)
+ await saveForm(user)
+}
+
+async function changeExistingModel(
+ user: ReturnType<typeof userEvent.setup>,
+ envName: string,
+ currentModel = 'old-model',
+ nextModel = 'new-model',
+) {
+ await openEditVariable(user, envName)
+ await selectModel(user, currentModel, nextModel)
+ await saveForm(user)
+}
+
describe('EnvPanel container', () => {
beforeEach(() => {
- vi.clearAllMocks()
mockDoSyncWorkflowDraft.mockReset()
mockUpdateEnvironmentVariables.mockReset()
mockFetchWorkflowDraft.mockReset()
mockFetchModelParameterRulesForModel.mockReset()
+ mockGetSocket.mockReset()
mockDoSyncWorkflowDraft.mockImplementation(async (_notRefresh, callback) => {
callback?.onSuccess?.()
})
- initialNodes = []
- graph = undefined
- mockVariableTriggerState.savePayload = undefined
mockUpdateEnvironmentVariables.mockResolvedValue({})
mockFetchWorkflowDraft.mockRejectedValue(new Error('draft refresh unavailable'))
mockFetchModelParameterRulesForModel.mockResolvedValue([])
@@ -269,25 +343,28 @@ describe('EnvPanel container', () => {
it('adds a plain variable through the environment API', async () => {
const user = userEvent.setup()
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [], envSecrets: {} },
})
- await saveVariable(user)
+ await createTextVariable(user, {
+ name: 'created_name',
+ value: 'created-value',
+ description: 'created',
+ })
- await waitFor(() => {
+ await waitFor(() =>
expect(store.getState().environmentVariables).toEqual([
expect.objectContaining({
- id: 'env-created',
name: 'created_name',
value: 'created-value',
+ description: 'created',
}),
- ])
- })
+ ]),
+ )
expect(mockUpdateEnvironmentVariables).toHaveBeenCalledWith({
appId: 'app-1',
- environmentVariables: [expect.objectContaining({ id: 'env-created' })],
+ environmentVariables: [expect.objectContaining({ name: 'created_name' })],
deletedEnvironmentVariableIds: [],
})
expect(mockDoSyncWorkflowDraft).not.toHaveBeenCalled()
@@ -302,16 +379,12 @@ describe('EnvPanel container', () => {
})
const emit = vi.fn()
mockGetSocket.mockReturnValue({ emit })
- const { store } = renderWithProviders(
- <EnvPanel />,
- {
- environmentVariables: [existingEnv],
- envSecrets: {},
- },
- { kind: 'knowledge-pipeline', pipelineId: 'pipeline-1' },
- )
let completeSync!: () => void
let variablesSentToDraft: EnvironmentVariable[] = []
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [existingEnv], envSecrets: {} },
+ resource: { kind: 'knowledge-pipeline', pipelineId: 'pipeline-1' },
+ })
mockDoSyncWorkflowDraft.mockImplementationOnce((_notRefresh, callback) => {
variablesSentToDraft = store.getState().environmentVariables
return new Promise((resolve) => {
@@ -322,22 +395,21 @@ describe('EnvPanel container', () => {
})
})
- await saveVariable(user)
- expect(await screen.findByText('created_name')).toBeInTheDocument()
+ await createTextVariable(user, { name: 'created_name', value: 'created-value' })
expect(variablesSentToDraft).toEqual([
- expect.objectContaining({ id: 'env-created', name: 'created_name', value: 'created-value' }),
+ expect.objectContaining({ name: 'created_name', value: 'created-value' }),
existingEnv,
])
await act(async () => completeSync())
- expect(screen.getByText('created_name')).toBeInTheDocument()
+ expect(await screen.findByText('created_name')).toBeInTheDocument()
expect(screen.getByText('existing_variable')).toBeInTheDocument()
expect(mockUpdateEnvironmentVariables).not.toHaveBeenCalled()
expect(mockGetSocket).not.toHaveBeenCalled()
expect(emit).not.toHaveBeenCalled()
})
- it('restores the persisted pipeline variable after draft sync fails and preserves other variables', async () => {
+ it('restores persisted pipeline variables after draft sync fails', async () => {
const user = userEvent.setup()
const existingEnv = createEnv({
name: 'existing_variable',
@@ -350,67 +422,41 @@ describe('EnvPanel container', () => {
value_type: 'string',
value: 'untouched',
})
- const emit = vi.fn()
- mockGetSocket.mockReturnValue({ emit })
- mockVariableTriggerState.savePayload = { ...existingEnv, name: 'rejected_name' }
mockFetchWorkflowDraft.mockResolvedValue({ environment_variables: [existingEnv, untouchedEnv] })
- let failSync!: () => void
mockDoSyncWorkflowDraft.mockImplementation(async (_notRefresh, callback) => {
callback?.onError?.()
})
- mockDoSyncWorkflowDraft.mockImplementationOnce(
- (_notRefresh, callback) =>
- new Promise((resolve) => {
- failSync = () => {
- callback?.onError?.()
- resolve()
- }
- }),
- )
- renderWithProviders(
- <EnvPanel />,
- {
+ renderPanel({
+ initialStoreState: {
environmentVariables: [existingEnv, untouchedEnv],
envSecrets: {},
},
- { kind: 'knowledge-pipeline', pipelineId: 'pipeline-1' },
- )
+ resource: { kind: 'knowledge-pipeline', pipelineId: 'pipeline-1' },
+ })
- await user.click(
- screen.getByRole('button', { name: 'common.operation.edit existing_variable' }),
- )
- await saveVariable(user)
- expect(
- await screen.findByRole('button', { name: 'common.operation.edit rejected_name' }),
- ).toBeInTheDocument()
- await act(async () => failSync())
+ await openEditVariable(user, existingEnv.name)
+ await setTextField('workflow.env.modal.name', 'rejected_name', user)
+ await saveForm(user)
expect(
await screen.findByRole('button', { name: 'common.operation.edit existing_variable' }),
).toBeInTheDocument()
- expect(
- screen.queryByRole('button', { name: 'common.operation.edit rejected_name' }),
- ).not.toBeInTheDocument()
expect(screen.getByText('untouched_variable')).toBeInTheDocument()
expect(mockFetchWorkflowDraft).toHaveBeenCalled()
expect(mockUpdateEnvironmentVariables).not.toHaveBeenCalled()
expect(mockGetSocket).not.toHaveBeenCalled()
- expect(emit).not.toHaveBeenCalled()
})
- it('should delete unused variables and sync draft changes', async () => {
+ it('deletes unused variables through the environment API', async () => {
const user = userEvent.setup()
const env = createEnv({ value_type: 'string', value: 'plain-text' })
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
await user.click(screen.getByRole('button', { name: `common.operation.delete ${env.name}` }))
- await waitFor(() => {
- expect(store.getState().environmentVariables).toEqual([])
- })
+ await waitFor(() => expect(store.getState().environmentVariables).toEqual([]))
expect(mockUpdateEnvironmentVariables).toHaveBeenCalledWith({
appId: 'app-1',
environmentVariables: [],
@@ -419,87 +465,35 @@ describe('EnvPanel container', () => {
expect(mockDoSyncWorkflowDraft).not.toHaveBeenCalled()
})
- it('should add secret variables, persist masked secrets, and sanitize the stored env value', async () => {
+ it('adds secret variables and stores only masked values after persistence', async () => {
const user = userEvent.setup()
vi.spyOn(collaborationManager, 'isConnected').mockReturnValue(true)
- const secretEnv = createEnv({
- id: 'env-secret',
- name: 'secret_key',
- value: '1234567890',
- value_type: 'secret',
- })
- mockVariableTriggerState.savePayload = secretEnv
- mockFetchWorkflowDraft.mockResolvedValueOnce({
- environment_variables: [{ ...secretEnv, value: '********************' }],
+ mockFetchWorkflowDraft.mockImplementationOnce(async () => {
+ const saved = mockUpdateEnvironmentVariables.mock.calls[0]![0].environmentVariables[0]!
+ return {
+ environment_variables: [{ ...saved, value: '********************' }],
+ }
})
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [], envSecrets: {} },
})
- await saveVariable(user)
+ await createSecretVariable(user, { name: 'secret_key', value: '1234567890' })
- await waitFor(() => {
+ await waitFor(() =>
expect(store.getState().environmentVariables).toEqual([
expect.objectContaining({
- id: 'env-secret',
name: 'secret_key',
value: '[__HIDDEN__]',
value_type: 'secret',
}),
- ])
- })
- expect(store.getState().envSecrets).toEqual({
- 'env-secret': '123456************90',
- })
- })
-
- it('should keep a new secret available until draft fallback persistence finishes', async () => {
- const user = userEvent.setup()
- const secretEnv = createEnv({
- id: 'env-secret',
- name: 'secret_key',
- value: '1234567890',
- value_type: 'secret',
- })
- mockVariableTriggerState.savePayload = secretEnv
- mockUpdateEnvironmentVariables.mockRejectedValueOnce(new Error('app-only endpoint'))
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [],
- envSecrets: {},
- })
- let valueDuringDraftFallback: EnvironmentVariable['value'] | undefined
- mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback) => {
- valueDuringDraftFallback = store.getState().environmentVariables[0]?.value
- callback?.onSuccess?.()
- })
-
- await saveVariable(user)
-
- await waitFor(() => {
- expect(store.getState().environmentVariables[0]?.value).toBe('[__HIDDEN__]')
- })
- expect(valueDuringDraftFallback).toBe(secretEnv.value)
- expect(store.getState().envSecrets).toEqual({
- [secretEnv.id]: '123456************90',
- })
+ ]),
+ )
+ expect(Object.values(store.getState().envSecrets)).toEqual(['123456************90'])
})
- it('should retain masks for multiple secrets saved through the queue', async () => {
+ it('retains masks for multiple secrets saved through the reachable queue', async () => {
const user = userEvent.setup()
- const firstSecret = createEnv({
- id: 'secret-a',
- name: 'secret_a',
- value: 'first-secret-01',
- value_type: 'secret',
- })
- const secondSecret = createEnv({
- id: 'secret-b',
- name: 'secret_b',
- value: 'second-secret-02',
- value_type: 'secret',
- })
let resolveFirstPersistence!: (value: unknown) => void
mockUpdateEnvironmentVariables
.mockReturnValueOnce(
@@ -508,90 +502,73 @@ describe('EnvPanel container', () => {
}),
)
.mockResolvedValueOnce({})
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [], envSecrets: {} },
})
- mockVariableTriggerState.savePayload = firstSecret
- await saveVariable(user)
+ await createSecretVariable(user, { name: 'secret_a', value: 'first-secret-01' })
await waitFor(() => expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1))
-
- mockVariableTriggerState.savePayload = secondSecret
- await saveVariable(user)
+ await createSecretVariable(user, { name: 'secret_b', value: 'second-secret-02' })
expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1)
- resolveFirstPersistence({})
- await waitFor(() => {
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(2)
- expect(store.getState().envSecrets).toEqual({
- [firstSecret.id]: 'first-************01',
- [secondSecret.id]: 'second************02',
- })
- })
+ await act(async () => resolveFirstPersistence({}))
+ await waitFor(() => expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(2))
+ expect(store.getState().environmentVariables.map((env) => env.name)).toEqual([
+ 'secret_b',
+ 'secret_a',
+ ])
+ expect(Object.values(store.getState().envSecrets)).toEqual([
+ 'first-************01',
+ 'second************02',
+ ])
})
- it('should clear the current variable when the variable modal closes', async () => {
+ it('clears the edited variable when the real form closes', async () => {
const user = userEvent.setup()
const env = createEnv({ value_type: 'string', value: 'plain-text' })
-
- renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ renderPanel({
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- expect(await screen.findByRole('textbox', { name: 'Variable being edited' })).toHaveValue(
- 'api_key',
- )
-
- await user.click(screen.getByRole('button', { name: 'Close variable modal' }))
-
+ await openEditVariable(user, env.name)
+ expect(screen.getByRole('textbox', { name: 'workflow.env.modal.name' })).toHaveValue(env.name)
+ await user.click(screen.getAllByRole('button', { name: 'common.operation.close' }).at(-1)!)
await waitFor(() =>
- expect(screen.queryByRole('button', { name: 'Save variable' })).not.toBeInTheDocument(),
+ expect(
+ screen.queryByRole('textbox', { name: 'workflow.env.modal.name' }),
+ ).not.toBeInTheDocument(),
)
- await user.click(screen.getByRole('button', { name: 'workflow.env.envPanelButton' }))
- expect(await screen.findByRole('textbox', { name: 'Variable being edited' })).toHaveValue('')
+ await openCreateVariable(user)
+
+ expect(screen.getByRole('textbox', { name: 'workflow.env.modal.name' })).toHaveValue('')
expect(mockUpdateEnvironmentVariables).not.toHaveBeenCalled()
})
- it('should rename existing secret variables and update affected nodes without re-saving unchanged secrets', async () => {
+ it('renames existing secrets and updates affected nodes without re-saving the secret', async () => {
const user = userEvent.setup()
const env = createEnv()
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: 'renamed_key',
- value: '[__HIDDEN__]',
- value_type: 'secret',
- })
- setNodes([
+ const nodes = [
createCodeNode('node-1', [{ variable: 'key', value_selector: ['env', env.name] }]),
createCodeNode('node-2'),
- ])
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {
- [env.id]: '[__HIDDEN__]',
+ ]
+ const { getNodes, store } = renderPanel({
+ nodes,
+ initialStoreState: {
+ environmentVariables: [env],
+ envSecrets: { [env.id]: '[__HIDDEN__]' },
},
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await openEditVariable(user, env.name)
+ await setTextField('workflow.env.modal.name', 'renamed_key', user)
+ await saveForm(user)
- await waitFor(() => {
+ await waitFor(() =>
expect(store.getState().environmentVariables).toEqual([
- expect.objectContaining({
- id: env.id,
- name: 'renamed_key',
- value: '[__HIDDEN__]',
- value_type: 'secret',
- }),
- ])
- })
- expect(store.getState().envSecrets).toEqual({
- [env.id]: '[__HIDDEN__]',
- })
+ expect.objectContaining({ name: 'renamed_key', value: '[__HIDDEN__]' }),
+ ]),
+ )
+ expect(store.getState().envSecrets).toEqual({ [env.id]: '[__HIDDEN__]' })
expect(getNodes()).toEqual([
expect.objectContaining({
id: 'node-1',
@@ -603,53 +580,32 @@ describe('EnvPanel container', () => {
])
})
- it('should convert edited plain variables into secrets and store the masked secret value', async () => {
+ it('converts edited plain variables into masked secrets', async () => {
const user = userEvent.setup()
const env = createEnv({ value_type: 'string', value: 'plain-text' })
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value: 'abcdef123456',
- value_type: 'secret',
- })
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await openEditVariable(user, env.name)
+ await user.click(screen.getByRole('button', { name: 'Secret', pressed: false }))
+ await setTextField('workflow.env.modal.value', 'abcdef123456', user)
+ await saveForm(user)
- await waitFor(() => {
+ await waitFor(() =>
expect(store.getState().environmentVariables).toEqual([
- expect.objectContaining({
- id: env.id,
- value: '[__HIDDEN__]',
- value_type: 'secret',
- }),
- ])
- })
- expect(store.getState().envSecrets).toEqual({
- [env.id]: 'abcdef************56',
- })
+ expect.objectContaining({ value: '[__HIDDEN__]', value_type: 'secret' }),
+ ]),
+ )
+ expect(store.getState().envSecrets).toEqual({ [env.id]: 'abcdef************56' })
})
- it('should reconcile nodes when a shared LLM model changes', async () => {
+ it('reconciles referenced nodes when a shared model changes', async () => {
const user = userEvent.setup()
const emit = vi.fn()
mockGetSocket.mockReturnValue({ emit })
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- })
+ mockFetchModelParameterRulesForModel.mockResolvedValue([modelRule])
+ const env = oldModelEnv()
const llmNode = createLLMNode({
data: {
model: {
@@ -665,139 +621,103 @@ describe('EnvPanel container', () => {
},
},
})
- setNodes([llmNode])
- mockFetchModelParameterRulesForModel.mockResolvedValue([
- {
- name: 'temperature',
- type: 'float',
- min: 0,
- max: 2,
- label: { en_US: 'Temperature', zh_Hans: 'Temperature' },
- required: false,
- },
- ])
-
- renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ const { getNodes } = renderPanel({
+ nodes: [llmNode],
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await changeExistingModel(user, env.name)
- await waitFor(() => {
- expect(getNodes()).toEqual([
+ await waitFor(() =>
+ expect(getNodes()[0]?.data).toEqual(
expect.objectContaining({
- id: 'llm-node',
- data: expect.objectContaining({
- model: expect.objectContaining({
- provider: 'new-provider',
- name: 'new-model',
- completion_params: { temperature: 0.7 },
- }),
- vision: { enabled: false },
+ model: expect.objectContaining({
+ provider: 'new-provider',
+ name: 'new-model',
+ completion_params: { temperature: 0.7 },
}),
+ vision: { enabled: false },
}),
- ])
- })
- expect(mockDoSyncWorkflowDraft).toHaveBeenCalledTimes(1)
+ ),
+ )
expect(mockDoSyncWorkflowDraft).toHaveBeenCalledWith(false, expect.any(Object), {
environmentVariablePatch: {
environmentVariables: [
- expect.objectContaining({
- id: env.id,
- value: expect.objectContaining({ name: 'new-model' }),
- }),
+ expect.objectContaining({ value: expect.objectContaining({ name: 'new-model' }) }),
],
deletedEnvironmentVariableIds: [],
},
})
- await waitFor(() => {
- expect(emit).toHaveBeenCalledWith('collaboration_event', {
- type: 'vars_and_features_update',
- })
+ expect(emit).toHaveBeenCalledWith('collaboration_event', {
+ type: 'vars_and_features_update',
})
})
- it('should persist shared LLM parameters without rewriting referenced nodes', async () => {
+ it('persists shared model parameters without rewriting the graph', async () => {
const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
+ const env = oldModelEnv({
value: {
- provider: 'shared-provider',
- name: 'shared-model',
+ provider: 'old-provider',
+ name: 'old-model',
mode: 'chat',
completion_params: { temperature: 0.2 },
},
})
- const nextEnv = createEnv({
- ...env,
- value: {
- provider: 'shared-provider',
- name: 'shared-model',
- mode: 'chat',
- completion_params: { temperature: 0.8 },
- },
+ const { getNodes, store } = renderPanel({
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- mockVariableTriggerState.savePayload = nextEnv
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await openEditVariable(user, env.name)
+ await user.click(screen.getByRole('button', { name: /modelProvider.modelSettings/ }))
+ const temperature = screen.getByRole('spinbutton', { name: 'Temperature' })
+ await user.clear(temperature)
+ await user.type(temperature, '0.8')
+ await user.tab()
+ await user.keyboard('{Escape}')
+ await saveForm(user)
- await waitFor(() => {
- expect(store.getState().environmentVariables).toEqual([nextEnv])
- })
+ await waitFor(() =>
+ expect(store.getState().environmentVariables[0]?.value).toEqual(
+ expect.objectContaining({ completion_params: { temperature: 0.8 } }),
+ ),
+ )
expect(mockUpdateEnvironmentVariables).toHaveBeenCalledWith({
appId: 'app-1',
- environmentVariables: [nextEnv],
+ environmentVariables: [
+ expect.objectContaining({
+ value: expect.objectContaining({ completion_params: { temperature: 0.8 } }),
+ }),
+ ],
deletedEnvironmentVariableIds: [],
})
- expect(getNodes()).toMatchObject(initialNodes)
+ expect(getNodes()).toEqual([])
+ expect(mockDoSyncWorkflowDraft).not.toHaveBeenCalled()
})
- it('should persist follower graph edits before asking the leader to sync', async () => {
+ it('persists follower graph edits before asking the leader to sync', async () => {
const user = userEvent.setup()
const emit = vi.fn()
mockGetSocket.mockReturnValue({ emit })
vi.spyOn(collaborationManager, 'isConnected').mockReturnValue(true)
vi.spyOn(collaborationManager, 'getIsLeader').mockReturnValue(false)
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const nextEnv = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
+ const env = oldModelEnv()
+ const { store } = renderPanel({
+ nodes: [createLLMNode({ data: { model_selector: ['env', env.name] } })],
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- const llmNode = createLLMNode({
- data: {
- model_selector: ['env', env.name],
- },
- })
- mockVariableTriggerState.savePayload = nextEnv
- setNodes([llmNode])
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await changeExistingModel(user, env.name)
- await waitFor(() => {
- expect(store.getState().environmentVariables).toEqual([nextEnv])
- })
+ await waitFor(() =>
+ expect(store.getState().environmentVariables[0]?.value).toEqual(
+ expect.objectContaining({ provider: 'new-provider', name: 'new-model' }),
+ ),
+ )
expect(mockUpdateEnvironmentVariables).toHaveBeenCalledWith({
appId: 'app-1',
- environmentVariables: [nextEnv],
+ environmentVariables: [
+ expect.objectContaining({ value: expect.objectContaining({ name: 'new-model' }) }),
+ ],
deletedEnvironmentVariableIds: [],
})
expect(mockDoSyncWorkflowDraft).not.toHaveBeenCalled()
@@ -807,90 +727,9 @@ describe('EnvPanel container', () => {
})
})
- it('should reconcile the latest node parameters after model rules finish loading', async () => {
- const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- })
- const staleNode = createLLMNode({
- data: {
- model: {
- provider: 'old-provider',
- name: 'old-model',
- mode: 'chat',
- completion_params: { temperature: 0.2 },
- },
- model_selector: ['env', env.name],
- },
- })
- const latestNode = createLLMNode({
- ...staleNode,
- data: {
- ...staleNode.data,
- model: {
- ...staleNode.data.model,
- completion_params: { temperature: 0.9, obsolete: true },
- },
- },
- })
- let resolveRules!: (rules: ModelParameterRule[]) => void
- mockFetchModelParameterRulesForModel.mockReturnValueOnce(
- new Promise((resolve) => {
- resolveRules = resolve
- }),
- )
- setNodes([staleNode])
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
- await waitFor(() => {
- expect(mockFetchModelParameterRulesForModel).toHaveBeenCalledTimes(1)
- })
- expect(store.getState().environmentVariables).toEqual([env])
- expect(mockDoSyncWorkflowDraft).not.toHaveBeenCalled()
-
- setNodes([latestNode])
- resolveRules([
- {
- name: 'temperature',
- type: 'float',
- min: 0,
- max: 2,
- label: { en_US: 'Temperature', zh_Hans: 'Temperature' },
- required: false,
- },
- ])
-
- await waitFor(() => {
- expect(getNodes()).toEqual([
- expect.objectContaining({
- data: expect.objectContaining({
- model: expect.objectContaining({ completion_params: { temperature: 0.9 } }),
- }),
- }),
- ])
- })
- })
-
- it('should preserve the shared model and nodes when model rules cannot be fetched', async () => {
+ it('preserves the shared model and nodes when model rules cannot be fetched', async () => {
const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
+ const env = oldModelEnv()
const llmNode = createLLMNode({
data: {
model: {
@@ -902,136 +741,55 @@ describe('EnvPanel container', () => {
model_selector: ['env', env.name],
},
})
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- })
- setNodes([llmNode])
mockFetchModelParameterRulesForModel.mockRejectedValueOnce(new Error('network error'))
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ const { getNodes, store } = renderPanel({
+ nodes: [llmNode],
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
- await waitFor(() => {
- expect(mockFetchModelParameterRulesForModel).toHaveBeenCalledTimes(1)
- })
- await waitFor(() => {
- expect(store.getState().environmentVariables).toEqual([env])
- })
- expect(getNodes()).toMatchObject(initialNodes)
+ await changeExistingModel(user, env.name)
+
+ await waitFor(() => expect(store.getState().environmentVariables).toEqual([env]))
+ expect(getNodes()[0]?.data).toEqual(llmNode.data)
expect(mockUpdateEnvironmentVariables).not.toHaveBeenCalled()
expect(mockDoSyncWorkflowDraft).not.toHaveBeenCalled()
})
- it('should roll back a shared model when both persistence paths fail', async () => {
+ it('rolls back a shared model when both persistence paths fail', async () => {
const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- })
+ const env = oldModelEnv()
mockUpdateEnvironmentVariables.mockRejectedValueOnce(new Error('environment API failed'))
mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback) => {
callback?.onError?.()
})
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+
+ await changeExistingModel(user, env.name)
await waitFor(() => {
expect(mockDoSyncWorkflowDraft).toHaveBeenCalledTimes(1)
expect(store.getState().environmentVariables).toEqual([env])
})
- expect(getNodes()).toMatchObject(initialNodes)
})
- it('should preserve a newer remote value when a local alias save fails', async () => {
+ it('preserves a newer remote value when a local model save fails', async () => {
const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const remoteEnv = createEnv({
- ...env,
+ const env = oldModelEnv()
+ const remoteEnv = oldModelEnv({
value: { provider: 'remote-provider', name: 'remote-model', mode: 'chat' },
})
- mockVariableTriggerState.savePayload = createEnv({
- ...env,
- value: { provider: 'new-provider', name: 'local-model', mode: 'chat' },
- })
mockUpdateEnvironmentVariables.mockRejectedValueOnce(new Error('environment API failed'))
mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback) => {
callback?.onError?.()
})
mockFetchWorkflowDraft.mockResolvedValueOnce({ environment_variables: [remoteEnv] })
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
- await waitFor(() => {
- expect(mockFetchWorkflowDraft).toHaveBeenCalledTimes(1)
- expect(store.getState().environmentVariables).toEqual([remoteEnv])
- })
- })
-
- it('should preserve an observed remote value when failure recovery cannot refetch', async () => {
- const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const remoteEnv = createEnv({
- ...env,
- value: { provider: 'remote-provider', name: 'remote-model', mode: 'chat' },
- })
- mockVariableTriggerState.savePayload = createEnv({
- ...env,
- value: { provider: 'new-provider', name: 'local-model', mode: 'chat' },
- })
- let rejectPersistence!: (reason: Error) => void
- mockUpdateEnvironmentVariables.mockReturnValueOnce(
- new Promise((_resolve, reject) => {
- rejectPersistence = reject
- }),
- )
- mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback) => {
- callback?.onError?.()
- })
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
- await waitFor(() => expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1))
-
- act(() => {
- store.getState().setEnvironmentVariables([remoteEnv])
- })
- rejectPersistence(new Error('environment API failed'))
+ await changeExistingModel(user, env.name)
await waitFor(() => {
expect(mockFetchWorkflowDraft).toHaveBeenCalledTimes(1)
@@ -1039,529 +797,231 @@ describe('EnvPanel container', () => {
})
})
- it('should accept an alias save that committed before its response failed', async () => {
+ it('accepts a model save that committed before its response failed', async () => {
const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const savedEnv = createEnv({
- ...env,
- value: { provider: 'new-provider', name: 'saved-model', mode: 'chat' },
+ const env = oldModelEnv()
+ const savedEnv = oldModelEnv({
+ value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
})
- mockVariableTriggerState.savePayload = savedEnv
mockUpdateEnvironmentVariables.mockRejectedValueOnce(new Error('response lost'))
mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback) => {
callback?.onError?.()
})
mockFetchWorkflowDraft.mockResolvedValueOnce({ environment_variables: [savedEnv] })
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ const { store } = renderPanel({
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
- await waitFor(() => {
- expect(store.getState().environmentVariables).toEqual([savedEnv])
- })
+ await changeExistingModel(user, env.name)
+
+ await waitFor(() => expect(store.getState().environmentVariables).toEqual([savedEnv]))
expect(mockFetchWorkflowDraft).toHaveBeenCalledTimes(1)
})
- it('should roll back model reconciliation when the atomic draft sync fails', async () => {
+ it('rolls back model reconciliation when atomic draft sync fails', async () => {
const user = userEvent.setup()
+ const env = oldModelEnv()
+ const llmNode = createLLMNode({ data: { model_selector: ['env', env.name] } })
let modelAtSync: unknown
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const llmNode = createLLMNode({
- data: {
- model_selector: ['env', env.name],
- },
- })
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
+ const { getNodes, store } = renderPanel({
+ nodes: [llmNode],
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- setNodes([llmNode])
mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback) => {
modelAtSync = getNodes()[0]?.data.model
- setNodes([
- createLLMNode({
- id: llmNode.id,
- data: {
- ...llmNode.data,
- title: 'Concurrent edit',
- model: {
- ...llmNode.data.model,
- provider: 'new-provider',
- name: 'new-model',
- },
- },
- }),
- ])
callback?.onError?.()
})
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await changeExistingModel(user, env.name)
await waitFor(() => {
- expect(mockDoSyncWorkflowDraft).toHaveBeenCalledTimes(1)
expect(getNodes()[0]?.data.model).toMatchObject({
provider: 'old-provider',
name: 'old-model',
})
expect(store.getState().environmentVariables).toEqual([env])
})
- expect(getNodes()).toEqual([
- expect.objectContaining({
- data: expect.objectContaining({
- title: 'Concurrent edit',
- model: expect.objectContaining({
- provider: 'old-provider',
- name: 'old-model',
- }),
- }),
- }),
- ])
expect(modelAtSync).toMatchObject({ provider: 'new-provider', name: 'new-model' })
expect(mockUpdateEnvironmentVariables).not.toHaveBeenCalled()
})
- it('should roll back a graph edit when draft sync settles without succeeding', async () => {
+ it('keeps model reconciliation when a remote snapshot changes only alias metadata', async () => {
const user = userEvent.setup()
- let modelAtSync: unknown
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
+ vi.spyOn(collaborationManager, 'isConnected').mockReturnValue(true)
+ vi.spyOn(collaborationManager, 'getIsLeader').mockReturnValue(true)
+ const env = oldModelEnv()
+ let savedEnv: EnvironmentVariable | undefined
+ mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback, options) => {
+ savedEnv = options?.environmentVariablePatch?.environmentVariables[0]
+ callback?.onSuccess?.()
})
- const llmNode = createLLMNode({
- data: {
- model_selector: ['env', env.name],
- },
+ mockFetchWorkflowDraft.mockImplementationOnce(async () => {
+ if (!savedEnv) throw new Error('No model save reached draft persistence')
+ return {
+ environment_variables: [{ ...savedEnv, description: 'remote description' }],
+ }
})
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- })
- setNodes([llmNode])
- mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback) => {
- modelAtSync = getNodes()[0]?.data.model
- callback?.onSettled?.()
+ const { getNodes, store } = renderPanel({
+ nodes: [createLLMNode({ data: { model_selector: ['env', env.name] } })],
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await changeExistingModel(user, env.name)
- await waitFor(() => {
- expect(mockDoSyncWorkflowDraft).toHaveBeenCalledTimes(1)
- expect(getNodes()[0]?.data.model).toMatchObject({
- provider: 'old-provider',
- name: 'old-model',
- })
- expect(store.getState().environmentVariables).toEqual([env])
+ await waitFor(() =>
+ expect(store.getState().environmentVariables).toEqual([
+ expect.objectContaining({ description: 'remote description' }),
+ ]),
+ )
+ expect(getNodes()[0]?.data.model).toMatchObject({
+ provider: 'new-provider',
+ name: 'new-model',
})
- expect(modelAtSync).toMatchObject({ provider: 'new-provider', name: 'new-model' })
- expect(mockUpdateEnvironmentVariables).not.toHaveBeenCalled()
})
it('should reconcile a model change before a queued metadata-only save', async () => {
const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const llmNode = createLLMNode({
- data: {
- model_selector: ['env', env.name],
- },
- })
+ const env = oldModelEnv()
+ const requestPayloads: Array<{
+ description: string
+ model: string | undefined
+ persistence: 'draft' | 'environment'
+ }> = []
let resolveFirstRules!: (rules: ModelParameterRule[]) => void
mockFetchModelParameterRulesForModel.mockReturnValueOnce(
new Promise((resolve) => {
resolveFirstRules = resolve
}),
)
- setNodes([llmNode])
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
+ mockDoSyncWorkflowDraft.mockImplementationOnce(async (_notRefresh, callback, options) => {
+ const savedEnv = options?.environmentVariablePatch?.environmentVariables[0]
+ requestPayloads.push({
+ description: savedEnv?.description ?? '',
+ model: isLLMEnvironmentVariableValue(savedEnv?.value) ? savedEnv.value.name : undefined,
+ persistence: 'draft',
+ })
+ callback?.onSuccess?.()
})
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
+ mockUpdateEnvironmentVariables.mockImplementationOnce(async (payload) => {
+ const savedEnv = payload.environmentVariables[0]
+ requestPayloads.push({
+ description: savedEnv?.description ?? '',
+ model: isLLMEnvironmentVariableValue(savedEnv?.value) ? savedEnv.value.name : undefined,
+ persistence: 'environment',
+ })
+ return {}
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- description: 'updated description',
+ const { getNodes, store } = renderPanel({
+ nodes: [createLLMNode({ data: { model_selector: ['env', env.name] } })],
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- await saveVariable(user)
+
+ await changeExistingModel(user, env.name)
+ await openEditVariable(user, env.name)
+ await selectModel(user, 'old-model', 'new-model')
+ await setTextField('workflow.env.modal.description', 'updated description', user)
+ await saveForm(user)
+
expect(mockFetchModelParameterRulesForModel).toHaveBeenCalledTimes(1)
+ expect(requestPayloads).toEqual([])
- resolveFirstRules([])
+ await act(async () => resolveFirstRules([]))
- await waitFor(() => {
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1)
- })
- expect(mockUpdateEnvironmentVariables).toHaveBeenLastCalledWith(
- expect.objectContaining({
- environmentVariables: [
- expect.objectContaining({
- description: 'updated description',
- value: expect.objectContaining({ name: 'new-model' }),
- }),
- ],
- }),
+ await waitFor(() =>
+ expect(store.getState().environmentVariables).toEqual([
+ expect.objectContaining({
+ description: 'updated description',
+ value: expect.objectContaining({ name: 'new-model' }),
+ }),
+ ]),
)
- expect(getNodes()[0]?.data.model).toMatchObject({ provider: 'new-provider', name: 'new-model' })
- expect(store.getState().environmentVariables).toEqual([
- expect.objectContaining({
+ expect(requestPayloads).toEqual([
+ { description: '', model: 'new-model', persistence: 'draft' },
+ {
description: 'updated description',
- value: expect.objectContaining({ name: 'new-model' }),
- }),
+ model: 'new-model',
+ persistence: 'environment',
+ },
])
- })
-
- it('should serialize shared-model persistence so the latest save reaches the server last', async () => {
- const user = userEvent.setup()
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- let resolveFirstPersistence!: (value: unknown) => void
- mockUpdateEnvironmentVariables
- .mockReturnValueOnce(
- new Promise((resolve) => {
- resolveFirstPersistence = resolve
- }),
- )
- .mockResolvedValueOnce({})
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- })
-
- renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
- await waitFor(() => {
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1)
- })
-
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'newest-model', mode: 'chat' },
- })
- await saveVariable(user)
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1)
-
- resolveFirstPersistence({})
- await waitFor(() => {
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(2)
+ expect(getNodes()[0]?.data.model).toMatchObject({
+ provider: 'new-provider',
+ name: 'new-model',
})
- expect(mockUpdateEnvironmentVariables).toHaveBeenLastCalledWith(
- expect.objectContaining({
- environmentVariables: [
- expect.objectContaining({ value: expect.objectContaining({ name: 'newest-model' }) }),
- ],
- }),
- )
})
- it('should preserve a remote update to an untouched alias across queued local saves', async () => {
+ it('should serialize shared-model persistence so the latest save reaches the server last', async () => {
const user = userEvent.setup()
- const localEnv = createEnv({
- id: 'env-local',
- name: 'local_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-local', mode: 'chat' },
- })
- const remoteEnv = createEnv({
- id: 'env-remote',
- name: 'remote_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-remote', mode: 'chat' },
- })
- const remotelyUpdatedEnv = createEnv({
- ...remoteEnv,
- value: { provider: 'remote-provider', name: 'remote-update', mode: 'chat' },
- })
- let resolveFirstPersistence!: (value: unknown) => void
+ const env = oldModelEnv()
+ let persistedEnv = env
+ let resolveFirstPersistence!: () => void
+ vi.spyOn(collaborationManager, 'isConnected').mockReturnValue(true)
+ vi.spyOn(collaborationManager, 'getIsLeader').mockReturnValue(false)
+ mockFetchWorkflowDraft.mockImplementation(async () => ({
+ environment_variables: [persistedEnv],
+ }))
mockUpdateEnvironmentVariables
- .mockReturnValueOnce(
- new Promise((resolve) => {
- resolveFirstPersistence = resolve
- }),
- )
- .mockResolvedValueOnce({})
- mockVariableTriggerState.savePayload = createEnv({
- ...localEnv,
- value: { provider: 'new-provider', name: 'first-local-update', mode: 'chat' },
- })
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [localEnv, remoteEnv],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${localEnv.name}` }))
- await saveVariable(user)
- await waitFor(() => {
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1)
- })
-
- act(() => {
- store.getState().setEnvironmentVariables([localEnv, remotelyUpdatedEnv])
- })
- mockVariableTriggerState.savePayload = createEnv({
- ...localEnv,
- value: { provider: 'new-provider', name: 'second-local-update', mode: 'chat' },
- })
- await saveVariable(user)
- resolveFirstPersistence({})
-
- await waitFor(() => {
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(2)
- })
- expect(mockUpdateEnvironmentVariables).toHaveBeenLastCalledWith(
- expect.objectContaining({
- environmentVariables: [
- expect.objectContaining({
- id: localEnv.id,
- value: expect.objectContaining({ name: 'second-local-update' }),
+ .mockImplementationOnce(
+ (payload) =>
+ new Promise((resolve) => {
+ resolveFirstPersistence = () => {
+ persistedEnv = payload.environmentVariables[0]!
+ resolve({})
+ }
}),
- ],
- deletedEnvironmentVariableIds: [],
- }),
- )
- })
-
- it('should keep a newer server value for the same alias after a delayed local response', async () => {
- const user = userEvent.setup()
- vi.spyOn(collaborationManager, 'isConnected').mockReturnValue(true)
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const localEnv = createEnv({
- ...env,
- value: { provider: 'local-provider', name: 'local-model', mode: 'chat' },
- })
- const remoteEnv = createEnv({
- ...env,
- value: { provider: 'remote-provider', name: 'remote-model', mode: 'chat' },
+ )
+ .mockImplementationOnce(async (payload) => {
+ persistedEnv = payload.environmentVariables[0]!
+ return {}
+ })
+ const { getNodes, store } = renderPanel({
+ nodes: [createLLMNode({ data: { model_selector: ['env', env.name] } })],
+ initialStoreState: { environmentVariables: [env], envSecrets: {} },
})
- let resolvePersistence!: (value: unknown) => void
- mockUpdateEnvironmentVariables.mockReturnValueOnce(
- new Promise((resolve) => {
- resolvePersistence = resolve
- }),
- )
- mockFetchWorkflowDraft.mockResolvedValueOnce({ environment_variables: [remoteEnv] })
- mockVariableTriggerState.savePayload = localEnv
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await changeExistingModel(user, env.name)
await waitFor(() => expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1))
+ await openEditVariable(user, env.name)
+ await selectModel(user, 'new-model', 'newest-model')
+ await setTextField('workflow.env.modal.description', 'latest description', user)
+ await saveForm(user)
+ expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(1)
- act(() => {
- store.getState().setEnvironmentVariables([remoteEnv])
- })
- resolvePersistence({})
-
- await waitFor(() => {
- expect(mockFetchWorkflowDraft).toHaveBeenCalledTimes(1)
- expect(store.getState().environmentVariables).toEqual([remoteEnv])
- })
- })
-
- it('should keep model reconciliation when only remote alias metadata differs', async () => {
- const user = userEvent.setup()
- vi.spyOn(collaborationManager, 'isConnected').mockReturnValue(true)
- vi.spyOn(collaborationManager, 'getIsLeader').mockReturnValue(true)
- const env = createEnv({
- name: 'shared_model',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-model', mode: 'chat' },
- })
- const localEnv = createEnv({
- ...env,
- description: 'local description',
- value: { provider: 'new-provider', name: 'new-model', mode: 'chat' },
- })
- const serverEnv = { ...localEnv, description: 'remote description' }
- const llmNode = createLLMNode({
- data: {
- model_selector: ['env', env.name],
- },
- })
- mockVariableTriggerState.savePayload = localEnv
- setNodes([llmNode])
- mockFetchWorkflowDraft.mockResolvedValueOnce({ environment_variables: [serverEnv] })
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
-
- await waitFor(() => {
- expect(store.getState().environmentVariables).toEqual([serverEnv])
- })
- expect(getNodes()[0]?.data.model).toMatchObject({ provider: 'new-provider', name: 'new-model' })
- expect(getNodes()[0]?.data?.model).toEqual(
- expect.objectContaining({ provider: 'new-provider', name: 'new-model' }),
- )
- })
-
- it('should carry a draft-fallback alias save into the next queued alias update', async () => {
- const user = userEvent.setup()
- const firstEnv = createEnv({
- id: 'env-a',
- name: 'model_a',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-a', mode: 'chat' },
- })
- const secondEnv = createEnv({
- id: 'env-b',
- name: 'model_b',
- value_type: 'llm',
- value: { provider: 'old-provider', name: 'old-b', mode: 'chat' },
- })
- mockUpdateEnvironmentVariables.mockRejectedValueOnce(new Error('app-only endpoint'))
- mockVariableTriggerState.savePayload = createEnv({
- id: firstEnv.id,
- name: firstEnv.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-a', mode: 'chat' },
- })
-
- renderWithProviders(<EnvPanel />, {
- environmentVariables: [firstEnv, secondEnv],
- envSecrets: {},
- })
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${firstEnv.name}` }))
- await saveVariable(user)
- await waitFor(() => {
- expect(mockDoSyncWorkflowDraft).toHaveBeenCalledTimes(1)
- })
-
- mockVariableTriggerState.savePayload = createEnv({
- id: secondEnv.id,
- name: secondEnv.name,
- value_type: 'llm',
- value: { provider: 'new-provider', name: 'new-b', mode: 'chat' },
- })
- await user.click(
- screen.getByRole('button', { name: `common.operation.edit ${secondEnv.name}` }),
- )
- await saveVariable(user)
-
- await waitFor(() => {
- expect(mockUpdateEnvironmentVariables).toHaveBeenCalledTimes(2)
- })
- expect(mockUpdateEnvironmentVariables).toHaveBeenLastCalledWith(
- expect.objectContaining({
- environmentVariables: [
- expect.objectContaining({
- id: secondEnv.id,
- value: expect.objectContaining({ name: 'new-b' }),
- }),
- ],
- deletedEnvironmentVariableIds: [],
- }),
- )
- })
-
- it('should persist a new masked secret when an existing secret variable changes value', async () => {
- const user = userEvent.setup()
- const env = createEnv()
- mockVariableTriggerState.savePayload = createEnv({
- id: env.id,
- name: env.name,
- value: 'updated-secret-99',
- value_type: 'secret',
- })
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {
- [env.id]: '[__HIDDEN__]',
- },
- })
-
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await act(async () => resolveFirstPersistence())
- await waitFor(() => {
+ await waitFor(() =>
expect(store.getState().environmentVariables).toEqual([
expect.objectContaining({
- id: env.id,
- value: '[__HIDDEN__]',
- value_type: 'secret',
+ description: 'latest description',
+ value: expect.objectContaining({ name: 'newest-model' }),
}),
- ])
- })
- expect(store.getState().envSecrets).toEqual({
- [env.id]: 'update************99',
+ ]),
+ )
+ expect(
+ mockUpdateEnvironmentVariables.mock.calls.map(([payload]) => {
+ const savedEnv = payload.environmentVariables[0]!
+ return {
+ description: savedEnv.description,
+ model: isLLMEnvironmentVariableValue(savedEnv.value) ? savedEnv.value.name : undefined,
+ }
+ }),
+ ).toEqual([
+ { description: '', model: 'new-model' },
+ { description: 'latest description', model: 'newest-model' },
+ ])
+ expect(getNodes()[0]?.data.model).toMatchObject({
+ provider: 'new-provider',
+ name: 'newest-model',
})
})
- it('should keep an edited secret available until draft fallback persistence finishes', async () => {
+ it('keeps an edited secret available through draft fallback and then masks it', async () => {
const user = userEvent.setup()
const env = createEnv()
- const nextEnv = createEnv({
- id: env.id,
- name: env.name,
- value: 'updated-secret-99',
- value_type: 'secret',
- })
- mockVariableTriggerState.savePayload = nextEnv
mockUpdateEnvironmentVariables.mockRejectedValueOnce(new Error('app-only endpoint'))
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {
- [env.id]: '[__HIDDEN__]',
+ const { store } = renderPanel({
+ initialStoreState: {
+ environmentVariables: [env],
+ envSecrets: { [env.id]: '[__HIDDEN__]' },
},
})
let valueDuringDraftFallback: EnvironmentVariable['value'] | undefined
@@ -1570,30 +1030,28 @@ describe('EnvPanel container', () => {
callback?.onSuccess?.()
})
- await user.click(screen.getByRole('button', { name: `common.operation.edit ${env.name}` }))
- await saveVariable(user)
+ await openEditVariable(user, env.name)
+ await setTextField('workflow.env.modal.value', 'updated-secret-99', user)
+ await saveForm(user)
- await waitFor(() => {
- expect(store.getState().environmentVariables[0]?.value).toBe('[__HIDDEN__]')
- })
- expect(valueDuringDraftFallback).toBe(nextEnv.value)
- expect(store.getState().envSecrets).toEqual({
- [env.id]: 'update************99',
- })
+ await waitFor(() =>
+ expect(store.getState().environmentVariables[0]?.value).toBe('[__HIDDEN__]'),
+ )
+ expect(valueDuringDraftFallback).toBe('updated-secret-99')
+ expect(store.getState().envSecrets).toEqual({ [env.id]: 'update************99' })
})
- it('should require confirmation before deleting affected secret variables', async () => {
+ it('requires confirmation before deleting affected secret variables', async () => {
const user = userEvent.setup()
const env = createEnv()
- setNodes([
- createCodeNode('node-1', [{ variable: 'key', value_selector: ['env', env.name] }]),
- createCodeNode('node-2'),
- ])
-
- const { store } = renderWithProviders(<EnvPanel />, {
- environmentVariables: [env],
- envSecrets: {
- [env.id]: 'abcdef************56',
+ const { getNodes, store } = renderPanel({
+ nodes: [
+ createCodeNode('node-1', [{ variable: 'key', value_selector: ['env', env.name] }]),
+ createCodeNode('node-2'),
+ ],
+ initialStoreState: {
+ environmentVariables: [env],
+ envSecrets: { [env.id]: 'abcdef************56' },
},
})
@@ -1602,16 +1060,10 @@ describe('EnvPanel container', () => {
expect(store.getState().environmentVariables).toHaveLength(1)
await user.click(screen.getByRole('button', { name: 'common.operation.cancel' }))
- expect(
- screen.queryByRole('button', { name: 'common.operation.confirm' }),
- ).not.toBeInTheDocument()
-
await user.click(screen.getByRole('button', { name: `common.operation.delete ${env.name}` }))
await user.click(screen.getByRole('button', { name: 'common.operation.confirm' }))
- await waitFor(() => {
- expect(store.getState().environmentVariables).toEqual([])
- })
+ await waitFor(() => expect(store.getState().environmentVariables).toEqual([]))
expect(store.getState().envSecrets).toEqual({})
expect(getNodes()).toEqual([
expect.objectContaining({