Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

test(web): verify rendered image behavior (#1195)

Generbb331c45c676
diff --git a/src/web/src/components/avatar/profile-avatar.error.dom.test.ts b/src/web/src/components/avatar/profile-avatar.error.dom.test.ts
index e5aae538f..a6dbecd29 100644
--- a/src/web/src/components/avatar/profile-avatar.error.dom.test.ts
+++ b/src/web/src/components/avatar/profile-avatar.error.dom.test.ts
@@ -41,8 +41,7 @@ describe("ProfileAvatar photo errors", () => {
await act(async () => { await Promise.resolve() })
rendered.rerender(element("/second.png"))
expect(original.isConnected).toBe(true)
- expect(original).toHaveClass("opacity-100")
- expect(placeholder(rendered.container)).not.toHaveClass("animate-pulse")
+
rendered.rerender(element("/second.png", "user_2"))
expect(original.isConnected).toBe(false)
expect(photo(rendered.container)).toHaveAttribute("src", "/second.png")
@@ -95,7 +94,7 @@ describe("ProfileAvatar photo errors", () => {
expect(rendered.container.querySelector("svg")).toBeInTheDocument()
})
- it("reveals a cached photo whose load event completed before hydration", async () => {
+ it("settles a photo cached before hydration", async () => {
mockImageReadiness(true, 40, 40)
const rendered = render(createElement(ProfileAvatar, {
label: "Ada",
@@ -106,10 +105,10 @@ describe("ProfileAvatar photo errors", () => {
await waitFor(() => expect(photo(rendered.container))
.toHaveAttribute("data-avatar-photo-state", "ready"))
expect(placeholder(rendered.container)).not.toHaveAttribute("data-avatar-photo-placeholder")
- expect(placeholder(rendered.container)).not.toHaveClass("animate-pulse")
+
})
- it("shows a static neutral placeholder when a cached photo failed before hydration", () => {
+ it("reports a cached photo error without a letter or SVG fallback", () => {
mockImageReadiness(true, 0, 0)
const rendered = render(createElement(ProfileAvatar, {
label: "Ada",
@@ -119,13 +118,13 @@ describe("ProfileAvatar photo errors", () => {
expect(photo(rendered.container)).toHaveAttribute("data-avatar-photo-state", "failed")
expect(placeholder(rendered.container)).toHaveAttribute("data-avatar-photo-placeholder", "failed")
- expect(placeholder(rendered.container)).not.toHaveClass("animate-pulse")
+
expect(rendered.container.querySelector('[data-slot="avatar-fallback"]')).not.toBeInTheDocument()
expect(rendered.container.querySelector("svg")).not.toBeInTheDocument()
expect(rendered.container).not.toHaveTextContent("A")
})
- it("stops the neutral skeleton after the photo reports an error", () => {
+ it("reports a native photo error without changing identity fallback", () => {
const rendered = render(createElement(ProfileAvatar, {
label: "Ada",
src: "https://cdn.example.com/missing.png",
@@ -138,11 +137,11 @@ describe("ProfileAvatar photo errors", () => {
expect(photo(rendered.container)).toHaveAttribute("data-avatar-photo-state", "failed")
expect(placeholder(rendered.container)).toHaveAttribute("data-avatar-photo-placeholder", "failed")
- expect(placeholder(rendered.container)).not.toHaveClass("animate-pulse")
+
expect(rendered.container.querySelector('[data-slot="avatar-fallback"]')).not.toBeInTheDocument()
})
- it("reveals a loaded photo over its retained neutral placeholder", async () => {
+ it("retains the loaded photo ready state after timer advancement", async () => {
vi.useFakeTimers()
const rendered = render(createElement(ProfileAvatar, {
label: "Ada",
@@ -156,13 +155,12 @@ describe("ProfileAvatar photo errors", () => {
expect(photo(rendered.container)).toHaveAttribute("data-avatar-photo-state", "ready")
expect(placeholder(rendered.container)).not.toHaveAttribute("data-avatar-photo-placeholder")
- expect(placeholder(rendered.container)).not.toHaveClass("animate-pulse")
await act(async () => vi.advanceTimersByTime(5_000))
expect(photo(rendered.container)).toHaveAttribute("data-avatar-photo-state", "ready")
})
- it("keeps a slow photo pending and reveals its late success", async () => {
+ it("keeps a slow photo pending until its late success", async () => {
vi.useFakeTimers()
const rendered = render(createElement(ProfileAvatar, {
label: "Ada",
@@ -175,17 +173,16 @@ describe("ProfileAvatar photo errors", () => {
const image = photo(rendered.container)
expect(image).toHaveAttribute("data-avatar-photo-state", "pending")
expect(placeholder(rendered.container)).toHaveAttribute("data-avatar-photo-placeholder", "pending")
- expect(placeholder(rendered.container)).toHaveClass("animate-pulse")
setLoadedImageMetrics(image)
fireEvent.load(image)
await act(async () => { await Promise.resolve() })
expect(photo(rendered.container)).toHaveAttribute("data-avatar-photo-state", "ready")
expect(placeholder(rendered.container)).not.toHaveAttribute("data-avatar-photo-placeholder")
- expect(placeholder(rendered.container)).not.toHaveClass("animate-pulse")
+
})
- it("retries from a neutral skeleton when the photo source changes", () => {
+ it("resets a failed photo to pending for the new source", () => {
const props = { label: "Ada", seed: "user_1" }
const rendered = render(createElement(ProfileAvatar, {
...props,
@@ -201,7 +198,7 @@ describe("ProfileAvatar photo errors", () => {
expect(photo(rendered.container)).toHaveAttribute("src", "https://cdn.example.com/second.png")
expect(photo(rendered.container)).toHaveAttribute("data-avatar-photo-state", "pending")
expect(placeholder(rendered.container)).toHaveAttribute("data-avatar-photo-placeholder", "pending")
- expect(placeholder(rendered.container)).toHaveClass("animate-pulse")
+
expect(rendered.container.querySelector('[data-slot="avatar-fallback"]')).not.toBeInTheDocument()
})
})
diff --git a/src/web/src/components/avatar/profile-avatar.test.ts b/src/web/src/components/avatar/profile-avatar.test.ts
index 6dd8e0c06..627ec5070 100644
--- a/src/web/src/components/avatar/profile-avatar.test.ts
+++ b/src/web/src/components/avatar/profile-avatar.test.ts
@@ -1,100 +1,95 @@
import { createElement } from "react"
import { renderToStaticMarkup } from "react-dom/server"
-import { describe, expect, it } from "vitest"
+import { JSDOM } from "jsdom"
+import { within } from "@testing-library/react/pure"
+import { afterEach, describe, expect, it } from "vitest"
import { serializeBeamSeed } from "@/lib/avatar/seed-url"
import { ProfileAvatar, type ProfileAvatarProps } from "./profile-avatar"
+const closeDocuments = new Set<() => void>()
+
+afterEach(() => {
+ for (const close of closeDocuments) close()
+ closeDocuments.clear()
+})
+
function normalize(html: string): string {
return html.replace(/_R_[0-9a-z]+_/g, "_ID_").replace(/#[0-9a-z]+_ID_/g, "#_ID_")
}
-function render(props: ProfileAvatarProps): string {
- return renderToStaticMarkup(createElement(ProfileAvatar, props))
+function render(props: ProfileAvatarProps) {
+ expect(typeof globalThis.window).toBe("undefined")
+ expect(typeof globalThis.document).toBe("undefined")
+ const markup = renderToStaticMarkup(createElement(ProfileAvatar, props))
+ const dom = new JSDOM(markup)
+ closeDocuments.add(() => dom.window.close())
+ expect(typeof globalThis.window).toBe("undefined")
+ expect(typeof globalThis.document).toBe("undefined")
+ const container = dom.window.document.body
+ return { container, markup, view: within(container) }
}
describe("ProfileAvatar", () => {
- it("mounts a photo over a same-size neutral pending skeleton", () => {
- const html = render({
- label: "Ada",
- src: "https://cdn.example.com/ada.png",
- seed: "user_1",
- size: 40,
- className: "ring-2",
- "data-testid": "profile-avatar",
+ it("emits a photo and pending placeholder at the supplied size", () => {
+ const { view, container } = render({
+ label: "Ada", src: "https://cdn.example.com/ada.png", seed: "user_1",
+ size: 40, "data-testid": "profile-avatar",
})
-
- expect(html).toContain('data-testid="profile-avatar"')
- expect(html).toContain('data-avatar-kind="photo"')
- expect(html).toContain('data-slot="avatar-photo-placeholder" data-avatar-photo-placeholder="pending"')
- expect(html).toContain("absolute inset-0 bg-muted animate-pulse motion-reduce:animate-none rounded-full")
- expect(html).not.toContain('data-slot="avatar-fallback"')
- expect(html).not.toContain(">A</span>")
- expect(html).toContain('data-slot="avatar-image" data-avatar-photo-state="pending"')
- expect(html).toContain('src="https://cdn.example.com/ada.png" alt="Ada"')
- expect(html).toContain("opacity-0")
- expect(html).not.toContain("transition-opacity")
- expect(html).toContain("transition-none")
- expect(html).toContain("width:40px;height:40px")
- expect(html).toContain("ring-2")
+ expect(view.getByRole("img", { name: "Ada" }).getAttribute("src")).toBe("https://cdn.example.com/ada.png")
+ const avatar = view.getByTestId("profile-avatar")
+ expect(avatar.style.width).toBe("40px")
+ expect(avatar.style.height).toBe("40px")
+ expect(container.querySelector('[data-slot="avatar-photo-placeholder"]')).not.toBeNull()
+ expect(container.querySelector('[data-slot="avatar-fallback"]')).toBeNull()
+ expect(view.queryByText("A", { exact: true })).toBeNull()
})
it("renders a stored beam seed without emitting an image or fallback", () => {
- const html = render({
- label: "Ada",
- src: serializeBeamSeed("stored-seed"),
- seed: "user_1",
- })
-
- expect(html).toContain("<svg")
- expect(html).not.toContain("<img")
- expect(html).not.toContain('data-slot="avatar-fallback"')
- expect(html).toContain('role="img"')
- expect(html).toContain('aria-label="Ada"')
+ const { view, container } = render({ label: "Ada", src: serializeBeamSeed("stored-seed"), seed: "user_1" })
+ expect(view.getByRole("img", { name: "Ada" })).not.toBeNull()
+ expect(container.querySelector("svg")).not.toBeNull()
+ expect(container.querySelector("img")).toBeNull()
+ expect(container.querySelector('[data-slot="avatar-fallback"]')).toBeNull()
})
it("uses the stable id for a missing avatar and stays unchanged across rename", () => {
- const before = normalize(render({ label: "Ada", src: null, seed: "user_1" }))
- const after = normalize(render({ label: "Adelaide", src: null, seed: "user_1" }))
-
- expect(before).toContain("<svg")
- expect(after.replace('aria-label="Adelaide"', 'aria-label="Ada"')).toBe(before)
+ const before = render({ label: "Ada", src: null, seed: "user_1" })
+ const after = render({ label: "Adelaide", src: null, seed: "user_1" })
+ expect(before.view.getByRole("img", { name: "Ada" })).not.toBeNull()
+ expect(after.view.getByRole("img", { name: "Adelaide" })).not.toBeNull()
+ const beforeArt = before.container.querySelector("svg")
+ const afterArt = after.container.querySelector("svg")
+ expect(beforeArt).not.toBeNull()
+ expect(afterArt).not.toBeNull()
+ expect(normalize(afterArt!.outerHTML)).toBe(normalize(beforeArt!.outerHTML))
})
it("uses one letter only when neither avatar nor stable id is available", () => {
- const html = render({ label: "Ada", src: null })
-
- expect(html).toContain('data-slot="avatar-fallback"')
- expect(html).toContain(">A<")
- expect(html).not.toContain("<svg")
+ const { view, container } = render({ label: "Ada", src: null })
+ expect(view.getByRole("img", { name: "Ada" })).not.toBeNull()
+ expect(view.getByText("A", { exact: true })).not.toBeNull()
+ expect(container.querySelector("svg")).toBeNull()
+ expect(container.querySelector("img")).toBeNull()
})
it("honors decorative alt text and dimming", () => {
- const html = render({
- label: "Ada",
- src: "/api/avatar",
- seed: "user_1",
- alt: "",
- dim: true,
- })
-
- expect(html).toContain('data-avatar-kind="photo"')
- expect(html).toContain('data-avatar-photo-placeholder="pending"')
- expect(html).not.toContain('data-slot="avatar-fallback"')
- expect(html).toContain('data-slot="avatar-image" data-avatar-photo-state="pending"')
- expect(html).toContain('src="/api/avatar" alt=""')
- expect(html).toContain('aria-hidden="true"')
- expect(html).not.toContain('role="img"')
- expect(html).not.toContain("aria-label")
- expect(html).toContain("opacity:0.4")
+ const { view, container } = render({ label: "Ada", src: "/api/avatar", seed: "user_1", alt: "", dim: true })
+ expect(view.queryByRole("img")).toBeNull()
+ const photo = container.querySelector("img")
+ expect(photo?.getAttribute("src")).toBe("/api/avatar")
+ expect(photo?.getAttribute("alt")).toBe("")
+ expect(container.querySelector('[data-slot="avatar-fallback"]')).toBeNull()
+ const opacity = Number((container.querySelector('[data-slot="avatar"]') as HTMLElement).style.opacity)
+ expect(opacity).toBeGreaterThan(0)
+ expect(opacity).toBeLessThan(1)
})
it("makes generated avatars decorative without exposing their source", () => {
const source = serializeBeamSeed("private-seed")
- const html = render({ label: source, src: source, seed: "user_1", alt: "" })
-
- expect(html).toContain('aria-hidden="true"')
- expect(html).not.toContain('role="img"')
- expect(html).not.toContain("aria-label")
- expect(html).not.toContain(source)
+ const { view, container, markup } = render({ label: source, src: source, seed: "user_1", alt: "" })
+ expect(container.querySelector("svg")).not.toBeNull()
+ expect(view.queryByRole("img")).toBeNull()
+ expect(container.textContent).not.toContain(source)
+ expect(markup).not.toContain(source)
})
})
diff --git a/src/web/src/components/community/messages/image-lightbox.dom.test.ts b/src/web/src/components/community/messages/image-lightbox.dom.test.ts
index 24b928683..2a5a3a11b 100644
--- a/src/web/src/components/community/messages/image-lightbox.dom.test.ts
+++ b/src/web/src/components/community/messages/image-lightbox.dom.test.ts
@@ -76,7 +76,7 @@ describe("ImageLightbox", () => {
vi.unstubAllGlobals()
})
- it("shows a complete cached original immediately without decode or a scheduled reveal", () => {
+ it("enables cached-original controls immediately without decode or a scheduled reveal", () => {
const descriptor = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, "decode")
const decode = vi.fn(() => new Promise<void>(() => {}))
Object.defineProperty(HTMLImageElement.prototype, "decode", { configurable: true, value: decode })
@@ -88,9 +88,6 @@ describe("ImageLightbox", () => {
try {
for (let mount = 0; mount < 2; mount++) {
const { renderer } = renderLightbox({ originalUrl: "/cached-original", thumbnailUrl: "/cached-thumbnail", name: "cached" })
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100", "pointer-events-auto")
- expect(image(renderer, tid.imageLightboxOriginal)).not.toHaveClass("transition-opacity")
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("opacity-0")
expect(renderer.queryByTestId(tid.imageLightboxLoading)).not.toBeInTheDocument()
expect(image(renderer, tid.imageLightboxOriginal)).toHaveStyle({ maxWidth: "1000px", maxHeight: "500px" })
expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
@@ -121,19 +118,19 @@ describe("ImageLightbox", () => {
expect(retried).not.toBe(old)
expect(retried).toHaveAttribute("src", "/original?v=3&size=640")
expect(image(renderer, tid.imageLightboxThumbnail)).toBe(thumbnail)
- expect(thumbnail).toHaveClass("opacity-100")
+
await act(async () => { finish(); await oldDecode })
expect(retried).toHaveAttribute("data-remote-image-state", "pending")
fireEvent.error(old)
expect(retried).toHaveAttribute("data-remote-image-state", "pending")
await loadImage(retried, 640, 480, () => Promise.resolve())
- expect(retried).toHaveClass("opacity-100")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
expect(renderer.queryByTestId(tid.imageLightboxError)).not.toBeInTheDocument()
fireEvent(window, new Event("online"))
expect(image(renderer, tid.imageLightboxOriginal)).toBe(retried)
})
- it("keeps one image region and the same fit for both layers through decode", async () => {
+ it("keeps one region and both known dimension caps through decode", async () => {
let resolveDecode!: () => void
const decodePromise = new Promise<void>((resolve) => { resolveDecode = resolve })
const { renderer } = renderLightbox({
@@ -152,39 +149,24 @@ describe("ImageLightbox", () => {
expect(thumbnail).toHaveStyle({ maxWidth: "800px", maxHeight: "450px" })
expect(original).toHaveStyle({ maxWidth: "800px", maxHeight: "450px" })
expect(frame).toHaveAttribute("data-native-context-menu", "true")
- expect(thumbnail).toHaveClass("absolute", "inset-0", "size-full")
- expect(thumbnail).toHaveClass("pointer-events-none")
- expect(original).toHaveClass(
- "absolute",
- "inset-0",
- "size-full",
- "pointer-events-none",
- "opacity-0",
- )
- expect(frame.parentElement).not.toHaveClass("invisible")
+
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeDisabled()
+
expect(renderer.getByTestId(tid.imageLightboxLoading))
.toHaveTextContent("Loading original image")
await loadThumbnail(renderer, 200, 112)
- expect(renderer.getByTestId(tid.imageLightbox).parentElement).not.toHaveClass("invisible")
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("pointer-events-auto")
prepareImage(original, 800, 450, () => decodePromise)
fireEvent.load(original)
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-0")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeDisabled()
await act(async () => {
resolveDecode()
await decodePromise
})
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass(
- "pointer-events-auto",
- "opacity-100",
- )
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass(
- "pointer-events-none",
- "opacity-0",
- )
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
+
expect(renderer.getByTestId(tid.imageLightbox)).toBe(frame)
expect(frame.style.width).toBe("")
expect(frame.style.aspectRatio).toBe("")
@@ -205,7 +187,7 @@ describe("ImageLightbox", () => {
expect(renderer.queryAllByTestId(tid.imageLightboxOriginal)).toHaveLength(0)
expect(image(renderer, tid.imageLightboxThumbnail)).toHaveAttribute("src", "/thumbnail")
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("pointer-events-auto")
+
expect(renderer.getByTestId(tid.imageLightboxError))
.toHaveTextContent("Failed to load original image")
expect(renderer.getByTestId(tid.imageLightboxRetry)).toHaveTextContent("Retry")
@@ -216,10 +198,10 @@ describe("ImageLightbox", () => {
expect(renderer.queryAllByTestId(tid.imageLightboxError)).toHaveLength(0)
await loadImage(retriedOriginal, 640, 480, () => Promise.resolve())
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
})
- it("learns legacy image dimensions after decode without resizing or replacing the region", async () => {
+ it("learns legacy dimension caps after decode without replacing the region", async () => {
let resolveDecode!: () => void
const decodePromise = new Promise<void>((resolve) => { resolveDecode = resolve })
const { renderer } = renderLightbox({
@@ -237,7 +219,7 @@ describe("ImageLightbox", () => {
prepareImage(original, 1000, 500, () => decodePromise)
fireEvent.load(original)
expect(original.style.maxWidth).toBe("")
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-0")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeDisabled()
await act(async () => {
resolveDecode()
@@ -248,7 +230,7 @@ describe("ImageLightbox", () => {
expect(frame.style.aspectRatio).toBe("")
expect(original).toHaveStyle({ maxWidth: "1000px", maxHeight: "500px" })
expect(image(renderer, tid.imageLightboxThumbnail)).toHaveStyle({ maxWidth: "1000px", maxHeight: "500px" })
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
})
it("treats a decode failure like an original load failure", async () => {
@@ -265,7 +247,7 @@ describe("ImageLightbox", () => {
() => Promise.reject(new Error("decode failed")),
)
expect(renderer.getByTestId(tid.imageLightboxError)).toBeInTheDocument()
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("opacity-100")
+
})
it("ignores late load, decode, and error callbacks from a retried attempt", async () => {
@@ -289,16 +271,16 @@ describe("ImageLightbox", () => {
fireEvent.error(oldOriginal)
expect(renderer.queryAllByTestId(tid.imageLightboxError)).toHaveLength(0)
- expect(retriedOriginal).toHaveClass("opacity-0")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeDisabled()
await act(async () => {
resolveOldDecode()
await oldDecode
})
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-0")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeDisabled()
await loadImage(retriedOriginal, 640, 480, () => Promise.resolve())
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
})
it("shows an explicit original-loading fallback when no thumbnail exists", () => {
@@ -308,35 +290,34 @@ describe("ImageLightbox", () => {
expect(renderer.getByTestId(tid.imageLightbox).style.aspectRatio).toBe("")
})
- it("keeps a slow original pending and displays its success beyond five seconds", async () => {
+ it("keeps a slow original pending and enables controls after late success", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] })
const { renderer } = renderLightbox({ originalUrl: "/stalled", name: "stalled" })
const loading = renderer.getByTestId(tid.imageLightboxLoading)
- expect(loading).toHaveClass("motion-reduce:animate-none")
await act(async () => vi.advanceTimersByTime(30_000))
expect(renderer.getByTestId(tid.imageLightboxLoading)).toBe(loading)
expect(renderer.queryByTestId(tid.imageLightboxError)).not.toBeInTheDocument()
await loadImage(image(renderer, tid.imageLightboxOriginal), 800, 600, () => Promise.resolve())
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
expect(renderer.queryByTestId(tid.imageLightboxLoading)).not.toBeInTheDocument()
})
- it("reveals a decoded original even when its thumbnail stays pending", async () => {
+ it("enables original controls independently of a pending or late thumbnail", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] })
const { renderer } = renderLightbox({ originalUrl: "/original", thumbnailUrl: "/stalled-thumbnail", name: "Photo" })
await act(async () => vi.advanceTimersByTime(30_000))
expect(image(renderer, tid.imageLightboxThumbnail)).toHaveAttribute("data-remote-image-state", "pending")
await loadImage(image(renderer, tid.imageLightboxOriginal), 1200, 600, () => Promise.resolve())
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
expect(image(renderer, tid.imageLightboxThumbnail)).toHaveAttribute("data-remote-image-state", "pending")
expect(renderer.queryByTestId(tid.imageLightboxLoading)).not.toBeInTheDocument()
await loadThumbnail(renderer, 512, 256)
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("opacity-0")
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
+
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
})
- it("keeps a cold thumbnail until the original is decoded without an additional reveal frame", async () => {
+ it("settles cold-thumbnail then original readiness without a scheduled reveal", async () => {
const schedule = vi.fn()
vi.stubGlobal("requestAnimationFrame", schedule)
vi.stubGlobal("cancelAnimationFrame", vi.fn())
@@ -352,43 +333,19 @@ describe("ImageLightbox", () => {
const frame = () => renderer.getByTestId(tid.imageLightbox)
const original = image(renderer, tid.imageLightboxOriginal)
- expect(frame().parentElement).not.toHaveClass("invisible")
expect(renderer.getByTestId(tid.imageLightboxLoading)).toBeInTheDocument()
await loadThumbnail(renderer, 512, 269)
- expect(frame().parentElement).not.toHaveClass("invisible")
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("opacity-100")
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-0")
+
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeDisabled()
await loadImage(original, 1200, 630, () => Promise.resolve())
- expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
- expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("opacity-0")
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
+
expect(schedule).not.toHaveBeenCalled()
} finally {
vi.unstubAllGlobals()
}
})
- it.each([
- { name: "extreme landscape", width: 4000, height: 100 },
- { name: "extreme portrait", width: 100, height: 4000 },
- ])("keeps controls above the transparent, overflowing image layer for $name", ({ width, height }) => {
- const { renderer } = renderLightbox({ originalUrl: "/original", name: "extreme", width, height })
- fireEvent.error(image(renderer, tid.imageLightboxOriginal))
- const frame = renderer.getByTestId(tid.imageLightbox)
- const error = renderer.getByTestId(tid.imageLightboxError)
- const retry = renderer.getByTestId(tid.imageLightboxRetry)
-
- expect(frame.querySelectorAll(`[data-testid="${tid.imageLightboxError}"]`)).toHaveLength(0)
- expect(error.parentElement).toBe(frame.parentElement)
- const toolbar = renderer.getByRole("toolbar", { name: "Image controls" })
- expect(toolbar.parentElement).toBe(frame.parentElement)
- expect(toolbar.nextElementSibling).toBe(frame)
- expect(toolbar).toHaveClass("relative", "z-20")
- expect(frame).toHaveClass("z-0", "overflow-visible")
- expect(frame).not.toHaveClass("overflow-hidden", "bg-background")
- expect(error).toHaveClass("w-max")
- expect(retry).toHaveClass("h-12", "min-w-12")
- })
-
it("preserves the dialog close callback", () => {
const { renderer, onClose } = renderLightbox({ originalUrl: "/original", name: "photo" })
fireEvent.click(renderer.container.querySelector('[data-dialog-open-change="true"]')!)
@@ -553,7 +510,6 @@ describe("ImageLightbox", () => {
expect(renderer.getByTestId(tid.imageLightboxRetry)).toBeVisible()
})
-
it("preserves free pan on resize, cancels its drag, and disconnects on close", async () => {
let resize!: ResizeObserverCallback
const disconnect = vi.fn()
diff --git a/src/web/src/components/remote-image/remote-image.dom.test.ts b/src/web/src/components/remote-image/remote-image.dom.test.ts
index 901fb5862..27d89e747 100644
--- a/src/web/src/components/remote-image/remote-image.dom.test.ts
+++ b/src/web/src/components/remote-image/remote-image.dom.test.ts
@@ -59,7 +59,7 @@ describe("remote image state adapters", () => {
rendered.rerender(tree("visible"))
expect(sourceImage(rendered.container, "/activity-ready.png")).toBe(image)
expect(image).toHaveAttribute("data-remote-image-state", "ready")
- expect(image).toHaveClass("opacity-100")
+
expect(image).toBeVisible()
})
@@ -81,7 +81,7 @@ describe("remote image state adapters", () => {
rendered.rerender(tree("visible"))
expect(sourceImage(rendered.container, "/activity-pending.png")).toBe(image)
expect(image).toHaveAttribute("data-remote-image-state", "ready")
- expect(image).toHaveClass("opacity-100")
+
expect(decode).not.toHaveBeenCalled()
})
@@ -99,7 +99,7 @@ describe("remote image state adapters", () => {
expect(image).toHaveAttribute("data-remote-image-state", "ready")
await act(async () => { reject(new Error("retired decode")); await pending.catch(() => {}) })
expect(image).toHaveAttribute("data-remote-image-state", "ready")
- expect(image).toHaveClass("opacity-100")
+
})
it("updates the source while hidden and retires a changed identity", async () => {
@@ -119,9 +119,9 @@ describe("remote image state adapters", () => {
expect(image.isConnected).toBe(false)
const replacement = sourceImage(rendered.container, "/other-peer?v=1")
expect(replacement).not.toBe(image)
- expect(replacement).toHaveClass("opacity-0")
+
await makeReady(replacement)
- expect(replacement).toHaveClass("opacity-100")
+
})
it("recovers a failed image after online occurs while Activity is hidden", async () => {
@@ -137,10 +137,10 @@ describe("remote image state adapters", () => {
expect(sourceImage(rendered.container, "/activity-error?v=1")).toBe(image)
expect(image).toHaveAttribute("data-remote-image-state", "pending")
await makeReady(image)
- expect(image).toHaveClass("opacity-100")
+
})
- it("shows a complete identity image with natural pixels synchronously without another decode", () => {
+ it("settles a complete cached identity synchronously without another decode", () => {
const descriptor = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, "decode")
const decode = vi.fn(() => new Promise<void>(() => {}))
Object.defineProperty(HTMLImageElement.prototype, "decode", { configurable: true, value: decode })
@@ -151,8 +151,7 @@ describe("remote image state adapters", () => {
for (let mount = 0; mount < 2; mount++) {
const rendered = render(identityElement("/cached.png"))
expect(sourceImage(rendered.container, "/cached.png")).toHaveAttribute("data-remote-image-state", "ready")
- expect(sourceImage(rendered.container, "/cached.png")).toHaveClass("opacity-100")
- expect(rendered.container.querySelector(".animate-pulse")).toBeNull()
+
rendered.unmount()
}
expect(decode).not.toHaveBeenCalled()
@@ -162,7 +161,7 @@ describe("remote image state adapters", () => {
}
})
- it.each([false, true])("shows content and Markdown cached pixels synchronously (StrictMode: %s)", (strict) => {
+ it.each([false, true])("settles content and Markdown cached readiness synchronously (StrictMode: %s)", (strict) => {
const descriptor = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, "decode")
const decode = vi.fn(() => new Promise<void>(() => {}))
Object.defineProperty(HTMLImageElement.prototype, "decode", { configurable: true, value: decode })
@@ -178,9 +177,10 @@ describe("remote image state adapters", () => {
for (let mount = 0; mount < 2; mount++) {
const rendered = render(strict ? React.createElement(React.StrictMode, null, tree) : tree)
const images = [...rendered.container.querySelectorAll("img")]
+ expect(images).toHaveLength(2)
+ expect(images.map(image => image.getAttribute("src")).sort()).toEqual(["/cached-content.png", "/cached-markdown.png"].sort())
expect(images.every((image) => image.dataset.remoteImageState === "ready")).toBe(true)
- expect(images.every((image) => image.classList.contains("opacity-100"))).toBe(true)
- expect(images.every((image) => !image.classList.contains("transition-opacity"))).toBe(true)
+
expect(rendered.container.querySelector("[data-remote-image-placeholder]")).toBeNull()
rendered.unmount()
}
@@ -256,7 +256,7 @@ describe("remote image state adapters", () => {
vi.spyOn(HTMLImageElement.prototype, "currentSrc", "get").mockReturnValue(currentSrc)
const rendered = render(React.createElement(RemoteContentImage, { src: "/current.png", alt: "Current" }))
expect(contentImage(rendered.container)).toHaveAttribute("data-remote-image-state", status)
- expect(contentImage(rendered.container)).toHaveClass("opacity-0")
+
})
it("keeps the same ready identity node when only its props update", async () => {
@@ -265,12 +265,11 @@ describe("remote image state adapters", () => {
await makeReady(original)
rendered.rerender(identityElement("/peer?v=1"))
expect(sourceImage(rendered.container, "/peer?v=1")).toBe(original)
- expect(original).toHaveClass("opacity-100")
- expect(rendered.container.querySelector(".animate-pulse")).toBeNull()
+
expect(rendered.container.querySelectorAll("img")).toHaveLength(1)
})
- it("keeps one identity node visible during native source replacement without exposing a placeholder", async () => {
+ it("keeps one identity host through native source replacement", async () => {
const rendered = render(identityElement("/peer?v=1"))
const original = sourceImage(rendered.container, "/peer?v=1")
await makeReady(original)
@@ -278,8 +277,7 @@ describe("remote image state adapters", () => {
expect(original.isConnected).toBe(true)
expect(sourceImage(rendered.container, "/peer?v=2")).toBe(original)
expect(rendered.container.querySelectorAll("img")).toHaveLength(1)
- expect(original).toHaveClass("opacity-100")
- expect(rendered.container.querySelector(".animate-pulse")).toBeNull()
+
let finish!: () => void
const pending = new Promise<void>((resolve) => { finish = resolve })
setImageMetrics(original, () => pending)
@@ -287,7 +285,7 @@ describe("remote image state adapters", () => {
expect(original.isConnected).toBe(true)
await act(async () => { finish(); await pending })
expect(sourceImage(rendered.container, "/peer?v=2")).toBe(original)
- expect(original).toHaveClass("opacity-100")
+
expect(original).toHaveAttribute("data-remote-image-state", "ready")
expect(original).toHaveAttribute("alt", "Peer")
expect(rendered.getAllByRole("img", { name: "Peer" })).toHaveLength(1)
@@ -307,9 +305,9 @@ describe("remote image state adapters", () => {
fireEvent.load(current)
fireEvent.error(current)
expect(original.isConnected).toBe(true)
- expect(original).toHaveClass("opacity-0")
+
expect(original).toHaveAttribute("data-remote-image-state", "error")
- expect(rendered.container.querySelector(".animate-pulse")).toBeNull()
+
fireEvent(window, new Event("online"))
const retried = sourceImage(rendered.container, "/peer?v=2&size=40")
expect(retried).toBe(original)
@@ -318,7 +316,7 @@ describe("remote image state adapters", () => {
expect(retried).toHaveAttribute("data-remote-image-state", "pending")
await makeReady(retried)
expect(original.isConnected).toBe(true)
- expect(retried).toHaveClass("opacity-100")
+
expect(rendered.container.querySelectorAll("img")).toHaveLength(1)
})
@@ -337,7 +335,7 @@ describe("remote image state adapters", () => {
await act(async () => { finish(); await pending })
expect(sourceImage(rendered.container, "/a.png")).toBe(original)
expect(original).toHaveAttribute("data-remote-image-state", "pending")
- expect(original).toHaveClass("opacity-100")
+
await makeReady(original)
expect(original).toHaveAttribute("data-remote-image-state", "ready")
expect(rendered.container.querySelectorAll("img")).toHaveLength(1)
@@ -357,7 +355,7 @@ describe("remote image state adapters", () => {
expect(original.isConnected).toBe(true)
expect(obsolete).toBe(original)
await act(async () => { finish(); await pending })
- expect(original).toHaveClass("opacity-100")
+
expect(sourceImage(rendered.container, "/c.png")).toHaveAttribute("data-remote-image-state", "pending")
await makeReady(sourceImage(rendered.container, "/c.png"))
expect(rendered.container.querySelectorAll("img")).toHaveLength(1)
@@ -381,7 +379,7 @@ describe("remote image state adapters", () => {
await act(async () => { await Promise.resolve() })
expect(decode).not.toHaveBeenCalled()
expect(original).toHaveAttribute("data-remote-image-state", "pending")
- expect(original).toHaveClass("opacity-100")
+
Object.defineProperty(original, "currentSrc", { configurable: true, value: original.src })
fireEvent.load(original)
await act(async () => { await Promise.resolve() })
@@ -433,7 +431,7 @@ describe("remote image state adapters", () => {
await makeReady(original)
rendered.rerender(element("/b.png", "one"))
expect(original.isConnected).toBe(true)
- expect(original).toHaveClass("opacity-100")
+
rendered.rerender(element("/b.png", "two"))
expect(original.isConnected).toBe(false)
expect(rendered.container.querySelectorAll("img")).toHaveLength(1)
@@ -452,7 +450,7 @@ describe("remote image state adapters", () => {
expect(images.every((image) => !image.hasAttribute("src"))).toBe(true)
})
- it("keeps an identity failure neutral and static", () => {
+ it("reports an identity failure without substituting an icon", () => {
const rendered = render(React.createElement(
"span",
{ className: "relative block size-10" },
@@ -471,7 +469,7 @@ describe("remote image state adapters", () => {
expect(placeholder).toHaveAttribute("data-remote-image-state", "error")
expect(placeholder).not.toHaveAttribute("data-avatar-photo-placeholder")
expect(placeholder).not.toHaveAttribute("data-slot")
- expect(placeholder).not.toHaveClass("animate-pulse")
+
expect(rendered.container.querySelectorAll("svg")).toHaveLength(0)
})
@@ -538,7 +536,6 @@ describe("remote image state adapters", () => {
fireEvent.load(oldImage)
fireEvent.error(oldImage)
const retry = screen.getByRole("button", { name: "Retry" })
- expect(retry).toHaveClass("min-h-11", "min-w-11")
fireEvent.click(retry)
const retried = contentImage(rendered.container)
@@ -562,27 +559,28 @@ describe("remote image state adapters", () => {
{ name: "eager content", element: () => React.createElement(RemoteContentImage, { src: "/slow-eager.png", alt: "Eager", loading: "eager" }) },
{ name: "lazy content", element: () => React.createElement(RemoteContentImage, { src: "/slow-lazy.png", alt: "Lazy", loading: "lazy" }) },
{ name: "Markdown", element: () => React.createElement(RemoteMarkdownImage, { src: "/slow-markdown.png", alt: "Markdown" }) },
- ])("keeps $name pending beyond five seconds and reveals its late decoded success", async ({ element }) => {
+ ])("keeps $name pending until its late decoded success", async ({ element }) => {
vi.useFakeTimers()
let finishDecode!: () => void
const decode = new Promise<void>((resolve) => { finishDecode = resolve })
const owner = createApplicationOwner("slow-image-viewer")
- const rendered = render(React.createElement(ApplicationOwnerProvider, { owner }, element()))
- const image = rendered.container.querySelector<HTMLImageElement>("img")!
- await act(async () => vi.advanceTimersByTime(30_000))
- expect(image).toHaveAttribute("data-remote-image-state", "pending")
- expect(image).toHaveClass("opacity-0")
- expect(rendered.queryByRole("button", { name: "Retry" })).not.toBeInTheDocument()
+ try {
+ const rendered = render(React.createElement(ApplicationOwnerProvider, { owner }, element()))
+ const image = rendered.container.querySelector<HTMLImageElement>("img")!
+ await act(async () => vi.advanceTimersByTime(30_000))
+ expect(image).toHaveAttribute("data-remote-image-state", "pending")
- setImageMetrics(image, () => decode)
- fireEvent.load(image)
- await act(async () => vi.advanceTimersByTime(30_000))
- expect(image).toHaveAttribute("data-remote-image-state", "pending")
- await act(async () => { finishDecode(); await decode })
- expect(image).toHaveAttribute("data-remote-image-state", "ready")
- expect(image).toHaveClass("opacity-100")
- rendered.unmount()
- owner.queryClient.clear()
+ expect(rendered.queryByRole("button", { name: "Retry" })).not.toBeInTheDocument()
+
+ setImageMetrics(image, () => decode)
+ fireEvent.load(image)
+ await act(async () => vi.advanceTimersByTime(30_000))
+ expect(image).toHaveAttribute("data-remote-image-state", "pending")
+ await act(async () => { finishDecode(); await decode })
+ expect(image).toHaveAttribute("data-remote-image-state", "ready")
+
+ rendered.unmount()
+ } finally { owner.queryClient.clear() }
})
it("keeps lazy loading native while a real decode failure remains retryable", async () => {
@@ -670,7 +668,7 @@ describe("remote image state adapters", () => {
fireEvent.error(image)
const retry = screen.getByRole("button", { name: "Retry" })
- expect(retry).toHaveClass("min-h-11")
+
fireEvent.click(retry)
expect(rendered.container.querySelector('[data-streamdown="image"]'))
diff --git a/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts b/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts
index 9e6ae7285..9d1f08b6d 100644
--- a/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts
+++ b/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts
@@ -25,6 +25,22 @@ type NativeImageContextMenuProbe = {
targetTestId: string | null
}
+async function expectImageLayer(image: Locator, painted: boolean) {
+ await expect.poll(() => image.evaluateAll((elements) => elements.map((element) => {
+ const image = element as HTMLImageElement
+ const rect = image.getBoundingClientRect()
+ let opacity = 1
+ for (let current: Element | null = image; current; current = current.parentElement) {
+ opacity *= Number(getComputedStyle(current).opacity)
+ }
+ return {
+ opacity,
+ centerHit: document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2) === image,
+ ...(opacity > 0 ? { nativePixels: image.complete && image.naturalWidth > 0 && image.naturalHeight > 0 && rect.width > 0 && rect.height > 0 } : {}),
+ }
+ }))).toEqual([painted ? { opacity: 1, centerHit: true, nativePixels: true } : { opacity: 0, centerHit: false }])
+}
+
async function boundingRect(locator: Locator): Promise<Rect> {
const rect = await locator.boundingBox()
expect(rect).not.toBeNull()
@@ -447,7 +463,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
const landscapeButton = page.getByRole("button", { name: "landscape.webp" })
await landscapeButton.hover()
await landscapeButton.click()
- await expect(page.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-0/)
+ await expectImageLayer(page.getByTestId(tid.imageLightboxOriginal), false)
await expect.poll(() => observedGetPaths.filter((path) => path === landscape.originalPath).length).toBe(1)
await expect.poll(() => coldThumbnailRequests).toBeGreaterThan(0)
await expect(page.getByTestId(tid.imageLightbox)).toBeVisible()
@@ -466,7 +482,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
expectSameRect(await boundingRect(landscapeListFrame), pendingListRect)
await expect(page.getByTestId(tid.imageLightbox)).toBeVisible()
expectSameRect(await previewRects(page, { width: 800, height: 450 }).then((rects) => rects.container), coldPendingRect.container)
- await expect(page.getByTestId(tid.imageLightboxThumbnail)).toHaveClass(/opacity-100/)
+ await expectImageLayer(page.getByTestId(tid.imageLightboxThumbnail), true)
const coldThumbnailReady = await page.getByTestId(tid.imageLightboxThumbnail).evaluate((element: HTMLImageElement) => ({
complete: element.complete,
naturalWidth: element.naturalWidth,
@@ -492,7 +508,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
releaseLandscape()
const landscapeOriginal = page.getByTestId(tid.imageLightboxOriginal)
- await expect(landscapeOriginal).toHaveClass(/pointer-events-auto opacity-100/)
+ await expectImageLayer(landscapeOriginal, true)
await expectNativeImageContextMenu(page, landscapeOriginal, {
src: landscape.originalPath,
testId: tid.imageLightboxOriginal,
@@ -569,11 +585,11 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect(desktopZoomFrame).toHaveCount(0)
await landscapeButton.click()
await expect(desktopZoomFrame).toHaveAttribute("data-zoom-scale", "1")
- await expect(landscapeOriginal).toHaveClass(/opacity-100/)
+ await expectImageLayer(landscapeOriginal, true)
await page.keyboard.press("Escape")
await expect(page.getByTestId(tid.imageLightbox)).toHaveCount(0)
await landscapeButton.click()
- await expect(landscapeOriginal).toHaveClass(/opacity-100/)
+ await expectImageLayer(landscapeOriginal, true)
await waitForDialogEntrance(page)
await page.mouse.click(1, 1)
await expect(desktopZoomFrame).toHaveCount(0)
@@ -614,7 +630,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await portraitButton.hover()
await portraitButton.click()
await expect.poll(() => portraitOriginalRequests.length).toBe(1)
- await expect(page.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-0/)
+ await expectImageLayer(page.getByTestId(tid.imageLightboxOriginal), false)
await waitForDialogEntrance(page)
const desktopPortraitLoading = await previewRects(page, { width: 450, height: 800 })
await attachScreenshot(testInfo, "desktop-portrait-loading", page)
@@ -622,7 +638,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect(page.getByTestId(tid.imageLightboxError)).toContainText("Failed to load original image")
const portraitThumbnail = page.getByTestId(tid.imageLightboxThumbnail)
await expect(portraitThumbnail).toBeVisible()
- await expect(portraitThumbnail).toHaveClass(/pointer-events-auto/)
+ await expectImageLayer(portraitThumbnail, true)
await expectNativeImageContextMenu(page, portraitThumbnail, {
src: portrait.thumbnailPath,
testId: tid.imageLightboxThumbnail,
@@ -640,7 +656,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await page.getByTestId(tid.imageLightboxRetry).click()
await expect.poll(() => portraitOriginalRequests.length).toBe(2)
- await expect(page.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-100/)
+ await expectImageLayer(page.getByTestId(tid.imageLightboxOriginal), true)
const desktopPortraitRetried = await previewRects(page, { width: 450, height: 800 })
expectSameRect(desktopPortraitRetried.container, desktopPortraitFailed.container)
await attachScreenshot(testInfo, "desktop-portrait-retried", page)
@@ -674,6 +690,20 @@ test("image previews keep one frame through loading, decode, failure, retry, and
mobilePortraitGetPaths.push(pathname)
}
})
+ let releaseMobileThumbnail!: () => void
+ const mobileThumbnailGate = new Promise<void>((resolve) => { releaseMobileThumbnail = resolve })
+ caseResources.own(releaseMobileThumbnail, async (captured) => { captured() })
+ let mobileThumbnailRequests = 0
+ await mobilePage.route(`**${landscape.thumbnailPath}`, async (route) => {
+ if (route.request().method() === "GET" && new URL(route.request().url()).pathname === landscape.thumbnailPath) {
+ mobileThumbnailRequests++
+ const response = await route.fetch()
+ await mobileThumbnailGate
+ await route.fulfill({ response })
+ return
+ }
+ await route.continue()
+ })
await mobilePage.setViewportSize({ width: 390, height: 844 })
await mobilePage.goto(channelUrl)
await mobilePage.waitForURL(new RegExp(`/c/channels/[^/]+/${channelId}$`), { waitUntil: "commit" })
@@ -698,12 +728,22 @@ test("image previews keep one frame through loading, decode, failure, retry, and
})
await mobilePage.getByRole("button", { name: "landscape.webp" }).click()
await expect.poll(() => mobileLandscapeRequests).toBe(1)
- await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-0/)
+ await expectImageLayer(mobilePage.getByTestId(tid.imageLightboxOriginal), false)
await waitForDialogEntrance(mobilePage)
const mobileLandscapeLoading = await previewRects(mobilePage, { width: 800, height: 450 })
await attachScreenshot(testInfo, "mobile-landscape-loading", mobilePage)
+ await expect.poll(() => mobileThumbnailRequests).toBeGreaterThan(0)
+ const lateThumbnail = mobilePage.getByTestId(tid.imageLightboxThumbnail)
+ expect(await lateThumbnail.evaluate((image: HTMLImageElement) => ({ complete: image.complete, width: image.naturalWidth })))
+ .toEqual({ complete: false, width: 0 })
releaseMobileLandscape()
- await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-100/)
+ await expectImageLayer(mobilePage.getByTestId(tid.imageLightboxOriginal), true)
+ await expectImageLayer(lateThumbnail, false)
+ releaseMobileThumbnail()
+ await expect.poll(() => lateThumbnail.evaluate((image: HTMLImageElement) => image.complete && image.naturalWidth > 0 && image.naturalHeight > 0)).toBe(true)
+ await expectImageLayer(lateThumbnail, false)
+ await expectImageLayer(mobilePage.getByTestId(tid.imageLightboxOriginal), true)
+ await mobilePage.unroute(`**${landscape.thumbnailPath}`)
const mobileLandscapeLoaded = await previewRects(mobilePage, { width: 800, height: 450 })
expectSameRect(mobileLandscapeLoaded.container, mobileLandscapeLoading.container)
await attachScreenshot(testInfo, "mobile-landscape-loaded", mobilePage)
@@ -755,10 +795,10 @@ test("image previews keep one frame through loading, decode, failure, retry, and
})
await mobilePage.getByRole("button", { name: "portrait.webp" }).click()
await expect.poll(() => mobilePortraitRequests).toBe(1)
- await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-0/)
+ await expectImageLayer(mobilePage.getByTestId(tid.imageLightboxOriginal), false)
await waitForDialogEntrance(mobilePage)
const mobilePortraitLoading = await previewRects(mobilePage, { width: 450, height: 800 })
- await expect(mobilePage.getByTestId(tid.imageLightboxThumbnail)).toHaveClass(/opacity-100/)
+ await expectImageLayer(mobilePage.getByTestId(tid.imageLightboxThumbnail), true)
const mobileNodes = await previewNodes(mobilePage)
caseResources.own(mobileNodes, async (captured) => { await Promise.all(captured.map(({ node }) => node?.dispose())) })
const pendingMobileGets = [...mobilePortraitGetPaths]
@@ -777,7 +817,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
expect(mobilePortraitGetPaths).toEqual(pendingMobileGets)
releaseMobilePortrait()
- await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-100/)
+ await expectImageLayer(mobilePage.getByTestId(tid.imageLightboxOriginal), true)
const mobilePortraitLoaded = await previewRects(mobilePage, { width: 450, height: 800 })
expectSameRect(mobilePortraitLoaded.container, mobilePortraitRestored.container)
const loadedMobileGets = [...mobilePortraitGetPaths]
@@ -830,7 +870,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expectToolbarAboveImage(mobilePage, mobilePortraitZoomedRestored.painted)
expectSameRect(mobilePortraitZoomedRestored.container, mobilePortraitLoaded.container)
await expectSamePreviewNodes(mobilePage, mobileNodes)
- await expect(mobileOriginal).toHaveClass(/opacity-100/)
+ await expectImageLayer(mobileOriginal, true)
expect(mobilePortraitGetPaths).toEqual(loadedMobileGets)
await attachScreenshot(testInfo, "mobile-original-pinched", mobilePage)
for (const name of ["Zoom out", "Fit image", "Zoom in", "Close image preview"]) {
@@ -876,6 +916,14 @@ test("image previews keep one frame through loading, decode, failure, retry, and
expect(error.y).toBeGreaterThanOrEqual(0)
expect(error.x + error.width).toBeLessThanOrEqual(390)
expect(error.y + error.height).toBeLessThanOrEqual(844)
+ expect(await mobilePage.getByTestId(tid.imageLightboxRetry).evaluate((button) => {
+ const rect = button.getBoundingClientRect()
+ return button.contains(document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2))
+ })).toBe(true)
+ await mobilePage.getByTestId(tid.imageLightboxRetry).click()
+ await expect.poll(() => requests).toBe(2)
+ await expect(mobilePage.getByTestId(tid.imageLightboxError)).toBeVisible()
+ await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveCount(0)
await attachScreenshot(testInfo, screenshotName, mobilePage)
await mobilePage.keyboard.press("Escape")
await mobilePage.unroute(`**${attachment.originalPath}`)
diff --git a/src/web/src/test/e2e-ui/29-community-bot-avatar-cleanup.spec.ts b/src/web/src/test/e2e-ui/29-community-bot-avatar-cleanup.spec.ts
index e52840af5..14da4dcdb 100644
--- a/src/web/src/test/e2e-ui/29-community-bot-avatar-cleanup.spec.ts
+++ b/src/web/src/test/e2e-ui/29-community-bot-avatar-cleanup.spec.ts
@@ -136,6 +136,7 @@ test("real bot avatars become unreadable after single delete and authenticated m
}
await route.continue()
})
+ await alice.page.emulateMedia({ reducedMotion: "no-preference" })
await alice.page.reload({ waitUntil: "commit" })
await expect(alice.page.getByText(botName, { exact: true })).toHaveCount(1)
await expect(alice.page.getByText(botName, { exact: true })).toBeVisible()
@@ -146,10 +147,18 @@ test("real bot avatars become unreadable after single delete and authenticated m
expect(pendingFrame).not.toBeNull()
await expect(avatarFrame.locator('[data-remote-image-placeholder="identity"][data-remote-image-state="pending"]'))
.toBeVisible()
+ await expect.poll(() => avatar.evaluate((image) => Number(getComputedStyle(image).opacity))).toBe(0)
+ await expect.poll(() => avatarFrame.locator('[data-remote-image-placeholder="identity"]').evaluate((placeholder) => (
+ placeholder.getAnimations().some((animation) => animation.playState === "running")
+ ))).toBe(true)
releaseAvatar()
await expect(avatar).toHaveAttribute("data-remote-image-state", "error")
await expect(avatarFrame.locator('[data-remote-image-placeholder="identity"][data-remote-image-state="error"]'))
.toBeVisible()
+ await expect.poll(() => avatarFrame.locator('[data-remote-image-placeholder="identity"]').evaluate((placeholder) => (
+ placeholder.getAnimations().filter((animation) => animation.playState === "running").length
+ ))).toBe(0)
+ await expect.poll(() => avatar.evaluate((image) => Number(getComputedStyle(image).opacity))).toBe(0)
await expect(avatarFrame.locator("svg")).toHaveCount(0)
expect(await avatarFrame.boundingBox()).toEqual(pendingFrame)
@@ -161,6 +170,7 @@ test("real bot avatars become unreadable after single delete and authenticated m
await expect.poll(() => avatarRequests).toBeGreaterThan(requestsBeforeReload)
await expect(avatar).toHaveCount(1)
await expect(avatar).toHaveAttribute("data-remote-image-state", "ready")
+ await expect.poll(() => avatar.evaluate((image) => Number(getComputedStyle(image).opacity))).toBe(1)
const readyFrame = await avatarFrame.boundingBox()
expect(readyFrame).toEqual(pendingFrame)
await alice.page.unroute(`**${avatarPath}*`)
diff --git a/src/web/src/test/e2e-ui/42-versioned-avatar-identity.spec.ts b/src/web/src/test/e2e-ui/42-versioned-avatar-identity.spec.ts
index d493d9d70..1df647be8 100644
--- a/src/web/src/test/e2e-ui/42-versioned-avatar-identity.spec.ts
+++ b/src/web/src/test/e2e-ui/42-versioned-avatar-identity.spec.ts
@@ -1,5 +1,6 @@
import { CURRENT_COMMUNITY_FIXTURE_HEADERS, confirmCommunityFixtureApiResponse } from "./_fixtures/business-contract"
-import type { Page } from "@playwright/test"
+import sharp from "sharp"
+import type { Locator, Page } from "@playwright/test"
import { expect, test } from "./_fixtures/case-fixture"
import { gotoAfterUserWsAuth } from "./_fixtures/actions"
@@ -69,9 +70,23 @@ async function uploadSolidAvatar(page: Page, color: string): Promise<AvatarUploa
async function expectPhoto(locator: ReturnType<Page["locator"]>, url: string) {
const photo = locator.locator(`img[src="${url}"]`).first()
await expect(photo).toBeVisible({ timeout: 20_000 })
- await expect.poll(() => photo.evaluate((image: HTMLImageElement) => (
- image.complete && image.naturalWidth > 0
- )), { timeout: 20_000 }).toBe(true)
+ await expect.poll(() => photo.evaluate((image: HTMLImageElement) => {
+ let opacity = 1
+ for (let current: Element | null = image; current; current = current.parentElement) {
+ opacity *= Number(getComputedStyle(current).opacity)
+ }
+ return image.complete && image.naturalWidth > 0 && image.naturalHeight > 0
+ && Number(getComputedStyle(image).opacity) === 1 && opacity > 0
+ }), { timeout: 20_000 }).toBe(true)
+}
+
+async function paintedPixel(photo: Locator): Promise<number[]> {
+ const screenshot = await photo.screenshot({ animations: "allow", scale: "css" })
+ const { data, info } = await sharp(screenshot).ensureAlpha().raw().toBuffer({ resolveWithObject: true })
+ expect(info.width).toBeGreaterThan(0)
+ expect(info.height).toBeGreaterThan(0)
+ const offset = (Math.floor(info.height * 0.3) * info.width + Math.floor(info.width * 0.3)) * info.channels
+ return [...data.subarray(offset, offset + 3)]
}
test("versioned avatars converge across live, stale, reconnect, cold, and concurrent clients", async ({ caseActors, caseResources }, testInfo) => {
@@ -132,6 +147,9 @@ test("versioned avatars converge across live, stale, reconnect, cold, and concur
await expectPhoto(message, warm.url)
const warmImage = await message.locator(`img[src="${warm.url}"]`).first().elementHandle()
if (!warmImage) throw new Error("Warm identity image is missing")
+ const warmPixel = await paintedPixel(message.locator(`img[src="${warm.url}"]`).first())
+ expect(warmPixel[0]! - warmPixel[1]!).toBeGreaterThan(60)
+ expect(warmPixel[0]! - warmPixel[2]!).toBeGreaterThan(60)
const profileGate = deferred(caseResources)
const profileStarted = deferred(caseResources)
@@ -173,30 +191,35 @@ test("versioned avatars converge across live, stale, reconnect, cold, and concur
(event) => event.avatarVersion === second.avatarVersion,
), { timeout: 20_000 }).toBe(true)
await avatarStarted.promise
- const { current, pixels, naturalWidth, naturalHeight, ...pendingImage } = await warmImage.evaluate((image: HTMLImageElement) => ({
+ const { current, pixels, naturalWidth, naturalHeight, transition, ...pendingImage } = await warmImage.evaluate((image: HTMLImageElement) => ({
connected: image.isConnected,
source: image.getAttribute("src"),
current: image.currentSrc,
- opacity: getComputedStyle(image).opacity,
+ opacity: Number(getComputedStyle(image).opacity),
transition: getComputedStyle(image).transitionProperty,
pixels: image.naturalWidth > 0 && image.naturalHeight > 0,
naturalWidth: image.naturalWidth,
naturalHeight: image.naturalHeight,
}))
await testInfo.attach("pending-avatar-image", {
- body: JSON.stringify({ ...pendingImage, current, pixels, naturalWidth, naturalHeight }),
+ body: JSON.stringify({ ...pendingImage, current, pixels, naturalWidth, naturalHeight, transition }),
contentType: "application/json",
})
expect(pendingImage).toEqual({
connected: true,
source: second.url,
- opacity: "1",
- transition: "none",
+ opacity: 1,
})
await expect(message.locator(`img[src="${second.url}"]`)).toBeVisible()
- await expect(message.locator('[data-remote-image-placeholder="identity"].animate-pulse')).toHaveCount(0)
+ const pendingPixel = await paintedPixel(message.locator(`img[src="${second.url}"]`).first())
+ for (let channel = 0; channel < 3; channel++) {
+ expect(Math.abs(pendingPixel[channel]! - warmPixel[channel]!)).toBeLessThanOrEqual(8)
+ }
avatarGate.resolve()
await expectPhoto(message, second.url)
+ const readyPixel = await paintedPixel(message.locator(`img[src="${second.url}"]`).first())
+ expect(readyPixel[2]! - readyPixel[0]!).toBeGreaterThan(60)
+ expect(readyPixel[2]! - readyPixel[1]!).toBeGreaterThan(60)
expect(await warmImage.evaluate((image: HTMLImageElement) => ({
connected: image.isConnected,
source: image.getAttribute("src"),