astrbot_plugin_imagestudio/tests/test_image_provider.py

225 行
8.1 KiB
Python

from __future__ import annotations
import base64
import json
import unittest
import zlib
from unittest.mock import patch
from engines.image_provider import (
MAX_PROVIDER_JSON_HARD_BYTES,
ImageGenerationRequest,
ImageProviderConfig,
ImageProviderError,
MockImageProvider,
OpenAIImageProvider,
_provider_json_limit,
)
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:]
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",
negative_prompt="blur, watermark",
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"])
self.assertEqual(calls[0][1]["negative_prompt"], "blur, watermark")
self.assertEqual(calls[0][1]["response_format"], "b64_json")
self.assertEqual(calls[0][3], 180)
self.assertEqual(result.raw_metadata["provider_base_url"], "https://botcf.com")
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")
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])
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")
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)
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()