mirror of
https://github.com/Shu-Ying/main_plugin_farm.git
synced 2026-10-27 12:40:01 +08:00
354 lines
14 KiB
Python
354 lines
14 KiB
Python
import asyncio
|
|
from dataclasses import replace
|
|
from io import BytesIO
|
|
from pathlib import Path
|
|
import os
|
|
import threading
|
|
import time
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
from PIL import Image, features
|
|
|
|
from farm_core import Catalogue, Identity
|
|
from farm_core.domain import Account, Plot, Snapshot
|
|
|
|
try:
|
|
from farm_render import FarmRenderer, RenderOptions, RenderService
|
|
from farm_render.assets import ByteLRU
|
|
from farm_render.canvas import Canvas
|
|
except ImportError:
|
|
FarmRenderer = None
|
|
|
|
|
|
FONT = Path("C:/Windows/Fonts/msyh.ttc")
|
|
if not FONT.exists():
|
|
FONT = Path("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf")
|
|
FONT = Path(os.environ.get("FARM_TEST_FONT", FONT))
|
|
|
|
|
|
def snapshot(plots=None, **account):
|
|
values = dict(name="演示农场", point=500, vip_point=0, experience=0)
|
|
values.update(account)
|
|
return Snapshot(Account(**values), (), tuple(
|
|
plots if plots is not None else [Plot(i) for i in range(1, 4)]
|
|
))
|
|
|
|
|
|
class RenderTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.assertIsNotNone(FarmRenderer, "共享图片模块尚未实现")
|
|
self.renderer = FarmRenderer(FONT)
|
|
self.who = Identity("test", "local", "qq", "one")
|
|
self.plant = next(iter(Catalogue.bundled()))
|
|
|
|
def test_canvas_alpha_crop_text_and_formats(self):
|
|
canvas = Canvas.new((100, 80), "white")
|
|
overlay = Image.new("RGBA", (20, 20), (255, 0, 0, 128))
|
|
canvas.paste(overlay, (0, 0))
|
|
self.assertEqual(canvas.image.getpixel((5, 5))[:3], (255, 127, 127))
|
|
self.assertEqual(canvas.crop((0, 0, 10, 10)).image.size, (10, 10))
|
|
self.assertEqual(canvas.resize((50, 40)).image.size, (50, 40))
|
|
text = canvas.fit_text("long farm name" * 20, FONT, 16, 80)
|
|
self.assertLessEqual(canvas.measure_text(text, FONT, 16), 80)
|
|
canvas.text((1, 30), text, FONT, 16, "black")
|
|
for fmt in ("PNG", "JPEG", "WEBP"):
|
|
if fmt == "WEBP" and not features.check("webp"):
|
|
continue
|
|
content = canvas.encode(fmt, 75, 2)
|
|
with Image.open(BytesIO(content)) as image:
|
|
self.assertEqual(image.format, fmt)
|
|
self.assertEqual(image.size, (100, 80))
|
|
|
|
def test_profiles_formats_and_bad_avatar_fallback(self):
|
|
for width in (1024, 1536):
|
|
for fmt in ("JPEG", "PNG", "WEBP"):
|
|
if fmt == "WEBP" and not features.check("webp"):
|
|
continue
|
|
result = self.renderer.render(
|
|
self.who, snapshot(), 0,
|
|
RenderOptions(width=width, format=fmt), b"broken avatar",
|
|
)
|
|
with Image.open(BytesIO(result.content)) as image:
|
|
self.assertEqual(image.width, width)
|
|
self.assertEqual(image.format, fmt)
|
|
self.assertEqual(result.width, width)
|
|
self.assertGreater(result.compose_ms, 0)
|
|
|
|
def test_stage_boundaries_multiseason_and_withered(self):
|
|
plant = self.plant
|
|
plot = Plot(1, plant, plant.growth_seconds)
|
|
view = lambda p, now: self.renderer.scene(
|
|
self.who, snapshot([p]), now,
|
|
).plots[0]
|
|
self.assertEqual(view(plot, 0).state, "growing")
|
|
self.assertEqual(view(plot, plant.growth_seconds).state, "ripe")
|
|
self.assertNotEqual(view(plot, 0).sprite, view(plot, 20000).sprite)
|
|
multi = replace(plant, crop=3)
|
|
again = Plot(1, multi, multi.regrowth_seconds + 100, 1)
|
|
self.assertEqual(view(again, 100).stage, 0)
|
|
self.assertGreater(view(again, again.mature_at - 1).stage, 0)
|
|
dead = replace(again, harvest_count=3)
|
|
self.assertEqual(view(dead, 999999).state, "withered")
|
|
self.assertEqual(view(dead, 999999).sprite, "webgl/wither.png")
|
|
|
|
def test_result_cache_visible_state_scope_and_time(self):
|
|
plant = self.plant
|
|
data = snapshot([Plot(1, plant, plant.growth_seconds)])
|
|
first = self.renderer.render(self.who, data, 0)
|
|
warm = self.renderer.render(self.who, data, 1)
|
|
self.assertFalse(first.cache_hit)
|
|
self.assertTrue(warm.cache_hit)
|
|
self.assertEqual(first.content, warm.content)
|
|
ripe = self.renderer.render(self.who, data, plant.growth_seconds)
|
|
self.assertFalse(ripe.cache_hit)
|
|
self.assertNotEqual(first.content, ripe.content)
|
|
changed = replace(data, account=replace(data.account, point=501))
|
|
self.assertFalse(self.renderer.render(
|
|
self.who, changed, 0,
|
|
).cache_hit)
|
|
other = replace(self.who, realm="other")
|
|
self.assertFalse(self.renderer.render(other, data, 0).cache_hit)
|
|
self.assertFalse(self.renderer.render(
|
|
self.who, data, 0, avatar=b"changed",
|
|
).cache_hit)
|
|
changed = replace(data, account=replace(data.account, experience=200))
|
|
self.assertFalse(self.renderer.render(self.who, changed, 0).cache_hit)
|
|
|
|
def test_legacy_panel_assets_avatar_size_and_layer_order(self):
|
|
avatar = BytesIO()
|
|
Image.new("RGB", (80, 40), "red").save(avatar, "PNG")
|
|
scene = self.renderer.scene(self.who, snapshot(), 0)
|
|
for width in (1024, 1536, 3072):
|
|
options = RenderOptions(width=width)
|
|
s = lambda n: round(n * width / 3072)
|
|
actual = Canvas.new((width, s(1872)))
|
|
expected = Canvas.new((width, s(1872)))
|
|
name = "background/userInfo.png"
|
|
size = self.renderer.assets.metadata["images"][name]["size"]
|
|
expected.paste(self.renderer.assets.image(
|
|
name, tuple(s(n) for n in size),
|
|
), (s(100), s(30)))
|
|
expected.paste(Image.new("RGBA", (s(140), s(150)), "red"),
|
|
(s(125), s(85)))
|
|
name = "background/frame/frame.png"
|
|
size = self.renderer.assets.metadata["images"][name]["size"]
|
|
expected.paste(self.renderer.assets.image(
|
|
name, tuple(s(n) for n in size),
|
|
), (s(75), s(44)))
|
|
with patch.object(actual, "text"), patch.object(actual, "rectangle"):
|
|
self.renderer._panel(actual, scene, options, avatar.getvalue())
|
|
self.assertEqual(actual.image.tobytes(), expected.image.tobytes())
|
|
|
|
def test_legacy_panel_fields_progress_and_level_boundaries(self):
|
|
options = RenderOptions(width=3072)
|
|
for exp, level, current, threshold in (
|
|
(0, 0, 0, 200), (199, 0, 199, 200), (200, 1, 0, 600),
|
|
(599, 1, 399, 600), (600, 2, 0, 1200), (3420, 5, 420, 4200),
|
|
):
|
|
data = snapshot(name="农场", point=12580, vip_point=36,
|
|
experience=exp)
|
|
scene = self.renderer.scene(self.who, data, 0)
|
|
canvas = Canvas.new((3072, 1872))
|
|
with patch.object(canvas, "text") as text, patch.object(
|
|
canvas, "rectangle",
|
|
) as rectangle:
|
|
self.renderer._panel(canvas, scene, options, None)
|
|
values = [(call.args[0], call.args[1])
|
|
for call in text.call_args_list]
|
|
self.assertEqual(values, [
|
|
((300, 92), "农场"),
|
|
((365, 164), f"{current} / {threshold}"),
|
|
((570, 158), str(level)),
|
|
((330, 211), "12580"), ((570, 211), "36"),
|
|
])
|
|
progress = current * 247 // threshold
|
|
if progress:
|
|
rectangle.assert_called_once_with(
|
|
(292, 164, 292 + progress, 189), (171, 194, 41),
|
|
)
|
|
else:
|
|
rectangle.assert_not_called()
|
|
|
|
def test_lru_budget_and_shared_image_safety(self):
|
|
cache = ByteLRU(10)
|
|
cache.put("a", b"123456", 6)
|
|
cache.put("b", b"abcdef", 6)
|
|
self.assertIsNone(cache.get("a"))
|
|
self.assertLessEqual(cache.used_bytes, 10)
|
|
cache.put("huge", bytes(20), 20)
|
|
self.assertIsNone(cache.get("huge"))
|
|
image = self.renderer.assets.image("soil/草土地.png", (80, 50))
|
|
before = image.tobytes()
|
|
image.paste("red", (0, 0, 80, 50))
|
|
fresh = self.renderer.assets.image("soil/草土地.png", (80, 50))
|
|
self.assertEqual(before, fresh.tobytes())
|
|
self.assertLessEqual(
|
|
self.renderer.assets.cache.used_bytes,
|
|
self.renderer.assets.cache.limit,
|
|
)
|
|
|
|
def test_auto_codec_fallback_and_invalid_options(self):
|
|
with patch("farm_render.models.features.check", return_value=False):
|
|
self.assertEqual(RenderOptions().codec(("WEBP", "JPEG")), "JPEG")
|
|
with self.assertRaises(ValueError):
|
|
RenderOptions(format="WEBP").codec(("WEBP",))
|
|
for kwargs in ({"width":True}, {"width":99999}, {"quality":101},
|
|
{"method":7}, {"theme":"../oops"}):
|
|
with self.assertRaises(ValueError):
|
|
RenderOptions(**kwargs)
|
|
|
|
def test_first_stage_exact_boundary_and_target_canvas(self):
|
|
plot = Plot(1, self.plant, self.plant.growth_seconds)
|
|
metadata = self.renderer.assets.metadata["plants"][self.plant.name]
|
|
threshold = int(metadata["phase"].split(",")[0])
|
|
data = snapshot([plot])
|
|
self.assertEqual(self.renderer.scene(
|
|
self.who, data, threshold - 1,
|
|
).plots[0].stage, 0)
|
|
self.assertEqual(self.renderer.scene(
|
|
self.who, data, threshold,
|
|
).plots[0].stage, 1)
|
|
widths = []
|
|
original = Canvas.__init__
|
|
|
|
def capture(canvas, image):
|
|
widths.append(image.width)
|
|
original(canvas, image)
|
|
|
|
with patch.object(Canvas, "__init__", capture):
|
|
self.renderer.render(self.who, data, 0)
|
|
self.assertTrue(widths)
|
|
self.assertEqual(set(widths), {1024})
|
|
|
|
def test_missing_sprite_and_private_logs(self):
|
|
metadata = self.renderer.assets.metadata
|
|
plant = next(p for p in Catalogue.bundled() if (
|
|
f'plant/{p.name}/1.png' not in metadata["images"]
|
|
))
|
|
data = snapshot([Plot(1, plant, 0)], name="PRIVATE FARM")
|
|
with self.assertLogs("farm_render.renderer", "INFO") as recorded:
|
|
result = self.renderer.render(self.who, data, 0)
|
|
self.assertTrue(result.content)
|
|
logs = " ".join(recorded.output)
|
|
self.assertIn("missing packaged crop sprite", logs)
|
|
self.assertNotIn("PRIVATE FARM", logs)
|
|
self.assertNotIn(self.who.key, logs)
|
|
|
|
def test_oversized_avatar_is_not_decoded(self):
|
|
content = BytesIO()
|
|
Image.new("RGB", (3000, 3000), "white").save(content, "PNG")
|
|
result = self.renderer.render(
|
|
self.who, snapshot(), 0, avatar=content.getvalue(),
|
|
)
|
|
self.assertTrue(result.content)
|
|
with self.assertRaises(ValueError):
|
|
FarmRenderer(Path("missing-font.ttf"))
|
|
|
|
|
|
class AsyncRenderTests(unittest.IsolatedAsyncioTestCase):
|
|
async def asyncSetUp(self):
|
|
self.assertIsNotNone(FarmRenderer, "异步渲染模块尚未实现")
|
|
self.renderer = FarmRenderer(FONT)
|
|
self.who = Identity("test", "local", "qq", "async")
|
|
|
|
async def test_snapshot_once_and_loop_not_blocked(self):
|
|
class Source:
|
|
calls = 0
|
|
|
|
async def snapshot(inner, who):
|
|
inner.calls += 1
|
|
return snapshot()
|
|
|
|
source = Source()
|
|
service = RenderService(self.renderer)
|
|
original = self.renderer.render
|
|
reached = threading.Event()
|
|
|
|
def slow(*args, **kwargs):
|
|
reached.set()
|
|
time.sleep(0.1)
|
|
return original(*args, **kwargs)
|
|
|
|
self.renderer.render = slow
|
|
task = asyncio.create_task(service.my_farm(source, self.who, now=0))
|
|
await asyncio.to_thread(reached.wait, 2)
|
|
self.assertFalse(task.done())
|
|
self.assertTrue((await task).content)
|
|
self.assertEqual(source.calls, 1)
|
|
await service.close()
|
|
|
|
async def test_singleflight_cancel_capacity_and_close(self):
|
|
service = RenderService(self.renderer, concurrency=1, max_pending=1)
|
|
entered = threading.Event()
|
|
release = threading.Event()
|
|
original = self.renderer.render
|
|
calls = []
|
|
|
|
def slow(*args, **kwargs):
|
|
calls.append(1)
|
|
entered.set()
|
|
release.wait(3)
|
|
return original(*args, **kwargs)
|
|
|
|
self.renderer.render = slow
|
|
data = snapshot()
|
|
first = asyncio.create_task(service.render(self.who, data, 0))
|
|
await asyncio.to_thread(entered.wait, 2)
|
|
same = asyncio.create_task(service.render(self.who, data, 0))
|
|
await asyncio.sleep(0)
|
|
first.cancel()
|
|
with self.assertRaises(asyncio.CancelledError):
|
|
await first
|
|
with self.assertRaises(RuntimeError):
|
|
await service.render(replace(self.who, user_id="two"), data, 0)
|
|
closing = asyncio.create_task(service.close())
|
|
await asyncio.sleep(0.02)
|
|
self.assertFalse(closing.done())
|
|
release.set()
|
|
self.assertTrue((await same).content)
|
|
await closing
|
|
self.assertEqual(len(calls), 1)
|
|
with self.assertRaises(RuntimeError):
|
|
await service.render(self.who, data, 0)
|
|
|
|
async def test_failure_frees_capacity_for_retry(self):
|
|
service = RenderService(self.renderer)
|
|
original = self.renderer.render
|
|
with patch.object(self.renderer, "render", side_effect=ValueError):
|
|
with self.assertRaises(ValueError):
|
|
await service.render(self.who, snapshot(), 0)
|
|
self.renderer.render = original
|
|
self.assertTrue((await service.render(
|
|
self.who, snapshot(), 0,
|
|
)).content)
|
|
await service.close()
|
|
|
|
async def test_limit_bounds_distinct_parallel_jobs(self):
|
|
service = RenderService(self.renderer, concurrency=2, max_pending=4)
|
|
lock = threading.Lock()
|
|
active = 0
|
|
maximum = 0
|
|
original = self.renderer.render
|
|
|
|
def observed(*args, **kwargs):
|
|
nonlocal active, maximum
|
|
with lock:
|
|
active += 1
|
|
maximum = max(maximum, active)
|
|
try:
|
|
time.sleep(0.03)
|
|
return original(*args, **kwargs)
|
|
finally:
|
|
with lock:
|
|
active -= 1
|
|
|
|
self.renderer.render = observed
|
|
await asyncio.gather(*(
|
|
service.render(replace(self.who, user_id=str(i)), snapshot(), 0)
|
|
for i in range(4)
|
|
))
|
|
self.assertEqual(maximum, 2)
|
|
self.assertEqual(active, 0)
|
|
await service.close()
|