wehub-resource-sync
248 lines
10 KiB
JavaScript
248 lines
10 KiB
JavaScript
import { describe, it } from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { assertLocalDiagnosticsRequest, parseDataUrl, sanitizeFileName } from '../server/http-utils.mjs'
|
|
import { getModelExtension, shouldAttachTripoAuth, validateModelBuffer } from '../server/model-store.mjs'
|
|
import { findFirstValue, findModelUrl, isSuccessStatus } from '../server/object-utils.mjs'
|
|
import { buildFalInput, decodeFalTaskId, encodeFalTaskId, findFalModelFile, normalizeFalModelId, normalizeFalStatus } from '../server/providers/fal.mjs'
|
|
import { decodeRodinTaskId, encodeRodinTaskId, findRodinDownloadItem, normalizeRodinStatus } from '../server/providers/rodin.mjs'
|
|
import { extractJsonObject, normalizeVisionInsight } from '../server/providers/vision.mjs'
|
|
import { compactCustomCellsForStorage, persistCustomCells } from '../src/domain/cellPersistence.js'
|
|
|
|
describe('server utility functions', () => {
|
|
it('sanitizes uploaded filenames without losing readable words', () => {
|
|
assert.equal(sanitizeFileName('../plant cell ✨.png'), 'plant cell .png')
|
|
assert.equal(sanitizeFileName(''), 'asset-reference.png')
|
|
})
|
|
|
|
it('parses supported image data URLs and rejects tiny payloads', () => {
|
|
const dataUrl = `data:image/png;base64,${Buffer.alloc(1024).toString('base64')}`
|
|
const image = parseDataUrl(dataUrl)
|
|
|
|
assert.equal(image.mime, 'image/png')
|
|
assert.equal(image.ext, 'png')
|
|
assert.equal(image.buffer.length, 1024)
|
|
assert.throws(() => parseDataUrl('data:text/plain;base64,abc'), /Only PNG, JPEG, or WebP/)
|
|
assert.throws(() => parseDataUrl(`data:image/png;base64,${Buffer.alloc(8).toString('base64')}`), /too small/)
|
|
})
|
|
|
|
it('restricts diagnostics logs to local callers and localhost pages', () => {
|
|
assert.doesNotThrow(() => assertLocalDiagnosticsRequest({
|
|
socket: { remoteAddress: '127.0.0.1' },
|
|
headers: { origin: 'http://127.0.0.1:5174' },
|
|
}))
|
|
assert.doesNotThrow(() => assertLocalDiagnosticsRequest({
|
|
socket: { remoteAddress: '::ffff:127.0.0.1' },
|
|
headers: { referer: 'http://localhost:5174/logs' },
|
|
}))
|
|
|
|
assert.throws(
|
|
() => assertLocalDiagnosticsRequest({
|
|
socket: { remoteAddress: '192.168.1.8' },
|
|
headers: {},
|
|
}),
|
|
/only available from this machine/,
|
|
)
|
|
assert.throws(
|
|
() => assertLocalDiagnosticsRequest({
|
|
socket: { remoteAddress: '127.0.0.1' },
|
|
headers: { origin: 'https://example.com' },
|
|
}),
|
|
/only available to localhost pages/,
|
|
)
|
|
})
|
|
|
|
it('detects model extensions and validates GLB headers', () => {
|
|
assert.equal(getModelExtension('https://example.com/model.glb?download=1'), 'glb')
|
|
assert.equal(getModelExtension('scene.gltf'), 'gltf')
|
|
assert.throws(() => getModelExtension('model.obj'), /Only GLB/)
|
|
|
|
assert.doesNotThrow(() => validateModelBuffer(Buffer.concat([Buffer.from('glTF'), Buffer.alloc(28)]), 'glb'))
|
|
assert.throws(() => validateModelBuffer(Buffer.concat([Buffer.from('nope'), Buffer.alloc(28)]), 'glb'), /GLB files/)
|
|
})
|
|
|
|
it('does not attach Tripo auth to arbitrary model URLs', () => {
|
|
assert.equal(shouldAttachTripoAuth('https://example.com/model.glb'), false)
|
|
assert.equal(shouldAttachTripoAuth('http://127.0.0.1:8787/model.glb'), false)
|
|
})
|
|
|
|
it('finds nested task ids and preferred model URLs', () => {
|
|
const payload = {
|
|
data: {
|
|
task: { task_id: 'task-123' },
|
|
assets: [
|
|
{ url: 'https://example.com/preview.png' },
|
|
{ result: 'https://example.com/model.obj' },
|
|
{ result: 'https://example.com/model.glb?x=1' },
|
|
],
|
|
},
|
|
}
|
|
|
|
assert.equal(findFirstValue(payload, ['task_id']), 'task-123')
|
|
assert.equal(findModelUrl(payload), 'https://example.com/model.glb?x=1')
|
|
assert.equal(findModelUrl({ result: 'https://example.com/model.obj' }), '')
|
|
assert.equal(isSuccessStatus('finished'), true)
|
|
assert.equal(isSuccessStatus('running'), false)
|
|
})
|
|
|
|
it('normalizes model vision output for asset intelligence', () => {
|
|
const parsed = extractJsonObject('```json\n{"objectName":"Red Supercar","categoryId":"car","confidence":92,"tags":["Vehicle","Gloss"]}\n```')
|
|
const insight = normalizeVisionInsight(parsed, { provider: 'openai', model: 'test-model' })
|
|
|
|
assert.equal(insight.objectName, 'Red Supercar')
|
|
assert.equal(insight.categoryId, 'road')
|
|
assert.equal(insight.categoryLabel, 'Performance Vehicle')
|
|
assert.equal(insight.confidence, 0.92)
|
|
assert.deepEqual(insight.tags, ['vehicle', 'gloss'])
|
|
})
|
|
|
|
it('normalizes Rodin task ids, statuses, and downloads', () => {
|
|
const task = { taskUuid: 'task-uuid-1', subscriptionKey: 'subscription-key-1' }
|
|
const encoded = encodeRodinTaskId(task)
|
|
|
|
assert.deepEqual(decodeRodinTaskId(encoded), task)
|
|
assert.deepEqual(decodeRodinTaskId('legacy-task-id'), { taskUuid: 'legacy-task-id', subscriptionKey: 'legacy-task-id' })
|
|
assert.equal(normalizeRodinStatus(['Done', 'Done']), 'success')
|
|
assert.equal(normalizeRodinStatus(['Waiting']), 'queued')
|
|
assert.equal(normalizeRodinStatus(['Generating']), 'running')
|
|
assert.equal(normalizeRodinStatus(['Done', 'Failed']), 'failed')
|
|
assert.deepEqual(
|
|
findRodinDownloadItem({
|
|
list: [
|
|
{ name: 'preview.webp', url: 'https://example.com/preview.webp' },
|
|
{ name: 'model.glb', url: 'https://cdn.example.com/signed-download' },
|
|
],
|
|
}),
|
|
{ name: 'model.glb', url: 'https://cdn.example.com/signed-download' },
|
|
)
|
|
})
|
|
|
|
it('normalizes Fal model ids, task ids, inputs, statuses, and model files', () => {
|
|
const task = { modelId: 'tripo3d/tripo/v2.5/image-to-3d', requestId: 'fal-request-1' }
|
|
const encoded = encodeFalTaskId(task)
|
|
|
|
assert.deepEqual(decodeFalTaskId(encoded), task)
|
|
assert.equal(normalizeFalModelId('tripo3d/tripo/v2.5/image-to-3d'), 'tripo3d/tripo/v2.5/image-to-3d')
|
|
assert.equal(normalizeFalModelId('fal-ai/tripo3d/v2.5/image-to-3d'), 'fal-ai/hunyuan3d/v2')
|
|
assert.equal(normalizeFalStatus('IN_QUEUE'), 'queued')
|
|
assert.equal(normalizeFalStatus('IN_PROGRESS'), 'running')
|
|
assert.equal(normalizeFalStatus('COMPLETED'), 'success')
|
|
assert.equal(normalizeFalStatus('ERROR'), 'failed')
|
|
|
|
assert.deepEqual(
|
|
buildFalInput('fal-ai/hunyuan3d/v2', 'https://cdn.example.com/input.png', { seed: 12 }),
|
|
{ input_image_url: 'https://cdn.example.com/input.png', seed: 12 },
|
|
)
|
|
assert.deepEqual(
|
|
buildFalInput('fal-ai/hyper3d/rodin', 'https://cdn.example.com/input.png', { prompt: 'a detailed cell', seed: 7 }),
|
|
{
|
|
geometry_file_format: 'glb',
|
|
input_image_urls: ['https://cdn.example.com/input.png'],
|
|
material: 'PBR',
|
|
prompt: 'a detailed cell',
|
|
quality: 'medium',
|
|
seed: 7,
|
|
tier: 'Regular',
|
|
},
|
|
)
|
|
|
|
assert.deepEqual(
|
|
findFalModelFile({
|
|
base_model: { url: 'https://cdn.example.com/base.glb' },
|
|
pbr_model: { url: 'https://cdn.example.com/file', content_type: 'model/gltf-binary' },
|
|
}),
|
|
{ url: 'https://cdn.example.com/file', ext: 'glb' },
|
|
)
|
|
})
|
|
|
|
it('compacts generated custom cells without dropping pending retry images first', () => {
|
|
const generated = {
|
|
id: 'custom-ready',
|
|
imageUrl: 'data:image/webp;base64,large',
|
|
thumbnailUrl: 'data:image/webp;base64,thumb',
|
|
generation: { status: 'success', modelUrl: '/api/3d/local-model/task.glb', rawModelUrl: 'https://signed.example.com/model.glb', message: 'ready' },
|
|
}
|
|
const pending = {
|
|
id: 'custom-pending',
|
|
imageUrl: 'data:image/webp;base64,source',
|
|
generation: { status: 'failed', modelUrl: '', rawModelUrl: '', message: 'retry possible' },
|
|
}
|
|
|
|
assert.deepEqual(
|
|
compactCustomCellsForStorage([generated, pending], 'generated-previews').map((cell) => cell.imageUrl),
|
|
['', pending.imageUrl],
|
|
)
|
|
assert.equal(compactCustomCellsForStorage([generated, pending], 'generated-previews')[0].thumbnailUrl, generated.thumbnailUrl)
|
|
assert.deepEqual(
|
|
compactCustomCellsForStorage([generated, pending], 'minimal').map((cell) => ({
|
|
imageUrl: cell.imageUrl,
|
|
thumbnailUrl: cell.thumbnailUrl,
|
|
rawModelUrl: cell.generation.rawModelUrl,
|
|
})),
|
|
[
|
|
{ imageUrl: '', thumbnailUrl: generated.thumbnailUrl, rawModelUrl: '' },
|
|
{ imageUrl: '', thumbnailUrl: undefined, rawModelUrl: '' },
|
|
],
|
|
)
|
|
})
|
|
|
|
it('falls back to compact custom-cell storage when localStorage quota fails', () => {
|
|
const writes = []
|
|
global.window = {
|
|
localStorage: {
|
|
setItem(key, value) {
|
|
writes.push({ key, value: JSON.parse(value) })
|
|
if (writes.length === 1) throw new Error('quota exceeded')
|
|
},
|
|
},
|
|
}
|
|
|
|
try {
|
|
const result = persistCustomCells([
|
|
{
|
|
id: 'custom-ready',
|
|
imageUrl: 'data:image/webp;base64,large',
|
|
thumbnailUrl: 'data:image/webp;base64,thumb',
|
|
generation: { status: 'success', modelUrl: '/api/3d/local-model/task.glb', rawModelUrl: 'https://signed.example.com/model.glb', message: 'ready' },
|
|
},
|
|
])
|
|
|
|
assert.equal(result.stored, true)
|
|
assert.equal(result.compacted, true)
|
|
assert.equal(result.cells[0].imageUrl, '')
|
|
assert.equal(result.cells[0].thumbnailUrl, 'data:image/webp;base64,thumb')
|
|
assert.equal(result.cells[0].generation.modelUrl, '/api/3d/local-model/task.glb')
|
|
assert.equal(writes.length, 2)
|
|
} finally {
|
|
delete global.window
|
|
}
|
|
})
|
|
|
|
it('keeps compacted custom-cell array identity when storage remains unavailable', () => {
|
|
global.window = {
|
|
localStorage: {
|
|
setItem() {
|
|
throw new Error('storage unavailable')
|
|
},
|
|
},
|
|
}
|
|
|
|
try {
|
|
const compacted = [
|
|
{
|
|
id: 'custom-ready',
|
|
imageUrl: '',
|
|
previewDropped: true,
|
|
generation: { status: 'success', modelUrl: '/api/3d/local-model/task.glb', rawModelUrl: '', message: 'ready' },
|
|
},
|
|
]
|
|
const result = persistCustomCells(compacted)
|
|
|
|
assert.equal(result.stored, false)
|
|
assert.equal(result.compacted, true)
|
|
assert.equal(result.cells, compacted)
|
|
} finally {
|
|
delete global.window
|
|
}
|
|
})
|
|
})
|