2026-07-06 01:47:45 +08:00
|
|
|
from __future__ import annotations
|
|
|
|
|
|
2026-07-11 21:50:34 +08:00
|
|
|
import base64
|
|
|
|
|
import json
|
2026-07-06 01:47:45 +08:00
|
|
|
import unittest
|
2026-07-11 21:50:34 +08:00
|
|
|
import zlib
|
|
|
|
|
from unittest.mock import patch
|
2026-07-06 01:47:45 +08:00
|
|
|
|
|
|
|
|
from engines.image_provider import (
|
2026-07-11 21:50:34 +08:00
|
|
|
MAX_PROVIDER_JSON_HARD_BYTES,
|
2026-07-06 01:47:45 +08:00
|
|
|
ImageGenerationRequest,
|
|
|
|
|
ImageProviderConfig,
|
|
|
|
|
ImageProviderError,
|
|
|
|
|
MockImageProvider,
|
|
|
|
|
OpenAIImageProvider,
|
2026-07-11 21:50:34 +08:00
|
|
|
_provider_json_limit,
|
2026-07-06 01:47:45 +08:00
|
|
|
)
|
2026-07-11 21:50:34 +08:00
|
|
|
from engines.single_flow import _image_bytes
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ONE_PIXEL_PNG = base64.b64decode(
|
|
|
|
|
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII="
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _png_with_text_payload(size: int) -> bytes:
|
|
|
|
|
data = b"note\x00" + (b"x" * size)
|
|
|
|
|
chunk_type = b"tEXt"
|
|
|
|
|
chunk = (
|
|
|
|
|
len(data).to_bytes(4, "big")
|
|
|
|
|
+ chunk_type
|
|
|
|
|
+ data
|
|
|
|
|
+ (zlib.crc32(chunk_type + data) & 0xFFFFFFFF).to_bytes(4, "big")
|
|
|
|
|
)
|
|
|
|
|
return ONE_PIXEL_PNG[:-12] + chunk + ONE_PIXEL_PNG[-12:]
|
2026-07-06 01:47:45 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
class ImageProviderTests(unittest.TestCase):
|
|
|
|
|
def test_openai_image_provider_normalizes_generation_response(self):
|
|
|
|
|
calls = []
|
|
|
|
|
|
|
|
|
|
def transport(url, payload, headers, timeout):
|
|
|
|
|
calls.append((url, payload, headers, timeout))
|
|
|
|
|
return {
|
|
|
|
|
"created": 1783268032,
|
|
|
|
|
"data": [
|
|
|
|
|
{
|
|
|
|
|
"b64_json": "aW1hZ2U=",
|
|
|
|
|
"url": "https://example.test/image.png",
|
|
|
|
|
"revised_prompt": "red dot",
|
|
|
|
|
}
|
|
|
|
|
],
|
|
|
|
|
"usage": {"total_tokens": 12},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
provider = OpenAIImageProvider(
|
|
|
|
|
ImageProviderConfig(
|
|
|
|
|
provider_id="site_b",
|
|
|
|
|
base_url="https://botcf.com",
|
|
|
|
|
api_key="secret",
|
|
|
|
|
image_model="image2",
|
|
|
|
|
timeout_seconds=180,
|
|
|
|
|
),
|
|
|
|
|
transport=transport,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
result = provider.generate_image(
|
|
|
|
|
ImageGenerationRequest(
|
|
|
|
|
prompt="red dot",
|
2026-07-11 21:50:34 +08:00
|
|
|
negative_prompt="blur, watermark",
|
2026-07-06 01:47:45 +08:00
|
|
|
input_images=("https://example.test/input.jpg",),
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
self.assertTrue(result.has_images)
|
|
|
|
|
self.assertEqual(result.provider_id, "site_b")
|
|
|
|
|
self.assertEqual(result.model, "image2")
|
|
|
|
|
self.assertEqual(result.usage["total_tokens"], 12)
|
|
|
|
|
self.assertEqual(result.images[0].b64_json, "aW1hZ2U=")
|
|
|
|
|
self.assertEqual(result.images[0].url, "https://example.test/image.png")
|
|
|
|
|
self.assertEqual(calls[0][0], "https://botcf.com/v1/images/generations")
|
|
|
|
|
self.assertEqual(calls[0][1]["model"], "image2")
|
|
|
|
|
self.assertEqual(calls[0][1]["image"], ["https://example.test/input.jpg"])
|
2026-07-11 21:50:34 +08:00
|
|
|
self.assertEqual(calls[0][1]["negative_prompt"], "blur, watermark")
|
|
|
|
|
self.assertEqual(calls[0][1]["response_format"], "b64_json")
|
2026-07-06 01:47:45 +08:00
|
|
|
self.assertEqual(calls[0][3], 180)
|
2026-07-11 21:50:34 +08:00
|
|
|
self.assertEqual(result.raw_metadata["provider_base_url"], "https://botcf.com")
|
2026-07-06 01:47:45 +08:00
|
|
|
|
|
|
|
|
def test_provider_requires_model(self):
|
|
|
|
|
provider = OpenAIImageProvider(ImageProviderConfig(provider_id="missing", base_url="https://example.test"))
|
|
|
|
|
|
|
|
|
|
with self.assertRaises(ImageProviderError) as raised:
|
|
|
|
|
provider.generate_image(ImageGenerationRequest(prompt="red dot"))
|
|
|
|
|
|
|
|
|
|
self.assertEqual(raised.exception.error_type, "configuration_error")
|
|
|
|
|
|
2026-07-11 21:50:34 +08:00
|
|
|
def test_provider_omits_authorization_header_for_no_auth_local_backend(self):
|
|
|
|
|
calls = []
|
|
|
|
|
|
|
|
|
|
def transport(url, payload, headers, timeout):
|
|
|
|
|
calls.append(headers)
|
|
|
|
|
return {"data": [{"b64_json": "aW1hZ2U="}]}
|
|
|
|
|
|
|
|
|
|
provider = OpenAIImageProvider(
|
|
|
|
|
ImageProviderConfig(
|
|
|
|
|
provider_id="local",
|
|
|
|
|
base_url="http://127.0.0.1:8080",
|
|
|
|
|
image_model="local-image",
|
|
|
|
|
),
|
|
|
|
|
transport=transport,
|
|
|
|
|
)
|
|
|
|
|
provider.generate_image(ImageGenerationRequest(prompt="red dot"))
|
|
|
|
|
|
|
|
|
|
self.assertNotIn("Authorization", calls[0])
|
|
|
|
|
|
|
|
|
|
def test_provider_can_explicitly_disable_negative_prompt_for_strict_endpoints(self):
|
|
|
|
|
calls = []
|
|
|
|
|
|
|
|
|
|
def transport(url, payload, headers, timeout):
|
|
|
|
|
calls.append(payload)
|
|
|
|
|
return {"data": [{"b64_json": "aW1hZ2U="}]}
|
|
|
|
|
|
|
|
|
|
provider = OpenAIImageProvider(
|
|
|
|
|
ImageProviderConfig(
|
|
|
|
|
provider_id="strict-openai",
|
|
|
|
|
base_url="https://api.openai.com",
|
|
|
|
|
image_model="gpt-image-1",
|
|
|
|
|
supports_negative_prompt=False,
|
|
|
|
|
),
|
|
|
|
|
transport=transport,
|
|
|
|
|
)
|
|
|
|
|
provider.generate_image(
|
|
|
|
|
ImageGenerationRequest(prompt="red dot", negative_prompt="blur, watermark")
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
self.assertNotIn("negative_prompt", calls[0])
|
|
|
|
|
|
2026-07-06 02:14:13 +08:00
|
|
|
def test_provider_relabels_transport_errors_with_configured_provider(self):
|
|
|
|
|
def transport(url, payload, headers, timeout):
|
|
|
|
|
raise ImageProviderError(
|
|
|
|
|
"remote unauthorized",
|
|
|
|
|
provider_id="unknown",
|
|
|
|
|
status_code=401,
|
|
|
|
|
error_type="http_error",
|
|
|
|
|
details={"body_preview": "invalid credentials"},
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
provider = OpenAIImageProvider(
|
|
|
|
|
ImageProviderConfig(
|
|
|
|
|
provider_id="site_b",
|
|
|
|
|
base_url="https://botcf.com",
|
|
|
|
|
api_key="secret",
|
|
|
|
|
image_model="image2",
|
|
|
|
|
),
|
|
|
|
|
transport=transport,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
with self.assertRaises(ImageProviderError) as raised:
|
|
|
|
|
provider.generate_image(ImageGenerationRequest(prompt="red dot"))
|
|
|
|
|
|
|
|
|
|
self.assertEqual(raised.exception.provider_id, "site_b")
|
|
|
|
|
self.assertEqual(raised.exception.status_code, 401)
|
|
|
|
|
self.assertEqual(raised.exception.error_type, "http_error")
|
|
|
|
|
|
2026-07-11 21:50:34 +08:00
|
|
|
def test_default_transport_accepts_legal_base64_json_responses_over_four_mib(self):
|
|
|
|
|
provider = OpenAIImageProvider(
|
|
|
|
|
ImageProviderConfig(
|
|
|
|
|
provider_id="large",
|
|
|
|
|
base_url="https://example.test",
|
|
|
|
|
image_model="large-image",
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
cases = (
|
|
|
|
|
(1, [_png_with_text_payload(3 * 1024 * 1024)]),
|
|
|
|
|
(
|
|
|
|
|
2,
|
|
|
|
|
[
|
|
|
|
|
_png_with_text_payload(1600 * 1024),
|
|
|
|
|
_png_with_text_payload(1600 * 1024),
|
|
|
|
|
],
|
|
|
|
|
),
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
for count, image_bodies in cases:
|
|
|
|
|
with self.subTest(count=count):
|
|
|
|
|
response_body = json.dumps(
|
|
|
|
|
{
|
|
|
|
|
"data": [
|
|
|
|
|
{"b64_json": base64.b64encode(body).decode("ascii")}
|
|
|
|
|
for body in image_bodies
|
|
|
|
|
]
|
|
|
|
|
},
|
|
|
|
|
separators=(",", ":"),
|
|
|
|
|
).encode("utf-8")
|
|
|
|
|
self.assertGreater(len(response_body), 4 * 1024 * 1024)
|
|
|
|
|
|
|
|
|
|
with patch(
|
|
|
|
|
"engines.image_provider.read_http_response_limited",
|
|
|
|
|
return_value=response_body,
|
|
|
|
|
) as fetch:
|
|
|
|
|
result = provider.generate_image(
|
|
|
|
|
ImageGenerationRequest(prompt="large response", count=count)
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
response_limit = fetch.call_args.kwargs["max_bytes"]
|
|
|
|
|
self.assertGreaterEqual(response_limit, len(response_body))
|
|
|
|
|
self.assertLessEqual(response_limit, MAX_PROVIDER_JSON_HARD_BYTES)
|
|
|
|
|
self.assertEqual(len(result.images), count)
|
|
|
|
|
for parsed, expected in zip(result.images, image_bodies):
|
|
|
|
|
self.assertEqual(_image_bytes(parsed.b64_json, None, provider_id="large"), expected)
|
|
|
|
|
|
|
|
|
|
def test_provider_json_limit_scales_by_count_and_keeps_aggregate_hard_cap(self):
|
|
|
|
|
self.assertGreater(_provider_json_limit(2), _provider_json_limit(1))
|
|
|
|
|
self.assertEqual(_provider_json_limit(8), MAX_PROVIDER_JSON_HARD_BYTES)
|
|
|
|
|
self.assertEqual(_provider_json_limit(999), MAX_PROVIDER_JSON_HARD_BYTES)
|
|
|
|
|
|
2026-07-06 01:47:45 +08:00
|
|
|
def test_mock_provider_returns_image_payload(self):
|
|
|
|
|
result = MockImageProvider().generate_image(ImageGenerationRequest(prompt="red dot", model="mock"))
|
|
|
|
|
|
|
|
|
|
self.assertTrue(result.has_images)
|
|
|
|
|
self.assertEqual(result.images[0].revised_prompt, "red dot")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
|
unittest.main()
|