diff --git a/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs b/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs index 350971dc96..f4d068c39c 100644 --- a/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs +++ b/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs @@ -166,9 +166,10 @@ impl FrontendFailureCategory { #[cfg(test)] mod tests { use crate::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory; - use crate::test_helpers::assert_serialization; + use crate::test_helpers::{assert_deserialization, assert_serialization}; + use strum::IntoEnumIterator; - mod explicit_checks { + mod manual_checks { use super::*; #[test] @@ -188,6 +189,28 @@ mod tests { assert_serialization(FrontendFailureCategory::GenerationFailed, "generation_failed"); } + #[test] + fn test_deserialization() { + assert_deserialization("face_not_detected", FrontendFailureCategory::FaceNotDetected); + assert_deserialization("keep_alive_elapsed", FrontendFailureCategory::KeepAliveElapsed); + assert_deserialization("not_yet_implemented", FrontendFailureCategory::NotYetImplemented); + assert_deserialization("retryable_worker_error", FrontendFailureCategory::RetryableWorkerError); + assert_deserialization("model_rules_violation", FrontendFailureCategory::ModelRulesViolation); + assert_deserialization("rule_bans_user_image", FrontendFailureCategory::RuleBansUserImage); + assert_deserialization("rule_bans_user_image_with_faces", FrontendFailureCategory::RuleBansUserImageWithFaces); + assert_deserialization("rule_bans_user_text_prompt", FrontendFailureCategory::RuleBansUserTextPrompt); + assert_deserialization("rule_bans_user_content", FrontendFailureCategory::RuleBansUserContent); + assert_deserialization("rule_bans_generated_video", FrontendFailureCategory::RuleBansGeneratedVideo); + assert_deserialization("rule_bans_generated_audio", FrontendFailureCategory::RuleBansGeneratedAudio); + assert_deserialization("rule_bans_generated_content", FrontendFailureCategory::RuleBansGeneratedContent); + assert_deserialization("generation_failed", FrontendFailureCategory::GenerationFailed); + } + + #[test] + fn variants_count_check() { + assert_eq!(FrontendFailureCategory::iter().count(), 13); + } + #[test] fn to_str() { assert_eq!(FrontendFailureCategory::FaceNotDetected.to_str(), "face_not_detected"); @@ -249,7 +272,6 @@ mod tests { #[test] fn variant_length() { - use strum::IntoEnumIterator; assert_eq!(FrontendFailureCategory::all_variants().len(), FrontendFailureCategory::iter().len()); } @@ -261,5 +283,14 @@ mod tests { assert_eq!(variant, FrontendFailureCategory::from_str(&format!("{:?}", variant)).unwrap()); } } + + #[test] + fn round_trip_json() { + for variant in FrontendFailureCategory::iter() { + let json = serde_json::to_string(&variant).unwrap(); + let back: FrontendFailureCategory = serde_json::from_str(&json).unwrap(); + assert_eq!(variant, back); + } + } } } diff --git a/crates/schema/public/enums/src/by_table/model_weights/weights_types.rs b/crates/schema/public/enums/src/by_table/model_weights/weights_types.rs index 80d47ad0aa..eefde3e529 100644 --- a/crates/schema/public/enums/src/by_table/model_weights/weights_types.rs +++ b/crates/schema/public/enums/src/by_table/model_weights/weights_types.rs @@ -89,50 +89,89 @@ impl_mysql_from_row!(WeightsType); #[cfg(test)] mod tests { use super::*; + use crate::test_helpers::{assert_deserialization, assert_serialization}; + use strum::IntoEnumIterator; - #[test] - fn test_to_str() { - assert_eq!(WeightsType::HifiganTacotron2.to_str(), "hifigan_tt2"); - assert_eq!(WeightsType::RvcV2.to_str(), "rvc_v2"); - assert_eq!(WeightsType::StableDiffusion15.to_str(), "sd_1.5"); - assert_eq!(WeightsType::StableDiffusionXL.to_str(), "sdxl"); - assert_eq!(WeightsType::SoVitsSvc.to_str(), "so_vits_svc"); - assert_eq!(WeightsType::Tacotron2.to_str(), "tt2"); - assert_eq!(WeightsType::LoRA.to_str(), "loRA"); - assert_eq!(WeightsType::VallE.to_str(), "vall_e"); - assert_eq!(WeightsType::ComfyUi.to_str(), "comfy_ui"); - assert_eq!(WeightsType::GptSoVits.to_str(), "gpt_so_vits"); - } + mod manual_checks { + use super::*; - #[test] - fn test_from_str() { - assert_eq!(WeightsType::from_str("hifigan_tt2").unwrap(), WeightsType::HifiganTacotron2); - assert_eq!(WeightsType::from_str("rvc_v2").unwrap(), WeightsType::RvcV2); - assert_eq!(WeightsType::from_str("sd_1.5").unwrap(), WeightsType::StableDiffusion15); - assert_eq!(WeightsType::from_str("sdxl").unwrap(), WeightsType::StableDiffusionXL); - assert_eq!(WeightsType::from_str("so_vits_svc").unwrap(), WeightsType::SoVitsSvc); - assert_eq!(WeightsType::from_str("tt2").unwrap(), WeightsType::Tacotron2); - assert_eq!(WeightsType::from_str("loRA").unwrap(), WeightsType::LoRA); - assert_eq!(WeightsType::from_str("vall_e").unwrap(), WeightsType::VallE); - assert_eq!(WeightsType::from_str("comfy_ui").unwrap(), WeightsType::ComfyUi); - assert_eq!(WeightsType::from_str("gpt_so_vits").unwrap(), WeightsType::GptSoVits); - assert!(WeightsType::from_str("invalid").is_err()); - } + #[test] + fn test_serialization() { + assert_serialization(WeightsType::HifiganTacotron2, "hifigan_tt2"); + assert_serialization(WeightsType::RvcV2, "rvc_v2"); + assert_serialization(WeightsType::StableDiffusion15, "sd_1.5"); + assert_serialization(WeightsType::StableDiffusionXL, "sdxl"); + assert_serialization(WeightsType::SoVitsSvc, "so_vits_svc"); + assert_serialization(WeightsType::Tacotron2, "tt2"); + assert_serialization(WeightsType::LoRA, "loRA"); + assert_serialization(WeightsType::VallE, "vall_e"); + assert_serialization(WeightsType::ComfyUi, "comfy_ui"); + assert_serialization(WeightsType::GptSoVits, "gpt_so_vits"); + } - #[test] - fn test_all_variants() { - let variants = WeightsType::all_variants(); - assert_eq!(variants.len(), 10); - assert!(variants.contains(&WeightsType::HifiganTacotron2)); - assert!(variants.contains(&WeightsType::RvcV2)); - assert!(variants.contains(&WeightsType::StableDiffusion15)); - assert!(variants.contains(&WeightsType::StableDiffusionXL)); - assert!(variants.contains(&WeightsType::SoVitsSvc)); - assert!(variants.contains(&WeightsType::Tacotron2)); - assert!(variants.contains(&WeightsType::LoRA)); - assert!(variants.contains(&WeightsType::VallE)); - assert!(variants.contains(&WeightsType::ComfyUi)); - assert!(variants.contains(&WeightsType::GptSoVits)); + #[test] + fn test_deserialization() { + assert_deserialization("hifigan_tt2", WeightsType::HifiganTacotron2); + assert_deserialization("rvc_v2", WeightsType::RvcV2); + assert_deserialization("sd_1.5", WeightsType::StableDiffusion15); + assert_deserialization("sdxl", WeightsType::StableDiffusionXL); + assert_deserialization("so_vits_svc", WeightsType::SoVitsSvc); + assert_deserialization("tt2", WeightsType::Tacotron2); + assert_deserialization("loRA", WeightsType::LoRA); + assert_deserialization("vall_e", WeightsType::VallE); + assert_deserialization("comfy_ui", WeightsType::ComfyUi); + assert_deserialization("gpt_so_vits", WeightsType::GptSoVits); + } + + #[test] + fn variants_count_check() { + assert_eq!(WeightsType::iter().count(), 10); + } + + #[test] + fn to_str() { + assert_eq!(WeightsType::HifiganTacotron2.to_str(), "hifigan_tt2"); + assert_eq!(WeightsType::RvcV2.to_str(), "rvc_v2"); + assert_eq!(WeightsType::StableDiffusion15.to_str(), "sd_1.5"); + assert_eq!(WeightsType::StableDiffusionXL.to_str(), "sdxl"); + assert_eq!(WeightsType::SoVitsSvc.to_str(), "so_vits_svc"); + assert_eq!(WeightsType::Tacotron2.to_str(), "tt2"); + assert_eq!(WeightsType::LoRA.to_str(), "loRA"); + assert_eq!(WeightsType::VallE.to_str(), "vall_e"); + assert_eq!(WeightsType::ComfyUi.to_str(), "comfy_ui"); + assert_eq!(WeightsType::GptSoVits.to_str(), "gpt_so_vits"); + } + + #[test] + fn from_str() { + assert_eq!(WeightsType::from_str("hifigan_tt2").unwrap(), WeightsType::HifiganTacotron2); + assert_eq!(WeightsType::from_str("rvc_v2").unwrap(), WeightsType::RvcV2); + assert_eq!(WeightsType::from_str("sd_1.5").unwrap(), WeightsType::StableDiffusion15); + assert_eq!(WeightsType::from_str("sdxl").unwrap(), WeightsType::StableDiffusionXL); + assert_eq!(WeightsType::from_str("so_vits_svc").unwrap(), WeightsType::SoVitsSvc); + assert_eq!(WeightsType::from_str("tt2").unwrap(), WeightsType::Tacotron2); + assert_eq!(WeightsType::from_str("loRA").unwrap(), WeightsType::LoRA); + assert_eq!(WeightsType::from_str("vall_e").unwrap(), WeightsType::VallE); + assert_eq!(WeightsType::from_str("comfy_ui").unwrap(), WeightsType::ComfyUi); + assert_eq!(WeightsType::from_str("gpt_so_vits").unwrap(), WeightsType::GptSoVits); + assert!(WeightsType::from_str("invalid").is_err()); + } + + #[test] + fn all_variants() { + let variants = WeightsType::all_variants(); + assert_eq!(variants.len(), 10); + assert!(variants.contains(&WeightsType::HifiganTacotron2)); + assert!(variants.contains(&WeightsType::RvcV2)); + assert!(variants.contains(&WeightsType::StableDiffusion15)); + assert!(variants.contains(&WeightsType::StableDiffusionXL)); + assert!(variants.contains(&WeightsType::SoVitsSvc)); + assert!(variants.contains(&WeightsType::Tacotron2)); + assert!(variants.contains(&WeightsType::LoRA)); + assert!(variants.contains(&WeightsType::VallE)); + assert!(variants.contains(&WeightsType::ComfyUi)); + assert!(variants.contains(&WeightsType::GptSoVits)); + } } mod mechanical_checks { @@ -140,7 +179,6 @@ mod tests { #[test] fn variant_length() { - use strum::IntoEnumIterator; assert_eq!(WeightsType::all_variants().len(), WeightsType::iter().len()); } @@ -153,6 +191,15 @@ mod tests { } } + #[test] + fn round_trip_json() { + for variant in WeightsType::iter() { + let json = serde_json::to_string(&variant).unwrap(); + let back: WeightsType = serde_json::from_str(&json).unwrap(); + assert_eq!(variant, back); + } + } + #[test] fn serialized_length_ok_for_database() { const MAX_LENGTH : usize = 16; diff --git a/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_action.rs b/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_action.rs index 41729c695b..3c6fa9d125 100644 --- a/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_action.rs +++ b/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_action.rs @@ -33,11 +33,32 @@ pub enum AuditLogEntityAction { #[cfg(test)] mod tests { use super::AuditLogEntityAction; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(AuditLogEntityAction::Create, "create"); + assert_serialization(AuditLogEntityAction::Edit, "edit"); + assert_serialization(AuditLogEntityAction::EditFeatures, "edit_features"); + assert_serialization(AuditLogEntityAction::Delete, "delete"); + assert_serialization(AuditLogEntityAction::FeaturedItemCreate, "featured_item_create"); + assert_serialization(AuditLogEntityAction::FeaturedItemDelete, "featured_item_delete"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("create", AuditLogEntityAction::Create); + assert_deserialization("edit", AuditLogEntityAction::Edit); + assert_deserialization("edit_features", AuditLogEntityAction::EditFeatures); + assert_deserialization("delete", AuditLogEntityAction::Delete); + assert_deserialization("featured_item_create", AuditLogEntityAction::FeaturedItemCreate); + assert_deserialization("featured_item_delete", AuditLogEntityAction::FeaturedItemDelete); + } + #[test] fn variants_count_check() { assert_eq!(AuditLogEntityAction::iter().count(), 6); diff --git a/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_type.rs b/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_type.rs index 6e36b4a222..a6e8262a79 100644 --- a/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_type.rs @@ -25,11 +25,28 @@ pub enum AuditLogEntityType { #[cfg(test)] mod tests { use super::AuditLogEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(AuditLogEntityType::Comment, "comment"); + assert_serialization(AuditLogEntityType::MediaFile, "media_file"); + assert_serialization(AuditLogEntityType::ModelWeight, "model_weight"); + assert_serialization(AuditLogEntityType::User, "user"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("comment", AuditLogEntityType::Comment); + assert_deserialization("media_file", AuditLogEntityType::MediaFile); + assert_deserialization("model_weight", AuditLogEntityType::ModelWeight); + assert_deserialization("user", AuditLogEntityType::User); + } + #[test] fn variants_count_check() { assert_eq!(AuditLogEntityType::iter().count(), 4); diff --git a/crates/schema/public/enums_api/src/by_table/batch_generations/batch_generation_entity_type.rs b/crates/schema/public/enums_api/src/by_table/batch_generations/batch_generation_entity_type.rs index 9a4ab6619c..6be49242d3 100644 --- a/crates/schema/public/enums_api/src/by_table/batch_generations/batch_generation_entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/batch_generations/batch_generation_entity_type.rs @@ -14,11 +14,22 @@ pub enum BatchGenerationEntityType { #[cfg(test)] mod tests { use super::BatchGenerationEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(BatchGenerationEntityType::MediaFile, "media_file"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_file", BatchGenerationEntityType::MediaFile); + } + #[test] fn variants_count_check() { assert_eq!(BatchGenerationEntityType::iter().count(), 1); diff --git a/crates/schema/public/enums_api/src/by_table/beta_keys/beta_key_product.rs b/crates/schema/public/enums_api/src/by_table/beta_keys/beta_key_product.rs index 1ecafeb14a..54b228eb5f 100644 --- a/crates/schema/public/enums_api/src/by_table/beta_keys/beta_key_product.rs +++ b/crates/schema/public/enums_api/src/by_table/beta_keys/beta_key_product.rs @@ -14,11 +14,22 @@ pub enum BetaKeyProduct { #[cfg(test)] mod tests { use super::BetaKeyProduct; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(BetaKeyProduct::Studio, "studio"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("studio", BetaKeyProduct::Studio); + } + #[test] fn variants_count_check() { assert_eq!(BetaKeyProduct::iter().count(), 1); diff --git a/crates/schema/public/enums_api/src/by_table/comments/comment_entity_type.rs b/crates/schema/public/enums_api/src/by_table/comments/comment_entity_type.rs index 05f91b1fc8..6a08feafb4 100644 --- a/crates/schema/public/enums_api/src/by_table/comments/comment_entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/comments/comment_entity_type.rs @@ -37,11 +37,34 @@ pub enum CommentEntityType { #[cfg(test)] mod tests { use super::CommentEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(CommentEntityType::User, "user"); + assert_serialization(CommentEntityType::MediaFile, "media_file"); + assert_serialization(CommentEntityType::ModelWeight, "model_weight"); + assert_serialization(CommentEntityType::TtsModel, "tts_model"); + assert_serialization(CommentEntityType::TtsResult, "tts_result"); + assert_serialization(CommentEntityType::W2lTemplate, "w2l_template"); + assert_serialization(CommentEntityType::W2lResult, "w2l_result"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("user", CommentEntityType::User); + assert_deserialization("media_file", CommentEntityType::MediaFile); + assert_deserialization("model_weight", CommentEntityType::ModelWeight); + assert_deserialization("tts_model", CommentEntityType::TtsModel); + assert_deserialization("tts_result", CommentEntityType::TtsResult); + assert_deserialization("w2l_template", CommentEntityType::W2lTemplate); + assert_deserialization("w2l_result", CommentEntityType::W2lResult); + } + #[test] fn variants_count_check() { assert_eq!(CommentEntityType::iter().count(), 7); diff --git a/crates/schema/public/enums_api/src/by_table/email_sender_jobs/email_category.rs b/crates/schema/public/enums_api/src/by_table/email_sender_jobs/email_category.rs index 26d3200df3..f618dfd586 100644 --- a/crates/schema/public/enums_api/src/by_table/email_sender_jobs/email_category.rs +++ b/crates/schema/public/enums_api/src/by_table/email_sender_jobs/email_category.rs @@ -21,11 +21,24 @@ pub enum EmailCategory { #[cfg(test)] mod tests { use super::EmailCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(EmailCategory::Welcome, "welcome"); + assert_serialization(EmailCategory::PasswordReset, "password_reset"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("welcome", EmailCategory::Welcome); + assert_deserialization("password_reset", EmailCategory::PasswordReset); + } + #[test] fn variants_count_check() { assert_eq!(EmailCategory::iter().count(), 2); diff --git a/crates/schema/public/enums_api/src/by_table/entity_stats/stats_entity_type.rs b/crates/schema/public/enums_api/src/by_table/entity_stats/stats_entity_type.rs index 0d7ef1f747..52950db376 100644 --- a/crates/schema/public/enums_api/src/by_table/entity_stats/stats_entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/entity_stats/stats_entity_type.rs @@ -21,11 +21,26 @@ pub enum StatsEntityType { #[cfg(test)] mod tests { use super::StatsEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(StatsEntityType::Comment, "comment"); + assert_serialization(StatsEntityType::MediaFile, "media_file"); + assert_serialization(StatsEntityType::ModelWeight, "model_weight"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("comment", StatsEntityType::Comment); + assert_deserialization("media_file", StatsEntityType::MediaFile); + assert_deserialization("model_weight", StatsEntityType::ModelWeight); + } + #[test] fn variants_count_check() { assert_eq!(StatsEntityType::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/featured_items/featured_item_entity_type.rs b/crates/schema/public/enums_api/src/by_table/featured_items/featured_item_entity_type.rs index b21243c425..577ab531b8 100644 --- a/crates/schema/public/enums_api/src/by_table/featured_items/featured_item_entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/featured_items/featured_item_entity_type.rs @@ -21,11 +21,26 @@ pub enum FeaturedItemEntityType { #[cfg(test)] mod tests { use super::FeaturedItemEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(FeaturedItemEntityType::MediaFile, "media_file"); + assert_serialization(FeaturedItemEntityType::ModelWeight, "model_weight"); + assert_serialization(FeaturedItemEntityType::User, "user"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_file", FeaturedItemEntityType::MediaFile); + assert_deserialization("model_weight", FeaturedItemEntityType::ModelWeight); + assert_deserialization("user", FeaturedItemEntityType::User); + } + #[test] fn variants_count_check() { assert_eq!(FeaturedItemEntityType::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/generic_download_jobs/generic_download_type.rs b/crates/schema/public/enums_api/src/by_table/generic_download_jobs/generic_download_type.rs index a69b22ebf9..1100e08797 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_download_jobs/generic_download_type.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_download_jobs/generic_download_type.rs @@ -58,11 +58,36 @@ pub enum GenericDownloadType { #[cfg(test)] mod tests { use super::GenericDownloadType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(GenericDownloadType::HifiGan, "hifigan"); + assert_serialization(GenericDownloadType::HifiGanRocketVc, "hifigan_rocket_vc"); + assert_serialization(GenericDownloadType::HifiGanSoVitsSvc, "hifigan_so_vits_svc"); + assert_serialization(GenericDownloadType::RocketVc, "rocket_vc"); + assert_serialization(GenericDownloadType::RvcV2, "rvc_v2"); + assert_serialization(GenericDownloadType::SoVitsSvc, "so_vits_svc"); + assert_serialization(GenericDownloadType::Tacotron2, "tacotron2"); + assert_serialization(GenericDownloadType::Vits, "vits"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("hifigan", GenericDownloadType::HifiGan); + assert_deserialization("hifigan_rocket_vc", GenericDownloadType::HifiGanRocketVc); + assert_deserialization("hifigan_so_vits_svc", GenericDownloadType::HifiGanSoVitsSvc); + assert_deserialization("rocket_vc", GenericDownloadType::RocketVc); + assert_deserialization("rvc_v2", GenericDownloadType::RvcV2); + assert_deserialization("so_vits_svc", GenericDownloadType::SoVitsSvc); + assert_deserialization("tacotron2", GenericDownloadType::Tacotron2); + assert_deserialization("vits", GenericDownloadType::Vits); + } + #[test] fn variants_count_check() { assert_eq!(GenericDownloadType::iter().count(), 8); diff --git a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/frontend_failure_category.rs b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/frontend_failure_category.rs index 5d8b806016..3c6710d2e2 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/frontend_failure_category.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/frontend_failure_category.rs @@ -97,11 +97,46 @@ pub enum FrontendFailureCategory { #[cfg(test)] mod tests { use super::FrontendFailureCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(FrontendFailureCategory::FaceNotDetected, "face_not_detected"); + assert_serialization(FrontendFailureCategory::KeepAliveElapsed, "keep_alive_elapsed"); + assert_serialization(FrontendFailureCategory::NotYetImplemented, "not_yet_implemented"); + assert_serialization(FrontendFailureCategory::RetryableWorkerError, "retryable_worker_error"); + assert_serialization(FrontendFailureCategory::ModelRulesViolation, "model_rules_violation"); + assert_serialization(FrontendFailureCategory::RuleBansUserImage, "rule_bans_user_image"); + assert_serialization(FrontendFailureCategory::RuleBansUserImageWithFaces, "rule_bans_user_image_with_faces"); + assert_serialization(FrontendFailureCategory::RuleBansUserTextPrompt, "rule_bans_user_text_prompt"); + assert_serialization(FrontendFailureCategory::RuleBansUserContent, "rule_bans_user_content"); + assert_serialization(FrontendFailureCategory::RuleBansGeneratedVideo, "rule_bans_generated_video"); + assert_serialization(FrontendFailureCategory::RuleBansGeneratedAudio, "rule_bans_generated_audio"); + assert_serialization(FrontendFailureCategory::RuleBansGeneratedContent, "rule_bans_generated_content"); + assert_serialization(FrontendFailureCategory::GenerationFailed, "generation_failed"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("face_not_detected", FrontendFailureCategory::FaceNotDetected); + assert_deserialization("keep_alive_elapsed", FrontendFailureCategory::KeepAliveElapsed); + assert_deserialization("not_yet_implemented", FrontendFailureCategory::NotYetImplemented); + assert_deserialization("retryable_worker_error", FrontendFailureCategory::RetryableWorkerError); + assert_deserialization("model_rules_violation", FrontendFailureCategory::ModelRulesViolation); + assert_deserialization("rule_bans_user_image", FrontendFailureCategory::RuleBansUserImage); + assert_deserialization("rule_bans_user_image_with_faces", FrontendFailureCategory::RuleBansUserImageWithFaces); + assert_deserialization("rule_bans_user_text_prompt", FrontendFailureCategory::RuleBansUserTextPrompt); + assert_deserialization("rule_bans_user_content", FrontendFailureCategory::RuleBansUserContent); + assert_deserialization("rule_bans_generated_video", FrontendFailureCategory::RuleBansGeneratedVideo); + assert_deserialization("rule_bans_generated_audio", FrontendFailureCategory::RuleBansGeneratedAudio); + assert_deserialization("rule_bans_generated_content", FrontendFailureCategory::RuleBansGeneratedContent); + assert_deserialization("generation_failed", FrontendFailureCategory::GenerationFailed); + } + #[test] fn variants_count_check() { assert_eq!(FrontendFailureCategory::iter().count(), 13); diff --git a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_category.rs b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_category.rs index ce18642ae7..e032566d09 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_category.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_category.rs @@ -90,11 +90,54 @@ pub enum InferenceCategory { #[cfg(test)] mod tests { use super::InferenceCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(InferenceCategory::DeprecatedField, "deprecated_field"); + assert_serialization(InferenceCategory::LipsyncAnimation, "lipsync_animation"); + assert_serialization(InferenceCategory::TextToSpeech, "text_to_speech"); + assert_serialization(InferenceCategory::VoiceConversion, "voice_conversion"); + assert_serialization(InferenceCategory::ImageGeneration, "image_generation"); + assert_serialization(InferenceCategory::VideoGeneration, "video_generation"); + assert_serialization(InferenceCategory::ObjectGeneration, "object_generation"); + assert_serialization(InferenceCategory::SplatGeneration, "splat_generation"); + assert_serialization(InferenceCategory::BackgroundRemoval, "background_removal"); + assert_serialization(InferenceCategory::Mocap, "mocap"); + assert_serialization(InferenceCategory::Workflow, "workflow"); + assert_serialization(InferenceCategory::FormatConversion, "format_conversion"); + assert_serialization(InferenceCategory::LivePortrait, "live_portrait"); + assert_serialization(InferenceCategory::SeedVc, "seed_vc"); + assert_serialization(InferenceCategory::VideoFilter, "video_filter"); + assert_serialization(InferenceCategory::ConvertBvhToWorkflow, "convert_bvh_to_workflow"); + assert_serialization(InferenceCategory::F5TTS, "f5_tts"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("deprecated_field", InferenceCategory::DeprecatedField); + assert_deserialization("lipsync_animation", InferenceCategory::LipsyncAnimation); + assert_deserialization("text_to_speech", InferenceCategory::TextToSpeech); + assert_deserialization("voice_conversion", InferenceCategory::VoiceConversion); + assert_deserialization("image_generation", InferenceCategory::ImageGeneration); + assert_deserialization("video_generation", InferenceCategory::VideoGeneration); + assert_deserialization("object_generation", InferenceCategory::ObjectGeneration); + assert_deserialization("splat_generation", InferenceCategory::SplatGeneration); + assert_deserialization("background_removal", InferenceCategory::BackgroundRemoval); + assert_deserialization("mocap", InferenceCategory::Mocap); + assert_deserialization("workflow", InferenceCategory::Workflow); + assert_deserialization("format_conversion", InferenceCategory::FormatConversion); + assert_deserialization("live_portrait", InferenceCategory::LivePortrait); + assert_deserialization("seed_vc", InferenceCategory::SeedVc); + assert_deserialization("video_filter", InferenceCategory::VideoFilter); + assert_deserialization("convert_bvh_to_workflow", InferenceCategory::ConvertBvhToWorkflow); + assert_deserialization("f5_tts", InferenceCategory::F5TTS); + } + #[test] fn variants_count_check() { assert_eq!(InferenceCategory::iter().count(), 17); diff --git a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_input_source_token_type.rs b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_input_source_token_type.rs index d8c031e206..2b077067d9 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_input_source_token_type.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_input_source_token_type.rs @@ -16,11 +16,24 @@ pub enum InferenceInputSourceTokenType { #[cfg(test)] mod tests { use super::InferenceInputSourceTokenType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(InferenceInputSourceTokenType::MediaFile, "media_file"); + assert_serialization(InferenceInputSourceTokenType::MediaUpload, "media_upload"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_file", InferenceInputSourceTokenType::MediaFile); + assert_deserialization("media_upload", InferenceInputSourceTokenType::MediaUpload); + } + #[test] fn variants_count_check() { assert_eq!(InferenceInputSourceTokenType::iter().count(), 2); diff --git a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs index 8736533420..b004776558 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs @@ -25,11 +25,26 @@ pub enum InferenceJobExternalThirdParty { #[cfg(test)] mod tests { use super::InferenceJobExternalThirdParty; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(InferenceJobExternalThirdParty::Fal, "fal"); + assert_serialization(InferenceJobExternalThirdParty::Seedance2Pro, "seedance2pro"); + assert_serialization(InferenceJobExternalThirdParty::Worldlabs, "worldlabs"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("fal", InferenceJobExternalThirdParty::Fal); + assert_deserialization("seedance2pro", InferenceJobExternalThirdParty::Seedance2Pro); + assert_deserialization("worldlabs", InferenceJobExternalThirdParty::Worldlabs); + } + #[test] fn variants_count_check() { assert_eq!(InferenceJobExternalThirdParty::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_product_category.rs b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_product_category.rs index 26277fc16f..1010662c7d 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_product_category.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_product_category.rs @@ -122,11 +122,78 @@ pub enum InferenceJobProductCategory { #[cfg(test)] mod tests { use super::InferenceJobProductCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(InferenceJobProductCategory::DownloadGptSoVits, "download_gpt_so_vits"); + assert_serialization(InferenceJobProductCategory::FalImage, "fal_image"); + assert_serialization(InferenceJobProductCategory::FalVideo, "fal_video"); + assert_serialization(InferenceJobProductCategory::FalObject, "fal_object"); + assert_serialization(InferenceJobProductCategory::FalBgRemoval, "fal_bg_removal"); + assert_serialization(InferenceJobProductCategory::Seedance2ProVideo, "seedance2pro_video"); + assert_serialization(InferenceJobProductCategory::WorldlabsSplat, "worldlabs_splat"); + assert_serialization(InferenceJobProductCategory::TtsGptSoVits, "tts_gpt_so_vits"); + assert_serialization(InferenceJobProductCategory::TtsF5, "tts_f5"); + assert_serialization(InferenceJobProductCategory::TtsStyleTts2, "tts_style_tts2"); + assert_serialization(InferenceJobProductCategory::TtsTacotron2, "tts_tacotron2"); + assert_serialization(InferenceJobProductCategory::VcRvc2, "vc_rvc2"); + assert_serialization(InferenceJobProductCategory::VcSvc, "vc_svc"); + assert_serialization(InferenceJobProductCategory::VcSeedVc, "vc_seed_vc"); + assert_serialization(InferenceJobProductCategory::VidLipsyncFaceFusion, "vid_lipsync_face_fusion"); + assert_serialization(InferenceJobProductCategory::VidLipsyncSadTalker, "vid_lipsync_sad_talker"); + assert_serialization(InferenceJobProductCategory::VidLivePortrait, "vid_live_portrait"); + assert_serialization(InferenceJobProductCategory::VidLivePortraitWebcam, "vid_live_portrait_webcam"); + assert_serialization(InferenceJobProductCategory::VidStudio, "vid_studio"); + assert_serialization(InferenceJobProductCategory::VidStudioGen2, "vid_studio_gen2"); + assert_serialization(InferenceJobProductCategory::VidStyleTransfer, "vid_style_transfer"); + assert_serialization(InferenceJobProductCategory::LipsyncFaceFusion, "lipsync_face_fusion"); + assert_serialization(InferenceJobProductCategory::LipsyncSadTalker, "lipsync_sad_talker"); + assert_serialization(InferenceJobProductCategory::LivePortrait, "live_portrait"); + assert_serialization(InferenceJobProductCategory::LivePortraitWebcam, "live_portrait_webcam"); + assert_serialization(InferenceJobProductCategory::StableDiffusion, "stable_diffusion"); + assert_serialization(InferenceJobProductCategory::Studio, "studio"); + assert_serialization(InferenceJobProductCategory::VidFaceFusion, "vid_face_fusion"); + assert_serialization(InferenceJobProductCategory::Vst, "vst"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("download_gpt_so_vits", InferenceJobProductCategory::DownloadGptSoVits); + assert_deserialization("fal_image", InferenceJobProductCategory::FalImage); + assert_deserialization("fal_video", InferenceJobProductCategory::FalVideo); + assert_deserialization("fal_object", InferenceJobProductCategory::FalObject); + assert_deserialization("fal_bg_removal", InferenceJobProductCategory::FalBgRemoval); + assert_deserialization("seedance2pro_video", InferenceJobProductCategory::Seedance2ProVideo); + assert_deserialization("worldlabs_splat", InferenceJobProductCategory::WorldlabsSplat); + assert_deserialization("tts_gpt_so_vits", InferenceJobProductCategory::TtsGptSoVits); + assert_deserialization("tts_f5", InferenceJobProductCategory::TtsF5); + assert_deserialization("tts_style_tts2", InferenceJobProductCategory::TtsStyleTts2); + assert_deserialization("tts_tacotron2", InferenceJobProductCategory::TtsTacotron2); + assert_deserialization("vc_rvc2", InferenceJobProductCategory::VcRvc2); + assert_deserialization("vc_svc", InferenceJobProductCategory::VcSvc); + assert_deserialization("vc_seed_vc", InferenceJobProductCategory::VcSeedVc); + assert_deserialization("vid_lipsync_face_fusion", InferenceJobProductCategory::VidLipsyncFaceFusion); + assert_deserialization("vid_lipsync_sad_talker", InferenceJobProductCategory::VidLipsyncSadTalker); + assert_deserialization("vid_live_portrait", InferenceJobProductCategory::VidLivePortrait); + assert_deserialization("vid_live_portrait_webcam", InferenceJobProductCategory::VidLivePortraitWebcam); + assert_deserialization("vid_studio", InferenceJobProductCategory::VidStudio); + assert_deserialization("vid_studio_gen2", InferenceJobProductCategory::VidStudioGen2); + assert_deserialization("vid_style_transfer", InferenceJobProductCategory::VidStyleTransfer); + assert_deserialization("lipsync_face_fusion", InferenceJobProductCategory::LipsyncFaceFusion); + assert_deserialization("lipsync_sad_talker", InferenceJobProductCategory::LipsyncSadTalker); + assert_deserialization("live_portrait", InferenceJobProductCategory::LivePortrait); + assert_deserialization("live_portrait_webcam", InferenceJobProductCategory::LivePortraitWebcam); + assert_deserialization("stable_diffusion", InferenceJobProductCategory::StableDiffusion); + assert_deserialization("studio", InferenceJobProductCategory::Studio); + assert_deserialization("vid_face_fusion", InferenceJobProductCategory::VidFaceFusion); + assert_deserialization("vst", InferenceJobProductCategory::Vst); + } + #[test] fn variants_count_check() { assert_eq!(InferenceJobProductCategory::iter().count(), 29); diff --git a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_model_type.rs b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_model_type.rs index b50d996962..3d07113f08 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_model_type.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_model_type.rs @@ -57,11 +57,50 @@ pub enum InferenceModelType { #[cfg(test)] mod tests { use super::InferenceModelType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(InferenceModelType::ComfyUi, "comfy_ui"); + assert_serialization(InferenceModelType::RvcV2, "rvc_v2"); + assert_serialization(InferenceModelType::SadTalker, "sad_talker"); + assert_serialization(InferenceModelType::SoVitsSvc, "so_vits_svc"); + assert_serialization(InferenceModelType::SeedVc, "seed_vc"); + assert_serialization(InferenceModelType::ImageGenApi, "image_gen_api"); + assert_serialization(InferenceModelType::Tacotron2, "tacotron2"); + assert_serialization(InferenceModelType::Vits, "vits"); + assert_serialization(InferenceModelType::VallEX, "vall_e_x"); + assert_serialization(InferenceModelType::RerenderAVideo, "rerender_a_video"); + assert_serialization(InferenceModelType::StableDiffusion, "stable_diffusion"); + assert_serialization(InferenceModelType::MocapNet, "mocap_net"); + assert_serialization(InferenceModelType::StyleTTS2, "styletts2"); + assert_serialization(InferenceModelType::ConvertFbxToGltf, "convert_fbx_gltf"); + assert_serialization(InferenceModelType::BvhToWorkflow, "bvh_to_workflow"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("comfy_ui", InferenceModelType::ComfyUi); + assert_deserialization("rvc_v2", InferenceModelType::RvcV2); + assert_deserialization("sad_talker", InferenceModelType::SadTalker); + assert_deserialization("so_vits_svc", InferenceModelType::SoVitsSvc); + assert_deserialization("seed_vc", InferenceModelType::SeedVc); + assert_deserialization("image_gen_api", InferenceModelType::ImageGenApi); + assert_deserialization("tacotron2", InferenceModelType::Tacotron2); + assert_deserialization("vits", InferenceModelType::Vits); + assert_deserialization("vall_e_x", InferenceModelType::VallEX); + assert_deserialization("rerender_a_video", InferenceModelType::RerenderAVideo); + assert_deserialization("stable_diffusion", InferenceModelType::StableDiffusion); + assert_deserialization("mocap_net", InferenceModelType::MocapNet); + assert_deserialization("styletts2", InferenceModelType::StyleTTS2); + assert_deserialization("convert_fbx_gltf", InferenceModelType::ConvertFbxToGltf); + assert_deserialization("bvh_to_workflow", InferenceModelType::BvhToWorkflow); + } + #[test] fn variants_count_check() { assert_eq!(InferenceModelType::iter().count(), 15); diff --git a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_result_type.rs b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_result_type.rs index 8f4cc59619..cf59dffa5e 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_result_type.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_result_type.rs @@ -33,11 +33,30 @@ pub enum InferenceResultType { #[cfg(test)] mod tests { use super::InferenceResultType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(InferenceResultType::MediaFile, "media_file"); + assert_serialization(InferenceResultType::TextToSpeech, "text_to_speech"); + assert_serialization(InferenceResultType::VoiceConversion, "voice_conversion"); + assert_serialization(InferenceResultType::ZeroShotVoiceEmbedding, "zs_voice_embedding"); + assert_serialization(InferenceResultType::UploadModel, "upload_model"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_file", InferenceResultType::MediaFile); + assert_deserialization("text_to_speech", InferenceResultType::TextToSpeech); + assert_deserialization("voice_conversion", InferenceResultType::VoiceConversion); + assert_deserialization("zs_voice_embedding", InferenceResultType::ZeroShotVoiceEmbedding); + assert_deserialization("upload_model", InferenceResultType::UploadModel); + } + #[test] fn variants_count_check() { assert_eq!(InferenceResultType::iter().count(), 5); diff --git a/crates/schema/public/enums_api/src/by_table/generic_synthetic_ids/id_category.rs b/crates/schema/public/enums_api/src/by_table/generic_synthetic_ids/id_category.rs index 09bb35958a..5c5126cf85 100644 --- a/crates/schema/public/enums_api/src/by_table/generic_synthetic_ids/id_category.rs +++ b/crates/schema/public/enums_api/src/by_table/generic_synthetic_ids/id_category.rs @@ -74,11 +74,50 @@ pub enum IdCategory { #[cfg(test)] mod tests { use super::IdCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(IdCategory::MediaFile, "media_file"); + assert_serialization(IdCategory::LipsyncAnimationResult, "lipsync_animation"); + assert_serialization(IdCategory::FaceFusionResult, "face_fusion"); + assert_serialization(IdCategory::VideoFilterResult, "video_filter"); + assert_serialization(IdCategory::LivePortraitResult, "live_portrait"); + assert_serialization(IdCategory::StudioRender, "studio_render"); + assert_serialization(IdCategory::MocapResult, "mocap"); + assert_serialization(IdCategory::WorkflowResult, "workflow"); + assert_serialization(IdCategory::TtsResult, "tts_result"); + assert_serialization(IdCategory::VoiceConversionResult, "voice_conversion"); + assert_serialization(IdCategory::ZeroShotTtsResult, "zs_tts_result"); + assert_serialization(IdCategory::ZeroShotVoiceDataset, "zs_dataset"); + assert_serialization(IdCategory::ZeroShotVoiceEmbedding, "zs_voice"); + assert_serialization(IdCategory::ModelWeights, "model_weights"); + assert_serialization(IdCategory::FileUpload, "file_upload"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_file", IdCategory::MediaFile); + assert_deserialization("lipsync_animation", IdCategory::LipsyncAnimationResult); + assert_deserialization("face_fusion", IdCategory::FaceFusionResult); + assert_deserialization("video_filter", IdCategory::VideoFilterResult); + assert_deserialization("live_portrait", IdCategory::LivePortraitResult); + assert_deserialization("studio_render", IdCategory::StudioRender); + assert_deserialization("mocap", IdCategory::MocapResult); + assert_deserialization("workflow", IdCategory::WorkflowResult); + assert_deserialization("tts_result", IdCategory::TtsResult); + assert_deserialization("voice_conversion", IdCategory::VoiceConversionResult); + assert_deserialization("zs_tts_result", IdCategory::ZeroShotTtsResult); + assert_deserialization("zs_dataset", IdCategory::ZeroShotVoiceDataset); + assert_deserialization("zs_voice", IdCategory::ZeroShotVoiceEmbedding); + assert_deserialization("model_weights", IdCategory::ModelWeights); + assert_deserialization("file_upload", IdCategory::FileUpload); + } + #[test] fn variants_count_check() { assert_eq!(IdCategory::iter().count(), 15); diff --git a/crates/schema/public/enums_api/src/by_table/media_files/media_file_animation_type.rs b/crates/schema/public/enums_api/src/by_table/media_files/media_file_animation_type.rs index 09f99ae2f6..74c93bff20 100644 --- a/crates/schema/public/enums_api/src/by_table/media_files/media_file_animation_type.rs +++ b/crates/schema/public/enums_api/src/by_table/media_files/media_file_animation_type.rs @@ -64,11 +64,46 @@ pub enum MediaFileAnimationType { #[cfg(test)] mod tests { use super::MediaFileAnimationType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaFileAnimationType::ArKit, "ar_kit"); + assert_serialization(MediaFileAnimationType::MikuMikuDance, "miku_miku_dance"); + assert_serialization(MediaFileAnimationType::MikuMikuDanceArKit, "miku_miku_dance_ar_kit"); + assert_serialization(MediaFileAnimationType::Mixamo, "mixamo"); + assert_serialization(MediaFileAnimationType::MixamoArKit, "mixamo_ar_kit"); + assert_serialization(MediaFileAnimationType::MocapNet, "mocap_net"); + assert_serialization(MediaFileAnimationType::MocapNetArKit, "mocap_net_ar_kit"); + assert_serialization(MediaFileAnimationType::MoveAi, "move_ai"); + assert_serialization(MediaFileAnimationType::MoveAiArKit, "move_ai_ar_kit"); + assert_serialization(MediaFileAnimationType::Rigify, "rigify"); + assert_serialization(MediaFileAnimationType::RigifyArKit, "rigify_ar_kit"); + assert_serialization(MediaFileAnimationType::Rokoko, "rokoko"); + assert_serialization(MediaFileAnimationType::RokokoArKit, "rokoko_ar_kit"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("ar_kit", MediaFileAnimationType::ArKit); + assert_deserialization("miku_miku_dance", MediaFileAnimationType::MikuMikuDance); + assert_deserialization("miku_miku_dance_ar_kit", MediaFileAnimationType::MikuMikuDanceArKit); + assert_deserialization("mixamo", MediaFileAnimationType::Mixamo); + assert_deserialization("mixamo_ar_kit", MediaFileAnimationType::MixamoArKit); + assert_deserialization("mocap_net", MediaFileAnimationType::MocapNet); + assert_deserialization("mocap_net_ar_kit", MediaFileAnimationType::MocapNetArKit); + assert_deserialization("move_ai", MediaFileAnimationType::MoveAi); + assert_deserialization("move_ai_ar_kit", MediaFileAnimationType::MoveAiArKit); + assert_deserialization("rigify", MediaFileAnimationType::Rigify); + assert_deserialization("rigify_ar_kit", MediaFileAnimationType::RigifyArKit); + assert_deserialization("rokoko", MediaFileAnimationType::Rokoko); + assert_deserialization("rokoko_ar_kit", MediaFileAnimationType::RokokoArKit); + } + #[test] fn variants_count_check() { assert_eq!(MediaFileAnimationType::iter().count(), 13); diff --git a/crates/schema/public/enums_api/src/by_table/media_files/media_file_class.rs b/crates/schema/public/enums_api/src/by_table/media_files/media_file_class.rs index 3c2f7c2ab1..b2c1b4dee3 100644 --- a/crates/schema/public/enums_api/src/by_table/media_files/media_file_class.rs +++ b/crates/schema/public/enums_api/src/by_table/media_files/media_file_class.rs @@ -28,11 +28,30 @@ pub enum MediaFileClass { #[cfg(test)] mod tests { use super::MediaFileClass; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaFileClass::Unknown, "unknown"); + assert_serialization(MediaFileClass::Audio, "audio"); + assert_serialization(MediaFileClass::Image, "image"); + assert_serialization(MediaFileClass::Video, "video"); + assert_serialization(MediaFileClass::Dimensional, "dimensional"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("unknown", MediaFileClass::Unknown); + assert_deserialization("audio", MediaFileClass::Audio); + assert_deserialization("image", MediaFileClass::Image); + assert_deserialization("video", MediaFileClass::Video); + assert_deserialization("dimensional", MediaFileClass::Dimensional); + } + #[test] fn variants_count_check() { assert_eq!(MediaFileClass::iter().count(), 5); diff --git a/crates/schema/public/enums_api/src/by_table/media_files/media_file_engine_category.rs b/crates/schema/public/enums_api/src/by_table/media_files/media_file_engine_category.rs index b86123effc..c9d9fbc11f 100644 --- a/crates/schema/public/enums_api/src/by_table/media_files/media_file_engine_category.rs +++ b/crates/schema/public/enums_api/src/by_table/media_files/media_file_engine_category.rs @@ -52,11 +52,42 @@ pub enum MediaFileEngineCategory { #[cfg(test)] mod tests { use super::MediaFileEngineCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaFileEngineCategory::Scene, "scene"); + assert_serialization(MediaFileEngineCategory::Character, "character"); + assert_serialization(MediaFileEngineCategory::Creature, "creature"); + assert_serialization(MediaFileEngineCategory::Animation, "animation"); + assert_serialization(MediaFileEngineCategory::Expression, "expression"); + assert_serialization(MediaFileEngineCategory::Location, "location"); + assert_serialization(MediaFileEngineCategory::SetDressing, "set_dressing"); + assert_serialization(MediaFileEngineCategory::Object, "object"); + assert_serialization(MediaFileEngineCategory::Skybox, "skybox"); + assert_serialization(MediaFileEngineCategory::ImagePlane, "image_plane"); + assert_serialization(MediaFileEngineCategory::VideoPlane, "video_plane"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("scene", MediaFileEngineCategory::Scene); + assert_deserialization("character", MediaFileEngineCategory::Character); + assert_deserialization("creature", MediaFileEngineCategory::Creature); + assert_deserialization("animation", MediaFileEngineCategory::Animation); + assert_deserialization("expression", MediaFileEngineCategory::Expression); + assert_deserialization("location", MediaFileEngineCategory::Location); + assert_deserialization("set_dressing", MediaFileEngineCategory::SetDressing); + assert_deserialization("object", MediaFileEngineCategory::Object); + assert_deserialization("skybox", MediaFileEngineCategory::Skybox); + assert_deserialization("image_plane", MediaFileEngineCategory::ImagePlane); + assert_deserialization("video_plane", MediaFileEngineCategory::VideoPlane); + } + #[test] fn variants_count_check() { assert_eq!(MediaFileEngineCategory::iter().count(), 11); diff --git a/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_category.rs b/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_category.rs index 47eae9949e..976ee58c52 100644 --- a/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_category.rs +++ b/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_category.rs @@ -33,11 +33,32 @@ pub enum MediaFileOriginCategory { #[cfg(test)] mod tests { use super::MediaFileOriginCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaFileOriginCategory::Inference, "inference"); + assert_serialization(MediaFileOriginCategory::Processed, "processed"); + assert_serialization(MediaFileOriginCategory::Upload, "upload"); + assert_serialization(MediaFileOriginCategory::DeviceApi, "device_api"); + assert_serialization(MediaFileOriginCategory::StorytellerStudio, "studio"); + assert_serialization(MediaFileOriginCategory::StoryEngine, "story_engine"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("inference", MediaFileOriginCategory::Inference); + assert_deserialization("processed", MediaFileOriginCategory::Processed); + assert_deserialization("upload", MediaFileOriginCategory::Upload); + assert_deserialization("device_api", MediaFileOriginCategory::DeviceApi); + assert_deserialization("studio", MediaFileOriginCategory::StorytellerStudio); + assert_deserialization("story_engine", MediaFileOriginCategory::StoryEngine); + } + #[test] fn variants_count_check() { assert_eq!(MediaFileOriginCategory::iter().count(), 6); diff --git a/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_product_category.rs b/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_product_category.rs index 10e4982b7a..452fd62047 100644 --- a/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_product_category.rs +++ b/crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_product_category.rs @@ -81,11 +81,52 @@ pub enum MediaFileOriginProductCategory { #[cfg(test)] mod tests { use super::MediaFileOriginProductCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaFileOriginProductCategory::Unknown, "unknown"); + assert_serialization(MediaFileOriginProductCategory::FaceAnimator, "face_animator"); + assert_serialization(MediaFileOriginProductCategory::FaceFusion, "face_fusion"); + assert_serialization(MediaFileOriginProductCategory::FaceMirror, "face_mirror"); + assert_serialization(MediaFileOriginProductCategory::VideoStyleTransfer, "vst"); + assert_serialization(MediaFileOriginProductCategory::ImageStudio, "image_studio"); + assert_serialization(MediaFileOriginProductCategory::StorytellerStudio, "studio"); + assert_serialization(MediaFileOriginProductCategory::TextToSpeech, "tts"); + assert_serialization(MediaFileOriginProductCategory::VoiceConversion, "voice_conversion"); + assert_serialization(MediaFileOriginProductCategory::ZeroShotVoice, "zs_voice"); + assert_serialization(MediaFileOriginProductCategory::Mocap, "mocap"); + assert_serialization(MediaFileOriginProductCategory::ImageGeneration, "image_gen"); + assert_serialization(MediaFileOriginProductCategory::VideoGeneration, "video_gen"); + assert_serialization(MediaFileOriginProductCategory::WorldGeneration, "world_gen"); + assert_serialization(MediaFileOriginProductCategory::VideoFilter, "video_filter"); + assert_serialization(MediaFileOriginProductCategory::Workflow, "workflow"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("unknown", MediaFileOriginProductCategory::Unknown); + assert_deserialization("face_animator", MediaFileOriginProductCategory::FaceAnimator); + assert_deserialization("face_fusion", MediaFileOriginProductCategory::FaceFusion); + assert_deserialization("face_mirror", MediaFileOriginProductCategory::FaceMirror); + assert_deserialization("vst", MediaFileOriginProductCategory::VideoStyleTransfer); + assert_deserialization("image_studio", MediaFileOriginProductCategory::ImageStudio); + assert_deserialization("studio", MediaFileOriginProductCategory::StorytellerStudio); + assert_deserialization("tts", MediaFileOriginProductCategory::TextToSpeech); + assert_deserialization("voice_conversion", MediaFileOriginProductCategory::VoiceConversion); + assert_deserialization("zs_voice", MediaFileOriginProductCategory::ZeroShotVoice); + assert_deserialization("mocap", MediaFileOriginProductCategory::Mocap); + assert_deserialization("image_gen", MediaFileOriginProductCategory::ImageGeneration); + assert_deserialization("video_gen", MediaFileOriginProductCategory::VideoGeneration); + assert_deserialization("world_gen", MediaFileOriginProductCategory::WorldGeneration); + assert_deserialization("video_filter", MediaFileOriginProductCategory::VideoFilter); + assert_deserialization("workflow", MediaFileOriginProductCategory::Workflow); + } + #[test] fn variants_count_check() { assert_eq!(MediaFileOriginProductCategory::iter().count(), 16); diff --git a/crates/schema/public/enums_api/src/by_table/media_files/media_file_subtype.rs b/crates/schema/public/enums_api/src/by_table/media_files/media_file_subtype.rs index 66d915c13a..bbbae2952b 100644 --- a/crates/schema/public/enums_api/src/by_table/media_files/media_file_subtype.rs +++ b/crates/schema/public/enums_api/src/by_table/media_files/media_file_subtype.rs @@ -57,11 +57,42 @@ pub enum MediaFileSubtype { #[cfg(test)] mod tests { use super::MediaFileSubtype; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaFileSubtype::Deprecated, "deprecated"); + assert_serialization(MediaFileSubtype::Mixamo, "mixamo"); + assert_serialization(MediaFileSubtype::MocapNet, "mocap_net"); + assert_serialization(MediaFileSubtype::AnimationOnly, "animation_only"); + assert_serialization(MediaFileSubtype::SceneImport, "scene_import"); + assert_serialization(MediaFileSubtype::StorytellerScene, "storyteller_scene"); + assert_serialization(MediaFileSubtype::Scene, "scene"); + assert_serialization(MediaFileSubtype::Character, "character"); + assert_serialization(MediaFileSubtype::Animation, "animation"); + assert_serialization(MediaFileSubtype::Object, "object"); + assert_serialization(MediaFileSubtype::Skybox, "skybox"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("deprecated", MediaFileSubtype::Deprecated); + assert_deserialization("mixamo", MediaFileSubtype::Mixamo); + assert_deserialization("mocap_net", MediaFileSubtype::MocapNet); + assert_deserialization("animation_only", MediaFileSubtype::AnimationOnly); + assert_deserialization("scene_import", MediaFileSubtype::SceneImport); + assert_deserialization("storyteller_scene", MediaFileSubtype::StorytellerScene); + assert_deserialization("scene", MediaFileSubtype::Scene); + assert_deserialization("character", MediaFileSubtype::Character); + assert_deserialization("animation", MediaFileSubtype::Animation); + assert_deserialization("object", MediaFileSubtype::Object); + assert_deserialization("skybox", MediaFileSubtype::Skybox); + } + #[test] fn variants_count_check() { assert_eq!(MediaFileSubtype::iter().count(), 11); diff --git a/crates/schema/public/enums_api/src/by_table/media_files/media_file_type.rs b/crates/schema/public/enums_api/src/by_table/media_files/media_file_type.rs index 90a12b9fcb..aec9e177d7 100644 --- a/crates/schema/public/enums_api/src/by_table/media_files/media_file_type.rs +++ b/crates/schema/public/enums_api/src/by_table/media_files/media_file_type.rs @@ -87,11 +87,60 @@ pub enum MediaFileType { #[cfg(test)] mod tests { use super::MediaFileType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaFileType::Audio, "audio"); + assert_serialization(MediaFileType::Image, "image"); + assert_serialization(MediaFileType::Video, "video"); + assert_serialization(MediaFileType::Bvh, "bvh"); + assert_serialization(MediaFileType::Fbx, "fbx"); + assert_serialization(MediaFileType::Glb, "glb"); + assert_serialization(MediaFileType::Gltf, "gltf"); + assert_serialization(MediaFileType::Spz, "spz"); + assert_serialization(MediaFileType::SceneRon, "scene_ron"); + assert_serialization(MediaFileType::SceneJson, "scene_json"); + assert_serialization(MediaFileType::Pmd, "pmd"); + assert_serialization(MediaFileType::Vmd, "vmd"); + assert_serialization(MediaFileType::Pmx, "pmx"); + assert_serialization(MediaFileType::Csv, "csv"); + assert_serialization(MediaFileType::Jpg, "jpg"); + assert_serialization(MediaFileType::Png, "png"); + assert_serialization(MediaFileType::Gif, "gif"); + assert_serialization(MediaFileType::Mp4, "mp4"); + assert_serialization(MediaFileType::Wav, "wav"); + assert_serialization(MediaFileType::Mp3, "mp3"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("audio", MediaFileType::Audio); + assert_deserialization("image", MediaFileType::Image); + assert_deserialization("video", MediaFileType::Video); + assert_deserialization("bvh", MediaFileType::Bvh); + assert_deserialization("fbx", MediaFileType::Fbx); + assert_deserialization("glb", MediaFileType::Glb); + assert_deserialization("gltf", MediaFileType::Gltf); + assert_deserialization("spz", MediaFileType::Spz); + assert_deserialization("scene_ron", MediaFileType::SceneRon); + assert_deserialization("scene_json", MediaFileType::SceneJson); + assert_deserialization("pmd", MediaFileType::Pmd); + assert_deserialization("vmd", MediaFileType::Vmd); + assert_deserialization("pmx", MediaFileType::Pmx); + assert_deserialization("csv", MediaFileType::Csv); + assert_deserialization("jpg", MediaFileType::Jpg); + assert_deserialization("png", MediaFileType::Png); + assert_deserialization("gif", MediaFileType::Gif); + assert_deserialization("mp4", MediaFileType::Mp4); + assert_deserialization("wav", MediaFileType::Wav); + assert_deserialization("mp3", MediaFileType::Mp3); + } + #[test] fn variants_count_check() { assert_eq!(MediaFileType::iter().count(), 20); diff --git a/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_source.rs b/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_source.rs index 8d3359752d..36a485ad79 100644 --- a/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_source.rs +++ b/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_source.rs @@ -23,11 +23,26 @@ pub enum MediaUploadSource { #[cfg(test)] mod tests { use super::MediaUploadSource; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaUploadSource::DeviceApi, "device_api"); + assert_serialization(MediaUploadSource::File, "file"); + assert_serialization(MediaUploadSource::Unknown, "unknown"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("device_api", MediaUploadSource::DeviceApi); + assert_deserialization("file", MediaUploadSource::File); + assert_deserialization("unknown", MediaUploadSource::Unknown); + } + #[test] fn variants_count_check() { assert_eq!(MediaUploadSource::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_type.rs b/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_type.rs index 52b3628cfd..afda14ab37 100644 --- a/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_type.rs +++ b/crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_type.rs @@ -24,11 +24,28 @@ pub enum MediaUploadType { #[cfg(test)] mod tests { use super::MediaUploadType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(MediaUploadType::Audio, "audio"); + assert_serialization(MediaUploadType::Image, "image"); + assert_serialization(MediaUploadType::Video, "video"); + assert_serialization(MediaUploadType::Binary, "binary"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("audio", MediaUploadType::Audio); + assert_deserialization("image", MediaUploadType::Image); + assert_deserialization("video", MediaUploadType::Video); + assert_deserialization("binary", MediaUploadType::Binary); + } + #[test] fn variants_count_check() { assert_eq!(MediaUploadType::iter().count(), 4); diff --git a/crates/schema/public/enums_api/src/by_table/model_categories/model_type.rs b/crates/schema/public/enums_api/src/by_table/model_categories/model_type.rs index de85b85133..b9d0caecfb 100644 --- a/crates/schema/public/enums_api/src/by_table/model_categories/model_type.rs +++ b/crates/schema/public/enums_api/src/by_table/model_categories/model_type.rs @@ -16,11 +16,24 @@ pub enum ModelType { #[cfg(test)] mod tests { use super::ModelType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(ModelType::Tts, "tts"); + assert_serialization(ModelType::W2l, "w2l"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("tts", ModelType::Tts); + assert_deserialization("w2l", ModelType::W2l); + } + #[test] fn variants_count_check() { assert_eq!(ModelType::iter().count(), 2); diff --git a/crates/schema/public/enums_api/src/by_table/model_weights/weights_category.rs b/crates/schema/public/enums_api/src/by_table/model_weights/weights_category.rs index 065a59f5e9..4a610bc5a0 100644 --- a/crates/schema/public/enums_api/src/by_table/model_weights/weights_category.rs +++ b/crates/schema/public/enums_api/src/by_table/model_weights/weights_category.rs @@ -19,11 +19,30 @@ pub enum WeightsCategory { #[cfg(test)] mod tests { use super::WeightsCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(WeightsCategory::ImageGeneration, "image_generation"); + assert_serialization(WeightsCategory::TextToSpeech, "text_to_speech"); + assert_serialization(WeightsCategory::Vocoder, "vocoder"); + assert_serialization(WeightsCategory::VoiceConversion, "voice_conversion"); + assert_serialization(WeightsCategory::WorkflowConfig, "workflow_config"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("image_generation", WeightsCategory::ImageGeneration); + assert_deserialization("text_to_speech", WeightsCategory::TextToSpeech); + assert_deserialization("vocoder", WeightsCategory::Vocoder); + assert_deserialization("voice_conversion", WeightsCategory::VoiceConversion); + assert_deserialization("workflow_config", WeightsCategory::WorkflowConfig); + } + #[test] fn variants_count_check() { assert_eq!(WeightsCategory::iter().count(), 5); diff --git a/crates/schema/public/enums_api/src/by_table/model_weights/weights_file_type.rs b/crates/schema/public/enums_api/src/by_table/model_weights/weights_file_type.rs index 834207c549..c1026e67e4 100644 --- a/crates/schema/public/enums_api/src/by_table/model_weights/weights_file_type.rs +++ b/crates/schema/public/enums_api/src/by_table/model_weights/weights_file_type.rs @@ -14,11 +14,24 @@ pub enum WeightsFileType { #[cfg(test)] mod tests { use super::WeightsFileType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(WeightsFileType::Checkpoint, "checkpoint"); + assert_serialization(WeightsFileType::SafeTensors, "safetensors"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("checkpoint", WeightsFileType::Checkpoint); + assert_deserialization("safetensors", WeightsFileType::SafeTensors); + } + #[test] fn variants_count_check() { assert_eq!(WeightsFileType::iter().count(), 2); diff --git a/crates/schema/public/enums_api/src/by_table/prompt_context_items/prompt_context_semantic_type.rs b/crates/schema/public/enums_api/src/by_table/prompt_context_items/prompt_context_semantic_type.rs index 7172a60640..d98cd1f77c 100644 --- a/crates/schema/public/enums_api/src/by_table/prompt_context_items/prompt_context_semantic_type.rs +++ b/crates/schema/public/enums_api/src/by_table/prompt_context_items/prompt_context_semantic_type.rs @@ -47,11 +47,40 @@ pub enum PromptContextSemanticType { #[cfg(test)] mod tests { use super::PromptContextSemanticType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(PromptContextSemanticType::VidStartFrame, "vid_start_frame"); + assert_serialization(PromptContextSemanticType::VidEndFrame, "vid_end_frame"); + assert_serialization(PromptContextSemanticType::VidRef, "vid_ref"); + assert_serialization(PromptContextSemanticType::Imgsrc, "imgsrc"); + assert_serialization(PromptContextSemanticType::Imgmask, "imgmask"); + assert_serialization(PromptContextSemanticType::Imgref, "imgref"); + assert_serialization(PromptContextSemanticType::ImgrefCharacter, "imgref_character"); + assert_serialization(PromptContextSemanticType::ImgrefStyle, "imgref_style"); + assert_serialization(PromptContextSemanticType::ImgrefBg, "imgref_bg"); + assert_serialization(PromptContextSemanticType::Audioref, "audioref"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("vid_start_frame", PromptContextSemanticType::VidStartFrame); + assert_deserialization("vid_end_frame", PromptContextSemanticType::VidEndFrame); + assert_deserialization("vid_ref", PromptContextSemanticType::VidRef); + assert_deserialization("imgsrc", PromptContextSemanticType::Imgsrc); + assert_deserialization("imgmask", PromptContextSemanticType::Imgmask); + assert_deserialization("imgref", PromptContextSemanticType::Imgref); + assert_deserialization("imgref_character", PromptContextSemanticType::ImgrefCharacter); + assert_deserialization("imgref_style", PromptContextSemanticType::ImgrefStyle); + assert_deserialization("imgref_bg", PromptContextSemanticType::ImgrefBg); + assert_deserialization("audioref", PromptContextSemanticType::Audioref); + } + #[test] fn variants_count_check() { assert_eq!(PromptContextSemanticType::iter().count(), 10); diff --git a/crates/schema/public/enums_api/src/by_table/prompts/prompt_type.rs b/crates/schema/public/enums_api/src/by_table/prompts/prompt_type.rs index 9d065bbb2e..f34a23b182 100644 --- a/crates/schema/public/enums_api/src/by_table/prompts/prompt_type.rs +++ b/crates/schema/public/enums_api/src/by_table/prompts/prompt_type.rs @@ -23,11 +23,26 @@ pub enum PromptType { #[cfg(test)] mod tests { use super::PromptType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(PromptType::ArtcraftApp, "artcraft_app"); + assert_serialization(PromptType::StableDiffusion, "stable_diffusion"); + assert_serialization(PromptType::ComfyUi, "comfy_ui"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("artcraft_app", PromptType::ArtcraftApp); + assert_deserialization("stable_diffusion", PromptType::StableDiffusion); + assert_deserialization("comfy_ui", PromptType::ComfyUi); + } + #[test] fn variants_count_check() { assert_eq!(PromptType::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/tag_uses/tag_use_entity_type.rs b/crates/schema/public/enums_api/src/by_table/tag_uses/tag_use_entity_type.rs index f2bcbfff1d..b56cc0f77a 100644 --- a/crates/schema/public/enums_api/src/by_table/tag_uses/tag_use_entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/tag_uses/tag_use_entity_type.rs @@ -17,11 +17,24 @@ pub enum TagUseEntityType { #[cfg(test)] mod tests { use super::TagUseEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(TagUseEntityType::MediaFile, "media_file"); + assert_serialization(TagUseEntityType::ModelWeight, "model_weight"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_file", TagUseEntityType::MediaFile); + assert_deserialization("model_weight", TagUseEntityType::ModelWeight); + } + #[test] fn variants_count_check() { assert_eq!(TagUseEntityType::iter().count(), 2); diff --git a/crates/schema/public/enums_api/src/by_table/trending_model_analytics/model_type.rs b/crates/schema/public/enums_api/src/by_table/trending_model_analytics/model_type.rs index 00941cb6ef..af5a6cf800 100644 --- a/crates/schema/public/enums_api/src/by_table/trending_model_analytics/model_type.rs +++ b/crates/schema/public/enums_api/src/by_table/trending_model_analytics/model_type.rs @@ -18,11 +18,22 @@ pub enum ModelType { #[cfg(test)] mod tests { use super::ModelType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(ModelType::Tts, "tts"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("tts", ModelType::Tts); + } + #[test] fn variants_count_check() { assert_eq!(ModelType::iter().count(), 1); diff --git a/crates/schema/public/enums_api/src/by_table/trending_model_analytics/window_name.rs b/crates/schema/public/enums_api/src/by_table/trending_model_analytics/window_name.rs index 091c739ddf..a9d6b829a3 100644 --- a/crates/schema/public/enums_api/src/by_table/trending_model_analytics/window_name.rs +++ b/crates/schema/public/enums_api/src/by_table/trending_model_analytics/window_name.rs @@ -25,11 +25,26 @@ pub enum WindowName { #[cfg(test)] mod tests { use super::WindowName; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(WindowName::Last3Hours, "last_3_hours"); + assert_serialization(WindowName::Last3Days, "last_3_days"); + assert_serialization(WindowName::AllTime, "all_time"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("last_3_hours", WindowName::Last3Hours); + assert_deserialization("last_3_days", WindowName::Last3Days); + assert_deserialization("all_time", WindowName::AllTime); + } + #[test] fn variants_count_check() { assert_eq!(WindowName::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/tts_models/tts_model_type.rs b/crates/schema/public/enums_api/src/by_table/tts_models/tts_model_type.rs index dc8d2f8f0c..9a79674a6c 100644 --- a/crates/schema/public/enums_api/src/by_table/tts_models/tts_model_type.rs +++ b/crates/schema/public/enums_api/src/by_table/tts_models/tts_model_type.rs @@ -18,11 +18,24 @@ pub enum TtsModelType { #[cfg(test)] mod tests { use super::TtsModelType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(TtsModelType::Tacotron2, "tacotron2"); + assert_serialization(TtsModelType::Vits, "vits"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("tacotron2", TtsModelType::Tacotron2); + assert_deserialization("vits", TtsModelType::Vits); + } + #[test] fn variants_count_check() { assert_eq!(TtsModelType::iter().count(), 2); diff --git a/crates/schema/public/enums_api/src/by_table/tts_render_tasks/tts_render_status.rs b/crates/schema/public/enums_api/src/by_table/tts_render_tasks/tts_render_status.rs index bbe719b573..62c110772b 100644 --- a/crates/schema/public/enums_api/src/by_table/tts_render_tasks/tts_render_status.rs +++ b/crates/schema/public/enums_api/src/by_table/tts_render_tasks/tts_render_status.rs @@ -28,11 +28,32 @@ pub enum TtsRenderStatus { #[cfg(test)] mod tests { use super::TtsRenderStatus; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(TtsRenderStatus::New, "new"); + assert_serialization(TtsRenderStatus::Processing, "processing"); + assert_serialization(TtsRenderStatus::Skipped, "skipped"); + assert_serialization(TtsRenderStatus::Failed, "failed"); + assert_serialization(TtsRenderStatus::PermanentlyFailed, "permanently_failed"); + assert_serialization(TtsRenderStatus::Success, "success"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("new", TtsRenderStatus::New); + assert_deserialization("processing", TtsRenderStatus::Processing); + assert_deserialization("skipped", TtsRenderStatus::Skipped); + assert_deserialization("failed", TtsRenderStatus::Failed); + assert_deserialization("permanently_failed", TtsRenderStatus::PermanentlyFailed); + assert_deserialization("success", TtsRenderStatus::Success); + } + #[test] fn variants_count_check() { assert_eq!(TtsRenderStatus::iter().count(), 6); diff --git a/crates/schema/public/enums_api/src/by_table/usages/usages_type.rs b/crates/schema/public/enums_api/src/by_table/usages/usages_type.rs index c89e8e2021..c5cbdfa443 100644 --- a/crates/schema/public/enums_api/src/by_table/usages/usages_type.rs +++ b/crates/schema/public/enums_api/src/by_table/usages/usages_type.rs @@ -18,11 +18,24 @@ pub enum UsagesType { #[cfg(test)] mod tests { use super::UsagesType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(UsagesType::ModelWeight, "model_weight"); + assert_serialization(UsagesType::MediaFile, "media_file"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("model_weight", UsagesType::ModelWeight); + assert_deserialization("media_file", UsagesType::MediaFile); + } + #[test] fn variants_count_check() { assert_eq!(UsagesType::iter().count(), 2); diff --git a/crates/schema/public/enums_api/src/by_table/user_bookmarks/user_bookmark_entity_type.rs b/crates/schema/public/enums_api/src/by_table/user_bookmarks/user_bookmark_entity_type.rs index 85b1a10af8..763f24c7cf 100644 --- a/crates/schema/public/enums_api/src/by_table/user_bookmarks/user_bookmark_entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/user_bookmarks/user_bookmark_entity_type.rs @@ -45,11 +45,38 @@ pub enum UserBookmarkEntityType { #[cfg(test)] mod tests { use super::UserBookmarkEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(UserBookmarkEntityType::User, "user"); + assert_serialization(UserBookmarkEntityType::TtsModel, "tts_model"); + assert_serialization(UserBookmarkEntityType::TtsResult, "tts_result"); + assert_serialization(UserBookmarkEntityType::W2lTemplate, "w2l_template"); + assert_serialization(UserBookmarkEntityType::W2lResult, "w2l_result"); + assert_serialization(UserBookmarkEntityType::MediaFile, "media_file"); + assert_serialization(UserBookmarkEntityType::ModelWeight, "model_weight"); + assert_serialization(UserBookmarkEntityType::VoiceConversionModel, "voice_conversion_model"); + assert_serialization(UserBookmarkEntityType::ZsVoice, "zs_voice"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("user", UserBookmarkEntityType::User); + assert_deserialization("tts_model", UserBookmarkEntityType::TtsModel); + assert_deserialization("tts_result", UserBookmarkEntityType::TtsResult); + assert_deserialization("w2l_template", UserBookmarkEntityType::W2lTemplate); + assert_deserialization("w2l_result", UserBookmarkEntityType::W2lResult); + assert_deserialization("media_file", UserBookmarkEntityType::MediaFile); + assert_deserialization("model_weight", UserBookmarkEntityType::ModelWeight); + assert_deserialization("voice_conversion_model", UserBookmarkEntityType::VoiceConversionModel); + assert_deserialization("zs_voice", UserBookmarkEntityType::ZsVoice); + } + #[test] fn variants_count_check() { assert_eq!(UserBookmarkEntityType::iter().count(), 9); diff --git a/crates/schema/public/enums_api/src/by_table/user_ratings/entity_type.rs b/crates/schema/public/enums_api/src/by_table/user_ratings/entity_type.rs index d4768a2323..19f3500a06 100644 --- a/crates/schema/public/enums_api/src/by_table/user_ratings/entity_type.rs +++ b/crates/schema/public/enums_api/src/by_table/user_ratings/entity_type.rs @@ -33,11 +33,32 @@ pub enum UserRatingEntityType { #[cfg(test)] mod tests { use super::UserRatingEntityType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(UserRatingEntityType::MediaFile, "media_file"); + assert_serialization(UserRatingEntityType::ModelWeight, "model_weight"); + assert_serialization(UserRatingEntityType::TtsModel, "tts_model"); + assert_serialization(UserRatingEntityType::TtsResult, "tts_result"); + assert_serialization(UserRatingEntityType::W2lTemplate, "w2l_template"); + assert_serialization(UserRatingEntityType::W2lResult, "w2l_result"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_file", UserRatingEntityType::MediaFile); + assert_deserialization("model_weight", UserRatingEntityType::ModelWeight); + assert_deserialization("tts_model", UserRatingEntityType::TtsModel); + assert_deserialization("tts_result", UserRatingEntityType::TtsResult); + assert_deserialization("w2l_template", UserRatingEntityType::W2lTemplate); + assert_deserialization("w2l_result", UserRatingEntityType::W2lResult); + } + #[test] fn variants_count_check() { assert_eq!(UserRatingEntityType::iter().count(), 6); diff --git a/crates/schema/public/enums_api/src/by_table/user_ratings/rating_value.rs b/crates/schema/public/enums_api/src/by_table/user_ratings/rating_value.rs index d33c1668e1..f88b3f8c93 100644 --- a/crates/schema/public/enums_api/src/by_table/user_ratings/rating_value.rs +++ b/crates/schema/public/enums_api/src/by_table/user_ratings/rating_value.rs @@ -33,11 +33,26 @@ pub enum UserRatingValue { #[cfg(test)] mod tests { use super::UserRatingValue; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(UserRatingValue::Neutral, "neutral"); + assert_serialization(UserRatingValue::Positive, "positive"); + assert_serialization(UserRatingValue::Negative, "negative"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("neutral", UserRatingValue::Neutral); + assert_deserialization("positive", UserRatingValue::Positive); + assert_deserialization("negative", UserRatingValue::Negative); + } + #[test] fn variants_count_check() { assert_eq!(UserRatingValue::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/users/user_feature_flag.rs b/crates/schema/public/enums_api/src/by_table/users/user_feature_flag.rs index a5a10bdf04..aba2ea3a0f 100644 --- a/crates/schema/public/enums_api/src/by_table/users/user_feature_flag.rs +++ b/crates/schema/public/enums_api/src/by_table/users/user_feature_flag.rs @@ -26,11 +26,28 @@ pub enum UserFeatureFlag { #[cfg(test)] mod tests { use super::UserFeatureFlag; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(UserFeatureFlag::ExploreMedia, "explore_media"); + assert_serialization(UserFeatureFlag::Studio, "studio"); + assert_serialization(UserFeatureFlag::Upload3d, "upload_3d"); + assert_serialization(UserFeatureFlag::VideoStyleTransfer, "video_style_transfer"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("explore_media", UserFeatureFlag::ExploreMedia); + assert_deserialization("studio", UserFeatureFlag::Studio); + assert_deserialization("upload_3d", UserFeatureFlag::Upload3d); + assert_deserialization("video_style_transfer", UserFeatureFlag::VideoStyleTransfer); + } + #[test] fn variants_count_check() { assert_eq!(UserFeatureFlag::iter().count(), 4); diff --git a/crates/schema/public/enums_api/src/by_table/users/user_signup_method.rs b/crates/schema/public/enums_api/src/by_table/users/user_signup_method.rs index 8ab521ec4c..00ba123b0e 100644 --- a/crates/schema/public/enums_api/src/by_table/users/user_signup_method.rs +++ b/crates/schema/public/enums_api/src/by_table/users/user_signup_method.rs @@ -23,11 +23,26 @@ pub enum UserSignupMethod { #[cfg(test)] mod tests { use super::UserSignupMethod; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(UserSignupMethod::EmailPassword, "email_password"); + assert_serialization(UserSignupMethod::GoogleSignIn, "google_sign_in"); + assert_serialization(UserSignupMethod::StripeCheckout, "stripe_checkout"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("email_password", UserSignupMethod::EmailPassword); + assert_deserialization("google_sign_in", UserSignupMethod::GoogleSignIn); + assert_deserialization("stripe_checkout", UserSignupMethod::StripeCheckout); + } + #[test] fn variants_count_check() { assert_eq!(UserSignupMethod::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/users/user_signup_source.rs b/crates/schema/public/enums_api/src/by_table/users/user_signup_source.rs index 723e91bfc6..df4542020d 100644 --- a/crates/schema/public/enums_api/src/by_table/users/user_signup_source.rs +++ b/crates/schema/public/enums_api/src/by_table/users/user_signup_source.rs @@ -42,11 +42,36 @@ pub enum UserSignupSource { #[cfg(test)] mod tests { use super::UserSignupSource; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(UserSignupSource::ArtCraft, "artcraft"); + assert_serialization(UserSignupSource::ArtCraftApp, "artcraft_app"); + assert_serialization(UserSignupSource::ArtCraftAiWeb, "artcraft_ai_web"); + assert_serialization(UserSignupSource::ArtCraftAiStripe, "artcraft_ai_s"); + assert_serialization(UserSignupSource::ArtCraftGetWeb, "artcraft_get_web"); + assert_serialization(UserSignupSource::ArtCraftGetStripe, "artcraft_get_s"); + assert_serialization(UserSignupSource::FakeYou, "fakeyou"); + assert_serialization(UserSignupSource::Storyteller, "storyteller"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("artcraft", UserSignupSource::ArtCraft); + assert_deserialization("artcraft_app", UserSignupSource::ArtCraftApp); + assert_deserialization("artcraft_ai_web", UserSignupSource::ArtCraftAiWeb); + assert_deserialization("artcraft_ai_s", UserSignupSource::ArtCraftAiStripe); + assert_deserialization("artcraft_get_web", UserSignupSource::ArtCraftGetWeb); + assert_deserialization("artcraft_get_s", UserSignupSource::ArtCraftGetStripe); + assert_deserialization("fakeyou", UserSignupSource::FakeYou); + assert_deserialization("storyteller", UserSignupSource::Storyteller); + } + #[test] fn variants_count_check() { assert_eq!(UserSignupSource::iter().count(), 8); diff --git a/crates/schema/public/enums_api/src/by_table/voice_conversion_models/voice_conversion_model_type.rs b/crates/schema/public/enums_api/src/by_table/voice_conversion_models/voice_conversion_model_type.rs index 6ca8985320..b58b89a46c 100644 --- a/crates/schema/public/enums_api/src/by_table/voice_conversion_models/voice_conversion_model_type.rs +++ b/crates/schema/public/enums_api/src/by_table/voice_conversion_models/voice_conversion_model_type.rs @@ -22,11 +22,26 @@ pub enum VoiceConversionModelType { #[cfg(test)] mod tests { use super::VoiceConversionModelType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(VoiceConversionModelType::RvcV2, "rvc_v2"); + assert_serialization(VoiceConversionModelType::SoftVc, "soft_vc"); + assert_serialization(VoiceConversionModelType::SoVitsSvc, "so_vits_svc"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("rvc_v2", VoiceConversionModelType::RvcV2); + assert_deserialization("soft_vc", VoiceConversionModelType::SoftVc); + assert_deserialization("so_vits_svc", VoiceConversionModelType::SoVitsSvc); + } + #[test] fn variants_count_check() { assert_eq!(VoiceConversionModelType::iter().count(), 3); diff --git a/crates/schema/public/enums_api/src/by_table/voice_conversion_results/voice_conversion_media_token_type.rs b/crates/schema/public/enums_api/src/by_table/voice_conversion_results/voice_conversion_media_token_type.rs index ba0fdebf7d..fdb3b4d1a9 100644 --- a/crates/schema/public/enums_api/src/by_table/voice_conversion_results/voice_conversion_media_token_type.rs +++ b/crates/schema/public/enums_api/src/by_table/voice_conversion_results/voice_conversion_media_token_type.rs @@ -15,11 +15,22 @@ pub enum VoiceConversionMediaTokenType { #[cfg(test)] mod tests { use super::VoiceConversionMediaTokenType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(VoiceConversionMediaTokenType::MediaUpload, "media_upload"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("media_upload", VoiceConversionMediaTokenType::MediaUpload); + } + #[test] fn variants_count_check() { assert_eq!(VoiceConversionMediaTokenType::iter().count(), 1); diff --git a/crates/schema/public/enums_api/src/by_table/wallet_ledger_entries/wallet_ledger_entry_type.rs b/crates/schema/public/enums_api/src/by_table/wallet_ledger_entries/wallet_ledger_entry_type.rs index c3e3f84118..b0bd39691c 100644 --- a/crates/schema/public/enums_api/src/by_table/wallet_ledger_entries/wallet_ledger_entry_type.rs +++ b/crates/schema/public/enums_api/src/by_table/wallet_ledger_entries/wallet_ledger_entry_type.rs @@ -52,11 +52,36 @@ pub enum WalletLedgerEntryType { #[cfg(test)] mod tests { use super::WalletLedgerEntryType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(WalletLedgerEntryType::Create, "create"); + assert_serialization(WalletLedgerEntryType::CreditBanked, "credit_banked"); + assert_serialization(WalletLedgerEntryType::CreditMonthly, "credit_monthly"); + assert_serialization(WalletLedgerEntryType::DeductMixed, "deduct_mixed"); + assert_serialization(WalletLedgerEntryType::DeductBanked, "deduct_banked"); + assert_serialization(WalletLedgerEntryType::DeductMonthly, "deduct_monthly"); + assert_serialization(WalletLedgerEntryType::RefundBanked, "refund_banked"); + assert_serialization(WalletLedgerEntryType::StaffAddBanked, "staff_add_banked"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("create", WalletLedgerEntryType::Create); + assert_deserialization("credit_banked", WalletLedgerEntryType::CreditBanked); + assert_deserialization("credit_monthly", WalletLedgerEntryType::CreditMonthly); + assert_deserialization("deduct_mixed", WalletLedgerEntryType::DeductMixed); + assert_deserialization("deduct_banked", WalletLedgerEntryType::DeductBanked); + assert_deserialization("deduct_monthly", WalletLedgerEntryType::DeductMonthly); + assert_deserialization("refund_banked", WalletLedgerEntryType::RefundBanked); + assert_deserialization("staff_add_banked", WalletLedgerEntryType::StaffAddBanked); + } + #[test] fn variants_count_check() { assert_eq!(WalletLedgerEntryType::iter().count(), 8); diff --git a/crates/schema/public/enums_api/src/by_table/web_rendition_targets/rendition_status.rs b/crates/schema/public/enums_api/src/by_table/web_rendition_targets/rendition_status.rs index ae12be7f5f..960a7d2112 100644 --- a/crates/schema/public/enums_api/src/by_table/web_rendition_targets/rendition_status.rs +++ b/crates/schema/public/enums_api/src/by_table/web_rendition_targets/rendition_status.rs @@ -24,11 +24,30 @@ pub enum RenditionStatus { #[cfg(test)] mod tests { use super::RenditionStatus; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(RenditionStatus::New, "new"); + assert_serialization(RenditionStatus::Skipped, "skipped"); + assert_serialization(RenditionStatus::Failed, "failed"); + assert_serialization(RenditionStatus::PermanentlyFailed, "permanently_failed"); + assert_serialization(RenditionStatus::Success, "success"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("new", RenditionStatus::New); + assert_deserialization("skipped", RenditionStatus::Skipped); + assert_deserialization("failed", RenditionStatus::Failed); + assert_deserialization("permanently_failed", RenditionStatus::PermanentlyFailed); + assert_deserialization("success", RenditionStatus::Success); + } + #[test] fn variants_count_check() { assert_eq!(RenditionStatus::iter().count(), 5); diff --git a/crates/schema/public/enums_api/src/by_table/web_scraping_targets/scraping_status.rs b/crates/schema/public/enums_api/src/by_table/web_scraping_targets/scraping_status.rs index b712ef2495..6eea0aafcb 100644 --- a/crates/schema/public/enums_api/src/by_table/web_scraping_targets/scraping_status.rs +++ b/crates/schema/public/enums_api/src/by_table/web_scraping_targets/scraping_status.rs @@ -24,11 +24,30 @@ pub enum ScrapingStatus { #[cfg(test)] mod tests { use super::ScrapingStatus; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(ScrapingStatus::New, "new"); + assert_serialization(ScrapingStatus::Skipped, "skipped"); + assert_serialization(ScrapingStatus::Failed, "failed"); + assert_serialization(ScrapingStatus::PermanentlyFailed, "permanently_failed"); + assert_serialization(ScrapingStatus::Success, "success"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("new", ScrapingStatus::New); + assert_deserialization("skipped", ScrapingStatus::Skipped); + assert_deserialization("failed", ScrapingStatus::Failed); + assert_deserialization("permanently_failed", ScrapingStatus::PermanentlyFailed); + assert_deserialization("success", ScrapingStatus::Success); + } + #[test] fn variants_count_check() { assert_eq!(ScrapingStatus::iter().count(), 5); diff --git a/crates/schema/public/enums_api/src/by_table/zs_voices/encoding_type.rs b/crates/schema/public/enums_api/src/by_table/zs_voices/encoding_type.rs index 3b683f1211..5d1fb108a0 100644 --- a/crates/schema/public/enums_api/src/by_table/zs_voices/encoding_type.rs +++ b/crates/schema/public/enums_api/src/by_table/zs_voices/encoding_type.rs @@ -17,11 +17,22 @@ pub enum ZsVoiceEncodingType { #[cfg(test)] mod tests { use super::ZsVoiceEncodingType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(ZsVoiceEncodingType::Encodec, "encodec"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("encodec", ZsVoiceEncodingType::Encodec); + } + #[test] fn variants_count_check() { assert_eq!(ZsVoiceEncodingType::iter().count(), 1); diff --git a/crates/schema/public/enums_api/src/by_table/zs_voices/model_category.rs b/crates/schema/public/enums_api/src/by_table/zs_voices/model_category.rs index 7dcd2c986a..31eb19e68a 100644 --- a/crates/schema/public/enums_api/src/by_table/zs_voices/model_category.rs +++ b/crates/schema/public/enums_api/src/by_table/zs_voices/model_category.rs @@ -17,11 +17,22 @@ pub enum ZsVoiceModelCategory { #[cfg(test)] mod tests { use super::ZsVoiceModelCategory; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(ZsVoiceModelCategory::Tts, "tts"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("tts", ZsVoiceModelCategory::Tts); + } + #[test] fn variants_count_check() { assert_eq!(ZsVoiceModelCategory::iter().count(), 1); diff --git a/crates/schema/public/enums_api/src/by_table/zs_voices/model_type.rs b/crates/schema/public/enums_api/src/by_table/zs_voices/model_type.rs index 629bc7dc91..2864d4211d 100644 --- a/crates/schema/public/enums_api/src/by_table/zs_voices/model_type.rs +++ b/crates/schema/public/enums_api/src/by_table/zs_voices/model_type.rs @@ -19,11 +19,24 @@ pub enum ZsVoiceModelType { #[cfg(test)] mod tests { use super::ZsVoiceModelType; + use enums_shared::test_helpers::{assert_deserialization, assert_serialization}; use strum::IntoEnumIterator; mod manual_checks { use super::*; + #[test] + fn test_serialization() { + assert_serialization(ZsVoiceModelType::VallEX, "vall-e-x"); + assert_serialization(ZsVoiceModelType::StyleTTS2, "styletts2"); + } + + #[test] + fn test_deserialization() { + assert_deserialization("vall-e-x", ZsVoiceModelType::VallEX); + assert_deserialization("styletts2", ZsVoiceModelType::StyleTTS2); + } + #[test] fn variants_count_check() { assert_eq!(ZsVoiceModelType::iter().count(), 2);