903 lines
25 KiB
TypeScript
903 lines
25 KiB
TypeScript
import { describe, expect, test } from 'vitest';
|
|
|
|
import type { BigFishWorkSummary } from '../../../packages/shared/src/contracts/bigFishWorkSummary';
|
|
import type { JumpHopWorkSummaryResponse } from '../../../packages/shared/src/contracts/jumpHop';
|
|
import type { Match3DWorkSummary } from '../../../packages/shared/src/contracts/match3dWorks';
|
|
import type { PuzzleWorkSummary } from '../../../packages/shared/src/contracts/puzzleWorkSummary';
|
|
import type { SquareHoleWorkSummary } from '../../../packages/shared/src/contracts/squareHoleWorks';
|
|
import type { VisualNovelWorkSummary } from '../../../packages/shared/src/contracts/visualNovel';
|
|
import type { WoodenFishWorkSummaryResponse } from '../../../packages/shared/src/contracts/woodenFish';
|
|
import { buildCreationWorkShelfItems } from '../custom-world-home/creationWorkShelf';
|
|
import {
|
|
buildCreationWorkShelfRuntimeState,
|
|
buildPendingPuzzleWorks,
|
|
buildPuzzleResultProfileId,
|
|
buildPuzzleResultWorkId,
|
|
collectVisibleDraftNoticeKeys,
|
|
countUnreadDraftGenerationUpdates,
|
|
createPendingDraftShelfState,
|
|
type DraftGenerationNoticeMap,
|
|
getGenerationNoticeShelfKeys,
|
|
hasUnreadDraftGenerationUpdates,
|
|
mergeBigFishWorkSummary,
|
|
mergePuzzleWorkSummary,
|
|
resolveBigFishDraftOpenIntent,
|
|
resolveJumpHopDraftOpenIntent,
|
|
resolveMatch3DDraftOpenIntent,
|
|
resolvePuzzleDraftOpenIntent,
|
|
resolveSquareHoleDraftOpenIntent,
|
|
resolveVisualNovelDraftOpenIntent,
|
|
resolveWoodenFishDraftOpenIntent,
|
|
} from './platformDraftGenerationShelfModel';
|
|
|
|
describe('platformDraftGenerationShelfModel', () => {
|
|
test('resolvePuzzleDraftOpenIntent sends published puzzle without session to detail', () => {
|
|
expect(
|
|
resolvePuzzleDraftOpenIntent({
|
|
item: buildPuzzleWork({
|
|
sourceSessionId: null,
|
|
publicationStatus: 'published',
|
|
}),
|
|
notices: {},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'open-published-detail',
|
|
});
|
|
});
|
|
|
|
test('resolvePuzzleDraftOpenIntent restores failed puzzle generation with notice copy', () => {
|
|
expect(
|
|
resolvePuzzleDraftOpenIntent({
|
|
item: buildPuzzleWork(),
|
|
notices: {
|
|
'puzzle:puzzle-session-base': {
|
|
status: 'failed',
|
|
seen: false,
|
|
message: '首图生成失败。',
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'failed-generation',
|
|
source: 'restored',
|
|
errorMessage: '首图生成失败。',
|
|
});
|
|
});
|
|
|
|
test('resolvePuzzleDraftOpenIntent prefers active generation before restoring draft', () => {
|
|
expect(
|
|
resolvePuzzleDraftOpenIntent({
|
|
item: buildPuzzleWork(),
|
|
notices: {},
|
|
generation: emptyGenerationFacts({
|
|
activeSessionId: 'puzzle-session-base',
|
|
hasActiveGenerationRunning: true,
|
|
}),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'active-generation',
|
|
});
|
|
});
|
|
|
|
test('resolvePuzzleDraftOpenIntent does not lock a puzzle draft that already has a cover', () => {
|
|
expect(
|
|
resolvePuzzleDraftOpenIntent({
|
|
item: buildPuzzleWork({
|
|
coverImageSrc: '/media/puzzle-cover.png',
|
|
}),
|
|
notices: {
|
|
'puzzle:puzzle-session-base': {
|
|
status: 'generating',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-draft',
|
|
});
|
|
});
|
|
|
|
test('resolvePuzzleDraftOpenIntent ignores stale generating notice after puzzle draft is ready', () => {
|
|
expect(
|
|
resolvePuzzleDraftOpenIntent({
|
|
item: buildPuzzleWork({
|
|
generationStatus: 'ready',
|
|
coverImageSrc: '/generated-puzzle-assets/session/cover.png',
|
|
levels: [
|
|
{
|
|
levelId: 'level-1',
|
|
levelName: '金色数字舞台',
|
|
pictureDescription: '123456',
|
|
pictureReference: null,
|
|
candidates: [],
|
|
selectedCandidateId: null,
|
|
coverImageSrc: '/generated-puzzle-assets/session/cover.png',
|
|
coverAssetId: 'asset-1',
|
|
generationStatus: 'ready',
|
|
},
|
|
],
|
|
}),
|
|
notices: {
|
|
'puzzle:puzzle-session-base': {
|
|
status: 'generating',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-draft',
|
|
});
|
|
});
|
|
|
|
test('resolvePuzzleDraftOpenIntent restores generating page from notice even before persisted status catches up', () => {
|
|
expect(
|
|
resolvePuzzleDraftOpenIntent({
|
|
item: buildPuzzleWork({
|
|
generationStatus: 'idle',
|
|
}),
|
|
notices: {
|
|
'puzzle:puzzle-session-base': {
|
|
status: 'generating',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-generating',
|
|
});
|
|
});
|
|
|
|
test('resolveMatch3DDraftOpenIntent opens published work detail unless forced into draft', () => {
|
|
const item = buildMatch3DWork({
|
|
publicationStatus: 'published',
|
|
});
|
|
|
|
expect(
|
|
resolveMatch3DDraftOpenIntent({
|
|
item,
|
|
notices: {},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'open-published-detail',
|
|
});
|
|
|
|
expect(
|
|
resolveMatch3DDraftOpenIntent({
|
|
item,
|
|
notices: {},
|
|
forceDraft: true,
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-draft',
|
|
});
|
|
});
|
|
|
|
test('resolveMatch3DDraftOpenIntent starts ready unread draft before failure fallback', () => {
|
|
expect(
|
|
resolveMatch3DDraftOpenIntent({
|
|
item: buildMatch3DWork(),
|
|
notices: {
|
|
'match3d:match3d-session-base': {
|
|
status: 'ready',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts({
|
|
hasBackgroundGenerationFailure: true,
|
|
}),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'ready-unread',
|
|
});
|
|
});
|
|
|
|
test('resolveMatch3DDraftOpenIntent restores persisted generating draft', () => {
|
|
expect(
|
|
resolveMatch3DDraftOpenIntent({
|
|
item: buildMatch3DWork({
|
|
generationStatus: 'generating',
|
|
}),
|
|
notices: {},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-generating',
|
|
});
|
|
});
|
|
|
|
test('resolveBigFishDraftOpenIntent reopens active generating session before restoring draft', () => {
|
|
expect(
|
|
resolveBigFishDraftOpenIntent({
|
|
item: buildBigFishWork(),
|
|
activeSessionId: 'big-fish-session-base',
|
|
hasActiveGenerationRunning: true,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'active-generation',
|
|
sourceSessionId: 'big-fish-session-base',
|
|
});
|
|
|
|
expect(
|
|
resolveBigFishDraftOpenIntent({
|
|
item: buildBigFishWork(),
|
|
activeSessionId: 'other-session',
|
|
hasActiveGenerationRunning: true,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-draft',
|
|
sourceSessionId: 'big-fish-session-base',
|
|
});
|
|
});
|
|
|
|
test('resolveSquareHoleDraftOpenIntent handles published, missing, active and restore states', () => {
|
|
expect(
|
|
resolveSquareHoleDraftOpenIntent({
|
|
item: buildSquareHoleWork({ publicationStatus: 'published' }),
|
|
activeSessionId: null,
|
|
hasActiveGenerationRunning: false,
|
|
isGenerationReady: false,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'open-published-detail',
|
|
});
|
|
|
|
expect(
|
|
resolveSquareHoleDraftOpenIntent({
|
|
item: buildSquareHoleWork({ sourceSessionId: null }),
|
|
forceDraft: true,
|
|
activeSessionId: null,
|
|
hasActiveGenerationRunning: false,
|
|
isGenerationReady: false,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'missing-session',
|
|
});
|
|
|
|
expect(
|
|
resolveSquareHoleDraftOpenIntent({
|
|
item: buildSquareHoleWork(),
|
|
activeSessionId: 'square-hole-session-base',
|
|
hasActiveGenerationRunning: true,
|
|
isGenerationReady: false,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'active-generation',
|
|
sourceSessionId: 'square-hole-session-base',
|
|
});
|
|
|
|
expect(
|
|
resolveSquareHoleDraftOpenIntent({
|
|
item: buildSquareHoleWork(),
|
|
activeSessionId: 'other-session',
|
|
hasActiveGenerationRunning: false,
|
|
isGenerationReady: false,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-draft',
|
|
shouldClearGenerationState: true,
|
|
});
|
|
});
|
|
|
|
test('resolveVisualNovelDraftOpenIntent handles published, active, current result and load detail states', () => {
|
|
expect(
|
|
resolveVisualNovelDraftOpenIntent({
|
|
item: buildVisualNovelWork({ publishStatus: 'published' }),
|
|
activeSessionId: null,
|
|
hasActiveGenerationRunning: false,
|
|
hasActiveSessionDraft: false,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'open-published-detail',
|
|
});
|
|
|
|
expect(
|
|
resolveVisualNovelDraftOpenIntent({
|
|
item: buildVisualNovelWork(),
|
|
forceDraft: true,
|
|
activeSessionId: 'visual-novel-profile-base',
|
|
hasActiveGenerationRunning: true,
|
|
hasActiveSessionDraft: false,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'active-generation',
|
|
profileId: 'visual-novel-profile-base',
|
|
});
|
|
|
|
expect(
|
|
resolveVisualNovelDraftOpenIntent({
|
|
item: buildVisualNovelWork(),
|
|
forceDraft: true,
|
|
activeSessionId: 'visual-novel-profile-base',
|
|
hasActiveGenerationRunning: false,
|
|
hasActiveSessionDraft: true,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'current-result',
|
|
profileId: 'visual-novel-profile-base',
|
|
});
|
|
|
|
expect(
|
|
resolveVisualNovelDraftOpenIntent({
|
|
item: buildVisualNovelWork(),
|
|
forceDraft: true,
|
|
activeSessionId: 'other-profile',
|
|
hasActiveGenerationRunning: false,
|
|
hasActiveSessionDraft: false,
|
|
}),
|
|
).toMatchObject({
|
|
type: 'load-detail',
|
|
profileId: 'visual-novel-profile-base',
|
|
});
|
|
});
|
|
|
|
test('resolveJumpHopDraftOpenIntent handles published, failed current generation, generating and detail states', () => {
|
|
expect(
|
|
resolveJumpHopDraftOpenIntent({
|
|
item: buildJumpHopWork({ publicationStatus: 'published' }),
|
|
notices: {},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'open-published-detail',
|
|
});
|
|
|
|
expect(
|
|
resolveJumpHopDraftOpenIntent({
|
|
item: buildJumpHopWork(),
|
|
notices: {
|
|
'jump-hop:jump-hop-session-base': {
|
|
status: 'failed',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts({
|
|
activeSessionId: 'jump-hop-session-base',
|
|
hasActiveGenerationFailure: true,
|
|
}),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'active-failed-generation',
|
|
});
|
|
|
|
expect(
|
|
resolveJumpHopDraftOpenIntent({
|
|
item: buildJumpHopWork({ generationStatus: 'generating' }),
|
|
notices: {},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-generating',
|
|
});
|
|
|
|
expect(
|
|
resolveJumpHopDraftOpenIntent({
|
|
item: buildJumpHopWork({ generationStatus: 'generating' }),
|
|
notices: {
|
|
'jump-hop:jump-hop-session-base': {
|
|
status: 'failed',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'load-detail',
|
|
});
|
|
|
|
expect(
|
|
resolveJumpHopDraftOpenIntent({
|
|
item: buildJumpHopWork({ sourceSessionId: null }),
|
|
notices: {
|
|
'jump-hop:jump-hop-work-base': {
|
|
status: 'failed',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts({
|
|
activeSessionId: null,
|
|
hasActiveGenerationFailure: true,
|
|
}),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'load-detail',
|
|
});
|
|
});
|
|
|
|
test('resolveWoodenFishDraftOpenIntent uses profile fallback and failure fallback stage', () => {
|
|
expect(
|
|
resolveWoodenFishDraftOpenIntent({
|
|
item: buildWoodenFishWork({
|
|
sourceSessionId: null,
|
|
generationStatus: 'generating',
|
|
}),
|
|
notices: {
|
|
'wooden-fish:wooden-fish-profile-base': {
|
|
status: 'failed',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts({
|
|
activeSessionId: 'wooden-fish-profile-base',
|
|
hasActiveGenerationFailure: true,
|
|
}),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'active-failed-generation',
|
|
});
|
|
|
|
expect(
|
|
resolveWoodenFishDraftOpenIntent({
|
|
item: buildWoodenFishWork({ generationStatus: 'generating' }),
|
|
notices: {},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'restore-generating',
|
|
});
|
|
|
|
expect(
|
|
resolveWoodenFishDraftOpenIntent({
|
|
item: buildWoodenFishWork(),
|
|
notices: {
|
|
'wooden-fish:wooden-fish-session-base': {
|
|
status: 'failed',
|
|
seen: false,
|
|
},
|
|
},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'load-detail',
|
|
failureFallbackStage: 'wooden-fish-workspace',
|
|
});
|
|
|
|
expect(
|
|
resolveWoodenFishDraftOpenIntent({
|
|
item: buildWoodenFishWork(),
|
|
notices: {},
|
|
generation: emptyGenerationFacts(),
|
|
}),
|
|
).toMatchObject({
|
|
type: 'load-detail',
|
|
failureFallbackStage: 'wooden-fish-generating',
|
|
});
|
|
});
|
|
|
|
test('buildPendingPuzzleWorks creates failed puzzle placeholder with stable ids and fallback title', () => {
|
|
const pending = buildPendingPuzzleWorks(
|
|
{
|
|
'puzzle-session-ocean': createPendingDraftShelfState(
|
|
'failed',
|
|
false,
|
|
'2026-06-03T08:00:00.000Z',
|
|
),
|
|
},
|
|
[],
|
|
);
|
|
|
|
expect(pending).toHaveLength(1);
|
|
expect(pending[0]).toMatchObject({
|
|
workId: 'puzzle-work-ocean',
|
|
profileId: 'puzzle-profile-ocean',
|
|
sourceSessionId: 'puzzle-session-ocean',
|
|
workTitle: '拼图草稿',
|
|
summary: '拼图草稿生成失败，可重新打开处理。',
|
|
generationStatus: 'failed',
|
|
});
|
|
});
|
|
|
|
test('buildPendingPuzzleWorks skips pending item when backend shelf already has the session', () => {
|
|
const pending = buildPendingPuzzleWorks(
|
|
{
|
|
'puzzle-session-ocean': createPendingDraftShelfState(
|
|
'generating',
|
|
false,
|
|
'2026-06-03T08:00:00.000Z',
|
|
),
|
|
},
|
|
[buildPuzzleWork({ sourceSessionId: 'puzzle-session-ocean' })],
|
|
);
|
|
|
|
expect(pending).toEqual([]);
|
|
});
|
|
|
|
test('mergePuzzleWorkSummary only replaces the matching profile', () => {
|
|
const current = buildPuzzleWork({
|
|
profileId: 'puzzle-profile-1',
|
|
workTitle: '旧拼图',
|
|
});
|
|
const updated = buildPuzzleWork({
|
|
profileId: 'puzzle-profile-1',
|
|
workTitle: '新拼图',
|
|
});
|
|
const other = buildPuzzleWork({
|
|
profileId: 'puzzle-profile-2',
|
|
workTitle: '别的拼图',
|
|
});
|
|
|
|
expect(mergePuzzleWorkSummary(current, updated)).toBe(updated);
|
|
expect(mergePuzzleWorkSummary(current, other)).toBe(current);
|
|
});
|
|
|
|
test('mergeBigFishWorkSummary only replaces the matching source session', () => {
|
|
const current = buildBigFishWork({
|
|
sourceSessionId: 'big-fish-session-1',
|
|
title: '旧大鱼',
|
|
});
|
|
const updated = buildBigFishWork({
|
|
sourceSessionId: 'big-fish-session-1',
|
|
title: '新大鱼',
|
|
});
|
|
const other = buildBigFishWork({
|
|
sourceSessionId: 'big-fish-session-2',
|
|
title: '别的大鱼',
|
|
});
|
|
|
|
expect(mergeBigFishWorkSummary(current, updated)).toBe(updated);
|
|
expect(mergeBigFishWorkSummary(current, other)).toBe(current);
|
|
});
|
|
|
|
test('buildCreationWorkShelfRuntimeState lets failure notice override persisted generating puzzle copy', () => {
|
|
const [item] = buildCreationWorkShelfItems({
|
|
rpgItems: [],
|
|
bigFishItems: [],
|
|
puzzleItems: [
|
|
buildPuzzleWork({
|
|
workId: 'puzzle-work-empty',
|
|
profileId: 'puzzle-profile-empty',
|
|
sourceSessionId: 'puzzle-session-empty',
|
|
workTitle: '',
|
|
workDescription: '',
|
|
levelName: '',
|
|
summary: '正在生成拼图草稿。',
|
|
generationStatus: 'generating',
|
|
}),
|
|
],
|
|
});
|
|
expect(item).toBeTruthy();
|
|
|
|
const noticeKeys = getGenerationNoticeShelfKeys(item!);
|
|
const notices = Object.fromEntries(
|
|
noticeKeys.map((key) => [
|
|
key,
|
|
{ status: 'failed', seen: false },
|
|
]),
|
|
) as DraftGenerationNoticeMap;
|
|
|
|
const state = buildCreationWorkShelfRuntimeState({
|
|
item: item!,
|
|
notices,
|
|
pendingShelfItems: {
|
|
puzzle: {
|
|
'puzzle-session-empty': createPendingDraftShelfState(
|
|
'failed',
|
|
false,
|
|
'2026-06-03T08:00:00.000Z',
|
|
{ summary: '图片生成超时，可重新打开处理。' },
|
|
),
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(state).toMatchObject({
|
|
isGenerating: false,
|
|
hasGenerationFailure: true,
|
|
generationFailureSummary: '拼图草稿生成失败，可重新打开处理。',
|
|
hasUnreadUpdate: false,
|
|
suppressPersistedGenerating: true,
|
|
titleOverride: '拼图草稿',
|
|
summaryOverride: '图片生成超时，可重新打开处理。',
|
|
});
|
|
});
|
|
|
|
test('collectVisibleDraftNoticeKeys and hasUnreadDraftGenerationUpdates share unread dot rule', () => {
|
|
const puzzle = buildPuzzleWork({
|
|
workId: 'puzzle-work-ocean',
|
|
profileId: 'puzzle-profile-ocean',
|
|
sourceSessionId: 'puzzle-session-ocean',
|
|
});
|
|
const visibleKeys = collectVisibleDraftNoticeKeys({
|
|
rpgItems: [],
|
|
bigFishItems: [],
|
|
jumpHopItems: [],
|
|
woodenFishItems: [],
|
|
match3dItems: [],
|
|
squareHoleItems: [],
|
|
puzzleItems: [puzzle],
|
|
visualNovelItems: [],
|
|
barkBattleItems: [],
|
|
babyObjectMatchItems: [],
|
|
});
|
|
|
|
expect(visibleKeys).toContain('puzzle:puzzle-work-ocean');
|
|
expect(visibleKeys).toContain('puzzle:puzzle-profile-ocean');
|
|
expect(visibleKeys).toContain('puzzle:puzzle-session-ocean');
|
|
expect(buildPuzzleResultWorkId('puzzle-session-ocean')).toBe(
|
|
'puzzle-work-ocean',
|
|
);
|
|
expect(buildPuzzleResultProfileId('puzzle-session-ocean')).toBe(
|
|
'puzzle-profile-ocean',
|
|
);
|
|
|
|
expect(
|
|
hasUnreadDraftGenerationUpdates(
|
|
{
|
|
'puzzle:puzzle-profile-ocean': {
|
|
status: 'ready',
|
|
seen: false,
|
|
},
|
|
},
|
|
visibleKeys,
|
|
),
|
|
).toBe(true);
|
|
expect(
|
|
hasUnreadDraftGenerationUpdates(
|
|
{
|
|
'puzzle:puzzle-profile-ocean': {
|
|
status: 'ready',
|
|
seen: true,
|
|
},
|
|
},
|
|
visibleKeys,
|
|
),
|
|
).toBe(false);
|
|
|
|
expect(
|
|
countUnreadDraftGenerationUpdates(
|
|
{
|
|
'puzzle:puzzle-work-ocean': {
|
|
status: 'ready',
|
|
seen: false,
|
|
},
|
|
'puzzle:puzzle-profile-ocean': {
|
|
status: 'ready',
|
|
seen: false,
|
|
},
|
|
'puzzle:puzzle-session-ocean': {
|
|
status: 'ready',
|
|
seen: false,
|
|
},
|
|
},
|
|
{
|
|
rpgItems: [],
|
|
bigFishItems: [],
|
|
jumpHopItems: [],
|
|
woodenFishItems: [],
|
|
match3dItems: [],
|
|
squareHoleItems: [],
|
|
puzzleItems: [puzzle],
|
|
visualNovelItems: [],
|
|
barkBattleItems: [],
|
|
babyObjectMatchItems: [],
|
|
},
|
|
),
|
|
).toBe(1);
|
|
expect(
|
|
countUnreadDraftGenerationUpdates(
|
|
{
|
|
'puzzle:puzzle-profile-ocean': {
|
|
status: 'failed',
|
|
seen: false,
|
|
},
|
|
'puzzle:puzzle-session-other': {
|
|
status: 'ready',
|
|
seen: false,
|
|
},
|
|
},
|
|
{
|
|
rpgItems: [],
|
|
bigFishItems: [],
|
|
jumpHopItems: [],
|
|
woodenFishItems: [],
|
|
match3dItems: [],
|
|
squareHoleItems: [],
|
|
puzzleItems: [puzzle],
|
|
visualNovelItems: [],
|
|
barkBattleItems: [],
|
|
babyObjectMatchItems: [],
|
|
},
|
|
),
|
|
).toBe(0);
|
|
});
|
|
});
|
|
|
|
function emptyGenerationFacts(
|
|
overrides: Partial<Parameters<typeof resolvePuzzleDraftOpenIntent>[0]['generation']> = {},
|
|
): Parameters<typeof resolvePuzzleDraftOpenIntent>[0]['generation'] {
|
|
return {
|
|
activeSessionId: null,
|
|
hasActiveGenerationFailure: false,
|
|
hasActiveGenerationRunning: false,
|
|
hasBackgroundGenerationFailure: false,
|
|
hasBackgroundGenerationRunning: false,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildPuzzleWork(
|
|
overrides: Partial<PuzzleWorkSummary> = {},
|
|
): PuzzleWorkSummary {
|
|
return {
|
|
workId: 'puzzle-work-base',
|
|
profileId: 'puzzle-profile-base',
|
|
ownerUserId: 'user-1',
|
|
sourceSessionId: 'puzzle-session-base',
|
|
authorDisplayName: '测试作者',
|
|
workTitle: '潮雾拼图',
|
|
workDescription: '潮雾港口拼图。',
|
|
levelName: '潮雾拼图',
|
|
summary: '潮雾港口拼图。',
|
|
themeTags: [],
|
|
coverImageSrc: null,
|
|
coverAssetId: null,
|
|
publicationStatus: 'draft',
|
|
updatedAt: '2026-06-03T08:00:00.000Z',
|
|
publishedAt: null,
|
|
playCount: 0,
|
|
remixCount: 0,
|
|
likeCount: 0,
|
|
publishReady: false,
|
|
levels: [],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildMatch3DWork(
|
|
overrides: Partial<Match3DWorkSummary> = {},
|
|
): Match3DWorkSummary {
|
|
return {
|
|
workId: 'match3d-work-base',
|
|
profileId: 'match3d-profile-base',
|
|
ownerUserId: 'user-1',
|
|
sourceSessionId: 'match3d-session-base',
|
|
gameName: '潮雾抓大鹅',
|
|
themeText: '潮雾港口',
|
|
summary: '潮雾港口抓大鹅。',
|
|
tags: [],
|
|
coverImageSrc: null,
|
|
referenceImageSrc: null,
|
|
clearCount: 0,
|
|
difficulty: 1,
|
|
publicationStatus: 'draft',
|
|
playCount: 0,
|
|
updatedAt: '2026-06-03T08:00:00.000Z',
|
|
publishedAt: null,
|
|
publishReady: false,
|
|
generationStatus: 'ready',
|
|
generatedItemAssets: [],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildBigFishWork(
|
|
overrides: Partial<BigFishWorkSummary> = {},
|
|
): BigFishWorkSummary {
|
|
return {
|
|
workId: 'big-fish-work-base',
|
|
sourceSessionId: 'big-fish-session-base',
|
|
ownerUserId: 'user-1',
|
|
authorDisplayName: '测试作者',
|
|
title: '潮雾大鱼',
|
|
subtitle: '潮雾港口',
|
|
summary: '潮雾港口大鱼吃小鱼。',
|
|
coverImageSrc: null,
|
|
status: 'draft',
|
|
updatedAt: '2026-06-03T08:00:00.000Z',
|
|
publishedAt: null,
|
|
playCount: 0,
|
|
remixCount: 0,
|
|
likeCount: 0,
|
|
publishReady: false,
|
|
levelCount: 1,
|
|
levelMainImageReadyCount: 0,
|
|
levelMotionReadyCount: 0,
|
|
backgroundReady: false,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildSquareHoleWork(
|
|
overrides: Partial<SquareHoleWorkSummary> = {},
|
|
): SquareHoleWorkSummary {
|
|
return {
|
|
workId: 'square-hole-work-base',
|
|
profileId: 'square-hole-profile-base',
|
|
ownerUserId: 'user-1',
|
|
sourceSessionId: 'square-hole-session-base',
|
|
gameName: '潮雾方洞',
|
|
themeText: '潮雾港口',
|
|
twistRule: '避开雾门',
|
|
summary: '潮雾港口方洞挑战。',
|
|
tags: [],
|
|
coverImageSrc: null,
|
|
backgroundPrompt: '潮雾港口',
|
|
backgroundImageSrc: null,
|
|
shapeOptions: [],
|
|
holeOptions: [],
|
|
shapeCount: 1,
|
|
difficulty: 1,
|
|
publicationStatus: 'draft',
|
|
playCount: 0,
|
|
updatedAt: '2026-06-03T08:00:00.000Z',
|
|
publishedAt: null,
|
|
publishReady: false,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildVisualNovelWork(
|
|
overrides: Partial<VisualNovelWorkSummary> = {},
|
|
): VisualNovelWorkSummary {
|
|
return {
|
|
runtimeKind: 'visual-novel',
|
|
profileId: 'visual-novel-profile-base',
|
|
ownerUserId: 'user-1',
|
|
title: '潮雾视觉小说',
|
|
description: '潮雾港口视觉小说。',
|
|
coverImageSrc: null,
|
|
tags: [],
|
|
publishStatus: 'draft',
|
|
publishReady: false,
|
|
playCount: 0,
|
|
updatedAt: '2026-06-03T08:00:00.000Z',
|
|
publishedAt: null,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildJumpHopWork(
|
|
overrides: Partial<JumpHopWorkSummaryResponse> = {},
|
|
): JumpHopWorkSummaryResponse {
|
|
return {
|
|
runtimeKind: 'jump-hop',
|
|
workId: 'jump-hop-work-base',
|
|
profileId: 'jump-hop-profile-base',
|
|
ownerUserId: 'user-1',
|
|
sourceSessionId: 'jump-hop-session-base',
|
|
themeText: '潮雾港口',
|
|
workTitle: '潮雾跳一跳',
|
|
workDescription: '潮雾港口跳一跳。',
|
|
themeTags: [],
|
|
difficulty: 'standard',
|
|
stylePreset: 'minimal-blocks',
|
|
coverImageSrc: null,
|
|
publicationStatus: 'draft',
|
|
playCount: 0,
|
|
updatedAt: '2026-06-03T08:00:00.000Z',
|
|
publishedAt: null,
|
|
publishReady: false,
|
|
generationStatus: 'ready',
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildWoodenFishWork(
|
|
overrides: Partial<WoodenFishWorkSummaryResponse> = {},
|
|
): WoodenFishWorkSummaryResponse {
|
|
return {
|
|
runtimeKind: 'wooden-fish',
|
|
workId: 'wooden-fish-work-base',
|
|
profileId: 'wooden-fish-profile-base',
|
|
ownerUserId: 'user-1',
|
|
sourceSessionId: 'wooden-fish-session-base',
|
|
workTitle: '潮雾敲木鱼',
|
|
workDescription: '潮雾港口敲木鱼。',
|
|
themeTags: ['敲木鱼'],
|
|
coverImageSrc: null,
|
|
publicationStatus: 'draft',
|
|
playCount: 0,
|
|
updatedAt: '2026-06-03T08:00:00.000Z',
|
|
publishedAt: null,
|
|
publishReady: false,
|
|
generationStatus: 'ready',
|
|
...overrides,
|
|
};
|
|
}
|