881 lines
32 KiB
Rust
881 lines
32 KiB
Rust
use super::*;
|
||
|
||
#[test]
|
||
fn puzzle_generated_image_size_is_square_1_1() {
|
||
assert_eq!(PUZZLE_GENERATED_IMAGE_SIZE, "1024*1024");
|
||
assert_eq!(PUZZLE_VECTOR_ENGINE_GENERATED_IMAGE_SIZE, "1024x1024");
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_request_uses_gpt_image_2_all_and_reference_images() {
|
||
let body = build_puzzle_vector_engine_image_request_body(
|
||
PuzzleImageModel::Gemini31FlashPreview,
|
||
"一只猫在雨夜灯牌下回头。",
|
||
PUZZLE_DEFAULT_NEGATIVE_PROMPT,
|
||
PUZZLE_VECTOR_ENGINE_GENERATED_IMAGE_SIZE,
|
||
4,
|
||
None,
|
||
);
|
||
|
||
assert_eq!(body["model"], VECTOR_ENGINE_GPT_IMAGE_2_MODEL);
|
||
assert_eq!(body["size"], PUZZLE_VECTOR_ENGINE_GENERATED_IMAGE_SIZE);
|
||
assert_eq!(body["n"], 1);
|
||
assert!(body.get("official_fallback").is_none());
|
||
assert!(body.get("image").is_none());
|
||
assert!(
|
||
body["prompt"]
|
||
.as_str()
|
||
.unwrap_or_default()
|
||
.contains("文字水印")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_generation_fallback_includes_reference_image() {
|
||
let image = image::DynamicImage::ImageRgb8(image::RgbImage::new(4, 4));
|
||
let mut cursor = std::io::Cursor::new(Vec::new());
|
||
image
|
||
.write_to(&mut cursor, ImageFormat::Png)
|
||
.expect("test image should encode");
|
||
let reference_image = PuzzleResolvedReferenceImage {
|
||
mime_type: "image/png".to_string(),
|
||
bytes_len: cursor.get_ref().len(),
|
||
bytes: cursor.into_inner(),
|
||
};
|
||
|
||
let body = build_puzzle_vector_engine_image_request_body(
|
||
PuzzleImageModel::GptImage2,
|
||
"参考图里的小猫做成拼图主图。",
|
||
PUZZLE_DEFAULT_NEGATIVE_PROMPT,
|
||
PUZZLE_VECTOR_ENGINE_GENERATED_IMAGE_SIZE,
|
||
1,
|
||
Some(&reference_image),
|
||
);
|
||
|
||
let images = body["image"]
|
||
.as_array()
|
||
.expect("fallback generation should include reference image array");
|
||
assert_eq!(images.len(), 1);
|
||
assert!(
|
||
images[0]
|
||
.as_str()
|
||
.unwrap_or_default()
|
||
.starts_with("data:image/png;base64,")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_edit_url_uses_images_edits_endpoint() {
|
||
let settings = PuzzleVectorEngineSettings {
|
||
base_url: "https://vector.example/v1".to_string(),
|
||
api_key: "test-key".to_string(),
|
||
};
|
||
|
||
assert_eq!(
|
||
puzzle_vector_engine_images_edit_url(&settings),
|
||
"https://vector.example/v1/images/edits"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_edit_response_decodes_b64_image() {
|
||
let images = puzzle_images_from_base64(
|
||
"edit-1".to_string(),
|
||
vec![BASE64_STANDARD.encode(b"\x89PNG\r\n\x1A\nrest")],
|
||
1,
|
||
);
|
||
|
||
assert_eq!(images.images.len(), 1);
|
||
assert_eq!(images.images[0].mime_type, "image/png");
|
||
assert_eq!(images.images[0].extension, "png");
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_prompt_strongly_uses_reference_image() {
|
||
let prompt = build_puzzle_vector_engine_generation_prompt("请生成雨夜猫街。", true);
|
||
|
||
assert!(prompt.contains("参考图作为第一优先级"));
|
||
assert!(prompt.contains("严格保留参考图的主要主体、构图关系、视角、姿态、配色和光影氛围"));
|
||
assert!(prompt.contains("请生成雨夜猫街。"));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_prompt_keeps_text_only_prompt_unchanged() {
|
||
let prompt = build_puzzle_vector_engine_generation_prompt("请生成雨夜猫街。", false);
|
||
|
||
assert_eq!(prompt, "请生成雨夜猫街。");
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_reference_image_edit_requires_ai_redraw() {
|
||
assert!(!should_use_puzzle_reference_image_edit(None, true));
|
||
assert!(!should_use_puzzle_reference_image_edit(
|
||
Some("data:image/png;base64,abcd"),
|
||
false
|
||
));
|
||
assert!(should_use_puzzle_reference_image_edit(
|
||
Some("data:image/png;base64,abcd"),
|
||
true
|
||
));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_reference_image_sources_are_deduped_and_limited() {
|
||
let sources = collect_puzzle_reference_image_sources(
|
||
Some("data:image/png;base64,a"),
|
||
&[
|
||
"data:image/png;base64,a".to_string(),
|
||
"data:image/png;base64,b".to_string(),
|
||
"data:image/png;base64,c".to_string(),
|
||
"data:image/png;base64,d".to_string(),
|
||
"data:image/png;base64,e".to_string(),
|
||
"data:image/png;base64,f".to_string(),
|
||
],
|
||
);
|
||
|
||
assert_eq!(sources.len(), 5);
|
||
assert_eq!(sources[0], "data:image/png;base64,a");
|
||
assert_eq!(sources[1], "data:image/png;base64,b");
|
||
assert!(!sources.contains(&"data:image/png;base64,f".to_string()));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_timeout_maps_to_gateway_timeout() {
|
||
let error = map_puzzle_vector_engine_request_error(
|
||
"创建拼图 VectorEngine 图片生成任务失败：operation timed out".to_string(),
|
||
);
|
||
|
||
let response = error.into_response();
|
||
assert_eq!(response.status(), StatusCode::GATEWAY_TIMEOUT);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_upstream_timeout_maps_to_gateway_timeout() {
|
||
let error = map_puzzle_vector_engine_upstream_error(
|
||
reqwest::StatusCode::GATEWAY_TIMEOUT,
|
||
r#"{"error":{"message":"VectorEngine edit endpoint timeout"}}"#,
|
||
"创建拼图 VectorEngine 图片编辑任务失败",
|
||
);
|
||
|
||
let response = error.into_response();
|
||
assert_eq!(response.status(), StatusCode::GATEWAY_TIMEOUT);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_reference_edit_fallback_only_accepts_timeout_errors() {
|
||
let timeout_error = map_puzzle_vector_engine_upstream_error(
|
||
reqwest::StatusCode::GATEWAY_TIMEOUT,
|
||
r#"{"error":{"message":"VectorEngine edit endpoint timeout"}}"#,
|
||
"创建拼图 VectorEngine 图片编辑任务失败",
|
||
);
|
||
assert!(should_fallback_puzzle_reference_edit_to_generation(
|
||
&timeout_error
|
||
));
|
||
|
||
let auth_error = map_puzzle_vector_engine_upstream_error(
|
||
reqwest::StatusCode::UNAUTHORIZED,
|
||
r#"{"error":{"message":"invalid api key"}}"#,
|
||
"创建拼图 VectorEngine 图片编辑任务失败",
|
||
);
|
||
assert!(!should_fallback_puzzle_reference_edit_to_generation(
|
||
&auth_error
|
||
));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_vector_engine_reqwest_error_maps_to_bad_gateway() {
|
||
let error = match reqwest::Client::new().get("http://[::1").build() {
|
||
Ok(_) => panic!("invalid url should fail request build"),
|
||
Err(error) => error,
|
||
};
|
||
let app_error = map_puzzle_vector_engine_reqwest_error(
|
||
"创建拼图 VectorEngine 图片编辑任务失败",
|
||
"https://api.vectorengine.ai/v1/images/edits",
|
||
error,
|
||
);
|
||
|
||
let response = app_error.into_response();
|
||
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_compile_error_preserves_vector_engine_unavailable_status() {
|
||
let error = map_puzzle_compile_error(SpacetimeClientError::Runtime(
|
||
"VECTOR_ENGINE_API_KEY 未配置".to_string(),
|
||
));
|
||
|
||
let response = error.into_response();
|
||
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn puzzle_compile_error_normalizes_legacy_apimart_image_message() {
|
||
let error = map_puzzle_compile_error(SpacetimeClientError::Runtime(
|
||
"APIMart 图片生成密钥未配置".to_string(),
|
||
));
|
||
|
||
let response = error.into_response();
|
||
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
|
||
let body = response.into_body();
|
||
let bytes = axum::body::to_bytes(body, usize::MAX)
|
||
.await
|
||
.expect("body bytes should read");
|
||
let payload: Value =
|
||
serde_json::from_slice(&bytes).expect("error response should be valid json");
|
||
assert_eq!(
|
||
payload["error"]["details"]["provider"],
|
||
Value::String(VECTOR_ENGINE_PROVIDER.to_string())
|
||
);
|
||
assert_eq!(
|
||
payload["error"]["details"]["message"],
|
||
Value::String("VectorEngine 图片生成密钥未配置".to_string())
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_image_generation_builds_fallback_session_from_levels_snapshot() {
|
||
let levels_json = serde_json::to_string(&vec![json!({
|
||
"level_id": "puzzle-level-1",
|
||
"level_name": "雨夜猫街",
|
||
"picture_description": "一只猫在雨夜灯牌下回头。",
|
||
"candidates": [],
|
||
"selected_candidate_id": null,
|
||
"cover_image_src": null,
|
||
"cover_asset_id": null,
|
||
"generation_status": "idle",
|
||
})])
|
||
.expect("levels json");
|
||
let payload = ExecutePuzzleAgentActionRequest {
|
||
action: "generate_puzzle_images".to_string(),
|
||
prompt_text: None,
|
||
reference_image_src: None,
|
||
reference_image_srcs: Vec::new(),
|
||
image_model: Some(PUZZLE_IMAGE_MODEL_GPT_IMAGE_2.to_string()),
|
||
ai_redraw: None,
|
||
candidate_count: Some(1),
|
||
candidate_id: None,
|
||
level_id: Some("puzzle-level-1".to_string()),
|
||
work_title: Some("暖灯猫街作品".to_string()),
|
||
work_description: Some("一套雨夜猫街主题拼图。".to_string()),
|
||
picture_description: None,
|
||
level_name: None,
|
||
summary: Some("当前关卡画面。".to_string()),
|
||
theme_tags: Some(vec!["猫咪".to_string(), "雨夜".to_string()]),
|
||
levels_json: Some(levels_json.clone()),
|
||
};
|
||
|
||
let session = build_puzzle_session_snapshot_from_action_payload(
|
||
"puzzle-session-1",
|
||
&payload,
|
||
Some(levels_json.as_str()),
|
||
1_713_686_401_234_567,
|
||
)
|
||
.expect("fallback session");
|
||
|
||
let draft = session.draft.expect("draft");
|
||
assert_eq!(session.stage, "ready_to_publish");
|
||
assert_eq!(draft.work_title, "暖灯猫街作品");
|
||
assert_eq!(draft.theme_tags, vec!["猫咪", "雨夜"]);
|
||
assert_eq!(draft.levels[0].level_id, "puzzle-level-1");
|
||
assert_eq!(
|
||
draft.levels[0].picture_description,
|
||
"一只猫在雨夜灯牌下回头。"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_first_level_name_parser_accepts_json_and_normalizes_text() {
|
||
assert_eq!(
|
||
parse_puzzle_first_level_name_from_text(r#"{"levelName":"雨夜猫街"}"#),
|
||
Some("雨夜猫街".to_string())
|
||
);
|
||
assert_eq!(
|
||
parse_puzzle_first_level_name_from_text("1. 《暖灯猫街》"),
|
||
Some("暖灯猫街".to_string())
|
||
);
|
||
assert_eq!(
|
||
parse_puzzle_first_level_name_from_text(r#"{"levelName":"雨夜猫街画面"}"#),
|
||
Some("雨夜猫街".to_string())
|
||
);
|
||
assert_eq!(
|
||
parse_puzzle_first_level_name_from_text(r#"{"levelNam"#),
|
||
None
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_level_naming_parser_accepts_metadata_and_ui_background_prompt() {
|
||
let naming = parse_puzzle_level_naming_from_text(
|
||
r#"{"levelName":"雨夜猫街","workDescription":"在湿润灯牌与猫影之间完成一套雨夜街角拼图。","workTags":["雨夜","猫咪","灯牌","街角","暖色","插画"],"uiBackgroundPrompt":"雨夜老街延展成竖屏空间，湿润石板路倒映暖色灯牌，远处屋檐和薄雾形成柔和层次"}"#,
|
||
)
|
||
.expect("naming should parse");
|
||
|
||
assert_eq!(naming.level_name, "雨夜猫街");
|
||
assert_eq!(
|
||
naming.work_description.as_deref(),
|
||
Some("在湿润灯牌与猫影之间完成一套雨夜街角拼图")
|
||
);
|
||
assert_eq!(naming.work_tags.len(), module_puzzle::PUZZLE_MAX_TAG_COUNT);
|
||
assert!(naming.work_tags.contains(&"雨夜".to_string()));
|
||
assert!(naming.work_tags.contains(&"猫咪".to_string()));
|
||
assert!(naming.work_tags.contains(&"灯牌".to_string()));
|
||
assert_eq!(
|
||
naming.ui_background_prompt.as_deref(),
|
||
Some("雨夜老街延展成竖屏空间，湿润石板路倒映暖色灯牌，远处屋檐和薄雾形成柔和层次")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_level_naming_parser_filters_forbidden_ui_prompt_words() {
|
||
let naming = parse_puzzle_level_naming_from_text(
|
||
r#"{"levelName":"雨夜猫街","uiBackgroundPrompt":"雨夜老街背景，中央不要出现拼图槽、棋盘、HUD、按钮、文字或水印，保留暖色灯光"}"#,
|
||
)
|
||
.expect("naming should parse");
|
||
let prompt = naming
|
||
.ui_background_prompt
|
||
.as_deref()
|
||
.expect("prompt should parse");
|
||
|
||
assert!(!prompt.contains("拼图槽"));
|
||
assert!(!prompt.contains("棋盘"));
|
||
assert!(!prompt.contains("HUD"));
|
||
assert!(!prompt.contains("按钮"));
|
||
assert!(!prompt.contains("文字"));
|
||
assert!(!prompt.contains("水印"));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_first_level_name_fallback_uses_picture_keywords() {
|
||
assert_eq!(
|
||
build_fallback_puzzle_first_level_name("一只猫在雨夜灯牌下回头。"),
|
||
"雨夜猫街"
|
||
);
|
||
assert_eq!(
|
||
build_fallback_puzzle_first_level_name("看不出关键词的抽象色块。"),
|
||
"奇境初见"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_level_name_image_data_url_downsizes_generated_image() {
|
||
let image = image::DynamicImage::ImageRgb8(image::RgbImage::new(4, 4));
|
||
let mut cursor = std::io::Cursor::new(Vec::new());
|
||
image
|
||
.write_to(&mut cursor, ImageFormat::Png)
|
||
.expect("test image should encode");
|
||
let downloaded = PuzzleDownloadedImage {
|
||
extension: "png".to_string(),
|
||
mime_type: "image/png".to_string(),
|
||
bytes: cursor.into_inner(),
|
||
};
|
||
|
||
let data_url =
|
||
build_puzzle_level_name_image_data_url(&downloaded).expect("data url should be generated");
|
||
|
||
assert!(data_url.starts_with("data:image/png;base64,"));
|
||
assert!(data_url.len() > "data:image/png;base64,".len());
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_first_level_name_snapshot_defaults_work_title() {
|
||
let levels_json = serde_json::to_string(&vec![json!({
|
||
"level_id": "puzzle-level-1",
|
||
"level_name": "猫画面",
|
||
"picture_description": "一只猫在雨夜灯牌下回头。",
|
||
"candidates": [],
|
||
"selected_candidate_id": null,
|
||
"cover_image_src": null,
|
||
"cover_asset_id": null,
|
||
"generation_status": "idle",
|
||
})])
|
||
.expect("levels json");
|
||
let payload = ExecutePuzzleAgentActionRequest {
|
||
action: "generate_puzzle_images".to_string(),
|
||
prompt_text: None,
|
||
reference_image_src: None,
|
||
reference_image_srcs: Vec::new(),
|
||
image_model: Some(PUZZLE_IMAGE_MODEL_GPT_IMAGE_2.to_string()),
|
||
ai_redraw: None,
|
||
candidate_count: Some(1),
|
||
candidate_id: None,
|
||
level_id: Some("puzzle-level-1".to_string()),
|
||
work_title: Some("猫画面".to_string()),
|
||
work_description: None,
|
||
picture_description: None,
|
||
level_name: None,
|
||
summary: None,
|
||
theme_tags: Some(vec![]),
|
||
levels_json: Some(levels_json.clone()),
|
||
};
|
||
let session = build_puzzle_session_snapshot_from_action_payload(
|
||
"puzzle-session-1",
|
||
&payload,
|
||
Some(levels_json.as_str()),
|
||
1_713_686_401_234_567,
|
||
)
|
||
.expect("fallback session");
|
||
|
||
let renamed = apply_generated_puzzle_first_level_name_to_session_snapshot(
|
||
session,
|
||
"puzzle-level-1",
|
||
"雨夜猫街",
|
||
"猫画面",
|
||
1_713_686_401_234_568,
|
||
);
|
||
let draft = renamed.draft.expect("draft");
|
||
assert_eq!(draft.level_name, "雨夜猫街");
|
||
assert_eq!(draft.work_title, "雨夜猫街");
|
||
assert_eq!(draft.levels[0].level_name, "雨夜猫街");
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_initial_metadata_defaults_empty_work_description_and_tags() {
|
||
let mut session = PuzzleAgentSessionRecord {
|
||
session_id: "puzzle-session-1".to_string(),
|
||
seed_text: "画面描述：一只猫在雨夜灯牌下回头。".to_string(),
|
||
current_turn: 1,
|
||
progress_percent: 94,
|
||
stage: "ready_to_publish".to_string(),
|
||
anchor_pack: test_puzzle_anchor_pack_record(),
|
||
draft: Some(test_puzzle_draft_record()),
|
||
messages: Vec::new(),
|
||
last_assistant_reply: None,
|
||
published_profile_id: None,
|
||
suggested_actions: Vec::new(),
|
||
result_preview: None,
|
||
updated_at: "2024-01-01T00:00:00Z".to_string(),
|
||
};
|
||
{
|
||
let draft = session.draft.as_mut().expect("draft");
|
||
draft.work_title = "猫画面".to_string();
|
||
draft.work_description = String::new();
|
||
draft.summary = String::new();
|
||
draft.theme_tags = Vec::new();
|
||
}
|
||
let metadata = PuzzleLevelNaming {
|
||
level_name: "雨夜猫街".to_string(),
|
||
work_description: Some("在湿润灯牌与猫影之间完成一套雨夜街角拼图".to_string()),
|
||
work_tags: vec![
|
||
"插画".to_string(),
|
||
"灯牌".to_string(),
|
||
"街角".to_string(),
|
||
"猫咪".to_string(),
|
||
"暖色".to_string(),
|
||
"雨夜".to_string(),
|
||
],
|
||
ui_background_prompt: None,
|
||
};
|
||
|
||
let session = apply_generated_puzzle_initial_metadata_to_session_snapshot(
|
||
session,
|
||
&metadata,
|
||
"猫画面",
|
||
1_713_686_401_234_568,
|
||
);
|
||
|
||
let draft = session.draft.expect("draft");
|
||
assert_eq!(draft.work_title, "雨夜猫街");
|
||
assert_eq!(
|
||
draft.work_description,
|
||
"在湿润灯牌与猫影之间完成一套雨夜街角拼图"
|
||
);
|
||
assert_eq!(draft.summary, draft.work_description);
|
||
assert_eq!(draft.theme_tags, metadata.work_tags);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_level_audio_asset_roundtrips_between_response_and_module_json() {
|
||
let level = PuzzleDraftLevelResponse {
|
||
level_id: "puzzle-level-1".to_string(),
|
||
level_name: "雨夜猫街".to_string(),
|
||
picture_description: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
picture_reference: None,
|
||
ui_background_prompt: None,
|
||
ui_background_image_src: None,
|
||
ui_background_image_object_key: None,
|
||
background_music: Some(CreationAudioAsset {
|
||
task_id: "suno-task-1".to_string(),
|
||
provider: "vector-engine-suno".to_string(),
|
||
asset_object_id: Some("assetobj_1".to_string()),
|
||
asset_kind: Some("puzzle_background_music".to_string()),
|
||
audio_src: "/generated-puzzle-assets/audio.mp3".to_string(),
|
||
prompt: Some("轻快拼图音乐".to_string()),
|
||
title: Some("雨夜猫街背景音乐".to_string()),
|
||
updated_at: Some("2026-05-11T00:00:00Z".to_string()),
|
||
}),
|
||
candidates: vec![],
|
||
selected_candidate_id: None,
|
||
cover_image_src: None,
|
||
cover_asset_id: None,
|
||
generation_status: "ready".to_string(),
|
||
};
|
||
let request_context = RequestContext::new(
|
||
"test-request".to_string(),
|
||
"PUT /api/runtime/puzzle/works/test".to_string(),
|
||
Duration::ZERO,
|
||
false,
|
||
);
|
||
|
||
let levels_json = serialize_puzzle_levels_response(&request_context, &[level])
|
||
.expect("levels should serialize");
|
||
let payload: Value = serde_json::from_str(&levels_json).expect("levels json should parse");
|
||
assert_eq!(
|
||
payload[0]["background_music"]["audio_src"],
|
||
Value::String("/generated-puzzle-assets/audio.mp3".to_string())
|
||
);
|
||
assert!(payload[0]["background_music"].get("audioSrc").is_none());
|
||
|
||
let records = parse_puzzle_level_records_from_module_json(&levels_json)
|
||
.expect("levels should map back into records");
|
||
let music = records[0]
|
||
.background_music
|
||
.as_ref()
|
||
.expect("background music should exist");
|
||
assert_eq!(music.audio_src, "/generated-puzzle-assets/audio.mp3");
|
||
assert_eq!(music.asset_kind.as_deref(), Some("puzzle_background_music"));
|
||
|
||
let response = map_puzzle_draft_level_response(records[0].clone());
|
||
assert_eq!(
|
||
response
|
||
.background_music
|
||
.as_ref()
|
||
.map(|asset| asset.audio_src.as_str()),
|
||
Some("/generated-puzzle-assets/audio.mp3")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_ui_background_fields_roundtrip_between_response_and_module_json() {
|
||
let level = PuzzleDraftLevelResponse {
|
||
level_id: "puzzle-level-1".to_string(),
|
||
level_name: "雨夜猫街".to_string(),
|
||
picture_description: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
picture_reference: None,
|
||
ui_background_prompt: Some("雨夜猫街竖屏拼图UI背景".to_string()),
|
||
ui_background_image_src: Some(
|
||
"/generated-puzzle-assets/session/ui/background.png".to_string(),
|
||
),
|
||
ui_background_image_object_key: Some(
|
||
"generated-puzzle-assets/session/ui/background.png".to_string(),
|
||
),
|
||
background_music: None,
|
||
candidates: vec![],
|
||
selected_candidate_id: None,
|
||
cover_image_src: Some("/generated-puzzle-assets/session/cover.png".to_string()),
|
||
cover_asset_id: Some("asset-1".to_string()),
|
||
generation_status: "ready".to_string(),
|
||
};
|
||
let request_context = RequestContext::new(
|
||
"test-request".to_string(),
|
||
"PUT /api/runtime/puzzle/works/test".to_string(),
|
||
Duration::ZERO,
|
||
false,
|
||
);
|
||
|
||
let levels_json = serialize_puzzle_levels_response(&request_context, &[level])
|
||
.expect("levels should serialize");
|
||
let payload: Value = serde_json::from_str(&levels_json).expect("levels json should parse");
|
||
assert_eq!(
|
||
payload[0]["ui_background_prompt"],
|
||
Value::String("雨夜猫街竖屏拼图UI背景".to_string())
|
||
);
|
||
assert!(payload[0].get("uiBackgroundPrompt").is_none());
|
||
|
||
let records = parse_puzzle_level_records_from_module_json(&levels_json)
|
||
.expect("levels should map back into records");
|
||
assert_eq!(
|
||
records[0].ui_background_image_src.as_deref(),
|
||
Some("/generated-puzzle-assets/session/ui/background.png")
|
||
);
|
||
|
||
let response = map_puzzle_draft_level_response(records[0].clone());
|
||
assert_eq!(
|
||
response.ui_background_image_object_key.as_deref(),
|
||
Some("generated-puzzle-assets/session/ui/background.png")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_work_summary_response_keeps_levels_for_shelf_cover() {
|
||
let state = AppState::new(crate::config::AppConfig::default()).expect("state should build");
|
||
let level = PuzzleDraftLevelRecord {
|
||
level_id: "puzzle-level-1".to_string(),
|
||
level_name: "雨夜猫街".to_string(),
|
||
picture_description: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
picture_reference: None,
|
||
ui_background_prompt: None,
|
||
ui_background_image_src: None,
|
||
ui_background_image_object_key: None,
|
||
background_music: None,
|
||
candidates: vec![PuzzleGeneratedImageCandidateRecord {
|
||
candidate_id: "candidate-1".to_string(),
|
||
image_src: "/generated-puzzle-assets/session/candidate-1.png".to_string(),
|
||
asset_id: "asset-1".to_string(),
|
||
prompt: "雨夜猫街".to_string(),
|
||
actual_prompt: None,
|
||
source_type: "generated".to_string(),
|
||
selected: true,
|
||
}],
|
||
selected_candidate_id: Some("candidate-1".to_string()),
|
||
cover_image_src: Some("/generated-puzzle-assets/session/cover.png".to_string()),
|
||
cover_asset_id: Some("asset-1".to_string()),
|
||
generation_status: "ready".to_string(),
|
||
};
|
||
|
||
let response = map_puzzle_work_summary_response(
|
||
&state,
|
||
PuzzleWorkProfileRecord {
|
||
work_id: "puzzle-work-1".to_string(),
|
||
profile_id: "puzzle-profile-1".to_string(),
|
||
owner_user_id: "user-1".to_string(),
|
||
source_session_id: Some("puzzle-session-1".to_string()),
|
||
author_display_name: "玩家".to_string(),
|
||
work_title: "雨夜猫街".to_string(),
|
||
work_description: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
level_name: "雨夜猫街".to_string(),
|
||
summary: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
theme_tags: vec!["猫".to_string()],
|
||
cover_image_src: None,
|
||
cover_asset_id: None,
|
||
publication_status: "draft".to_string(),
|
||
updated_at: "2026-05-08T00:00:00.000Z".to_string(),
|
||
published_at: None,
|
||
play_count: 0,
|
||
remix_count: 0,
|
||
like_count: 0,
|
||
recent_play_count_7d: 0,
|
||
point_incentive_total_half_points: 0,
|
||
point_incentive_claimed_points: 0,
|
||
publish_ready: false,
|
||
anchor_pack: test_puzzle_anchor_pack_record(),
|
||
levels: vec![level],
|
||
},
|
||
);
|
||
|
||
assert_eq!(response.levels.len(), 1);
|
||
assert_eq!(response.generation_status.as_deref(), Some("ready"));
|
||
assert_eq!(
|
||
response.levels[0].cover_image_src.as_deref(),
|
||
Some("/generated-puzzle-assets/session/cover.png")
|
||
);
|
||
assert_eq!(
|
||
response.levels[0].candidates[0].image_src,
|
||
"/generated-puzzle-assets/session/candidate-1.png"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_ui_background_prompt_keeps_generated_slots_out_of_background() {
|
||
let prompt = build_puzzle_ui_background_request_prompt_for_test("雨夜猫街", "雨夜猫街主题背景");
|
||
|
||
assert!(prompt.contains("9:16"));
|
||
assert!(prompt.contains("纯背景图"));
|
||
assert!(prompt.contains("不得出现拼图槽"));
|
||
assert!(prompt.contains("默认拼图槽"));
|
||
assert!(prompt.contains("文字"));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_initial_ui_background_prompt_prefers_ai_generated_prompt() {
|
||
let mut draft = test_puzzle_draft_record();
|
||
draft.work_title = "模板作品名".to_string();
|
||
draft.work_description = "模板作品描述".to_string();
|
||
let mut target_level = draft.levels[0].clone();
|
||
target_level.level_name = "雨夜猫街".to_string();
|
||
let ai_prompt = "雨夜老街延展成竖屏空间，湿润石板路倒映暖色灯牌，远处屋檐和薄雾形成柔和层次";
|
||
target_level.ui_background_prompt = Some(ai_prompt.to_string());
|
||
|
||
let prompt = resolve_puzzle_initial_ui_background_prompt(&draft, &target_level);
|
||
|
||
assert_eq!(prompt, ai_prompt);
|
||
assert!(!prompt.contains(PUZZLE_UI_BACKGROUND_PROMPT_FALLBACK_MARKER));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_initial_ui_background_prompt_falls_back_to_context_template() {
|
||
let draft = test_puzzle_draft_record();
|
||
let target_level = draft.levels[0].clone();
|
||
|
||
let prompt = resolve_puzzle_initial_ui_background_prompt(&draft, &target_level);
|
||
|
||
assert!(prompt.contains("雨夜猫街"));
|
||
assert!(prompt.contains(PUZZLE_UI_BACKGROUND_PROMPT_FALLBACK_MARKER));
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_ui_background_initial_attach_updates_first_level_fields() {
|
||
let draft = test_puzzle_draft_record();
|
||
let generated = GeneratedPuzzleUiBackgroundResponse {
|
||
image_src: "/generated-puzzle-assets/session/ui/background.png".to_string(),
|
||
object_key: "generated-puzzle-assets/session/ui/background.png".to_string(),
|
||
};
|
||
let mut levels = draft.levels.clone();
|
||
|
||
attach_puzzle_level_ui_background(
|
||
&mut levels,
|
||
"puzzle-level-1",
|
||
"雨夜猫街移动端拼图UI背景".to_string(),
|
||
generated,
|
||
);
|
||
|
||
assert_eq!(
|
||
levels[0].ui_background_prompt.as_deref(),
|
||
Some("雨夜猫街移动端拼图UI背景")
|
||
);
|
||
assert_eq!(
|
||
levels[0].ui_background_image_src.as_deref(),
|
||
Some("/generated-puzzle-assets/session/ui/background.png")
|
||
);
|
||
assert_eq!(
|
||
levels[0].ui_background_image_object_key.as_deref(),
|
||
Some("generated-puzzle-assets/session/ui/background.png")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_initial_draft_assets_must_include_ui_background() {
|
||
let mut draft = test_puzzle_draft_record();
|
||
let missing_all = ensure_puzzle_initial_level_assets_ready(&draft.levels[0])
|
||
.expect_err("缺少自动生成资产时不能把草稿标记为完成");
|
||
assert_eq!(missing_all.status_code(), StatusCode::BAD_GATEWAY);
|
||
assert!(missing_all.body_text().contains("UI背景图"));
|
||
|
||
draft.levels[0].ui_background_image_src =
|
||
Some("/generated-puzzle-assets/session/ui/background.png".to_string());
|
||
ensure_puzzle_initial_level_assets_ready(&draft.levels[0])
|
||
.expect("UI 背景存在时即可完成自动草稿资源检查");
|
||
}
|
||
|
||
fn test_puzzle_anchor_pack_record() -> PuzzleAnchorPackRecord {
|
||
let item = PuzzleAnchorItemRecord {
|
||
key: "visualSubject".to_string(),
|
||
label: "画面".to_string(),
|
||
value: "雨夜猫街".to_string(),
|
||
status: "confirmed".to_string(),
|
||
};
|
||
|
||
PuzzleAnchorPackRecord {
|
||
theme_promise: item.clone(),
|
||
visual_subject: item.clone(),
|
||
visual_mood: item.clone(),
|
||
composition_hooks: item.clone(),
|
||
tags_and_forbidden: item,
|
||
}
|
||
}
|
||
|
||
fn test_puzzle_draft_record() -> PuzzleResultDraftRecord {
|
||
let anchor_pack = test_puzzle_anchor_pack_record();
|
||
PuzzleResultDraftRecord {
|
||
work_title: "雨夜猫街".to_string(),
|
||
work_description: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
level_name: "猫画面".to_string(),
|
||
summary: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
theme_tags: vec![],
|
||
forbidden_directives: vec![],
|
||
creator_intent: None,
|
||
anchor_pack,
|
||
candidates: vec![],
|
||
selected_candidate_id: None,
|
||
cover_image_src: None,
|
||
cover_asset_id: None,
|
||
generation_status: "idle".to_string(),
|
||
levels: vec![PuzzleDraftLevelRecord {
|
||
level_id: "puzzle-level-1".to_string(),
|
||
level_name: "猫画面".to_string(),
|
||
picture_description: "一只猫在雨夜灯牌下回头。".to_string(),
|
||
picture_reference: None,
|
||
ui_background_prompt: None,
|
||
ui_background_image_src: None,
|
||
ui_background_image_object_key: None,
|
||
background_music: None,
|
||
candidates: vec![],
|
||
selected_candidate_id: None,
|
||
cover_image_src: None,
|
||
cover_asset_id: None,
|
||
generation_status: "idle".to_string(),
|
||
}],
|
||
form_draft: None,
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_primary_level_update_preserves_reference_for_regeneration() {
|
||
let draft = test_puzzle_draft_record();
|
||
let mut target_level = draft.levels[0].clone();
|
||
target_level.level_name = "雨夜猫街".to_string();
|
||
|
||
let levels = build_puzzle_levels_with_primary_update(
|
||
&draft,
|
||
&target_level,
|
||
Some("data:image/png;base64,abcd"),
|
||
);
|
||
|
||
assert_eq!(levels[0].level_name, "雨夜猫街");
|
||
assert_eq!(
|
||
levels[0].picture_reference.as_deref(),
|
||
Some("data:image/png;base64,abcd")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn puzzle_generated_fallback_snapshot_preserves_picture_reference() {
|
||
let anchor_pack = test_puzzle_anchor_pack_record();
|
||
let session = PuzzleAgentSessionRecord {
|
||
session_id: "puzzle-session-1".to_string(),
|
||
seed_text: "雨夜猫街".to_string(),
|
||
current_turn: 1,
|
||
progress_percent: 0,
|
||
stage: "draft_ready".to_string(),
|
||
anchor_pack: anchor_pack.clone(),
|
||
draft: Some(test_puzzle_draft_record()),
|
||
messages: Vec::new(),
|
||
last_assistant_reply: None,
|
||
published_profile_id: None,
|
||
suggested_actions: Vec::new(),
|
||
result_preview: None,
|
||
updated_at: "2024-01-01T00:00:00Z".to_string(),
|
||
};
|
||
let candidate = PuzzleGeneratedImageCandidateRecord {
|
||
candidate_id: "puzzle-session-1-candidate-1".to_string(),
|
||
image_src: "/generated-puzzle-assets/puzzle-session-1/1/cover.png".to_string(),
|
||
asset_id: "puzzle-cover-1".to_string(),
|
||
prompt: "雨夜猫街".to_string(),
|
||
actual_prompt: Some("雨夜猫街".to_string()),
|
||
source_type: "generated:gpt-image-2".to_string(),
|
||
selected: true,
|
||
};
|
||
|
||
let session = apply_generated_puzzle_candidates_to_session_snapshot(
|
||
session,
|
||
"puzzle-level-1",
|
||
vec![candidate],
|
||
Some("data:image/png;base64,abcd"),
|
||
1_713_686_401_234_568,
|
||
);
|
||
|
||
let draft = session.draft.expect("draft");
|
||
assert_eq!(
|
||
draft.levels[0].picture_reference.as_deref(),
|
||
Some("data:image/png;base64,abcd")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn freeze_boundary_sync_only_matches_freeze_invalid_operation() {
|
||
let invalid_operation = AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": "spacetimedb",
|
||
"message": "操作不合法",
|
||
}));
|
||
let other_error = AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": "spacetimedb",
|
||
"message": "泥点余额不足",
|
||
}));
|
||
|
||
assert!(should_sync_puzzle_freeze_boundary(&invalid_operation, true));
|
||
assert!(!should_sync_puzzle_freeze_boundary(
|
||
&invalid_operation,
|
||
false
|
||
));
|
||
assert!(!should_sync_puzzle_freeze_boundary(&other_error, true));
|
||
}
|