Merge branch 'worktree-agent-a1e8651ad784c651f'
This commit is contained in:
Vendored
+57
@@ -0,0 +1,57 @@
|
||||
#pragma once
|
||||
|
||||
// Shared rig for the media tests. A MockTransport only RECORDS the requests
|
||||
// the real clients build; the few replies it serves are labelled FIXTURE
|
||||
// (verbatim vendor documentation) or EMPTY (no content, the assertion is on
|
||||
// our request). Nothing here verifies vendor behavior: see
|
||||
// src/vendors/media/SPEC.md "Unverified".
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "clients/transports/mock_transport.h"
|
||||
#include "framework.h"
|
||||
#include "llm/error.h"
|
||||
#include "vendors/media/common/job.h"
|
||||
#include "vendors/media/common/media_service.h"
|
||||
|
||||
namespace media_test {
|
||||
|
||||
using molo::clients::ClientResponse;
|
||||
using molo::clients::HeaderMap;
|
||||
using molo::clients::Method;
|
||||
using molo::clients::transports::MockExpectation;
|
||||
using molo::clients::transports::MockTransport;
|
||||
using molo::llm::ApiError;
|
||||
using molo::media::Json;
|
||||
|
||||
inline ClientResponse reply(const std::string& body, int status = 200,
|
||||
const std::string& type = "application/json") {
|
||||
HeaderMap h;
|
||||
h.set("Content-Type", type);
|
||||
return ClientResponse(status, h, body);
|
||||
}
|
||||
|
||||
// EMPTY: a 200 with `{}`; used only to let the real client finish a request
|
||||
// whose OUTGOING shape the test inspects.
|
||||
inline ClientResponse empty_ok() { return reply("{}"); }
|
||||
|
||||
inline bool has(const std::string& hay, const std::string& needle) { return hay.find(needle) != std::string::npos; }
|
||||
|
||||
// Allows a path to answer several times.
|
||||
inline void serve(MockTransport* t, Method m, const std::string& path, ClientResponse r, int times = 8) {
|
||||
MockExpectation e;
|
||||
e.method = m;
|
||||
e.path = path;
|
||||
e.response = std::move(r);
|
||||
e.times = times;
|
||||
t->expect(e);
|
||||
}
|
||||
|
||||
struct Mock {
|
||||
std::unique_ptr<MockTransport> owned = std::make_unique<MockTransport>();
|
||||
MockTransport* raw = owned.get();
|
||||
std::unique_ptr<molo::clients::Transport> take() { return std::move(owned); }
|
||||
};
|
||||
|
||||
} // namespace media_test
|
||||
+361
@@ -0,0 +1,361 @@
|
||||
// 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));
|
||||
}
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
// Call tables: structure of every provider table, CallTable rules, registry.
|
||||
#include <set>
|
||||
|
||||
#include "support.h"
|
||||
#include "vendors/media/common/registry.h"
|
||||
|
||||
using namespace molo::media;
|
||||
using namespace media_test;
|
||||
|
||||
namespace {
|
||||
|
||||
struct Expect {
|
||||
const char* id;
|
||||
std::size_t rows; // rows declared from the published spec / SDK / docs (see SPEC.md)
|
||||
};
|
||||
|
||||
const Expect kExpected[] = {
|
||||
{"stability", 34}, {"bfl", 30}, {"replicate", 36}, {"fal", 16}, {"ideogram", 70}, {"recraft", 22},
|
||||
{"leonardo", 6}, {"runway", 66}, {"luma", 13}, {"minimax", 7}, {"kling", 6}, {"higgsfield", 10},
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(media_tables, every_provider_has_the_declared_row_count) {
|
||||
for (const Expect& e : kExpected) {
|
||||
const std::string id = e.id;
|
||||
const CallTable& t = MediaRegistry::table(id);
|
||||
ASSERT_EQ(t.size(), e.rows);
|
||||
ASSERT_EQ(t.vendor(), std::string(e.id));
|
||||
}
|
||||
ASSERT_EQ(MediaRegistry::providers().size(), sizeof(kExpected) / sizeof(kExpected[0]));
|
||||
}
|
||||
|
||||
TEST(media_tables, rows_are_well_formed) {
|
||||
for (const Expect& e : kExpected) {
|
||||
const std::string id = e.id;
|
||||
const CallTable& t = MediaRegistry::table(id);
|
||||
std::set<std::string> seen;
|
||||
for (std::size_t i = 0; i < t.size(); ++i) {
|
||||
const CallRow& r = t.at(i);
|
||||
ASSERT_TRUE(seen.insert(r.key).second);
|
||||
std::string method = r.http_method;
|
||||
std::string kind = r.body_kind;
|
||||
// a body-less method never declares body fields
|
||||
if (method == "GET" || method == "DELETE") ASSERT_TRUE(kind == "none");
|
||||
if (kind == "none") ASSERT_EQ(std::string(r.body_fields), std::string(""));
|
||||
if (kind != "none") ASSERT_TRUE(method != "GET");
|
||||
// destructive rows are DELETE or an explicit delete_* call
|
||||
if (CallTable::effect_of(r) == Effect::kDelete)
|
||||
ASSERT_TRUE(method == "DELETE" || std::string(r.key).find("delete") != std::string::npos);
|
||||
// every GET reads
|
||||
if (method == "GET") ASSERT_TRUE(CallTable::effect_of(r) == Effect::kRead);
|
||||
// placeholders are non-empty and unique within a path
|
||||
std::set<std::string> ph;
|
||||
for (const std::string& p : CallTable::placeholders(r.path)) {
|
||||
ASSERT_FALSE(p.empty());
|
||||
ASSERT_TRUE(ph.insert(p).second);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(media_tables, paid_rows_exist_for_every_generating_provider) {
|
||||
for (const Expect& e : kExpected) {
|
||||
const std::string id = e.id;
|
||||
const CallTable& t = MediaRegistry::table(id);
|
||||
std::size_t paid = 0;
|
||||
for (std::size_t i = 0; i < t.size(); ++i)
|
||||
if (CallTable::effect_of(t.at(i)) == Effect::kPaid) ++paid;
|
||||
ASSERT_TRUE(paid >= 1);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(media_tables, rejects_a_malformed_table) {
|
||||
static const CallRow dup[] = {{"a", "GET", "/x", "", "none", "", "", "read"}, {"a", "GET", "/y", "", "none", "", "", "read"}};
|
||||
ASSERT_THROW(CallTable("t", dup, 2), std::logic_error);
|
||||
static const CallRow badm[] = {{"a", "FETCH", "/x", "", "none", "", "", "read"}};
|
||||
ASSERT_THROW(CallTable("t", badm, 1), std::logic_error);
|
||||
static const CallRow badk[] = {{"a", "GET", "/x", "", "blob", "", "", "read"}};
|
||||
ASSERT_THROW(CallTable("t", badk, 1), std::logic_error);
|
||||
static const CallRow bade[] = {{"a", "GET", "/x", "", "none", "", "", "free"}};
|
||||
ASSERT_THROW(CallTable("t", bade, 1), std::logic_error);
|
||||
static const CallRow badp[] = {{"a", "GET", "x", "", "none", "", "", "read"}};
|
||||
ASSERT_THROW(CallTable("t", badp, 1), std::logic_error);
|
||||
}
|
||||
|
||||
TEST(media_tables, path_rendering_validates_every_argument) {
|
||||
static const CallRow rows[] = {
|
||||
{"one", "GET", "/a/{id}/b/{name}", "", "none", "", "", "read"},
|
||||
{"multi", "GET", "/{endpoint_id}/x", "", "none", "", "", "read"},
|
||||
};
|
||||
CallTable t("t", rows, 2);
|
||||
ASSERT_EQ(t.render_path(t.get("one"), {{"id", "abc-1"}, {"name", "n.v"}}), std::string("/a/abc-1/b/n.v"));
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", "abc"}}), ApiError); // missing
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", "a"}, {"name", "b"}, {"x", "c"}}), ApiError); // extra
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", "../x"}, {"name", "b"}}), ApiError); // traversal
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", "a/b"}, {"name", "b"}}), ApiError); // slash in a segment
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", ".."}, {"name", "b"}}), ApiError);
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", ""}, {"name", "b"}}), ApiError);
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", "a b"}, {"name", "b"}}), ApiError);
|
||||
ASSERT_THROW(t.render_path(t.get("one"), {{"id", std::string(257, 'a')}, {"name", "b"}}), ApiError);
|
||||
ASSERT_EQ(t.render_path(t.get("multi"), {{"endpoint_id", "fal-ai/flux/dev"}}), std::string("/fal-ai/flux/dev/x"));
|
||||
ASSERT_THROW(t.render_path(t.get("multi"), {{"endpoint_id", "a//b"}}), ApiError);
|
||||
ASSERT_THROW(t.render_path(t.get("multi"), {{"endpoint_id", "a/b/c/d/e/f/g"}}), ApiError); // 7 segments
|
||||
ASSERT_THROW(t.get("nope"), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_tables, segment_alphabet_matches_the_documented_id_shapes) {
|
||||
ASSERT_TRUE(CallTable::valid_segment("cneqzikepnug6xezperrr4z55o")); // Replicate file id
|
||||
ASSERT_TRUE(CallTable::valid_segment("d7e6c0f3-6699-4f6c-bb45-2ad7fd9158ff")); // Higgsfield uuid
|
||||
ASSERT_TRUE(CallTable::valid_segment("abc_DEF-123==")); // URL-safe base64 with padding
|
||||
ASSERT_FALSE(CallTable::valid_segment("a?b"));
|
||||
ASSERT_FALSE(CallTable::valid_segment("a#b"));
|
||||
ASSERT_FALSE(CallTable::valid_segment("a%2fb"));
|
||||
}
|
||||
|
||||
TEST(media_registry, lists_unsupported_products_with_a_reason) {
|
||||
const auto& u = MediaRegistry::unsupported();
|
||||
ASSERT_EQ(u.size(), static_cast<std::size_t>(2));
|
||||
ASSERT_EQ(u[0].name, std::string("Midjourney"));
|
||||
ASSERT_TRUE(has(u[0].reason, "No public API"));
|
||||
ASSERT_EQ(u[1].name, std::string("Pika"));
|
||||
for (const auto& x : u) ASSERT_TRUE(x.reason.size() > 40);
|
||||
}
|
||||
|
||||
TEST(media_registry, every_provider_declares_credentials_evidence_and_a_console) {
|
||||
for (const ProviderInfo& p : MediaRegistry::providers()) {
|
||||
ASSERT_FALSE(p.env.empty());
|
||||
ASSERT_TRUE(p.image || p.video);
|
||||
ASSERT_TRUE(p.console_url.rfind("https://", 0) == 0);
|
||||
ASSERT_TRUE(p.note.size() > 10);
|
||||
if (!p.account_key.empty()) {
|
||||
const CallRow& r = MediaRegistry::table(p.id).get(p.account_key);
|
||||
ASSERT_TRUE(CallTable::effect_of(r) == Effect::kRead); // the credential proof never costs money
|
||||
}
|
||||
}
|
||||
ASSERT_EQ(std::string(MediaRegistry::evidence_name(MediaRegistry::find("kling")->evidence)), std::string("probe-only"));
|
||||
ASSERT_EQ(std::string(MediaRegistry::evidence_name(MediaRegistry::find("bfl")->evidence)), std::string("openapi"));
|
||||
ASSERT_TRUE(MediaRegistry::find("midjourney") == nullptr);
|
||||
ASSERT_THROW(MediaRegistry::table("midjourney"), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_registry, required_environment_variables_are_the_documented_ones) {
|
||||
auto env = [](const char* id) { return MediaRegistry::find(id)->env; };
|
||||
ASSERT_EQ(env("stability")[0], std::string("STABILITY_API_KEY"));
|
||||
ASSERT_EQ(env("bfl")[0], std::string("BFL_API_KEY"));
|
||||
ASSERT_EQ(env("runway")[0], std::string("RUNWAY_API_KEY"));
|
||||
ASSERT_EQ(env("luma")[0], std::string("LUMA_API_KEY"));
|
||||
ASSERT_EQ(env("replicate")[0], std::string("REPLICATE_API_TOKEN"));
|
||||
ASSERT_EQ(env("fal")[0], std::string("FAL_KEY"));
|
||||
ASSERT_EQ(env("ideogram")[0], std::string("IDEOGRAM_API_KEY"));
|
||||
ASSERT_EQ(env("recraft")[0], std::string("RECRAFT_API_TOKEN"));
|
||||
ASSERT_EQ(env("leonardo")[0], std::string("LEONARDO_API_KEY"));
|
||||
}
|
||||
+414
@@ -0,0 +1,414 @@
|
||||
// The neutral job seam: request validation, JobRunner caps (with a fake
|
||||
// generator: local logic only), output scanning, status mappers, downloader
|
||||
// rules. Inputs to the mappers are hand-built (LOCAL-LOGIC): they exercise our
|
||||
// code, they are not claims about what a vendor returns.
|
||||
#include <vector>
|
||||
|
||||
#include "support.h"
|
||||
#include "vendors/media/bfl/bfl.h"
|
||||
#include "vendors/media/common/caps.h"
|
||||
#include "vendors/media/common/downloader.h"
|
||||
#include "vendors/media/common/job_runner.h"
|
||||
#include "vendors/media/common/output_scanner.h"
|
||||
#include "vendors/media/higgsfield/higgsfield.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/runway/runway.h"
|
||||
|
||||
using namespace molo::media;
|
||||
using namespace media_test;
|
||||
|
||||
namespace {
|
||||
|
||||
Json obj(std::initializer_list<std::pair<const char*, Json>> items) {
|
||||
Json o = Json::object();
|
||||
for (const auto& [k, v] : items) o.set(k, v);
|
||||
return o;
|
||||
}
|
||||
|
||||
Json arr(std::initializer_list<Json> items) {
|
||||
Json a = Json::array();
|
||||
for (const Json& v : items) a.push(v);
|
||||
return a;
|
||||
}
|
||||
|
||||
// Local fake: finishes after `finish_after` polls (0 = never).
|
||||
class FakeGenerator : public ImageGenerator {
|
||||
public:
|
||||
explicit FakeGenerator(int finish_after, JobState end = JobState::kSucceeded) : finish_after_(finish_after), end_(end) {}
|
||||
std::string provider() const override { return "fake"; }
|
||||
bool configured() const override { return true; }
|
||||
std::vector<std::string> models() const override { return {"m"}; }
|
||||
Json plan(const ImageRequest&) const override { return Json::object(); }
|
||||
JobTicket submit(const ImageRequest&, bool) override { return JobTicket{}; }
|
||||
JobStatus poll(const JobTicket&) override {
|
||||
++polls;
|
||||
JobStatus s;
|
||||
if (finish_after_ > 0 && polls >= finish_after_) {
|
||||
s.state = end_;
|
||||
if (end_ == JobState::kFailed) s.error = "boom";
|
||||
MediaAsset a;
|
||||
a.url = "https://example.com/out.png";
|
||||
if (end_ == JobState::kSucceeded) s.assets.push_back(a);
|
||||
} else {
|
||||
s.state = JobState::kRunning;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
bool cancel(const JobTicket&, bool) override { return false; }
|
||||
int suggested_poll_ms() const override { return 100; } // below the floor on purpose
|
||||
int polls = 0;
|
||||
|
||||
private:
|
||||
int finish_after_;
|
||||
JobState end_;
|
||||
};
|
||||
|
||||
struct Clockwork {
|
||||
long now = 0;
|
||||
std::vector<int> slept;
|
||||
JobRunner::Sleeper sleeper() {
|
||||
return [this](int ms) {
|
||||
slept.push_back(ms);
|
||||
now += ms;
|
||||
};
|
||||
}
|
||||
JobRunner::Clock clock() {
|
||||
return [this] { return now; };
|
||||
}
|
||||
};
|
||||
|
||||
JobTicket ticket(const std::string& id = "j1") {
|
||||
JobTicket t;
|
||||
t.provider = "fake";
|
||||
t.id = id;
|
||||
return t;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ------------------------------------------------------------------ JobRunner
|
||||
|
||||
TEST(media_runner, polls_until_terminal_and_applies_the_interval_floor_and_backoff) {
|
||||
Clockwork w;
|
||||
FakeGenerator g(5);
|
||||
WaitPolicy p;
|
||||
p.backoff = 2.0;
|
||||
p.max_interval_ms = 3000;
|
||||
JobRunner r(p, w.sleeper(), w.clock());
|
||||
JobStatus s = r.wait(g, ticket());
|
||||
ASSERT_TRUE(s.state == JobState::kSucceeded);
|
||||
ASSERT_EQ(g.polls, 5);
|
||||
// suggestion 100 ms is lifted to the 500 ms floor, then doubles, capped at 3000
|
||||
ASSERT_EQ(w.slept.size(), static_cast<std::size_t>(4));
|
||||
ASSERT_EQ(w.slept[0], 500);
|
||||
ASSERT_EQ(w.slept[1], 1000);
|
||||
ASSERT_EQ(w.slept[2], 2000);
|
||||
ASSERT_EQ(w.slept[3], 3000);
|
||||
}
|
||||
|
||||
TEST(media_runner, a_failed_job_is_a_status_not_an_exception) {
|
||||
Clockwork w;
|
||||
FakeGenerator g(2, JobState::kFailed);
|
||||
JobRunner r({}, w.sleeper(), w.clock());
|
||||
JobStatus s = r.wait(g, ticket());
|
||||
ASSERT_TRUE(s.state == JobState::kFailed);
|
||||
ASSERT_EQ(s.error, std::string("boom"));
|
||||
}
|
||||
|
||||
TEST(media_runner, attempt_cap_throws_loudly_and_does_not_cancel) {
|
||||
Clockwork w;
|
||||
FakeGenerator g(0);
|
||||
WaitPolicy p;
|
||||
p.max_attempts = 3;
|
||||
JobRunner r(p, w.sleeper(), w.clock());
|
||||
try {
|
||||
r.wait(g, ticket("job-77"));
|
||||
FAIL("expected WAIT_EXPIRED");
|
||||
} catch (const ApiError& e) {
|
||||
ASSERT_EQ(e.type(), std::string("WAIT_EXPIRED"));
|
||||
ASSERT_EQ(e.http_status(), 504);
|
||||
ASSERT_TRUE(has(e.message(), "job-77"));
|
||||
ASSERT_TRUE(has(e.message(), "NOT cancelled"));
|
||||
}
|
||||
ASSERT_EQ(g.polls, 3);
|
||||
}
|
||||
|
||||
TEST(media_runner, total_wait_cap_stops_before_sleeping_past_the_deadline) {
|
||||
Clockwork w;
|
||||
FakeGenerator g(0);
|
||||
WaitPolicy p;
|
||||
p.max_wait_seconds = 5;
|
||||
p.max_attempts = 200;
|
||||
p.first_interval_ms = 2000;
|
||||
p.backoff = 1.0;
|
||||
JobRunner r(p, w.sleeper(), w.clock());
|
||||
ASSERT_THROW(r.wait(g, ticket()), ApiError);
|
||||
long total = 0;
|
||||
for (int s : w.slept) total += s;
|
||||
ASSERT_TRUE(total <= 5000);
|
||||
ASSERT_TRUE(g.polls <= 4);
|
||||
}
|
||||
|
||||
TEST(media_runner, immediate_tickets_need_no_poll) {
|
||||
Clockwork w;
|
||||
FakeGenerator g(0);
|
||||
JobTicket t = ticket();
|
||||
t.immediate = true;
|
||||
MediaAsset a;
|
||||
a.data_base64 = "AAAA";
|
||||
t.assets.push_back(a);
|
||||
JobStatus s = JobRunner({}, w.sleeper(), w.clock()).wait(g, t);
|
||||
ASSERT_TRUE(s.state == JobState::kSucceeded);
|
||||
ASSERT_EQ(g.polls, 0);
|
||||
ASSERT_EQ(s.assets.size(), static_cast<std::size_t>(1));
|
||||
}
|
||||
|
||||
TEST(media_runner, policy_values_outside_the_caps_are_rejected) {
|
||||
auto bad = [](auto edit) {
|
||||
WaitPolicy p;
|
||||
edit(p);
|
||||
return p;
|
||||
};
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.max_attempts = 0; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.max_attempts = MediaCaps::kMaxPollAttempts + 1; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.max_wait_seconds = MediaCaps::kMaxWaitSeconds + 1; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.max_wait_seconds = 0; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.backoff = 0.9; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.backoff = 3.5; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.max_interval_ms = MediaCaps::kMinPollIntervalMs - 1; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.max_interval_ms = MediaCaps::kMaxPollIntervalMs + 1; })), ApiError);
|
||||
ASSERT_THROW(JobRunner(bad([](WaitPolicy& p) { p.first_interval_ms = -1; })), ApiError);
|
||||
JobRunner ok{WaitPolicy{}};
|
||||
ASSERT_EQ(ok.policy().max_attempts, 120);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------- requests
|
||||
|
||||
TEST(media_requests, image_validation) {
|
||||
ImageRequest r;
|
||||
ASSERT_THROW(r.validate(), ApiError); // no prompt
|
||||
r.prompt = "a cat";
|
||||
r.validate();
|
||||
r.count = 0;
|
||||
ASSERT_THROW(r.validate(), ApiError);
|
||||
r.count = MediaCaps::kMaxImagesPerRequest + 1;
|
||||
ASSERT_THROW(r.validate(), ApiError);
|
||||
r.count = 1;
|
||||
r.width = 512;
|
||||
ASSERT_THROW(r.validate(), ApiError); // width without height
|
||||
r.height = MediaCaps::kMaxDimension + 1;
|
||||
ASSERT_THROW(r.validate(), ApiError);
|
||||
r.height = 512;
|
||||
r.validate();
|
||||
r.seed = -2;
|
||||
ASSERT_THROW(r.validate(), ApiError);
|
||||
r.seed = 4294967296L;
|
||||
ASSERT_THROW(r.validate(), ApiError);
|
||||
r.seed = 7;
|
||||
r.extra = Json(5);
|
||||
ASSERT_THROW(r.validate(), ApiError);
|
||||
r.extra = Json::object();
|
||||
r.prompt = std::string(MediaCaps::kMaxPromptChars + 1, 'x');
|
||||
ASSERT_THROW(r.validate(), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_requests, video_validation) {
|
||||
VideoRequest v;
|
||||
ASSERT_THROW(v.validate(), ApiError);
|
||||
v.image_url = "https://example.com/a.png"; // image-to-video needs no prompt
|
||||
v.validate();
|
||||
v.duration_seconds = MediaCaps::kMaxVideoSeconds + 1;
|
||||
ASSERT_THROW(v.validate(), ApiError);
|
||||
v.duration_seconds = 5;
|
||||
v.validate();
|
||||
v.duration_seconds = -1;
|
||||
ASSERT_THROW(v.validate(), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_requests, ticket_and_status_json) {
|
||||
JobTicket t;
|
||||
t.provider = "fal";
|
||||
t.id = "r1";
|
||||
t.model = "fal-ai/flux/dev";
|
||||
t.kind = MediaKind::kVideo;
|
||||
t.meta = obj({{"endpoint", Json("fal-ai/flux/dev")}});
|
||||
JobTicket back = JobTicket::from_json(t.to_json());
|
||||
ASSERT_EQ(back.provider, std::string("fal"));
|
||||
ASSERT_EQ(back.id, std::string("r1"));
|
||||
ASSERT_TRUE(back.kind == MediaKind::kVideo);
|
||||
ASSERT_EQ(back.meta.find("endpoint")->as_string(), std::string("fal-ai/flux/dev"));
|
||||
ASSERT_THROW(JobTicket::from_json(Json(1)), ApiError);
|
||||
ASSERT_THROW(JobTicket::from_json(obj({{"provider", Json("x")}})), ApiError);
|
||||
JobStatus s;
|
||||
s.state = JobState::kRunning;
|
||||
s.progress = 0.5;
|
||||
ASSERT_TRUE(has(s.to_json().dump(), "\"state\":\"running\""));
|
||||
ASSERT_FALSE(s.terminal());
|
||||
s.state = JobState::kCancelled;
|
||||
ASSERT_TRUE(s.terminal());
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------- OutputScanner
|
||||
|
||||
TEST(media_scanner, finds_urls_in_the_shapes_providers_use) {
|
||||
// fal style: images[].url and video.url
|
||||
auto fal = OutputScanner::scan(obj({{"images", arr({obj({{"url", Json("https://v3.fal.media/a.png")}})})},
|
||||
{"video", obj({{"url", Json("https://v3.fal.media/b.mp4")}})}}),
|
||||
MediaKind::kImage);
|
||||
ASSERT_EQ(fal.size(), static_cast<std::size_t>(2));
|
||||
ASSERT_TRUE(fal[0].kind == MediaKind::kImage);
|
||||
ASSERT_EQ(fal[0].mime, std::string("image/png"));
|
||||
ASSERT_TRUE(fal[1].kind == MediaKind::kVideo);
|
||||
// Replicate style: a bare string, or an array
|
||||
ASSERT_EQ(OutputScanner::scan(Json("https://replicate.delivery/x/out.webp"), MediaKind::kImage).size(), static_cast<std::size_t>(1));
|
||||
ASSERT_EQ(OutputScanner::scan(arr({Json("https://a/1.png"), Json("https://a/2.png")}), MediaKind::kImage).size(), static_cast<std::size_t>(2));
|
||||
// non-URL strings are ignored
|
||||
ASSERT_EQ(OutputScanner::scan(arr({Json("hello"), Json("ftp://x/y.png")}), MediaKind::kImage).size(), static_cast<std::size_t>(0));
|
||||
}
|
||||
|
||||
TEST(media_scanner, skips_request_echoes_and_control_links_and_dedupes) {
|
||||
Json doc = obj({{"input", obj({{"image", Json("https://in/source.png")}})},
|
||||
{"urls", obj({{"get", Json("https://api.replicate.com/v1/predictions/p1")}})},
|
||||
{"status_url", Json("https://api.higgsfield.ai/requests/x/status")},
|
||||
{"output", arr({Json("https://out/a.png"), Json("https://out/a.png")})}});
|
||||
auto found = OutputScanner::scan(doc, MediaKind::kImage);
|
||||
ASSERT_EQ(found.size(), static_cast<std::size_t>(1));
|
||||
ASSERT_EQ(found[0].url, std::string("https://out/a.png"));
|
||||
}
|
||||
|
||||
TEST(media_scanner, data_urls_become_inline_assets_and_caps_hold) {
|
||||
auto d = OutputScanner::scan(Json("data:image/png;base64,iVBORw0KGgo="), MediaKind::kOther);
|
||||
ASSERT_EQ(d.size(), static_cast<std::size_t>(1));
|
||||
ASSERT_EQ(d[0].mime, std::string("image/png"));
|
||||
ASSERT_EQ(d[0].data_base64, std::string("iVBORw0KGgo="));
|
||||
ASSERT_TRUE(d[0].kind == MediaKind::kImage);
|
||||
Json many = Json::array();
|
||||
for (int i = 0; i < 100; ++i) many.push(Json("https://x/" + std::to_string(i) + ".png"));
|
||||
ASSERT_EQ(OutputScanner::scan(many, MediaKind::kImage).size(), MediaCaps::kMaxAssetsPerJob);
|
||||
Json deep = Json("https://deep/out.png");
|
||||
for (int i = 0; i < 20; ++i) deep = obj({{"k", deep}});
|
||||
ASSERT_EQ(OutputScanner::scan(deep, MediaKind::kImage).size(), static_cast<std::size_t>(0)); // depth cap
|
||||
ASSERT_TRUE(OutputScanner::kind_from_name("https://x/a.GLB?sig=1", MediaKind::kOther) == MediaKind::kModel3d);
|
||||
ASSERT_TRUE(OutputScanner::kind_from_name("https://x/a.wav", MediaKind::kOther) == MediaKind::kAudio);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ status mappers
|
||||
|
||||
TEST(media_status, bfl_words) {
|
||||
ASSERT_TRUE(BflImageGenerator::state_of("Ready") == JobState::kSucceeded);
|
||||
ASSERT_TRUE(BflImageGenerator::state_of("Pending") == JobState::kQueued);
|
||||
ASSERT_TRUE(BflImageGenerator::state_of("Generating") == JobState::kRunning);
|
||||
for (const char* w : {"Error", "Request Moderated", "Content Moderated", "Task not found", "No Card Generated"})
|
||||
ASSERT_TRUE(BflImageGenerator::state_of(w) == JobState::kFailed);
|
||||
ASSERT_TRUE(BflImageGenerator::state_of("something new") == JobState::kRunning); // unknown = keep polling, bounded by caps
|
||||
}
|
||||
|
||||
TEST(media_status, runway_tasks) {
|
||||
JobStatus ok = RunwayJobs::status_of(obj({{"status", Json("SUCCEEDED")}, {"output", arr({Json("https://r/v.mp4")})}}), MediaKind::kVideo);
|
||||
ASSERT_TRUE(ok.state == JobState::kSucceeded);
|
||||
ASSERT_TRUE(ok.assets[0].kind == MediaKind::kVideo);
|
||||
JobStatus empty = RunwayJobs::status_of(obj({{"status", Json("SUCCEEDED")}}), MediaKind::kVideo);
|
||||
ASSERT_TRUE(empty.state == JobState::kFailed);
|
||||
JobStatus run = RunwayJobs::status_of(obj({{"status", Json("RUNNING")}, {"progress", Json(0.4)}}), MediaKind::kVideo);
|
||||
ASSERT_TRUE(run.state == JobState::kRunning);
|
||||
ASSERT_TRUE(run.progress > 0.39 && run.progress < 0.41);
|
||||
JobStatus fail = RunwayJobs::status_of(obj({{"status", Json("FAILED")}, {"failure", Json("moderation")}, {"failureCode", Json("SAFETY")}}), MediaKind::kVideo);
|
||||
ASSERT_EQ(fail.error, std::string("moderation (SAFETY)"));
|
||||
ASSERT_TRUE(RunwayJobs::status_of(obj({{"status", Json("CANCELLED")}}), MediaKind::kVideo).state == JobState::kCancelled);
|
||||
ASSERT_TRUE(RunwayJobs::status_of(obj({{"status", Json("THROTTLED")}}), MediaKind::kVideo).state == JobState::kQueued);
|
||||
ASSERT_TRUE(RunwayJobs::status_of(obj({{"status", Json("PENDING")}}), MediaKind::kVideo).state == JobState::kQueued);
|
||||
}
|
||||
|
||||
TEST(media_status, luma_generations_ignore_the_progress_preview) {
|
||||
Json done = obj({{"state", Json("completed")},
|
||||
{"assets", obj({{"video", Json("https://l/final.mp4")}, {"progress_video", Json("https://l/progress.mp4")}})}});
|
||||
JobStatus s = LumaJobs::status_of(done, MediaKind::kVideo);
|
||||
ASSERT_TRUE(s.state == JobState::kSucceeded);
|
||||
ASSERT_EQ(s.assets.size(), static_cast<std::size_t>(1));
|
||||
ASSERT_EQ(s.assets[0].url, std::string("https://l/final.mp4"));
|
||||
ASSERT_TRUE(LumaJobs::status_of(obj({{"state", Json("dreaming")}}), MediaKind::kVideo).state == JobState::kRunning);
|
||||
ASSERT_TRUE(LumaJobs::status_of(obj({{"state", Json("queued")}}), MediaKind::kVideo).state == JobState::kQueued);
|
||||
JobStatus f = LumaJobs::status_of(obj({{"state", Json("failed")}, {"failure_reason", Json("nope")}}), MediaKind::kVideo);
|
||||
ASSERT_EQ(f.error, std::string("nope"));
|
||||
}
|
||||
|
||||
TEST(media_status, word_maps_of_minimax_higgsfield_kling) {
|
||||
ASSERT_TRUE(MinimaxVideoGenerator::state_of("Success") == JobState::kSucceeded);
|
||||
ASSERT_TRUE(MinimaxVideoGenerator::state_of("Fail") == JobState::kFailed);
|
||||
ASSERT_TRUE(MinimaxVideoGenerator::state_of("Processing") == JobState::kRunning);
|
||||
ASSERT_TRUE(MinimaxVideoGenerator::state_of("Queueing") == JobState::kQueued);
|
||||
ASSERT_TRUE(MinimaxVideoGenerator::state_of("Preparing") == JobState::kQueued);
|
||||
for (const char* w : {"completed"}) ASSERT_TRUE(HiggsfieldJobs::state_of(w) == JobState::kSucceeded);
|
||||
ASSERT_TRUE(HiggsfieldJobs::state_of("nsfw") == JobState::kFailed);
|
||||
ASSERT_TRUE(HiggsfieldJobs::state_of("failed") == JobState::kFailed);
|
||||
ASSERT_TRUE(HiggsfieldJobs::state_of("canceled") == JobState::kCancelled);
|
||||
ASSERT_TRUE(HiggsfieldJobs::state_of("in_progress") == JobState::kRunning);
|
||||
ASSERT_TRUE(HiggsfieldJobs::state_of("queued") == JobState::kQueued);
|
||||
ASSERT_TRUE(KlingVideoGenerator::state_of("succeed") == JobState::kSucceeded);
|
||||
ASSERT_TRUE(KlingVideoGenerator::state_of("failed") == JobState::kFailed);
|
||||
ASSERT_TRUE(KlingVideoGenerator::state_of("processing") == JobState::kRunning);
|
||||
ASSERT_TRUE(KlingVideoGenerator::state_of("submitted") == JobState::kQueued);
|
||||
}
|
||||
|
||||
TEST(media_status, leonardo_generation_shape_is_read_from_generations_by_pk) {
|
||||
Json done = obj({{"generations_by_pk", obj({{"status", Json("COMPLETE")},
|
||||
{"generated_images", arr({obj({{"url", Json("https://cdn.leonardo.ai/a.jpg")}, {"id", Json("i1")}})})}})}});
|
||||
JobStatus s = LeonardoJobs::status_of(done, MediaKind::kImage);
|
||||
ASSERT_TRUE(s.state == JobState::kSucceeded);
|
||||
ASSERT_EQ(s.assets.size(), static_cast<std::size_t>(1));
|
||||
ASSERT_TRUE(LeonardoJobs::status_of(obj({{"generations_by_pk", obj({{"status", Json("PENDING")}})}}), MediaKind::kImage).state == JobState::kRunning);
|
||||
ASSERT_TRUE(LeonardoJobs::status_of(obj({{"generations_by_pk", obj({{"status", Json("FAILED")}})}}), MediaKind::kImage).state == JobState::kFailed);
|
||||
ASSERT_TRUE(LeonardoJobs::status_of(obj({{"generations_by_pk", obj({{"status", Json("COMPLETE")}})}}), MediaKind::kImage).state == JobState::kFailed);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------- downloader
|
||||
|
||||
TEST(media_downloader, url_rules) {
|
||||
Downloader::validate_url("https://cdn.example.com/a.png?sig=abc");
|
||||
for (const char* bad : {"", "http://example.com/a.png", "ftp://x/y", "https://", "https:///path", "https://u:p@example.com/a",
|
||||
"https://exa mple.com/a", "javascript:alert(1)", "file:///etc/passwd", "data:image/png;base64,AA=="})
|
||||
ASSERT_THROW(Downloader::validate_url(bad), ApiError);
|
||||
ASSERT_THROW(Downloader::validate_url("https://x/" + std::string(MediaCaps::kMaxUrlChars, 'a')), ApiError);
|
||||
ASSERT_THROW(Downloader::validate_url("https://x/a\nb"), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_downloader, inline_assets_decode_without_network) {
|
||||
Mock m;
|
||||
MockTransport* t = m.raw;
|
||||
Downloader d(m.take());
|
||||
MediaAsset a;
|
||||
a.data_base64 = "aGVsbG8=";
|
||||
a.mime = "image/png";
|
||||
FetchedAsset f = d.fetch(a);
|
||||
ASSERT_EQ(f.bytes, std::string("hello"));
|
||||
ASSERT_EQ(f.content_type, std::string("image/png"));
|
||||
MediaAsset bad;
|
||||
bad.data_base64 = "@@@";
|
||||
ASSERT_THROW(d.fetch(bad), ApiError);
|
||||
ASSERT_THROW(d.fetch(MediaAsset{}), ApiError);
|
||||
MediaAsset insecure;
|
||||
insecure.url = "http://example.com/x.png";
|
||||
ASSERT_THROW(d.fetch(insecure), ApiError);
|
||||
ASSERT_EQ(t->send_count(), static_cast<std::size_t>(0));
|
||||
}
|
||||
|
||||
TEST(media_downloader, sends_no_credential_and_maps_failures) {
|
||||
Mock m;
|
||||
serve(m.raw, Method::kGet, "/missing.png", reply("not found", 404, "text/plain"));
|
||||
MockTransport* t = m.raw;
|
||||
Downloader d(m.take());
|
||||
try {
|
||||
d.fetch_url("https://cdn.example.com/missing.png");
|
||||
FAIL("expected a download failure");
|
||||
} catch (const ApiError& e) {
|
||||
ASSERT_EQ(e.type(), std::string("DOWNLOAD_FAILED"));
|
||||
ASSERT_EQ(e.http_status(), 404);
|
||||
}
|
||||
auto seen = t->seen();
|
||||
ASSERT_EQ(seen.size(), static_cast<std::size_t>(1));
|
||||
ASSERT_FALSE(seen[0].headers.get("Authorization").has_value());
|
||||
ASSERT_FALSE(seen[0].headers.get("x-key").has_value());
|
||||
}
|
||||
+106
@@ -0,0 +1,106 @@
|
||||
// Opt-in live checks. MOLO_LIVE_NET=1 enables the network; a provider's key
|
||||
// (via llm::Config) enables its read-only calls (account, balance, models).
|
||||
// Anything that spends money additionally needs MOLO_LIVE_PAID=1 and is
|
||||
// limited to a free price quote where the provider offers one (Ideogram
|
||||
// dry_run) - this file never submits a generation. Without the variables each
|
||||
// test prints a loud SKIP. Nothing is created or deleted.
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include "clients/transports/http_transport.h"
|
||||
#include "support.h"
|
||||
#include "vendors/media/common/downloader.h"
|
||||
#include "vendors/media/common/registry.h"
|
||||
#include "vendors/media/bfl/bfl.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 {
|
||||
|
||||
// Read once at startup: other suites in this binary unset MOLO_LIVE_NET while they run.
|
||||
const bool kLiveNet = std::getenv("MOLO_LIVE_NET") != nullptr;
|
||||
const bool kLivePaid = std::getenv("MOLO_LIVE_PAID") != nullptr;
|
||||
bool net() { return kLiveNet; }
|
||||
|
||||
void skip(const std::string& name, const std::string& why) { std::cout << "SKIP " << name << " (" << why << ")\n"; }
|
||||
|
||||
// Unauthenticated probe: a deliberately invalid key must be refused (the host
|
||||
// resolves, TLS works, the documented path exists). `accept` lists the HTTP
|
||||
// statuses seen on 2026-10-25: BFL answers 422 for a malformed key, MiniMax
|
||||
// answers 200 with base_resp 1004 (turned into an ApiError by the client).
|
||||
template <class Fn>
|
||||
void expect_refused(const std::string& name, Fn call, std::initializer_list<int> accept = {401, 403}) {
|
||||
try {
|
||||
call();
|
||||
FAIL(name << ": an invalid key was accepted");
|
||||
} catch (const ApiError& e) {
|
||||
std::cout << " " << name << ": " << e.http_status() << " " << e.type() << "\n";
|
||||
bool ok = false;
|
||||
for (int a : accept) ok = ok || e.http_status() == a;
|
||||
ASSERT_TRUE(ok);
|
||||
}
|
||||
}
|
||||
|
||||
std::unique_ptr<molo::clients::Transport> real() { return std::make_unique<molo::clients::transports::HttpTransport>(); }
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(media_live, invalid_keys_are_refused_by_every_provider) {
|
||||
if (!net()) return skip("media_live.invalid_keys_are_refused", "set MOLO_LIVE_NET=1");
|
||||
const std::string bad = "molo-invalid-probe";
|
||||
expect_refused("stability", [&] { StabilityClient::with(real(), bad)->balance(); });
|
||||
expect_refused("bfl", [&] { BflClient::with(real(), bad)->credits(); }, {401, 403, 422});
|
||||
expect_refused("replicate", [&] { ReplicateClient::with(real(), bad)->account(); });
|
||||
expect_refused("fal.platform", [&] { FalPlatform::with(real(), bad)->pricing("fal-ai/flux/dev"); });
|
||||
expect_refused("fal.queue", [&] { FalQueue::with(real(), bad)->status(FalEndpoint::parse("fal-ai/flux/dev"), "00000000-0000-0000-0000-000000000000"); });
|
||||
expect_refused("ideogram", [&] { IdeogramClient::with(real(), bad)->api_keys(); });
|
||||
expect_refused("recraft", [&] { RecraftClient::with(real(), bad)->me(); });
|
||||
expect_refused("leonardo", [&] { LeonardoClient::with(real(), bad)->models(); });
|
||||
expect_refused("runway", [&] { RunwayClient::with(real(), bad)->organization(); });
|
||||
expect_refused("luma", [&] { LumaClient::with(real(), bad)->credits(); });
|
||||
expect_refused("minimax", [&] { MinimaxClient::with(real(), bad)->query_video("1"); }, {400});
|
||||
expect_refused("kling", [&] { std::make_shared<KlingClient>("AK-invalid-probe", "SK-invalid-probe")->get("text2video.get", "0"); });
|
||||
expect_refused("higgsfield", [&] { HiggsfieldClient::with(real(), "a", "b")->status("00000000-0000-0000-0000-000000000000"); });
|
||||
}
|
||||
|
||||
TEST(media_live, read_only_account_calls_for_every_configured_provider) {
|
||||
MediaRegistry reg;
|
||||
int ran = 0;
|
||||
for (const ProviderInfo& p : MediaRegistry::providers()) {
|
||||
const std::string name = "media_live.account." + p.id;
|
||||
if (!net()) {
|
||||
skip(name, "set MOLO_LIVE_NET=1");
|
||||
continue;
|
||||
}
|
||||
if (!MediaRegistry::configured(p.id)) {
|
||||
skip(name, "set " + p.env[0]);
|
||||
continue;
|
||||
}
|
||||
if (p.account_key.empty()) {
|
||||
skip(name, p.id + " has no free account read");
|
||||
continue;
|
||||
}
|
||||
Json out = reg.account(p.id);
|
||||
std::cout << " " << p.id << " " << p.account_key << " -> " << out.dump().substr(0, 120) << "\n";
|
||||
ASSERT_TRUE(out.is_object());
|
||||
++ran;
|
||||
}
|
||||
std::cout << " account reads run: " << ran << "\n";
|
||||
}
|
||||
|
||||
TEST(media_live, paid_calls_are_not_exercised_here) {
|
||||
if (!kLivePaid) return skip("media_live.paid", "set MOLO_LIVE_PAID=1 (and read this file: nothing paid runs even then)");
|
||||
std::cout << " MOLO_LIVE_PAID is set; this file still submits no generation. Use the demo with confirm:true by hand.\n";
|
||||
}
|
||||
+430
@@ -0,0 +1,430 @@
|
||||
// Requests built from the call tables: exact targets, bodies, headers, field
|
||||
// validation and the confirmation gate. No reply is scripted except where a
|
||||
// fixture is labelled; prepare() itself never touches a transport.
|
||||
#include "support.h"
|
||||
#include "vendors/media/common/caps.h"
|
||||
#include "vendors/media/bfl/bfl.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 {
|
||||
Json obj(std::initializer_list<std::pair<const char*, Json>> items) {
|
||||
Json o = Json::object();
|
||||
for (const auto& [k, v] : items) o.set(k, v);
|
||||
return o;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
// ------------------------------------------------------------------ Stability
|
||||
|
||||
TEST(media_prepare, stability_generate_is_multipart_with_json_accept) {
|
||||
Mock m;
|
||||
auto c = StabilityClient::with(m.take(), "KEY");
|
||||
PreparedCall p = c->plan("stable-image.generate.core", obj({{"prompt", Json("a cat")}, {"output_format", Json("png")}}), {});
|
||||
ASSERT_EQ(p.method, std::string("POST"));
|
||||
ASSERT_EQ(p.target, std::string("/v2beta/stable-image/generate/core"));
|
||||
ASSERT_TRUE(has(p.content_type, "multipart/form-data; boundary="));
|
||||
ASSERT_TRUE(has(p.body, "name=\"prompt\""));
|
||||
ASSERT_TRUE(has(p.body, "a cat"));
|
||||
ASSERT_EQ(p.headers.at("Accept"), std::string("application/json"));
|
||||
ASSERT_TRUE(p.effect == Effect::kPaid);
|
||||
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
||||
}
|
||||
|
||||
TEST(media_prepare, stability_files_must_use_a_declared_field_and_fit_the_cap) {
|
||||
Mock m;
|
||||
auto c = StabilityClient::with(m.take(), "KEY");
|
||||
FilePart img{"image", "in.png", "image/png", "\x89PNG-bytes"};
|
||||
PreparedCall p = c->plan("stable-image.upscale.fast", obj({{"output_format", Json("webp")}}), {img});
|
||||
ASSERT_TRUE(has(p.body, "filename=\"in.png\""));
|
||||
ASSERT_TRUE(has(p.body, "Content-Type: image/png"));
|
||||
ASSERT_THROW(c->plan("stable-image.upscale.fast", Json::object(), {FilePart{"picture", "a.png", "image/png", "x"}}), ApiError);
|
||||
ASSERT_THROW(c->plan("stable-image.upscale.fast", Json::object(), {FilePart{"image", "a.png", "image/png", ""}}), ApiError);
|
||||
ASSERT_THROW(c->plan("stable-image.upscale.fast", Json::object(),
|
||||
{FilePart{"image", "a.png", "image/png", std::string(MediaCaps::kMaxFileBytes + 1, 'x')}}), ApiError);
|
||||
ASSERT_THROW(c->plan("stable-image.upscale.fast", Json::object(), {FilePart{"image", "a\".png", "image/png", "x"}}), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_prepare, stability_rejects_unknown_fields_and_unknown_calls) {
|
||||
Mock m;
|
||||
auto c = StabilityClient::with(m.take(), "KEY");
|
||||
ASSERT_THROW(c->plan("stable-image.generate.core", obj({{"prompt", Json("x")}, {"bogus", Json(1)}}), {}), ApiError);
|
||||
ASSERT_THROW(c->plan("stable-image.generate.nothing", Json::object(), {}), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_prepare, stability_result_ids_are_validated_before_any_traffic) {
|
||||
Mock m;
|
||||
auto c = StabilityClient::with(m.take(), "KEY");
|
||||
ASSERT_THROW(c->result("../etc"), ApiError);
|
||||
ASSERT_THROW(c->result("a/b"), ApiError);
|
||||
ASSERT_THROW(c->audio_result(""), ApiError);
|
||||
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
||||
}
|
||||
|
||||
TEST(media_prepare, stability_v1_text_to_image_is_json_with_an_engine_in_the_path) {
|
||||
Mock m;
|
||||
auto c = StabilityClient::with(m.take(), "KEY");
|
||||
CallArgs a;
|
||||
a.path["engine_id"] = "stable-diffusion-xl-1024-v1-0";
|
||||
a.body = obj({{"samples", Json(1)}, {"steps", Json(30)}});
|
||||
PreparedCall p = c->prepare("v1.generation.id.text-to-image", a);
|
||||
ASSERT_EQ(p.target, std::string("/v1/generation/stable-diffusion-xl-1024-v1-0/text-to-image"));
|
||||
ASSERT_EQ(p.content_type, std::string("application/json"));
|
||||
ASSERT_EQ(p.body, std::string("{\"samples\":1,\"steps\":30}"));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------ BFL
|
||||
|
||||
TEST(media_prepare, bfl_body_is_json_and_query_is_encoded) {
|
||||
Mock m;
|
||||
auto c = BflClient::with(m.take(), "KEY");
|
||||
PreparedCall p = c->plan("flux-2-pro", obj({{"prompt", Json("x")}, {"width", Json(1024)}, {"height", Json(768)}, {"seed", Json(7)}}));
|
||||
ASSERT_EQ(p.target, std::string("/v1/flux-2-pro"));
|
||||
ASSERT_EQ(p.body, std::string("{\"height\":768,\"prompt\":\"x\",\"seed\":7,\"width\":1024}"));
|
||||
CallArgs a;
|
||||
a.query["id"] = "a b&c";
|
||||
PreparedCall g = c->prepare("get_result", a);
|
||||
ASSERT_EQ(g.target, std::string("/v1/get_result?id=a%20b%26c"));
|
||||
ASSERT_EQ(g.body, std::string(""));
|
||||
CallArgs bad;
|
||||
bad.query["nope"] = "1";
|
||||
ASSERT_THROW(c->prepare("get_result", bad), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_prepare, bfl_sends_the_x_key_header_and_never_a_bearer) {
|
||||
Mock m;
|
||||
serve(m.raw, Method::kGet, "/v1/credits", empty_ok());
|
||||
MockTransport* t = m.raw;
|
||||
auto c = BflClient::with(m.take(), "SECRET-KEY");
|
||||
c->credits();
|
||||
auto seen = t->seen();
|
||||
ASSERT_EQ(seen.size(), static_cast<std::size_t>(1));
|
||||
ASSERT_EQ(*seen[0].headers.get("x-key"), std::string("SECRET-KEY"));
|
||||
ASSERT_FALSE(seen[0].headers.get("Authorization").has_value());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ Replicate
|
||||
|
||||
TEST(media_prepare, replicate_official_model_and_pinned_version_use_different_rows) {
|
||||
Mock m;
|
||||
auto c = ReplicateClient::with(m.take(), "KEY");
|
||||
Json in = obj({{"prompt", Json("a cat")}});
|
||||
PreparedCall a = c->plan_prediction(ReplicateClient::ModelRef::parse("black-forest-labs/flux-schnell"), in, Json::object());
|
||||
ASSERT_EQ(a.target, std::string("/models/black-forest-labs/flux-schnell/predictions"));
|
||||
ASSERT_EQ(a.body, std::string("{\"input\":{\"prompt\":\"a cat\"}}"));
|
||||
PreparedCall b = c->plan_prediction(ReplicateClient::ModelRef::parse("owner/name:abc123"), in, Json::object());
|
||||
ASSERT_EQ(b.target, std::string("/predictions"));
|
||||
ASSERT_EQ(b.body, std::string("{\"input\":{\"prompt\":\"a cat\"},\"version\":\"abc123\"}"));
|
||||
Json hook = obj({{"webhook", Json("https://example.com/h")}, {"webhook_events_filter", Json::array()}});
|
||||
PreparedCall w = c->plan_prediction(ReplicateClient::ModelRef::parse("o/n"), in, hook);
|
||||
ASSERT_TRUE(has(w.body, "\"webhook\":\"https://example.com/h\""));
|
||||
ASSERT_THROW(c->plan_prediction(ReplicateClient::ModelRef::parse("o/n"), in, obj({{"nope", Json(1)}})), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_prepare, replicate_model_references_are_validated) {
|
||||
using R = ReplicateClient::ModelRef;
|
||||
ASSERT_THROW(R::parse("justaname"), ApiError);
|
||||
ASSERT_THROW(R::parse("a/b/c"), ApiError);
|
||||
ASSERT_THROW(R::parse("a/../b"), ApiError);
|
||||
ASSERT_THROW(R::parse("a/b:v/x"), ApiError);
|
||||
ASSERT_THROW(R::parse("/b"), ApiError);
|
||||
R ok = R::parse("o/n:v1");
|
||||
ASSERT_EQ(ok.owner, std::string("o"));
|
||||
ASSERT_EQ(ok.version, std::string("v1"));
|
||||
}
|
||||
|
||||
TEST(media_prepare, replicate_uses_the_v1_base_and_bearer_auth) {
|
||||
Mock m;
|
||||
serve(m.raw, Method::kGet, "/v1/account", empty_ok());
|
||||
MockTransport* t = m.raw;
|
||||
auto c = ReplicateClient::with(m.take(), "tok");
|
||||
c->account();
|
||||
auto seen = t->seen();
|
||||
ASSERT_EQ(seen[0].target, std::string("/v1/account"));
|
||||
ASSERT_EQ(*seen[0].headers.get("Authorization"), std::string("Bearer tok"));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------ fal
|
||||
|
||||
TEST(media_prepare, fal_endpoint_ids_split_into_owner_app_path) {
|
||||
FalEndpoint e = FalEndpoint::parse("fal-ai/flux/dev");
|
||||
ASSERT_EQ(e.owner, std::string("fal-ai"));
|
||||
ASSERT_EQ(e.app, std::string("flux"));
|
||||
ASSERT_EQ(e.path, std::string("dev"));
|
||||
ASSERT_EQ(e.app_id(), std::string("fal-ai/flux"));
|
||||
FalEndpoint two = FalEndpoint::parse("fal-ai/veo3");
|
||||
ASSERT_EQ(two.path, std::string(""));
|
||||
FalEndpoint deep = FalEndpoint::parse("fal-ai/kling-video/v2.1/master/text-to-video");
|
||||
ASSERT_EQ(deep.path, std::string("v2.1/master/text-to-video"));
|
||||
ASSERT_THROW(FalEndpoint::parse("only"), ApiError);
|
||||
ASSERT_THROW(FalEndpoint::parse("a/../b"), ApiError);
|
||||
ASSERT_THROW(FalEndpoint::parse("a//b"), ApiError);
|
||||
ASSERT_THROW(FalEndpoint::parse("a/b/c/d/e/f"), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_prepare, fal_submit_carries_priority_header_and_webhook_query) {
|
||||
Mock m;
|
||||
auto q = FalQueue::with(m.take(), "id:secret");
|
||||
FalSubmitOptions o;
|
||||
o.priority = "high";
|
||||
o.webhook = "https://example.com/h";
|
||||
o.max_queue_length = 3;
|
||||
PreparedCall p = q->plan(FalEndpoint::parse("fal-ai/flux/dev"), obj({{"prompt", Json("x")}}), o);
|
||||
ASSERT_EQ(p.method, std::string("POST"));
|
||||
ASSERT_EQ(p.target, std::string("/fal-ai/flux/dev?fal_max_queue_length=3&fal_webhook=https%3A%2F%2Fexample.com%2Fh"));
|
||||
ASSERT_EQ(p.headers.at("X-Fal-Queue-Priority"), std::string("high"));
|
||||
ASSERT_EQ(p.body, std::string("{\"prompt\":\"x\"}"));
|
||||
PreparedCall two = q->plan(FalEndpoint::parse("fal-ai/veo3"), Json::object(), FalSubmitOptions{});
|
||||
ASSERT_EQ(two.target, std::string("/fal-ai/veo3"));
|
||||
FalSubmitOptions bad;
|
||||
bad.priority = "urgent";
|
||||
ASSERT_THROW(q->plan(FalEndpoint::parse("fal-ai/veo3"), Json::object(), bad), ApiError);
|
||||
}
|
||||
|
||||
TEST(media_prepare, fal_status_result_and_cancel_use_owner_app_only) {
|
||||
Mock m;
|
||||
auto q = FalQueue::with(m.take(), "k");
|
||||
ASSERT_THROW(q->status(FalEndpoint::parse("fal-ai/flux/dev"), "../x"), ApiError);
|
||||
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
||||
// FIXTURE: queue.json cancelQueueRequest example 202 (verbatim, https://fal.ai/docs/api-reference/inference-api/openapi/queue.json)
|
||||
serve(m.raw, Method::kPut, "/fal-ai/flux/requests/019a1b2c/cancel", reply("{\"status\": \"CANCELLATION_REQUESTED\"}", 202));
|
||||
serve(m.raw, Method::kGet, "/fal-ai/flux/requests/019a1b2c/status", empty_ok());
|
||||
Json r = q->cancel(FalEndpoint::parse("fal-ai/flux/dev"), "019a1b2c", true);
|
||||
ASSERT_EQ(r.find("status")->as_string(), std::string("CANCELLATION_REQUESTED"));
|
||||
q->status(FalEndpoint::parse("fal-ai/flux/dev"), "019a1b2c", true);
|
||||
auto seen = m.raw->seen();
|
||||
ASSERT_EQ(seen[0].method, std::string("PUT"));
|
||||
ASSERT_TRUE(has(seen[1].target, "/status?logs=1"));
|
||||
}
|
||||
|
||||
TEST(media_prepare, fal_sends_the_key_prefix_on_both_hosts) {
|
||||
Mock m;
|
||||
serve(m.raw, Method::kGet, "/v1/meta", empty_ok());
|
||||
MockTransport* t = m.raw;
|
||||
auto p = FalPlatform::with(m.take(), "id:secret");
|
||||
p->meta();
|
||||
ASSERT_EQ(*t->seen()[0].headers.get("Authorization"), std::string("Key id:secret"));
|
||||
ASSERT_EQ(FalQueue::header_value(""), std::string(""));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------- Ideogram
|
||||
|
||||
TEST(media_prepare, ideogram_quote_is_a_free_dry_run_and_generate_is_paid) {
|
||||
Mock m;
|
||||
auto c = IdeogramClient::with(m.take(), "KEY");
|
||||
Json f = obj({{"prompt", Json("a cat")}, {"num_images", Json(1)}});
|
||||
PreparedCall q = c->plan("image.generate.ideogram-3", f, {}, true);
|
||||
ASSERT_EQ(q.target, std::string("/v2/image/generate/ideogram-3?dry_run=true"));
|
||||
ASSERT_TRUE(has(q.content_type, "multipart/form-data")); // ideogram-3 declares multipart only
|
||||
ASSERT_TRUE(q.effect == Effect::kPaid);
|
||||
PreparedCall j = c->plan("image.generate.ideogram-4", f, {}, false);
|
||||
ASSERT_EQ(j.content_type, std::string("application/json"));
|
||||
ASSERT_EQ(j.target, std::string("/v2/image/generate/ideogram-4"));
|
||||
ASSERT_THROW(c->plan("image.generate.ideogram-3", obj({{"nope", Json(1)}}), {}), ApiError);
|
||||
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
||||
}
|
||||
|
||||
TEST(media_prepare, ideogram_uses_the_api_key_header) {
|
||||
Mock m;
|
||||
serve(m.raw, Method::kGet, "/v2/generations/abc", empty_ok());
|
||||
MockTransport* t = m.raw;
|
||||
auto c = IdeogramClient::with(m.take(), "KEY");
|
||||
c->generation("abc");
|
||||
ASSERT_EQ(*t->seen()[0].headers.get("Api-Key"), std::string("KEY"));
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------- Recraft
|
||||
|
||||
TEST(media_prepare, recraft_json_by_default_multipart_with_files) {
|
||||
Mock m;
|
||||
auto c = RecraftClient::with(m.take(), "KEY");
|
||||
PreparedCall j = c->plan("images.generations", obj({{"prompt", Json("x")}, {"n", Json(2)}}), {});
|
||||
ASSERT_EQ(j.target, std::string("/v1/images/generations"));
|
||||
ASSERT_EQ(j.body, std::string("{\"n\":2,\"prompt\":\"x\"}"));
|
||||
ASSERT_THROW(c->plan("images.generations", obj({{"prompt", Json("x")}}), {FilePart{"image", "a.png", "image/png", "x"}}),
|
||||
ApiError); // generations is JSON-only
|
||||
ASSERT_THROW(c->style("../x"), ApiError);
|
||||
ASSERT_THROW(c->delete_style("s1", false), ApiError); // gate
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------- Leonardo
|
||||
|
||||
TEST(media_prepare, leonardo_v2_create_wraps_model_and_parameters) {
|
||||
Mock m;
|
||||
auto c = LeonardoClient::with(m.take(), "KEY");
|
||||
Json b = LeonardoJobs::body("flux-dev", obj({{"prompt", Json("x")}}), false);
|
||||
PreparedCall p = c->plan(b);
|
||||
ASSERT_EQ(p.target, std::string("/v2/generations"));
|
||||
ASSERT_EQ(p.body, std::string("{\"model\":\"flux-dev\",\"parameters\":{\"prompt\":\"x\"},\"public\":false}"));
|
||||
ASSERT_THROW(c->generation("../x"), ApiError);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------- Runway
|
||||
|
||||
TEST(media_prepare, runway_sends_the_version_header_and_accepts_both_key_names) {
|
||||
Mock m;
|
||||
serve(m.raw, Method::kGet, "/v1/organization", empty_ok());
|
||||
MockTransport* t = m.raw;
|
||||
auto c = RunwayClient::with(m.take(), "KEY");
|
||||
c->organization();
|
||||
ASSERT_EQ(*t->seen()[0].headers.get("X-Runway-Version"), std::string(RunwayClient::kApiVersion));
|
||||
ASSERT_EQ(*t->seen()[0].headers.get("Authorization"), std::string("Bearer KEY"));
|
||||
ASSERT_EQ(std::string(RunwayClient::kKeyEnv), std::string("RUNWAY_API_KEY"));
|
||||
ASSERT_EQ(std::string(RunwayClient::kKeyEnvSdk), std::string("RUNWAYML_API_SECRET"));
|
||||
}
|
||||
|
||||
TEST(media_prepare, runway_task_bodies_are_checked_against_the_sdk_field_union) {
|
||||
Mock m;
|
||||
auto c = RunwayClient::with(m.take(), "KEY");
|
||||
PreparedCall p = c->plan("text_to_video", obj({{"model", Json("gen4.5")}, {"promptText", Json("x")}, {"duration", Json(5)}}));
|
||||
ASSERT_EQ(p.target, std::string("/v1/text_to_video"));
|
||||
ASSERT_THROW(c->plan("text_to_video", obj({{"promt", Json("typo")}})), ApiError);
|
||||
ASSERT_THROW(c->task("a/b"), ApiError);
|
||||
ASSERT_THROW(c->cancel_or_delete_task("t1", false), ApiError);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------ Luma
|
||||
|
||||
TEST(media_prepare, luma_paths_and_the_dream_machine_base) {
|
||||
Mock m;
|
||||
serve(m.raw, Method::kGet, "/dream-machine/v1/credits", empty_ok());
|
||||
MockTransport* t = m.raw;
|
||||
auto c = LumaClient::with(m.take(), "KEY");
|
||||
PreparedCall p = c->plan("generations.create_video", obj({{"model", Json("ray-2")}, {"prompt", Json("x")}}));
|
||||
ASSERT_EQ(p.target, std::string("/generations/video"));
|
||||
c->credits();
|
||||
ASSERT_EQ(t->seen()[0].target, std::string("/dream-machine/v1/credits"));
|
||||
CallArgs a;
|
||||
a.path["id"] = "g1";
|
||||
ASSERT_EQ(c->prepare("generations.upscale", a).target, std::string("/generations/g1/upscale"));
|
||||
ASSERT_THROW(c->remove("g1", false), ApiError);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------- MiniMax
|
||||
|
||||
TEST(media_prepare, minimax_v1_and_v2_rows) {
|
||||
Mock m;
|
||||
auto c = MinimaxClient::with(m.take(), "KEY");
|
||||
PreparedCall p = c->plan_video(obj({{"model", Json("MiniMax-Hailuo-2.3")}, {"prompt", Json("x")}, {"duration", Json(6)}}));
|
||||
ASSERT_EQ(p.target, std::string("/v1/video_generation"));
|
||||
CallArgs q;
|
||||
q.query["task_id"] = "t1";
|
||||
ASSERT_EQ(c->prepare("video.query", q).target, std::string("/v1/query/video_generation?task_id=t1"));
|
||||
CallArgs d;
|
||||
d.path["task_id"] = "t1";
|
||||
ASSERT_EQ(c->prepare("v2.video.delete", d).target, std::string("/v2/video_generation/t1"));
|
||||
ASSERT_THROW(c->delete_video_v2("t1", false), ApiError);
|
||||
Json ok = obj({{"base_resp", obj({{"status_code", Json(0)}, {"status_msg", Json("success")}})}});
|
||||
MinimaxClient::check_base_resp(ok); // no throw
|
||||
Json bad = obj({{"base_resp", obj({{"status_code", Json(1004)}, {"status_msg", Json("login fail")}})}});
|
||||
ASSERT_THROW(MinimaxClient::check_base_resp(bad), ApiError);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ Higgsfield
|
||||
|
||||
TEST(media_prepare, higgsfield_typed_rows_for_known_paths_and_a_generic_row_for_the_rest) {
|
||||
ASSERT_EQ(HiggsfieldClient::row_for("higgsfield-ai/soul/standard"), std::string("higgsfield-ai.soul.standard"));
|
||||
ASSERT_EQ(HiggsfieldClient::row_for("vendor/new-model/v9"), std::string("model.submit"));
|
||||
Mock m;
|
||||
auto c = HiggsfieldClient::with(m.take(), "id", "secret");
|
||||
PreparedCall typed = c->plan("higgsfield-ai/soul/standard", obj({{"prompt", Json("x")}}));
|
||||
ASSERT_EQ(typed.target, std::string("/higgsfield-ai/soul/standard"));
|
||||
ASSERT_THROW(c->plan("higgsfield-ai/soul/standard", obj({{"nope", Json(1)}})), ApiError); // typed row validates fields
|
||||
PreparedCall generic = c->plan("vendor/new-model/v9", obj({{"anything", Json(1)}}));
|
||||
ASSERT_EQ(generic.target, std::string("/vendor/new-model/v9"));
|
||||
ASSERT_THROW(c->plan("vendor/../x", Json::object()), ApiError);
|
||||
ASSERT_EQ(HiggsfieldClient::header_value("id", "secret"), std::string("Key id:secret"));
|
||||
ASSERT_EQ(HiggsfieldClient::header_value("id", ""), std::string(""));
|
||||
}
|
||||
|
||||
TEST(media_prepare, higgsfield_submit_and_status_over_the_wire) {
|
||||
Mock m;
|
||||
// FIXTURE: docs.higgsfield.ai quickstart, submit reply (verbatim)
|
||||
const char* kSubmit =
|
||||
"{\"status\":\"queued\",\"request_id\":\"d7e6c0f3-6699-4f6c-bb45-2ad7fd9158ff\","
|
||||
"\"status_url\":\"https://api.higgsfield.ai/requests/d7e6c0f3-6699-4f6c-bb45-2ad7fd9158ff/status\","
|
||||
"\"cancel_url\":\"https://api.higgsfield.ai/requests/d7e6c0f3-6699-4f6c-bb45-2ad7fd9158ff/cancel\"}";
|
||||
serve(m.raw, Method::kPost, "/higgsfield-ai/soul/standard", reply(kSubmit));
|
||||
MockTransport* t = m.raw;
|
||||
auto c = HiggsfieldClient::with(m.take(), "id", "secret");
|
||||
Json out = c->submit("higgsfield-ai/soul/standard", obj({{"prompt", Json("Editorial portrait in soft daylight")}}), true);
|
||||
JobTicket ticket = HiggsfieldJobs::ticket_from(out, "higgsfield-ai/soul/standard", MediaKind::kImage);
|
||||
ASSERT_EQ(ticket.id, std::string("d7e6c0f3-6699-4f6c-bb45-2ad7fd9158ff"));
|
||||
auto seen = t->seen();
|
||||
ASSERT_EQ(*seen[0].headers.get("Authorization"), std::string("Key id:secret"));
|
||||
ASSERT_EQ(seen[0].body, std::string("{\"prompt\":\"Editorial portrait in soft daylight\"}"));
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------- Kling
|
||||
|
||||
TEST(media_prepare, kling_rows_and_envelope) {
|
||||
Mock m;
|
||||
auto c = std::make_shared<KlingClient>("AK", "SK", [] { return std::make_unique<MockTransport>(); });
|
||||
PreparedCall p = c->plan("text2video.create", obj({{"model_name", Json("kling-v1-6")}, {"prompt", Json("x")}}));
|
||||
ASSERT_EQ(p.target, std::string("/v1/videos/text2video"));
|
||||
ASSERT_TRUE(c->configured());
|
||||
KlingClient::check_envelope(obj({{"code", Json(0)}}));
|
||||
ASSERT_THROW(KlingClient::check_envelope(obj({{"code", Json(1001)}, {"message", Json("Authorization is empty")}})), ApiError);
|
||||
auto none = std::make_shared<KlingClient>("", "", [] { return std::make_unique<MockTransport>(); });
|
||||
ASSERT_FALSE(none->configured());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------- confirmation gate
|
||||
|
||||
TEST(media_gate, non_read_calls_need_confirm_and_make_no_traffic_without_it) {
|
||||
Mock m;
|
||||
MockTransport* t = m.raw;
|
||||
auto bfl = BflClient::with(m.take(), "KEY");
|
||||
ASSERT_THROW(bfl->submit("flux-2-pro", obj({{"prompt", Json("x")}}), false), ApiError);
|
||||
ASSERT_THROW(bfl->delete_finetune("my-ft", false), ApiError);
|
||||
ASSERT_EQ(t->send_count(), static_cast<std::size_t>(0));
|
||||
Mock m2;
|
||||
MockTransport* t2 = m2.raw;
|
||||
auto rep = ReplicateClient::with(m2.take(), "KEY");
|
||||
ASSERT_THROW(rep->cancel_prediction("p1", false), ApiError);
|
||||
ASSERT_THROW(rep->file_delete("f1", false), ApiError);
|
||||
ASSERT_THROW(rep->file_upload("a.png", "image/png", "x", false), ApiError);
|
||||
ASSERT_THROW(rep->create_prediction(ReplicateClient::ModelRef::parse("o/n"), Json::object(), Json::object(), false), ApiError);
|
||||
ASSERT_EQ(t2->send_count(), static_cast<std::size_t>(0));
|
||||
}
|
||||
|
||||
TEST(media_gate, missing_credentials_fail_before_any_traffic) {
|
||||
Mock m;
|
||||
MockTransport* t = m.raw;
|
||||
auto c = BflClient::with(m.take(), "");
|
||||
ASSERT_FALSE(c->configured());
|
||||
ASSERT_THROW(c->credits(), molo::llm::NotConfiguredError);
|
||||
ASSERT_THROW(c->submit("flux-2-pro", obj({{"prompt", Json("x")}}), true), molo::llm::NotConfiguredError);
|
||||
ASSERT_EQ(t->send_count(), static_cast<std::size_t>(0));
|
||||
ASSERT_FALSE(FalQueue::with(std::make_unique<MockTransport>(), "")->configured());
|
||||
ASSERT_FALSE(HiggsfieldClient::with(std::make_unique<MockTransport>(), "id", "")->configured());
|
||||
}
|
||||
|
||||
TEST(media_gate, headers_and_query_are_bounded) {
|
||||
Mock m;
|
||||
auto c = BflClient::with(m.take(), "KEY");
|
||||
CallArgs a;
|
||||
a.headers["Bad Name"] = "v";
|
||||
ASSERT_THROW(c->prepare("credits", a), ApiError);
|
||||
CallArgs b;
|
||||
b.headers["X-A"] = "line\r\nbreak";
|
||||
ASSERT_THROW(c->prepare("credits", b), ApiError);
|
||||
CallArgs d;
|
||||
d.query["id"] = std::string(2000, 'x');
|
||||
ASSERT_THROW(c->prepare("get_result", d), ApiError);
|
||||
CallArgs e;
|
||||
e.body = obj({{"x", Json(1)}});
|
||||
ASSERT_THROW(c->prepare("credits", e), ApiError); // a GET takes no body
|
||||
}
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
// Webhook signature verification (Replicate, Standard Webhooks scheme) and the
|
||||
// Kling JWT. Both use vectors produced outside this code base.
|
||||
#include "support.h"
|
||||
#include "vendors/media/kling/kling.h"
|
||||
#include "vendors/media/replicate/replicate.h"
|
||||
|
||||
using namespace molo::media;
|
||||
using namespace media_test;
|
||||
|
||||
namespace {
|
||||
// Standard Webhooks published test vector (github.com/standard-webhooks): secret, id, timestamp, payload.
|
||||
const char* kSecret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
|
||||
const char* kId = "msg_p5jXN8AQM9LWM0D4loKWxJek";
|
||||
const char* kTimestamp = "1614265330";
|
||||
const char* kPayload = "{\"test\": 2432232314}";
|
||||
const char* kSignature = "g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=";
|
||||
} // namespace
|
||||
|
||||
TEST(media_signing, webhook_signature_matches_the_standard_webhooks_vector) {
|
||||
ASSERT_EQ(ReplicateWebhook::sign(kSecret, kId, kTimestamp, kPayload), std::string(kSignature));
|
||||
ASSERT_TRUE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, std::string("v1,") + kSignature, kPayload, 1614265330 + 10));
|
||||
}
|
||||
|
||||
TEST(media_signing, webhook_rejects_tampering_staleness_and_malformed_input) {
|
||||
const std::string good = std::string("v1,") + kSignature;
|
||||
const long now = 1614265330 + 10;
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, good, "{\"test\": 2432232315}", now)); // body changed
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, "msg_other", kTimestamp, good, kPayload, now)); // id changed
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, "1614265331", good, kPayload, now)); // timestamp changed
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, good, kPayload, 1614265330 + 301)); // too old
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, good, kPayload, 1614265330 - 301)); // too new
|
||||
ASSERT_TRUE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, good, kPayload, 1614265330 + 300)); // boundary
|
||||
ASSERT_FALSE(ReplicateWebhook::verify("whsec_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", kId, kTimestamp, good, kPayload, now)); // wrong secret
|
||||
ASSERT_FALSE(ReplicateWebhook::verify("whsec_!!notbase64!!", kId, kTimestamp, good, kPayload, now));
|
||||
ASSERT_FALSE(ReplicateWebhook::verify("", kId, kTimestamp, good, kPayload, now));
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, "", kTimestamp, good, kPayload, now));
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, "12ab", good, kPayload, now));
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, "", kPayload, now));
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, kSignature, kPayload, now)); // no v1, prefix
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, "v2," + std::string(kSignature), kPayload, now));
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, std::string(2000, 'x'), kPayload, now)); // header cap
|
||||
}
|
||||
|
||||
TEST(media_signing, webhook_accepts_any_of_several_signatures) {
|
||||
const long now = 1614265330;
|
||||
std::string rotated = "v1,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= v1," + std::string(kSignature);
|
||||
ASSERT_TRUE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, rotated, kPayload, now));
|
||||
ASSERT_FALSE(ReplicateWebhook::verify(kSecret, kId, kTimestamp, "v1,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", kPayload, now));
|
||||
}
|
||||
|
||||
TEST(media_signing, kling_jwt_matches_an_independent_hs256_implementation) {
|
||||
// Computed with python3 hmac / base64 (see SPEC "Verified against spec"): header {"alg":"HS256","typ":"JWT"},
|
||||
// payload {"exp":1700001800,"iss":"AK-test","nbf":1699999995}, secret "SK-test".
|
||||
const char* expected =
|
||||
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MDAwMDE4MDAsImlzcyI6IkFLLXRlc3QiLCJuYmYiOjE2OTk5OTk5OTV9."
|
||||
"f3MPnq8kVzVYtGGChN2U_Rd1oYs3-a_FFYC4PCVGdSc";
|
||||
ASSERT_EQ(KlingJwt::make("AK-test", "SK-test", 1700000000), std::string(expected));
|
||||
ASSERT_TRUE(KlingJwt::make("AK-test", "SK-other", 1700000000) != std::string(expected));
|
||||
ASSERT_EQ(KlingJwt::kTtlSeconds, 1800L);
|
||||
ASSERT_TRUE(KlingJwt::kRenewAfterSeconds < KlingJwt::kTtlSeconds);
|
||||
}
|
||||
Reference in New Issue
Block a user