From de8322c96543f8d5ff56d5bde3d7798d4eb9774a Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Tue, 21 Apr 2026 15:05:24 -0400 Subject: [PATCH] cost tests --- .../providers/kinovi/seedance_2p0/cost.rs | 408 +++++++++++++++++- .../video_generation_draft.rs | 4 +- 2 files changed, 400 insertions(+), 12 deletions(-) diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/kinovi/seedance_2p0/cost.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/kinovi/seedance_2p0/cost.rs index ce03d55415..483e119535 100644 --- a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/kinovi/seedance_2p0/cost.rs +++ b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/kinovi/seedance_2p0/cost.rs @@ -7,6 +7,9 @@ pub struct KinoviSeedance2p0CostState { pub resolution: KinoviOutputResolution, pub duration_seconds: u8, pub batch_count: KinoviBatchCount, + + /// Forward-looking: Kinovi charges for this. We need to take it into + /// account in the future. pub has_video_reference: bool, } @@ -16,19 +19,23 @@ impl KinoviSeedance2p0CostState { resolution: request.request.output_resolution.unwrap_or(KinoviOutputResolution::SevenTwentyP), duration_seconds: request.request.duration_seconds, batch_count: request.request.batch_count, - has_video_reference: request.request.reference_video_urls.is_some(), + has_video_reference: request.request.reference_video_urls + .as_ref() + .is_some_and(|urls| !urls.is_empty()), } } pub fn from_draft(draft: &KinoviSeedance2p0DraftState) -> Self { + let has_video_reference = draft.remaining_request + .as_ref() + .and_then(|rem| rem.reference_videos.as_ref()) + .is_some(); + Self { resolution: draft.resolution.unwrap_or(KinoviOutputResolution::SevenTwentyP), duration_seconds: draft.duration_seconds, batch_count: draft.batch_count, - has_video_reference: draft.remaining_request - .as_ref() - .map(|rem| &rem.reference_videos) - .is_some(), + has_video_reference, } } @@ -39,17 +46,17 @@ impl KinoviSeedance2p0CostState { output_resolution: Some(self.resolution), duration_seconds: self.duration_seconds, batch_count: self.batch_count, - reference_video_urls: if self.has_video_reference { - Some(vec!["https://example.com".to_string()]) - } else { - None - }, + + // NB: has_video_reference is tracked but does not affect price yet. + // When Kinovi starts charging for video references, add cost here. + // No impact on price - prompt: "".to_string(), + prompt: String::new(), aspect_ratio: KinoviAspectRatio::Portrait9x16, start_frame_url: None, end_frame_url: None, reference_image_urls: None, + reference_video_urls: None, reference_audio_urls: None, character_ids: None, use_face_blur_hack: None, @@ -68,3 +75,382 @@ impl KinoviSeedance2p0CostState { } } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::api::common_resolution::CommonResolution; + use crate::api::common_video_model::CommonVideoModel; + use crate::api::provider::Provider; + use crate::api::video_list_ref::VideoListRef; + use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy; + use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder; + + // ======================== Helpers ======================== + + fn cost_state( + resolution: KinoviOutputResolution, + duration_seconds: u8, + batch_count: KinoviBatchCount, + has_video_reference: bool, + ) -> KinoviSeedance2p0CostState { + KinoviSeedance2p0CostState { + resolution, + duration_seconds, + batch_count, + has_video_reference, + } + } + + fn usd_cents( + resolution: KinoviOutputResolution, + duration_seconds: u8, + batch_count: KinoviBatchCount, + ) -> u64 { + cost_state(resolution, duration_seconds, batch_count, false) + .estimate_cost() + .cost_in_usd_cents + .unwrap() + } + + fn credits( + resolution: KinoviOutputResolution, + duration_seconds: u8, + batch_count: KinoviBatchCount, + ) -> u64 { + cost_state(resolution, duration_seconds, batch_count, false) + .estimate_cost() + .cost_in_credits + .unwrap() + } + + /// Build a draft via the builder to test from_draft(). + fn make_draft( + duration_seconds: u16, + video_batch_count: u16, + resolution: Option, + with_video_ref: bool, + ) -> KinoviSeedance2p0DraftState { + let reference_videos = if with_video_ref { + Some(VideoListRef::Urls(vec!["https://example.com/video.mp4".to_string()])) + } else { + None + }; + + let builder = GenerateVideoRequestBuilder { + model: CommonVideoModel::Seedance2p0, + provider: Provider::Seedance2Pro, + prompt: Some("test".to_string()), + negative_prompt: None, + start_frame: None, + end_frame: None, + reference_images: None, + reference_videos, + reference_audio: None, + reference_character_tokens: None, + resolution, + aspect_ratio: None, + duration_seconds: Some(duration_seconds), + video_batch_count: Some(video_batch_count), + generate_audio: None, + request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade, + idempotency_token: None, + }; + + let draft_or_request = builder.build2().expect("build2 should succeed"); + match draft_or_request { + crate::generate::generate_video_v2::video_generation_draft_or_request::VideoGenerationDraftOrRequest::Draft( + crate::generate::generate_video_v2::video_generation_draft::VideoGenerationDraftRequest::KinoviSeedance2p0(draft) + ) => draft, + _ => panic!("expected KinoviSeedance2p0 draft"), + } + } + + /// Build a request state for from_request() tests. + fn make_request_state( + resolution: Option, + duration_seconds: u8, + batch_count: KinoviBatchCount, + with_video_ref: bool, + ) -> KinoviSeedance2p0RequestState { + let reference_video_urls = if with_video_ref { + Some(vec!["https://cdn.seedance2-pro.com/video.mp4".to_string()]) + } else { + None + }; + + KinoviSeedance2p0RequestState { + request: KinoviGenerateVideoRequest { + model_type: KinoviModelType::Seedance2Pro, + prompt: "test".to_string(), + aspect_ratio: KinoviAspectRatio::Landscape16x9, + output_resolution: resolution, + duration_seconds, + batch_count, + start_frame_url: None, + end_frame_url: None, + reference_image_urls: None, + reference_video_urls, + reference_audio_urls: None, + character_ids: None, + use_face_blur_hack: None, + }, + } + } + + // ======================== Direct estimate_cost() tests ======================== + // These must match the reference implementation values exactly. + + // -- 720p (legacy pricing: 250 credits/$1, 40 credits/sec) -- + + #[test] + fn cost_720p_batch_1() { + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 4, KinoviBatchCount::One), 64); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::One), 80); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 6, KinoviBatchCount::One), 96); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 7, KinoviBatchCount::One), 112); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 10, KinoviBatchCount::One), 160); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 15, KinoviBatchCount::One), 240); + } + + #[test] + fn cost_720p_batch_2() { + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 4, KinoviBatchCount::Two), 128); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::Two), 160); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 15, KinoviBatchCount::Two), 480); + } + + #[test] + fn cost_720p_batch_4() { + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 4, KinoviBatchCount::Four), 256); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::Four), 320); + assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 15, KinoviBatchCount::Four), 960); + } + + // -- 480p (new pricing: 193 credits/$1, 15 credits/sec) -- + + #[test] + fn cost_480p_batch_1() { + assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 4, KinoviBatchCount::One), 31); + assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::One), 39); + assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 10, KinoviBatchCount::One), 78); + assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 15, KinoviBatchCount::One), 117); + } + + #[test] + fn cost_480p_batch_2() { + assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Two), 78); + } + + #[test] + fn cost_480p_batch_4() { + assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Four), 155); + } + + // -- 1080p (new pricing: 193 credits/$1, 90 credits/sec) -- + + #[test] + fn cost_1080p_batch_1() { + assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 4, KinoviBatchCount::One), 187); + assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::One), 233); + assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 10, KinoviBatchCount::One), 466); + assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 15, KinoviBatchCount::One), 699); + } + + #[test] + fn cost_1080p_batch_2() { + assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::Two), 466); + } + + #[test] + fn cost_1080p_batch_4() { + assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::Four), 933); + } + + // -- Relative pricing -- + + #[test] + fn cost_480p_cheaper_than_720p_cheaper_than_1080p() { + let c480 = usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::One); + let c720 = usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::One); + let c1080 = usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::One); + assert!(c480 < c720, "480p ({}) should be cheaper than 720p ({})", c480, c720); + assert!(c720 < c1080, "720p ({}) should be cheaper than 1080p ({})", c720, c1080); + } + + #[test] + fn cost_scales_with_duration() { + let c4 = usd_cents(KinoviOutputResolution::SevenTwentyP, 4, KinoviBatchCount::One); + let c10 = usd_cents(KinoviOutputResolution::SevenTwentyP, 10, KinoviBatchCount::One); + let c15 = usd_cents(KinoviOutputResolution::SevenTwentyP, 15, KinoviBatchCount::One); + assert!(c4 < c10); + assert!(c10 < c15); + } + + #[test] + fn cost_scales_with_batch() { + let b1 = usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::One); + let b2 = usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::Two); + let b4 = usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::Four); + assert!(b1 < b2); + assert!(b2 < b4); + } + + // -- Video reference does NOT affect cost (yet) -- + + #[test] + fn video_reference_does_not_affect_cost() { + let without = cost_state(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::One, false) + .estimate_cost(); + let with = cost_state(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::One, true) + .estimate_cost(); + assert_eq!(without.cost_in_usd_cents, with.cost_in_usd_cents); + assert_eq!(without.cost_in_credits, with.cost_in_credits); + } + + // ======================== from_request() tests ======================== + + #[test] + fn from_request_720p() { + let req = make_request_state(Some(KinoviOutputResolution::SevenTwentyP), 5, KinoviBatchCount::One, false); + let cost = KinoviSeedance2p0CostState::from_request(&req); + assert!(matches!(cost.resolution, KinoviOutputResolution::SevenTwentyP)); + assert_eq!(cost.duration_seconds, 5); + assert!(matches!(cost.batch_count, KinoviBatchCount::One)); + assert!(!cost.has_video_reference); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(80)); + } + + #[test] + fn from_request_none_defaults_to_720p() { + let req = make_request_state(None, 5, KinoviBatchCount::One, false); + let cost = KinoviSeedance2p0CostState::from_request(&req); + assert!(matches!(cost.resolution, KinoviOutputResolution::SevenTwentyP)); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(80)); + } + + #[test] + fn from_request_480p() { + let req = make_request_state(Some(KinoviOutputResolution::FourEightyP), 5, KinoviBatchCount::One, false); + let cost = KinoviSeedance2p0CostState::from_request(&req); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(39)); + } + + #[test] + fn from_request_1080p_batch_2() { + let req = make_request_state(Some(KinoviOutputResolution::TenEightyP), 5, KinoviBatchCount::Two, false); + let cost = KinoviSeedance2p0CostState::from_request(&req); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(466)); + } + + #[test] + fn from_request_with_video_reference() { + let req = make_request_state(Some(KinoviOutputResolution::SevenTwentyP), 5, KinoviBatchCount::One, true); + let cost = KinoviSeedance2p0CostState::from_request(&req); + assert!(cost.has_video_reference); + // Video refs don't affect cost yet + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(80)); + } + + #[test] + fn from_request_without_video_reference() { + let req = make_request_state(Some(KinoviOutputResolution::SevenTwentyP), 5, KinoviBatchCount::One, false); + let cost = KinoviSeedance2p0CostState::from_request(&req); + assert!(!cost.has_video_reference); + } + + // ======================== from_draft() tests ======================== + + #[test] + fn from_draft_720p_default() { + let draft = make_draft(5, 1, None, false); + let cost = KinoviSeedance2p0CostState::from_draft(&draft); + assert!(matches!(cost.resolution, KinoviOutputResolution::SevenTwentyP)); + assert_eq!(cost.duration_seconds, 5); + assert!(matches!(cost.batch_count, KinoviBatchCount::One)); + assert!(!cost.has_video_reference); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(80)); + } + + #[test] + fn from_draft_480p() { + let draft = make_draft(5, 1, Some(CommonResolution::FourEightyP), false); + let cost = KinoviSeedance2p0CostState::from_draft(&draft); + assert!(matches!(cost.resolution, KinoviOutputResolution::FourEightyP)); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(39)); + } + + #[test] + fn from_draft_1080p_batch_4() { + let draft = make_draft(5, 4, Some(CommonResolution::TenEightyP), false); + let cost = KinoviSeedance2p0CostState::from_draft(&draft); + assert!(matches!(cost.resolution, KinoviOutputResolution::TenEightyP)); + assert!(matches!(cost.batch_count, KinoviBatchCount::Four)); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(933)); + } + + #[test] + fn from_draft_with_video_reference() { + let draft = make_draft(5, 1, None, true); + let cost = KinoviSeedance2p0CostState::from_draft(&draft); + assert!(cost.has_video_reference); + // Video refs don't affect cost yet + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(80)); + } + + #[test] + fn from_draft_without_video_reference() { + let draft = make_draft(5, 1, None, false); + let cost = KinoviSeedance2p0CostState::from_draft(&draft); + assert!(!cost.has_video_reference); + } + + #[test] + fn from_draft_duration_15_batch_2() { + let draft = make_draft(15, 2, Some(CommonResolution::SevenTwentyP), false); + let cost = KinoviSeedance2p0CostState::from_draft(&draft); + assert_eq!(cost.duration_seconds, 15); + assert!(matches!(cost.batch_count, KinoviBatchCount::Two)); + assert_eq!(cost.estimate_cost().cost_in_usd_cents, Some(480)); + } + + // ======================== Cross-check: from_draft matches from_request ======================== + + #[test] + fn draft_and_request_produce_same_cost() { + // 720p, 5s, batch 1 + let draft = make_draft(5, 1, Some(CommonResolution::SevenTwentyP), false); + let req = make_request_state(Some(KinoviOutputResolution::SevenTwentyP), 5, KinoviBatchCount::One, false); + let draft_cost = KinoviSeedance2p0CostState::from_draft(&draft).estimate_cost(); + let req_cost = KinoviSeedance2p0CostState::from_request(&req).estimate_cost(); + assert_eq!(draft_cost.cost_in_usd_cents, req_cost.cost_in_usd_cents); + assert_eq!(draft_cost.cost_in_credits, req_cost.cost_in_credits); + } + + #[test] + fn draft_and_request_produce_same_cost_1080p() { + let draft = make_draft(10, 2, Some(CommonResolution::TenEightyP), false); + let req = make_request_state(Some(KinoviOutputResolution::TenEightyP), 10, KinoviBatchCount::Two, false); + let draft_cost = KinoviSeedance2p0CostState::from_draft(&draft).estimate_cost(); + let req_cost = KinoviSeedance2p0CostState::from_request(&req).estimate_cost(); + assert_eq!(draft_cost.cost_in_usd_cents, req_cost.cost_in_usd_cents); + assert_eq!(draft_cost.cost_in_credits, req_cost.cost_in_credits); + } + + // ======================== Credits spot checks ======================== + + #[test] + fn credits_720p() { + assert_eq!(credits(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::One), 200); + } + + #[test] + fn credits_480p() { + assert_eq!(credits(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::One), 75); + } + + #[test] + fn credits_1080p() { + assert_eq!(credits(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::One), 450); + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/video_generation_draft.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/video_generation_draft.rs index 44c8c212b9..0a6ace16cc 100644 --- a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/video_generation_draft.rs +++ b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/video_generation_draft.rs @@ -3,9 +3,11 @@ use crate::errors::artcraft_router_error::ArtcraftRouterError; use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate; use crate::generate::generate_video_v2::providers::kinovi::seedance_2p0::cost::KinoviSeedance2p0CostState; use crate::generate::generate_video_v2::providers::kinovi::seedance_2p0::draft::KinoviSeedance2p0DraftState; -use crate::generate::generate_video_v2::providers::kinovi::seedance_2p0::request::KinoviSeedance2p0RequestState; use crate::generate::generate_video_v2::video_generation_request::VideoGenerationRequest; +/** + * Wrapper for all video generation draft requests. + */ #[derive(Clone, Debug)] pub enum VideoGenerationDraftRequest { KinoviSeedance2p0(KinoviSeedance2p0DraftState),