// ImageGenerator / VideoGenerator adapters: the exact request each one would // send (plan), loud refusal of options a provider cannot honour, and the // rule that submit() without confirm makes no network call. #include "support.h" #include "vendors/media/bfl/bfl.h" #include "vendors/media/common/registry.h" #include "vendors/media/fal/fal.h" #include "vendors/media/higgsfield/higgsfield.h" #include "vendors/media/ideogram/ideogram.h" #include "vendors/media/kling/kling.h" #include "vendors/media/leonardo/leonardo.h" #include "vendors/media/luma/luma.h" #include "vendors/media/minimax/minimax.h" #include "vendors/media/recraft/recraft.h" #include "vendors/media/replicate/replicate.h" #include "vendors/media/runway/runway.h" #include "vendors/media/stability/stability.h" using namespace molo::media; using namespace media_test; namespace { ImageRequest image(const std::string& model = "") { ImageRequest r; r.prompt = "a lighthouse at dusk"; r.model = model; return r; } VideoRequest video(const std::string& model = "") { VideoRequest r; r.prompt = "waves rolling in"; r.model = model; return r; } std::string target(const Json& plan) { return plan.find("target")->as_string(); } std::string body_of(const Json& plan) { return plan.find("body") ? plan.find("body")->dump() : ""; } } // namespace TEST(media_adapter, stability_picks_the_endpoint_from_the_model) { ASSERT_EQ(StabilityImageGenerator::key_for(""), std::string("stable-image.generate.core")); ASSERT_EQ(StabilityImageGenerator::key_for("ultra"), std::string("stable-image.generate.ultra")); ASSERT_EQ(StabilityImageGenerator::key_for("sd3.5-large"), std::string("stable-image.generate.sd3")); ASSERT_THROW(StabilityImageGenerator::key_for("dall-e"), ApiError); Mock m; StabilityImageGenerator g(StabilityClient::with(m.take(), "KEY")); ImageRequest r = image("sd3.5-large"); r.aspect_ratio = "16:9"; r.seed = 42; Json p = g.plan(r); ASSERT_EQ(target(p), std::string("/v2beta/stable-image/generate/sd3")); ASSERT_TRUE(has(body_of(p), "\"aspect_ratio\":\"16:9\"")); ASSERT_TRUE(has(body_of(p), "\"model\":\"sd3.5-large\"")); ASSERT_TRUE(has(body_of(p), "\"seed\":42")); ImageRequest wh = image(); wh.width = 512; wh.height = 512; ASSERT_THROW(g.plan(wh), ApiError); // stability sizes by aspect ratio only ImageRequest many = image(); many.count = 2; ASSERT_THROW(g.plan(many), ApiError); ImageRequest src = image(); src.source_url = "https://example.com/in.png"; ASSERT_THROW(g.plan(src), ApiError); ASSERT_THROW(g.submit(image(), false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, bfl_models_and_options) { Mock m; BflImageGenerator g(BflClient::with(m.take(), "KEY")); ImageRequest r = image("flux-kontext-pro"); r.aspect_ratio = "1:1"; Json p = g.plan(r); ASSERT_EQ(target(p), std::string("/v1/flux-kontext-pro")); ASSERT_TRUE(has(body_of(p), "\"aspect_ratio\":\"1:1\"")); ImageRequest wh = image("flux-kontext-pro"); // kontext takes aspect_ratio, not width / height wh.width = 1024; wh.height = 1024; ASSERT_THROW(g.plan(wh), ApiError); ImageRequest def = image(); def.width = 1024; def.height = 768; ASSERT_EQ(target(g.plan(def)), std::string("/v1/flux-2-pro")); // default model ImageRequest many = image(); many.count = 3; ASSERT_THROW(g.plan(many), ApiError); ImageRequest unknown = image("flux-9000"); ASSERT_THROW(g.plan(unknown), ApiError); // not in the table ASSERT_THROW(g.submit(def, false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); BflVideoGenerator v(BflClient::with(std::make_unique(), "KEY")); VideoRequest vr = video(); vr.duration_seconds = 5; vr.aspect_ratio = "16:9"; Json vp = v.plan(vr); ASSERT_EQ(target(vp), std::string("/v1/flux-3-video")); ASSERT_TRUE(has(body_of(vp), "\"duration\":5")); } TEST(media_adapter, replicate_needs_owner_name_and_maps_common_fields_into_input) { Mock m; ReplicateImageGenerator g(ReplicateClient::with(m.take(), "KEY")); ImageRequest r = image("black-forest-labs/flux-schnell"); r.aspect_ratio = "3:2"; r.count = 2; r.seed = 9; Json p = g.plan(r); ASSERT_EQ(target(p), std::string("/models/black-forest-labs/flux-schnell/predictions")); ASSERT_TRUE(has(body_of(p), "\"num_outputs\":2")); ASSERT_TRUE(has(body_of(p), "\"aspect_ratio\":\"3:2\"")); ASSERT_THROW(g.plan(image()), ApiError); ASSERT_THROW(g.plan(image("flux-schnell")), ApiError); ASSERT_THROW(g.submit(r, false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); ReplicateVideoGenerator v(ReplicateClient::with(std::make_unique(), "KEY")); VideoRequest vr = video("minimax/video-01"); vr.image_url = "https://example.com/a.png"; Json vp = v.plan(vr); ASSERT_TRUE(has(body_of(vp), "\"image\":\"https://example.com/a.png\"")); } TEST(media_adapter, fal_takes_any_endpoint_id) { Mock m; FalImageGenerator g(FalQueue::with(m.take(), "id:secret")); ImageRequest r = image("fal-ai/flux/dev"); r.width = 1024; r.height = 576; r.count = 2; Json p = g.plan(r); ASSERT_EQ(target(p), std::string("/fal-ai/flux/dev")); ASSERT_TRUE(has(body_of(p), "\"image_size\":{\"height\":576,\"width\":1024}")); ASSERT_TRUE(has(body_of(p), "\"num_images\":2")); ASSERT_THROW(g.plan(image()), ApiError); ASSERT_THROW(g.submit(r, false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); FalVideoGenerator v(FalQueue::with(std::make_unique(), "id:secret")); VideoRequest vr = video("fal-ai/kling-video/v2.1/master/text-to-video"); vr.duration_seconds = 5; Json vp = v.plan(vr); ASSERT_EQ(target(vp), std::string("/fal-ai/kling-video/v2.1/master/text-to-video")); ASSERT_TRUE(has(body_of(vp), "\"duration\":\"5\"")); } TEST(media_adapter, ideogram_models_map_to_rows_and_edit_inputs_are_files) { Mock m; IdeogramImageGenerator g(IdeogramClient::with(m.take(), "KEY")); ASSERT_EQ(IdeogramImageGenerator::key_for(""), std::string("image.generate.ideogram-3")); ImageRequest r = image("ideogram-4"); r.count = 2; r.width = 1024; r.height = 1024; Json p = g.plan(r); ASSERT_EQ(target(p), std::string("/v2/image/generate/ideogram-4")); ASSERT_TRUE(has(body_of(p), "\"resolution\":\"1024x1024\"")); ImageRequest src = image(); src.source_url = "https://example.com/in.png"; ASSERT_THROW(g.plan(src), ApiError); ASSERT_THROW(g.plan(image("ideogram-99")), ApiError); ASSERT_THROW(g.submit(image(), false), ApiError); IdeogramVideoGenerator v(IdeogramClient::with(std::make_unique(), "KEY")); ASSERT_THROW(v.plan(video()), ApiError); // a video model is required Json vp = v.plan(video("kling-3-standard-text-to-video")); ASSERT_EQ(target(vp), std::string("/v2/video/generate/kling-3-standard-text-to-video")); ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, recraft_sizes_by_wxh) { Mock m; RecraftImageGenerator g(RecraftClient::with(m.take(), "KEY")); ImageRequest r = image("recraftv3"); r.width = 1024; r.height = 1024; r.count = 2; Json p = g.plan(r); ASSERT_EQ(target(p), std::string("/v1/images/generations")); ASSERT_TRUE(has(body_of(p), "\"size\":\"1024x1024\"")); ASSERT_TRUE(has(body_of(p), "\"n\":2")); ImageRequest ar = image(); ar.aspect_ratio = "16:9"; ASSERT_THROW(g.plan(ar), ApiError); ASSERT_THROW(g.submit(r, false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, leonardo_wraps_parameters_and_never_publishes) { Mock m; LeonardoImageGenerator g(LeonardoClient::with(m.take(), "KEY")); ImageRequest r = image("flux-dev"); r.width = 1024; r.height = 1024; r.count = 4; Json p = g.plan(r); ASSERT_EQ(target(p), std::string("/v2/generations")); ASSERT_TRUE(has(body_of(p), "\"model\":\"flux-dev\"")); ASSERT_TRUE(has(body_of(p), "\"public\":false")); ASSERT_TRUE(has(body_of(p), "\"quantity\":4")); ASSERT_THROW(g.plan(image()), ApiError); // model required ImageRequest ar = image("flux-dev"); ar.aspect_ratio = "1:1"; ASSERT_THROW(g.plan(ar), ApiError); ASSERT_THROW(g.submit(r, false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, runway_chooses_text_or_image_to_video) { Mock m; RunwayVideoGenerator g(RunwayClient::with(m.take(), "KEY")); VideoRequest t = video(); t.duration_seconds = 5; t.aspect_ratio = "1280:720"; ASSERT_EQ(target(g.plan(t)), std::string("/v1/text_to_video")); ASSERT_TRUE(has(body_of(g.plan(t)), "\"model\":\"gen4.5\"")); VideoRequest i = video(); i.image_url = "https://example.com/a.png"; ASSERT_EQ(target(g.plan(i)), std::string("/v1/image_to_video")); ASSERT_TRUE(has(body_of(g.plan(i)), "\"model\":\"gen4_turbo\"")); ASSERT_TRUE(has(body_of(g.plan(i)), "\"promptImage\"")); RunwayImageGenerator ig(RunwayClient::with(std::make_unique(), "KEY")); ImageRequest r = image(); r.width = 1280; r.height = 720; Json p = ig.plan(r); ASSERT_EQ(target(p), std::string("/v1/text_to_image")); ASSERT_TRUE(has(body_of(p), "\"ratio\":\"1280:720\"")); ASSERT_TRUE(has(body_of(p), "\"promptText\"")); ASSERT_THROW(g.submit(t, false), ApiError); ASSERT_THROW(ig.cancel(JobTicket{}, false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, luma_durations_are_strings_and_keyframes_nest_frames) { Mock m; LumaVideoGenerator g(LumaClient::with(m.take(), "KEY")); VideoRequest v = video(); v.duration_seconds = 5; v.image_url = "https://example.com/start.png"; v.end_image_url = "https://example.com/end.png"; Json p = g.plan(v); ASSERT_EQ(target(p), std::string("/generations/video")); ASSERT_TRUE(has(body_of(p), "\"duration\":\"5s\"")); ASSERT_TRUE(has(body_of(p), "\"frame0\":{\"type\":\"image\",\"url\":\"https://example.com/start.png\"}")); ASSERT_TRUE(has(body_of(p), "\"frame1\"")); ASSERT_TRUE(has(body_of(p), "\"model\":\"ray-2\"")); LumaImageGenerator ig(LumaClient::with(std::make_unique(), "KEY")); ImageRequest wh = image(); wh.width = 512; wh.height = 512; ASSERT_THROW(ig.plan(wh), ApiError); ASSERT_EQ(target(ig.plan(image())), std::string("/generations/image")); ASSERT_THROW(g.cancel(JobTicket{}, false), ApiError); // cancel deletes: confirm required ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, minimax_refuses_options_v1_does_not_have) { Mock m; MinimaxVideoGenerator g(MinimaxClient::with(m.take(), "KEY")); VideoRequest v = video(); v.duration_seconds = 6; v.resolution = "768p"; Json p = g.plan(v); ASSERT_EQ(target(p), std::string("/v1/video_generation")); ASSERT_TRUE(has(body_of(p), "\"resolution\":\"768P\"")); ASSERT_TRUE(has(body_of(p), "\"model\":\"MiniMax-Hailuo-2.3\"")); VideoRequest ar = video(); ar.aspect_ratio = "16:9"; ASSERT_THROW(g.plan(ar), ApiError); VideoRequest sd = video(); sd.seed = 5; ASSERT_THROW(g.plan(sd), ApiError); ASSERT_THROW(g.submit(v, false), ApiError); ASSERT_FALSE(g.cancel(JobTicket{}, true)); // not supported, says so without a call ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, kling_and_higgsfield) { auto kc = std::make_shared("AK", "SK", [] { return std::make_unique(); }); KlingVideoGenerator k(kc); VideoRequest v = video(); v.duration_seconds = 5; Json p = k.plan(v); ASSERT_EQ(target(p), std::string("/v1/videos/text2video")); ASSERT_TRUE(has(body_of(p), "\"model_name\":\"kling-v1-6\"")); ASSERT_TRUE(has(body_of(p), "\"duration\":\"5\"")); VideoRequest i = video(); i.image_url = "https://example.com/a.png"; ASSERT_EQ(target(k.plan(i)), std::string("/v1/videos/image2video")); VideoRequest sd = video(); sd.seed = 1; ASSERT_THROW(k.plan(sd), ApiError); ASSERT_THROW(k.submit(v, false), ApiError); Mock m; HiggsfieldImageGenerator h(HiggsfieldClient::with(m.take(), "id", "secret")); Json hp = h.plan(image()); ASSERT_EQ(target(hp), std::string("/higgsfield-ai/soul/standard")); ImageRequest wh = image(); wh.width = 512; wh.height = 512; ASSERT_THROW(h.plan(wh), ApiError); HiggsfieldVideoGenerator hv(HiggsfieldClient::with(std::make_unique(), "id", "secret")); ASSERT_THROW(hv.plan(video()), ApiError); // model path required ASSERT_EQ(target(hv.plan(video("kling-video/v2.5-turbo/pro/text-to-video"))), std::string("/kling-video/v2.5-turbo/pro/text-to-video")); ASSERT_THROW(h.cancel(JobTicket{}, false), ApiError); ASSERT_EQ(m.raw->send_count(), static_cast(0)); } TEST(media_adapter, registry_builds_a_generator_for_every_declared_capability) { MediaRegistry reg; for (const ProviderInfo& p : MediaRegistry::providers()) { if (p.image) { auto g = reg.image(p.id); ASSERT_EQ(g->provider(), p.id); ASSERT_FALSE(g->models().empty()); } else { ASSERT_THROW(reg.image(p.id), ApiError); } if (p.video) { auto g = reg.video(p.id); ASSERT_EQ(g->provider(), p.id); ASSERT_FALSE(g->models().empty()); } else { ASSERT_THROW(reg.video(p.id), ApiError); } ASSERT_TRUE(reg.service(p.id) != nullptr); } ASSERT_THROW(reg.image("midjourney"), ApiError); ASSERT_THROW(reg.service("pika"), ApiError); } TEST(media_adapter, every_default_model_resolves_to_a_row_in_its_table) { // A model named by models() must plan cleanly where the adapter derives the row from it. MediaRegistry reg; ImageRequest r = image(); for (const std::string& model : reg.image("bfl")->models()) { r.model = model; r.width = 0; r.height = 0; if (model.rfind("flux-kontext", 0) == 0) r.aspect_ratio = "1:1"; else r.aspect_ratio = ""; if (model == "flux-3-image") continue; // takes images[], aspect_ratio: covered by the table test r.aspect_ratio = ""; reg.image("bfl")->plan(r); } for (const std::string& model : reg.image("ideogram")->models()) { r.model = model; r.aspect_ratio = ""; r.width = 0; r.height = 0; reg.image("ideogram")->plan(r); } for (const std::string& model : reg.video("ideogram")->models()) { VideoRequest v = video(model); reg.video("ideogram")->plan(v); } for (const std::string& model : reg.video("higgsfield")->models()) reg.video("higgsfield")->plan(video(model)); }