Files
gsfdc/demo-dify/dify/web/service/__tests__/base-request.spec.ts
T
wuzilongandCursor 6519682885 chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-18 13:59:25 +08:00

396 lines
14 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vite-plus/test'
import {
discardRegistrationSessionState,
OAUTH_REGISTRATION_GA_SENT_KEY,
REGISTRATION_SUCCESS_STORAGE_KEY,
} from '@/app/components/base/amplitude/registration-session-state'
import { toast } from '@/app/notifications'
// oxlint-disable-next-line no-restricted-imports -- This spec directly tests the legacy request owner.
import { request, ssePost, upload } from '../base'
const mocks = vi.hoisted(() => ({
isClient: true,
baseFetch: vi.fn(),
beginWebAppAuthorizationRecovery: vi.fn(),
clearWebAppPassport: vi.fn(),
completeWebAppAuthorizationRecovery: vi.fn(),
refreshAccessTokenOrReLogin: vi.fn(),
resolveWebAppAddress: vi.fn(),
}))
vi.mock('@/utils/client', () => ({
get isClient() {
return mocks.isClient
},
get isServer() {
return !mocks.isClient
},
}))
vi.mock('@/utils/var', () => ({
basePath: '/app',
}))
vi.mock('../refresh-token', () => ({
refreshAccessTokenOrReLogin: mocks.refreshAccessTokenOrReLogin,
}))
vi.mock('../webapp-address', async (importOriginal) => ({
...(await importOriginal<typeof import('../webapp-address')>()),
getWebAppPublicApiPath: (_address: unknown, path: string) => path,
resolveWebAppAddress: mocks.resolveWebAppAddress,
}))
vi.mock('../webapp-auth', () => ({
beginWebAppAuthorizationRecovery: mocks.beginWebAppAuthorizationRecovery,
clearWebAppPassport: mocks.clearWebAppPassport,
completeWebAppAuthorizationRecovery: mocks.completeWebAppAuthorizationRecovery,
getWebAppPassport: vi.fn(() => ''),
getWebAppAccessToken: vi.fn(() => ''),
}))
const createUnauthorizedResponse = () =>
new Response(
JSON.stringify({
code: 'unauthorized',
message: 'Invalid Authorization token.',
status: 401,
}),
{
status: 401,
headers: {
'Content-Type': 'application/json',
},
},
)
const createForcedLogoutResponse = () =>
new Response(
JSON.stringify({
code: 'unauthorized_and_force_logout',
message: 'This account session is no longer valid.',
status: 401,
}),
{
status: 401,
headers: {
'Content-Type': 'application/json',
},
},
)
type ClientRequestOptions = {
response: Response
refreshError?: Error
}
function arrangeClientRequest({ response, refreshError }: ClientRequestOptions) {
mocks.baseFetch.mockResolvedValue(response)
if (refreshError) mocks.refreshAccessTokenOrReLogin.mockRejectedValue(refreshError)
}
describe('request 401 handling', () => {
beforeEach(() => {
mocks.isClient = true
mocks.baseFetch.mockReset()
vi.stubGlobal('fetch', mocks.baseFetch)
mocks.beginWebAppAuthorizationRecovery.mockReset()
mocks.beginWebAppAuthorizationRecovery.mockReturnValue(true)
mocks.clearWebAppPassport.mockReset()
mocks.completeWebAppAuthorizationRecovery.mockReset()
mocks.refreshAccessTokenOrReLogin.mockReset()
mocks.resolveWebAppAddress.mockReset()
vi.stubGlobal('location', {
origin: 'https://example.com',
pathname: '/app/apps',
search: '?category=agent',
hash: '#recent',
href: 'https://example.com/app/apps?category=agent#recent',
reload: vi.fn(),
})
window.sessionStorage.clear()
})
afterEach(() => {
discardRegistrationSessionState()
vi.restoreAllMocks()
vi.unstubAllGlobals()
})
it.each([false, true])(
'keeps initialization password failures on the init page when silent is %s',
async (silent) => {
const message = 'Init validation failed. Please check the password and try again.'
const response = Response.json({ code: 'init_validate_failed', message }, { status: 401 })
arrangeClientRequest({ response, refreshError: new Error('No refresh token during setup') })
globalThis.location.pathname = '/app/init'
globalThis.location.href = 'https://example.com/app/init'
const toastError = vi.spyOn(toast, 'error').mockImplementation(() => '')
// oxlint-disable-next-line typescript/no-deprecated -- Exercise the request transport's initialization auth handling directly.
await expect(request('/init', { method: 'POST' }, { silent })).rejects.toMatchObject({
code: 'init_validate_failed',
status: 401,
message,
})
expect(mocks.refreshAccessTokenOrReLogin).not.toHaveBeenCalled()
expect(globalThis.location.href).toBe('https://example.com/app/init')
if (silent) expect(toastError).not.toHaveBeenCalled()
else expect(toastError).toHaveBeenCalledExactlyOnceWith(message, { timeout: 4000 })
},
)
it('should not run browser auth recovery when handling 401 on the server', async () => {
const response = createUnauthorizedResponse()
mocks.isClient = false
mocks.baseFetch.mockResolvedValue(response)
await expect(request('/account/profile')).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(mocks.refreshAccessTokenOrReLogin).not.toHaveBeenCalled()
})
it('should preserve the current URL when a 401 response cannot be parsed', async () => {
const response = new Response('not-json', { status: 401 })
arrangeClientRequest({ response })
window.sessionStorage.setItem(REGISTRATION_SUCCESS_STORAGE_KEY, 'account-a-marker')
await expect(request('/account/profile')).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(globalThis.location.href).toBe(
`https://example.com/app/signin?redirect_url=${encodeURIComponent('/app/apps?category=agent#recent')}`,
)
expect(window.sessionStorage.getItem(REGISTRATION_SUCCESS_STORAGE_KEY)).toBeNull()
expect(mocks.refreshAccessTokenOrReLogin).not.toHaveBeenCalled()
})
it('clears account A registration state before a forced reload so account B starts clean', async () => {
const response = createForcedLogoutResponse()
arrangeClientRequest({ response })
window.sessionStorage.setItem(REGISTRATION_SUCCESS_STORAGE_KEY, 'account-a-marker')
window.sessionStorage.setItem(OAUTH_REGISTRATION_GA_SENT_KEY, 'true')
const reload = vi.fn(() => {
expect(window.sessionStorage.getItem(REGISTRATION_SUCCESS_STORAGE_KEY)).toBeNull()
expect(window.sessionStorage.getItem(OAUTH_REGISTRATION_GA_SENT_KEY)).toBeNull()
})
globalThis.location.reload = reload
await expect(request('/account/profile')).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(reload).toHaveBeenCalledOnce()
})
it('should preserve the current URL when token refresh fails', async () => {
const response = createUnauthorizedResponse()
arrangeClientRequest({
response,
refreshError: new Error('refresh failed'),
})
window.sessionStorage.setItem(REGISTRATION_SUCCESS_STORAGE_KEY, 'account-a-marker')
await expect(request('/account/profile')).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(mocks.refreshAccessTokenOrReLogin).toHaveBeenCalledOnce()
expect(globalThis.location.href).toBe(
`https://example.com/app/signin?redirect_url=${encodeURIComponent('/app/apps?category=agent#recent')}`,
)
expect(window.sessionStorage.getItem(REGISTRATION_SUCCESS_STORAGE_KEY)).toBeNull()
})
it('does not clear console registration state for a public-app 401 redirect', async () => {
const response = createUnauthorizedResponse()
arrangeClientRequest({ response })
window.sessionStorage.setItem(REGISTRATION_SUCCESS_STORAGE_KEY, 'console-marker')
await expect(request('/account/profile', {}, { isPublicAPI: true })).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(window.sessionStorage.getItem(REGISTRATION_SUCCESS_STORAGE_KEY)).toBe('console-marker')
})
it('should reload an environment webapp after its passport becomes unauthorized', async () => {
const address = { kind: 'environment', code: 'environment-code' } as const
const response = new Response(
JSON.stringify({
code: 401,
reason: 'APPDEPLOY_UNAUTHORIZED',
message: 'Unauthorized',
}),
{ status: 401, headers: { 'Content-Type': 'application/json' } },
)
mocks.resolveWebAppAddress.mockReturnValue(address)
arrangeClientRequest({ response })
await expect(request('/messages')).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(mocks.clearWebAppPassport).toHaveBeenCalledWith(address)
expect(globalThis.location.reload).toHaveBeenCalledOnce()
expect(mocks.refreshAccessTokenOrReLogin).not.toHaveBeenCalled()
})
it('should complete authorization recovery after an environment request succeeds', async () => {
const address = { kind: 'environment', code: 'environment-code' } as const
mocks.resolveWebAppAddress.mockReturnValue(address)
mocks.baseFetch.mockImplementation(async () => Response.json({ app_id: 'app-id' }))
await request('/site', {}, { isPublicAPI: true })
expect(mocks.completeWebAppAuthorizationRecovery).toHaveBeenCalledWith(address)
})
it('should keep authorization recovery pending after passport succeeds', async () => {
const address = { kind: 'environment', code: 'environment-code' } as const
mocks.resolveWebAppAddress.mockReturnValue(address)
mocks.baseFetch.mockResolvedValue(Response.json({ access_token: 'passport' }))
await request('/passport', {}, { isPublicAPI: true })
expect(mocks.completeWebAppAuthorizationRecovery).not.toHaveBeenCalled()
})
it('should show forbidden when an environment SSE request is denied', async () => {
const address = { kind: 'environment', code: 'environment-code' } as const
mocks.resolveWebAppAddress.mockReturnValue(address)
vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
new Response(
JSON.stringify({
code: 401,
reason: 'APPDEPLOY_WEB_APP_ACCESS_DENIED',
message: 'You do not have permission to access this web app.',
}),
{ status: 401, headers: { 'Content-Type': 'application/json' } },
),
)
ssePost('/chat-messages', { body: { query: 'hello' } }, { isPublicAPI: true })
await vi.waitFor(() => {
expect(globalThis.location.href).toContain('/webapp-signin?')
expect(globalThis.location.href).toContain('code=403')
})
expect(mocks.clearWebAppPassport).not.toHaveBeenCalled()
expect(globalThis.location.reload).not.toHaveBeenCalled()
})
it('should stop reloading when environment authorization does not recover', async () => {
const address = { kind: 'environment', code: 'environment-code' } as const
const response = new Response(
JSON.stringify({
code: 401,
reason: 'APPDEPLOY_UNAUTHORIZED',
message: 'Unauthorized',
}),
{ status: 401, headers: { 'Content-Type': 'application/json' } },
)
mocks.resolveWebAppAddress.mockReturnValue(address)
mocks.beginWebAppAuthorizationRecovery.mockReturnValue(false)
arrangeClientRequest({ response })
await expect(request('/site')).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(mocks.clearWebAppPassport).not.toHaveBeenCalled()
expect(globalThis.location.reload).not.toHaveBeenCalled()
expect(globalThis.location.href).toContain('/webapp-signin?')
expect(globalThis.location.href).toContain('message=Unauthorized')
})
it('should report a public SSE 403 that is not recoverable', async () => {
const onError = vi.fn()
vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
new Response(
JSON.stringify({
code: 'web_app_disabled',
message: 'webapp is disabled',
}),
{ status: 403, headers: { 'Content-Type': 'application/json' } },
),
)
ssePost('/chat-messages', { body: { query: 'hello' } }, { isPublicAPI: true, onError })
await vi.waitFor(() => {
expect(onError).toHaveBeenCalledWith('webapp is disabled', 'web_app_disabled')
})
expect(mocks.beginWebAppAuthorizationRecovery).not.toHaveBeenCalled()
})
it('should show forbidden when an environment request is denied', async () => {
const address = { kind: 'environment', code: 'environment-code' } as const
const response = new Response(
JSON.stringify({
code: 401,
reason: 'APPDEPLOY_WEB_APP_ACCESS_DENIED',
message: 'You do not have permission to access this web app.',
}),
{ status: 401, headers: { 'Content-Type': 'application/json' } },
)
mocks.resolveWebAppAddress.mockReturnValue(address)
arrangeClientRequest({ response })
await expect(request('/messages', {}, { isPublicAPI: true })).rejects.toMatchObject({
defined: false,
status: response.status,
})
expect(globalThis.location.href).toContain('/webapp-signin?')
expect(globalThis.location.href).toContain('code=403')
expect(mocks.clearWebAppPassport).not.toHaveBeenCalled()
expect(globalThis.location.reload).not.toHaveBeenCalled()
})
it('should show forbidden when an environment upload is denied', async () => {
const address = { kind: 'environment', code: 'environment-code' } as const
mocks.resolveWebAppAddress.mockReturnValue(address)
const xhr = {
open: vi.fn(),
setRequestHeader: vi.fn(),
getAllResponseHeaders: vi.fn(() => ''),
send: vi.fn(function (this: { onreadystatechange?: () => void }) {
this.onreadystatechange?.()
}),
status: 401,
response: {
code: 401,
reason: 'APPDEPLOY_WEB_APP_ACCESS_DENIED',
message: 'You do not have permission to access this web app.',
},
readyState: 4,
upload: {},
withCredentials: false,
responseType: '',
} as unknown as XMLHttpRequest
await expect(upload({ xhr, data: new FormData() }, true)).rejects.toMatchObject({
defined: false,
status: 401,
data: { reason: 'APPDEPLOY_WEB_APP_ACCESS_DENIED' },
})
expect(globalThis.location.href).toContain('/webapp-signin?')
expect(globalThis.location.href).toContain('code=403')
expect(mocks.clearWebAppPassport).not.toHaveBeenCalled()
expect(globalThis.location.reload).not.toHaveBeenCalled()
})
})