Files
shumai/packages/webui/components/settings/TurntableSettingsCard.test.tsx
Yiling-J 43a2eced75 feat(transcode): add 3D asset support and turntable viewer (#454)
* feat(transcode): add 3D asset support and turntable viewer

* perf(turntable): stream file via Bun.file and increase upload timeout

* feat(turntable): increase upload timeout to 15m to support 5GB uploads

* fix(webui): align 3D model viewer layout and full-width control bar with video viewer

* feat(webui): unify 3D viewer bottom bar and redesign cyclic ruler slider

- Place RulerSlider in single row with playback and zoom controls, centered with max 320px width
- Flank RulerSlider with minus and plus buttons to step angle by 15°
- Redesign RulerSlider with fixed center indicator and moving cyclic track with continuous 360° wrapping
- Render major ticks longer at 60° intervals without numeric text labels on track
- Display floating degree tooltip above center indicator only during dragging

* fix(webui): prevent RulerSlider from collapsing to 0px width in control bar

- Use flex layout with flex-1 on left and right clusters to preserve center cluster width
- Enforce min-w-[140px] and w-full on RulerSlider
- Fix tooltip positioning and remove outer overflow-hidden

* feat(webui): snap RulerSlider track directly to discrete 15° ticks during drag

* fix(webui): prevent ruler snap-back caused by floating point second truncation

- Use Math.round instead of Math.floor in secondToDegree to avoid 0.999996 dropping to previous frame
- Ensure final dragDegree is committed on pointer up

* fix(webui): fix arrow key frame rounding and duplicate event bubbling

- Use Math.round instead of Math.floor for keyboard arrow frame navigation in ModelViewer
- Add e.stopPropagation() to RulerSlider keyboard events to prevent duplicate bubbling to window listener

* feat(webui): redesign RulerSlider with encapsulated step buttons and capsule pill track

* feat(webui): make RulerSlider responsive on mobile and remove bottom bar reset button

* fix(webui): load 3d video directly without poster and invert drag rotation to counterclockwise

* fix(webui): fix 3d asset viewer frame seeking and drag jitter

* feat(transcode): show 3D asset poster preview immediately after render start

* fix(viewer): synchronize 3D turntable playback via frame callback to prevent skipped degrees

* fix(viewer): handle touchpad zoom gestures and prevent page zoom in 3D viewer

* fix(viewer): eliminate 3D model rotation jitter at 345 degrees

* fix(share): watermark 3D asset turntable video on share links

* fix(share): preserve video transcode resolution on watermarked share links

* fix(viewer): download original 3D model file instead of rendered turntable MP4
2026-10-11 21:32:28 +08:00

246 lines
7.0 KiB
TypeScript

// @vitest-environment happy-dom
import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
import React from 'react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { TurntableSettingsCard } from './TurntableSettingsCard'
import type { TurntableSettingsResponse } from '@shumai/dtos'
const mockGetSettings = vi.fn()
const mockPutSettings = vi.fn()
const mockTestSettings = vi.fn()
vi.mock('@/ui/api/client', () => ({
client: {
api: {
teams: {
':teamId': {
'turntable-settings': {
$get: () => mockGetSettings(),
$put: (args: unknown) => mockPutSettings(args),
test: {
$post: (args: unknown) => mockTestSettings(args),
},
},
},
},
},
},
}))
vi.mock('sonner', () => ({
toast: {
success: vi.fn(),
error: vi.fn(),
},
}))
vi.mock('@/ui/paraglide/messages.js', () => ({
m: {
turntable_settings: () => 'Turntable Renderer Settings',
turntable_settings_description: () => 'Configure external Blender turntable renderer',
turntable_env_configured: () => 'Configured via Environment',
turntable_server_url: () => 'Server URL',
turntable_server_url_placeholder: () => 'http://localhost:3000',
turntable_username: () => 'Username',
turntable_password: () => 'Password',
turntable_password_placeholder: () => 'Saved password',
turntable_test_connection: () => 'Test Connection',
turntable_testing: () => 'Testing...',
turntable_connection_success: () => 'Connection successful',
turntable_connection_failed: () => 'Connection failed',
save: () => 'Save',
settings_updated: () => 'Settings updated',
failed_update_settings: () => 'Failed to update settings',
},
}))
const createWrapper = () => {
const queryClient = new QueryClient({
defaultOptions: {
queries: { retry: false },
mutations: { retry: false },
},
})
return ({ children }: { children: React.ReactNode }) => (
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
)
}
describe('TurntableSettingsCard', () => {
beforeEach(() => {
vi.clearAllMocks()
})
afterEach(() => {
cleanup()
})
it('renders loaded settings with URL and username', async () => {
const settings: TurntableSettingsResponse = {
isEnvConfigured: false,
url: 'http://turntable.local:3000',
username: 'render-user',
hasPassword: true,
}
mockGetSettings.mockResolvedValueOnce({
ok: true,
json: async () => settings,
})
render(<TurntableSettingsCard teamId="team-123" />, { wrapper: createWrapper() })
await waitFor(() => {
expect(screen.getByDisplayValue('http://turntable.local:3000')).toBeDefined()
expect(screen.getByDisplayValue('render-user')).toBeDefined()
})
})
it('disables inputs and displays badge when configured via environment', async () => {
const settings: TurntableSettingsResponse = {
isEnvConfigured: true,
url: 'http://env-turntable:3000',
username: 'env-user',
hasPassword: true,
}
mockGetSettings.mockResolvedValueOnce({
ok: true,
json: async () => settings,
})
render(<TurntableSettingsCard teamId="team-123" />, { wrapper: createWrapper() })
await waitFor(() => {
expect(screen.getByText('Configured via Environment')).toBeDefined()
const urlInput = screen.getByDisplayValue('http://env-turntable:3000') as HTMLInputElement
expect(urlInput.disabled).toBe(true)
const saveBtn = screen.getByRole('button', { name: 'Save' }) as HTMLButtonElement
expect(saveBtn.disabled).toBe(true)
})
})
it('saves updated settings', async () => {
const settings: TurntableSettingsResponse = {
isEnvConfigured: false,
url: '',
username: '',
hasPassword: false,
}
mockGetSettings.mockResolvedValueOnce({
ok: true,
json: async () => settings,
})
mockPutSettings.mockResolvedValueOnce({
ok: true,
json: async () => ({
...settings,
url: 'http://new-turntable:3000',
username: 'alice',
}),
})
render(<TurntableSettingsCard teamId="team-123" />, { wrapper: createWrapper() })
await waitFor(() => {
expect(screen.getByLabelText('Server URL')).toBeDefined()
})
const urlInput = screen.getByLabelText('Server URL')
fireEvent.change(urlInput, { target: { value: 'http://new-turntable:3000' } })
const usernameInput = screen.getByLabelText('Username')
fireEvent.change(usernameInput, { target: { value: 'alice' } })
const saveBtn = screen.getByRole('button', { name: 'Save' })
fireEvent.click(saveBtn)
await waitFor(() => {
expect(mockPutSettings).toHaveBeenCalledWith(
expect.objectContaining({
param: { teamId: 'team-123' },
json: expect.objectContaining({
url: 'http://new-turntable:3000',
username: 'alice',
}),
}),
)
})
})
it('tests connection successfully and displays version info', async () => {
const settings: TurntableSettingsResponse = {
isEnvConfigured: false,
url: 'http://turntable:3000',
username: 'user',
hasPassword: false,
}
mockGetSettings.mockResolvedValueOnce({
ok: true,
json: async () => settings,
})
mockTestSettings.mockResolvedValueOnce({
ok: true,
json: async () => ({
ok: true,
version: '1.0.0',
blender: '5.2.0',
}),
})
render(<TurntableSettingsCard teamId="team-123" />, { wrapper: createWrapper() })
await waitFor(() => {
expect(screen.getByDisplayValue('http://turntable:3000')).toBeDefined()
})
const testBtn = screen.getByRole('button', { name: 'Test Connection' })
fireEvent.click(testBtn)
await waitFor(() => {
expect(mockTestSettings).toHaveBeenCalled()
expect(screen.getByText(/Connection successful \(v1\.0\.0, Blender 5\.2\.0\)/)).toBeDefined()
})
})
it('tests connection and displays error when unreachable', async () => {
const settings: TurntableSettingsResponse = {
isEnvConfigured: false,
url: 'http://invalid-url:3000',
username: '',
hasPassword: false,
}
mockGetSettings.mockResolvedValueOnce({
ok: true,
json: async () => settings,
})
mockTestSettings.mockResolvedValueOnce({
ok: true,
json: async () => ({
ok: false,
error: 'ECONNREFUSED',
}),
})
render(<TurntableSettingsCard teamId="team-123" />, { wrapper: createWrapper() })
await waitFor(() => {
expect(screen.getByDisplayValue('http://invalid-url:3000')).toBeDefined()
})
const testBtn = screen.getByRole('button', { name: 'Test Connection' })
fireEvent.click(testBtn)
await waitFor(() => {
expect(screen.getByText(/Connection failed: ECONNREFUSED/)).toBeDefined()
})
})
})