269 lines
13 KiB
Python
269 lines
13 KiB
Python
import io
|
||
|
||
from PIL import Image
|
||
|
||
from app.core.config import settings
|
||
from tests.conftest import make_image
|
||
|
||
PROJECT = {
|
||
"title": "5 kW Rooftop – Patia",
|
||
"category": "residential",
|
||
"location": "Patia, Bhubaneswar",
|
||
"capacity_kw": 5,
|
||
"installation_date": "2026-03-15",
|
||
"description": "On-grid rooftop system.",
|
||
}
|
||
|
||
|
||
async def _project(client, headers, **overrides) -> dict:
|
||
r = await client.post("/api/admin/projects", headers=headers, json={**PROJECT, **overrides})
|
||
assert r.status_code == 201, r.text
|
||
return r.json()
|
||
|
||
|
||
def _files(*items):
|
||
return [("files", (name, data, mime)) for name, data, mime in items]
|
||
|
||
|
||
async def test_project_crud_and_publishing(client, editor_headers):
|
||
p = await _project(client, editor_headers)
|
||
assert p["slug"] == "5-kw-rooftop-patia"
|
||
assert p["is_published"] is False
|
||
p2 = await _project(client, editor_headers)
|
||
assert p2["slug"] == "5-kw-rooftop-patia-2"
|
||
|
||
bad = await client.post("/api/admin/projects", headers=editor_headers, json={**PROJECT, "capacity_kw": -1, "category": "space"})
|
||
assert bad.status_code == 422
|
||
|
||
# unpublished projects are hidden from the public site
|
||
assert (await client.get("/api/projects")).json()["total"] == 0
|
||
assert (await client.get(f"/api/projects/{p['id']}")).status_code == 404
|
||
|
||
r = await client.put(f"/api/admin/projects/{p['id']}", headers=editor_headers, json={"is_published": True, "capacity_kw": 6.5})
|
||
assert r.status_code == 200 and r.json()["capacity_kw"] == 6.5
|
||
assert (await client.put(f"/api/admin/projects/{p['id']}", headers=editor_headers, json={"title": None})).status_code == 422
|
||
|
||
public = (await client.get("/api/projects")).json()
|
||
assert public["total"] == 1
|
||
assert "is_published" not in public["items"][0]
|
||
assert (await client.get(f"/api/projects/{p['slug']}")).status_code == 200
|
||
assert (await client.get("/api/projects", params={"category": "commercial"})).json()["total"] == 0
|
||
|
||
lst = (await client.get("/api/admin/projects", params={"search": "patia"}, headers=editor_headers)).json()
|
||
assert lst["total"] == 2
|
||
|
||
assert (await client.delete(f"/api/admin/projects/{p2['id']}", headers=editor_headers)).status_code == 204
|
||
assert (await client.get(f"/api/admin/projects/{p2['id']}", headers=editor_headers)).status_code == 404
|
||
|
||
|
||
async def test_upload_jpeg_png_webp_with_watermark_and_thumbnails(client, editor_headers, upload_dir):
|
||
p = await _project(client, editor_headers, is_published=True)
|
||
jpeg = make_image("JPEG", (2400, 1600), quality=95)
|
||
png = make_image("PNG", (1200, 900), mode="RGBA")
|
||
webp = make_image("WEBP", (800, 1200), quality=90)
|
||
|
||
r = await client.post(
|
||
f"/api/admin/projects/{p['id']}/images",
|
||
headers=editor_headers,
|
||
files=_files(("roof.jpg", jpeg, "image/jpeg"), ("site.PNG", png, "image/png"), ("panel.webp", webp, "image/webp")),
|
||
)
|
||
assert r.status_code == 201, r.text
|
||
body = r.json()
|
||
uploaded = body["uploaded"]
|
||
assert [u["mime_type"] for u in uploaded] == ["image/jpeg", "image/png", "image/webp"]
|
||
assert [u["is_featured"] for u in uploaded] == [True, False, False]
|
||
assert body["project"]["featured_image"]["id"] == uploaded[0]["id"]
|
||
|
||
for u, (w, h), src in zip(uploaded, [(2400, 1600), (1200, 900), (800, 1200)], [jpeg, png, webp], strict=True):
|
||
assert (u["width"], u["height"]) == (w, h) # aspect ratio + size preserved
|
||
assert u["file_size"] == len(src)
|
||
name = u["url"].rsplit("/", 1)[-1]
|
||
assert len(name.split(".")[0]) == 32 # server-generated uuid name
|
||
|
||
orig_path = next((upload_dir / "originals").glob(name.split(".")[0] + ".*"))
|
||
assert orig_path.read_bytes() == src # original kept byte-for-byte
|
||
|
||
marked = Image.open(upload_dir / "watermarked" / name)
|
||
original = Image.open(io.BytesIO(src)).convert("RGB")
|
||
marked_rgb = marked.convert("RGB")
|
||
assert marked.size == original.size
|
||
# watermark: clearly visible change confined to the bottom-right corner
|
||
from PIL import ImageChops
|
||
|
||
changed = ImageChops.difference(original, marked_rgb).convert("L").point(lambda v: 255 if v > 30 else 0)
|
||
x0, y0, x1, y1 = changed.getbbox()
|
||
assert x0 > w / 2 and y0 > h / 2, "watermark not in bottom-right"
|
||
assert _region_diff(original, marked_rgb, (x0, y0, x1, y1)) > 25, "watermark too faint"
|
||
diff_tl = _region_diff(original, marked_rgb, (0, 0, int(w * 0.5), int(h * 0.5)))
|
||
assert diff_tl < 3, f"photo altered outside watermark ({diff_tl})"
|
||
|
||
thumb = Image.open(upload_dir / "thumbnails" / u["thumbnail_url"].rsplit("/", 1)[-1])
|
||
assert thumb.format == "WEBP"
|
||
assert max(thumb.size) == settings.THUMBNAIL_MAX_SIZE
|
||
|
||
# public gallery returns watermarked URLs, which are actually served
|
||
detail = (await client.get(f"/api/projects/{p['slug']}")).json()
|
||
assert len(detail["images"]) == 3
|
||
assert "original_filename" not in detail["images"][0]
|
||
path = detail["images"][0]["url"].replace("http://testserver", "")
|
||
served = await client.get(path)
|
||
assert served.status_code == 200 and served.headers["content-type"] == "image/jpeg"
|
||
|
||
# originals are never publicly reachable
|
||
orig_name = next((upload_dir / "originals").glob("*")).name
|
||
assert (await client.get(f"/media/originals/{orig_name}")).status_code == 404
|
||
# ...but admins can download them
|
||
dl = await client.get(uploaded[0]["original_download_path"], headers=editor_headers)
|
||
assert dl.status_code == 200 and dl.content == jpeg
|
||
assert (await client.get(uploaded[0]["original_download_path"])).status_code == 401
|
||
|
||
|
||
def _region_diff(a: Image.Image, b: Image.Image, box) -> float:
|
||
from PIL import ImageChops, ImageStat
|
||
|
||
return max(ImageStat.Stat(ImageChops.difference(a.crop(box), b.crop(box))).mean)
|
||
|
||
|
||
async def test_invalid_uploads_rejected(client, editor_headers, upload_dir, monkeypatch):
|
||
p = await _project(client, editor_headers)
|
||
url = f"/api/admin/projects/{p['id']}/images"
|
||
|
||
cases = [
|
||
(("notes.txt", b"hello", "text/plain"), 415),
|
||
(("fake.jpg", b"this is not an image at all", "image/jpeg"), 400),
|
||
(("evil.gif", make_image("GIF"), "image/gif"), 415),
|
||
(("mismatch.jpg", make_image("PNG"), "image/jpeg"), 415), # content PNG, name .jpg
|
||
(("empty.png", b"", "image/png"), 400),
|
||
(("truncated.jpg", make_image("JPEG")[:2000], "image/jpeg"), 400),
|
||
]
|
||
for file, code in cases:
|
||
r = await client.post(url, headers=editor_headers, files=_files(file))
|
||
assert r.status_code == code, (file[0], r.status_code, r.text)
|
||
assert r.json()["detail"]["errors"]
|
||
|
||
# one bad file in a batch -> whole batch rejected, nothing written
|
||
r = await client.post(
|
||
url,
|
||
headers=editor_headers,
|
||
files=_files(("ok.jpg", make_image("JPEG"), "image/jpeg"), ("bad.jpg", b"junk", "image/jpeg")),
|
||
)
|
||
assert r.status_code == 400
|
||
assert not any(list((upload_dir / d).glob("*")) for d in ("originals", "watermarked", "thumbnails"))
|
||
|
||
# size limit
|
||
monkeypatch.setattr(settings, "MAX_UPLOAD_SIZE_MB", 1)
|
||
big = make_image("PNG", (3000, 3000), mode="RGB", compress_level=0)
|
||
assert len(big) > 1024 * 1024
|
||
r = await client.post(url, headers=editor_headers, files=_files(("big.png", big, "image/png")))
|
||
assert r.status_code == 413
|
||
|
||
# no files at all
|
||
r = await client.post(url, headers=editor_headers)
|
||
assert r.status_code == 422
|
||
|
||
# unknown project
|
||
r = await client.post("/api/admin/projects/999/images", headers=editor_headers,
|
||
files=_files(("ok.jpg", make_image("JPEG"), "image/jpeg")))
|
||
assert r.status_code == 404
|
||
|
||
|
||
async def test_path_traversal_filename_is_neutralised(client, editor_headers, upload_dir):
|
||
p = await _project(client, editor_headers)
|
||
r = await client.post(
|
||
f"/api/admin/projects/{p['id']}/images",
|
||
headers=editor_headers,
|
||
files=_files(("../../../etc/evil.jpg", make_image("JPEG"), "image/jpeg")),
|
||
)
|
||
assert r.status_code == 201
|
||
img = r.json()["uploaded"][0]
|
||
assert img["original_filename"] == "evil.jpg"
|
||
assert ".." not in img["url"]
|
||
assert len(list((upload_dir / "originals").glob("*"))) == 1
|
||
|
||
|
||
async def test_featured_image_and_deletion(client, editor_headers, upload_dir):
|
||
p = await _project(client, editor_headers)
|
||
r = await client.post(
|
||
f"/api/admin/projects/{p['id']}/images",
|
||
headers=editor_headers,
|
||
files=_files(*[(f"p{i}.jpg", make_image("JPEG"), "image/jpeg") for i in range(3)]),
|
||
)
|
||
ids = [u["id"] for u in r.json()["uploaded"]]
|
||
|
||
r = await client.patch(f"/api/admin/project-images/{ids[2]}", headers=editor_headers,
|
||
json={"is_featured": True, "caption": "Completed array"})
|
||
assert r.status_code == 200
|
||
featured = [i for i in r.json()["images"] if i["is_featured"]]
|
||
assert [f["id"] for f in featured] == [ids[2]]
|
||
assert r.json()["featured_image"]["caption"] == "Completed array"
|
||
|
||
# second upload batch keeps existing featured image and appends sort order
|
||
r = await client.post(f"/api/admin/projects/{p['id']}/images", headers=editor_headers,
|
||
files=_files(("more.webp", make_image("WEBP"), "image/webp")))
|
||
assert r.json()["uploaded"][0]["is_featured"] is False
|
||
assert r.json()["uploaded"][0]["sort_order"] == 3
|
||
|
||
# deleting the featured image removes its files and promotes another image
|
||
assert len(list((upload_dir / "watermarked").glob("*"))) == 4
|
||
assert (await client.delete(f"/api/admin/project-images/{ids[2]}", headers=editor_headers)).status_code == 204
|
||
for d in ("originals", "watermarked", "thumbnails"):
|
||
assert len(list((upload_dir / d).glob("*"))) == 3
|
||
proj = (await client.get(f"/api/admin/projects/{p['id']}", headers=editor_headers)).json()
|
||
assert proj["featured_image"]["id"] == ids[0]
|
||
assert sum(i["is_featured"] for i in proj["images"]) == 1
|
||
assert (await client.delete(f"/api/admin/project-images/{ids[2]}", headers=editor_headers)).status_code == 404
|
||
|
||
# deleting the project removes all of its files
|
||
assert (await client.delete(f"/api/admin/projects/{p['id']}", headers=editor_headers)).status_code == 204
|
||
for d in ("originals", "watermarked", "thumbnails"):
|
||
assert list((upload_dir / d).glob("*")) == []
|
||
|
||
|
||
async def test_upload_fails_cleanly_without_logo(client, editor_headers, monkeypatch, tmp_path, upload_dir):
|
||
p = await _project(client, editor_headers)
|
||
monkeypatch.setattr(settings, "WATERMARK_LOGO_PATH", tmp_path / "missing.png")
|
||
r = await client.post(f"/api/admin/projects/{p['id']}/images", headers=editor_headers,
|
||
files=_files(("a.jpg", make_image("JPEG"), "image/jpeg")))
|
||
assert r.status_code == 503
|
||
assert "logo" in r.json()["detail"].lower()
|
||
assert list((upload_dir / "originals").glob("*")) == []
|
||
|
||
|
||
async def test_services_with_watermarked_image(client, editor_headers, upload_dir):
|
||
r = await client.post("/api/admin/services", headers=editor_headers,
|
||
json={"title": "Rooftop Solar", "short_description": "Homes", "sort_order": 1})
|
||
assert r.status_code == 201
|
||
sid = r.json()["id"]
|
||
assert r.json()["slug"] == "rooftop-solar"
|
||
assert (await client.get("/api/services")).json() == []
|
||
|
||
r = await client.put(f"/api/admin/services/{sid}", headers=editor_headers,
|
||
json={"is_published": True, "description": "Full description"})
|
||
assert r.status_code == 200
|
||
|
||
r = await client.post(f"/api/admin/services/{sid}/image", headers=editor_headers,
|
||
files={"file": ("svc.png", make_image("PNG"), "image/png")})
|
||
assert r.status_code == 200, r.text
|
||
first_url = r.json()["image_url"]
|
||
assert first_url and r.json()["thumbnail_url"]
|
||
|
||
# replacing deletes the old files
|
||
r = await client.post(f"/api/admin/services/{sid}/image", headers=editor_headers,
|
||
files={"file": ("svc2.jpg", make_image("JPEG"), "image/jpeg")})
|
||
assert r.json()["image_url"] != first_url
|
||
assert len(list((upload_dir / "watermarked").glob("*"))) == 1
|
||
|
||
bad = await client.post(f"/api/admin/services/{sid}/image", headers=editor_headers,
|
||
files={"file": ("x.jpg", b"nope", "image/jpeg")})
|
||
assert bad.status_code == 400
|
||
|
||
public = (await client.get("/api/services")).json()
|
||
assert len(public) == 1 and "is_published" not in public[0]
|
||
assert (await client.get("/api/services/rooftop-solar")).status_code == 200
|
||
|
||
r = await client.delete(f"/api/admin/services/{sid}/image", headers=editor_headers)
|
||
assert r.json()["image_url"] is None
|
||
assert list((upload_dir / "watermarked").glob("*")) == []
|
||
assert (await client.delete(f"/api/admin/services/{sid}", headers=editor_headers)).status_code == 204
|
||
assert (await client.get("/api/services/rooftop-solar")).status_code == 404
|