Merge branch 'worktree-agent-a1e8651ad784c651f'

This commit is contained in:
2026-10-25 15:24:28 +01:00
78 changed files with 8727 additions and 3 deletions
+47
View File
@@ -0,0 +1,47 @@
// Routes: GET /ai/media (page), /status, /calls (no credential needed)
#include <cstdlib>
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
setenv("MOLO_ENV_FILES", "off", 1);
for (const char* v : {"STABILITY_API_KEY", "BFL_API_KEY", "RUNWAY_API_KEY", "RUNWAYML_API_SECRET", "LUMA_API_KEY",
"REPLICATE_API_TOKEN", "FAL_KEY", "IDEOGRAM_API_KEY", "RECRAFT_API_TOKEN", "LEONARDO_API_KEY",
"MINIMAX_API_KEY", "KLING_ACCESS_KEY", "KLING_SECRET_KEY", "HF_API_KEY_ID", "HF_API_KEY_SECRET"})
unsetenv(v);
Fixture f;
auto page = f.client->get("/ai/media");
check(page.status == 200, "page 200");
check(contains(page.headers.get("Content-Type"), "text/html"), "html");
check(contains(page.body, "Media generation") && contains(page.body, "viewport"), "title and mobile viewport");
check(contains(page.body, "/embedded/ai_media.js"), "script wired");
check(f.client->post("/ai/media", "{}", "application/json").status == 405, "post page is 405");
auto st = f.client->get("/ai/media/status");
check(st.status == 200 && contains(st.body, "\"configured\":false"), "status without keys");
check(!contains(st.body, "\"configured\":true"), "no provider is configured");
for (const char* env : {"STABILITY_API_KEY", "BFL_API_KEY", "RUNWAY_API_KEY", "LUMA_API_KEY", "REPLICATE_API_TOKEN",
"FAL_KEY", "IDEOGRAM_API_KEY", "RECRAFT_API_TOKEN", "LEONARDO_API_KEY"})
check(contains(st.body, env), std::string("status names ") + env);
check(contains(st.body, "Midjourney") && contains(st.body, "No public API"), "Midjourney is listed as unavailable with the reason");
check(contains(st.body, "Pika"), "Pika is listed as unavailable");
check(contains(st.body, "\"evidence\":\"probe-only\"") && contains(st.body, "\"evidence\":\"openapi\""), "evidence levels shown");
check(contains(st.body, "flux-2-pro") && contains(st.body, "fal-ai/flux/dev"), "models are listed");
check(contains(st.body, "\"max_poll_attempts\":240"), "caps are shown");
check(f.client->post("/ai/media/status", "{}", "application/json").status == 405, "post status is 405");
auto all = f.client->get("/ai/media/calls");
check(all.status == 200 && contains(all.body, "\"provider\":\"stability\"") && contains(all.body, "\"provider\":\"higgsfield\""),
"calls lists every provider");
auto bfl = f.client->get("/ai/media/calls?provider=bfl");
check(bfl.status == 200 && contains(bfl.body, "/v1/flux-2-pro") && contains(bfl.body, "\"effect\":\"paid\"") &&
contains(bfl.body, "/v1/credits"),
"bfl call table");
auto fal = f.client->get("/ai/media/calls?provider=fal");
check(fal.status == 200 && contains(fal.body, "queue.fal.run") == false && contains(fal.body, "/{owner}/{app}/requests/{request_id}/status"),
"fal call table");
check(f.client->get("/ai/media/calls?provider=midjourney").status == 422, "unknown provider is 422");
return finish("ai/media/page");
}
+128
View File
@@ -0,0 +1,128 @@
// Routes: POST /ai/media/* (405, 422, dry runs, 503 without a credential)
#include <cstdlib>
#include "support/Assert.hpp"
using namespace molo::example::test;
int main() {
setenv("MOLO_ENV_FILES", "off", 1);
for (const char* v : {"STABILITY_API_KEY", "BFL_API_KEY", "RUNWAY_API_KEY", "RUNWAYML_API_SECRET", "LUMA_API_KEY",
"REPLICATE_API_TOKEN", "FAL_KEY", "IDEOGRAM_API_KEY", "RECRAFT_API_TOKEN", "LEONARDO_API_KEY",
"MINIMAX_API_KEY", "KLING_ACCESS_KEY", "KLING_SECRET_KEY", "HF_API_KEY_ID", "HF_API_KEY_SECRET"})
unsetenv(v);
Fixture f;
auto post = [&](const std::string& route, const std::string& body) {
return f.client->post("/ai/media/" + route, body, "application/json");
};
const char* posts[] = {"image", "video", "poll", "wait", "call", "account", "fetch", "webhook"};
for (const char* r : posts) {
std::string route = std::string("/ai/media/") + r;
check(f.client->get(route).status == 405, route + " get is 405");
check(post(r, "not json").status == 422, route + " bad json is 422");
check(post(r, "[1]").status == 422, route + " non-object is 422");
check(post(r, "{}").status == 422, route + " empty body is 422");
}
check(f.client->get("/ai/media/job").status == 405, "job get is 405");
check(f.client->request(molo::example::fw::Method::Delete, "/ai/media/job", "not json").status == 422, "job bad json is 422");
// 422: input rules run before anything else
check(post("image", "{\"provider\":\"midjourney\",\"prompt\":\"x\"}").status == 422, "midjourney has no API");
check(post("image", "{\"provider\":\"minimax\",\"prompt\":\"x\"}").status == 422, "minimax has no image generation");
check(post("video", "{\"provider\":\"stability\",\"prompt\":\"x\"}").status == 422, "stability has no video generation");
check(post("image", "{\"provider\":\"bfl\"}").status == 422, "prompt is required");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"count\":0}").status == 422, "count 0");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"count\":9}").status == 422, "count over 8");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"width\":512}").status == 422, "width without height");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"width\":9000,\"height\":9000}").status == 422, "dimension over the cap");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"extra\":{\"bogus\":1}}").status == 422, "field not in the call table");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"model\":\"flux-9000\"}").status == 422, "model not in the call table");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"count\":2}").status == 422, "bfl takes one image per call");
check(post("image", "{\"provider\":\"stability\",\"prompt\":\"x\",\"width\":512,\"height\":512}").status == 422, "stability sizes by aspect ratio");
check(post("image", "{\"provider\":\"fal\",\"prompt\":\"x\"}").status == 422, "fal needs an endpoint id");
check(post("image", "{\"provider\":\"fal\",\"prompt\":\"x\",\"model\":\"a/../b\"}").status == 422, "bad endpoint id");
check(post("image", "{\"provider\":\"replicate\",\"prompt\":\"x\",\"model\":\"nope\"}").status == 422, "replicate needs owner/name");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"seed\":\"a\"}").status == 422, "seed must be a number");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"confirm\":\"yes\"}").status == 422, "confirm must be a boolean");
check(post("video", "{\"provider\":\"runway\"}").status == 422, "video needs a prompt or an image");
check(post("video", "{\"provider\":\"runway\",\"prompt\":\"x\",\"duration_seconds\":999}").status == 422, "duration over the cap");
check(post("video", "{\"provider\":\"minimax\",\"prompt\":\"x\",\"aspect_ratio\":\"16:9\"}").status == 422, "minimax v1 has no aspect ratio");
check(post("poll", "{\"ticket\":{\"provider\":\"bfl\"}}").status == 422, "ticket needs an id");
check(post("poll", "{\"ticket\":{\"provider\":\"nope\",\"id\":\"1\"}}").status == 422, "ticket with an unknown provider");
check(post("wait", "{\"ticket\":{\"provider\":\"bfl\",\"id\":\"1\"},\"max_attempts\":31}").status == 422, "demo attempt cap");
check(post("wait", "{\"ticket\":{\"provider\":\"bfl\",\"id\":\"1\"},\"max_wait_seconds\":61}").status == 422, "demo wait cap");
check(post("wait", "{\"ticket\":{\"provider\":\"bfl\",\"id\":\"1\"},\"max_attempts\":0}").status == 422, "attempts under 1");
check(post("call", "{\"provider\":\"bfl\",\"key\":\"nope\"}").status == 422, "unknown call key");
check(post("call", "{\"provider\":\"bfl\",\"key\":\"get_result\",\"query\":{\"nope\":\"1\"}}").status == 422, "unknown query parameter");
check(post("call", "{\"provider\":\"replicate\",\"key\":\"predictions.get\",\"path\":{\"prediction_id\":\"../x\"}}").status == 422, "path traversal");
check(post("call", "{\"provider\":\"replicate\",\"key\":\"predictions.get\"}").status == 422, "missing path argument");
check(post("call", "{\"provider\":\"bfl\",\"key\":\"credits\",\"body\":{\"x\":1}}").status == 422, "a GET takes no body");
check(post("call", "{\"provider\":\"stability\",\"key\":\"stable-image.upscale.fast\",\"files\":[{\"field\":\"image\",\"data_base64\":\"@@\"}]}").status == 422,
"bad base64 file");
check(post("call", "{\"provider\":\"stability\",\"key\":\"stable-image.upscale.fast\",\"files\":[{\"field\":\"picture\",\"data_base64\":\"aGk=\"}]}").status == 422,
"file field not in the table");
check(post("fetch", "{\"url\":\"http://example.com/a.png\"}").status == 422, "fetch needs https");
check(post("fetch", "{\"url\":\"https://user:pw@example.com/a.png\"}").status == 422, "fetch refuses embedded credentials");
check(post("webhook", "{\"secret\":\"s\",\"webhook_id\":\"i\",\"timestamp\":\"1\",\"signature\":\"v1,x\"}").status == 422, "webhook needs a payload");
// dry runs: paid or resource-changing routes show the exact request
auto dry = post("image", "{\"provider\":\"bfl\",\"prompt\":\"a cat\",\"width\":1024,\"height\":768}");
check(dry.status == 200 && contains(dry.body, "\"dry_run\":true") && contains(dry.body, "/v1/flux-2-pro") &&
contains(dry.body, "\"effect\":\"paid\"") && contains(dry.body, "\"prompt\":\"a cat\""),
"image is a dry run without confirm");
check(contains(post("image", "{\"provider\":\"stability\",\"prompt\":\"a cat\",\"model\":\"ultra\",\"aspect_ratio\":\"16:9\"}").body,
"/v2beta/stable-image/generate/ultra"),
"stability dry run shows the endpoint");
check(contains(post("image", "{\"provider\":\"fal\",\"prompt\":\"x\",\"model\":\"fal-ai/flux/dev\"}").body, "\"target\":\"/fal-ai/flux/dev\""),
"fal dry run shows the queue target");
check(contains(post("image", "{\"provider\":\"replicate\",\"prompt\":\"x\",\"model\":\"black-forest-labs/flux-schnell\"}").body,
"/models/black-forest-labs/flux-schnell/predictions"),
"replicate dry run shows the prediction target");
check(contains(post("image", "{\"provider\":\"leonardo\",\"prompt\":\"x\",\"model\":\"flux-dev\"}").body, "\"public\":false"),
"leonardo never publishes by default");
check(contains(post("image", "{\"provider\":\"ideogram\",\"prompt\":\"x\",\"model\":\"ideogram-4\"}").body, "/v2/image/generate/ideogram-4"),
"ideogram dry run");
check(contains(post("image", "{\"provider\":\"recraft\",\"prompt\":\"x\",\"width\":1024,\"height\":1024}").body, "\"size\":\"1024x1024\""),
"recraft dry run");
check(contains(post("video", "{\"provider\":\"runway\",\"prompt\":\"waves\",\"duration_seconds\":5}").body, "/v1/text_to_video"),
"runway video dry run");
check(contains(post("video", "{\"provider\":\"luma\",\"prompt\":\"waves\",\"duration_seconds\":5}").body, "\"duration\":\"5s\""),
"luma video dry run");
check(contains(post("video", "{\"provider\":\"kling\",\"prompt\":\"waves\"}").body, "/v1/videos/text2video"), "kling video dry run");
check(contains(post("video", "{\"provider\":\"higgsfield\",\"prompt\":\"waves\",\"model\":\"minimax/hailuo-2.3/standard/text-to-video\"}").body,
"/minimax/hailuo-2.3/standard/text-to-video"),
"higgsfield video dry run");
check(contains(post("call", "{\"provider\":\"bfl\",\"key\":\"flux-dev\",\"body\":{\"prompt\":\"x\"}}").body, "\"dry_run\":true"),
"a paid table call is a dry run");
check(contains(post("call", "{\"provider\":\"replicate\",\"key\":\"files.delete\",\"path\":{\"file_id\":\"f1\"}}").body, "\"effect\":\"delete\""),
"a destructive table call is a dry run");
check(contains(post("call", "{\"provider\":\"bfl\",\"key\":\"delete_finetune\",\"body\":{\"finetune_id\":\"my-ft\"}}").body, "\"dry_run\":true"),
"delete_finetune is a dry run");
auto cancel = f.client->request(molo::example::fw::Method::Delete, "/ai/media/job", "{\"ticket\":{\"provider\":\"luma\",\"id\":\"g1\",\"kind\":\"video\"}}");
check(cancel.status == 200 && contains(cancel.body, "\"dry_run\":true"), "cancel is a dry run");
// pure routes
auto hook = post("webhook",
"{\"secret\":\"whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw\",\"webhook_id\":\"msg_p5jXN8AQM9LWM0D4loKWxJek\","
"\"timestamp\":\"1614265330\",\"signature\":\"v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=\","
"\"payload\":\"{\\\"test\\\": 2432232314}\"}");
check(hook.status == 200 && contains(hook.body, "\"valid\":false"), "a vector from 2021 is stale now, so it is rejected");
// 503: reads and confirmed calls need the credential
auto acct = post("account", "{\"provider\":\"bfl\"}");
check(acct.status == 503 && contains(acct.body, "media_not_configured"), "account without key is 503");
check(post("account", "{\"provider\":\"minimax\"}").status == 422, "minimax has no free account read");
check(post("account", "{\"provider\":\"midjourney\"}").status == 422, "unknown provider account");
check(post("call", "{\"provider\":\"bfl\",\"key\":\"credits\"}").status == 503, "read call without key is 503");
check(post("call", "{\"provider\":\"fal\",\"key\":\"platform.meta\"}").status == 503, "fal platform read without key is 503");
check(post("call", "{\"provider\":\"bfl\",\"key\":\"flux-dev\",\"body\":{\"prompt\":\"x\"},\"confirm\":true}").status == 503,
"confirmed paid call without key is 503");
check(post("image", "{\"provider\":\"bfl\",\"prompt\":\"x\",\"confirm\":true}").status == 503, "confirmed image without key is 503");
check(post("video", "{\"provider\":\"runway\",\"prompt\":\"x\",\"confirm\":true}").status == 503, "confirmed video without key is 503");
check(post("video", "{\"provider\":\"kling\",\"prompt\":\"x\",\"confirm\":true}").status == 503, "kling without keys is 503");
check(post("poll", "{\"ticket\":{\"provider\":\"bfl\",\"id\":\"1\"}}").status == 503, "poll without key is 503");
check(post("wait", "{\"ticket\":{\"provider\":\"fal\",\"id\":\"1\",\"meta\":{\"endpoint\":\"fal-ai/flux/dev\"}}}").status == 503, "wait without key is 503");
check(f.client->request(molo::example::fw::Method::Delete, "/ai/media/job", "{\"ticket\":{\"provider\":\"luma\",\"id\":\"g1\"},\"confirm\":true}").status == 503,
"confirmed cancel without key is 503");
return finish("ai/media/routes");
}
+57
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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);
}