Files
moloapp/tests/src/vendors/media/test_adapters.cpp
T
retoorandClaude Sonnet 5.5 5a0c18d0e0 feat(clients): media: image and video generation across 12 providers behind one job seam
Stability, BFL, Runway, Luma, Replicate, fal, Ideogram, Recraft, Leonardo,
MiniMax, Kling, Higgsfield: call tables checked against vendor specs/SDKs,
ImageGenerator/VideoGenerator seam with capped polling, /ai/media demo.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 15:19:43 +01:00

362 lines
14 KiB
C++

// 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<std::size_t>(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<std::size_t>(0));
BflVideoGenerator v(BflClient::with(std::make_unique<MockTransport>(), "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<std::size_t>(0));
ReplicateVideoGenerator v(ReplicateClient::with(std::make_unique<MockTransport>(), "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<std::size_t>(0));
FalVideoGenerator v(FalQueue::with(std::make_unique<MockTransport>(), "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<MockTransport>(), "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<std::size_t>(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<std::size_t>(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<std::size_t>(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<MockTransport>(), "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<std::size_t>(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<MockTransport>(), "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<std::size_t>(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<std::size_t>(0));
}
TEST(media_adapter, kling_and_higgsfield) {
auto kc = std::make_shared<KlingClient>("AK", "SK", [] { return std::make_unique<MockTransport>(); });
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<MockTransport>(), "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<std::size_t>(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));
}