mirrors/pdf.js
1
0
Fork 0
mirror of https://github.com/mozilla/pdf.js.git synced 2025-04-19 14:48:08 +02:00
Code Activity

Fix intermittent failures with freetext and stamp tests

Browse source 
They're potentially due to some concurrent access to the system clipboard.
So this patch makes them sequential.
This commit is contained in:
Calixte Denizet 2024-06-27 18:15:45 +02:00
parent af16aa62ad
commit 0e94f2bd00
2 changed files with 470 additions and 485 deletions
Download patch file Download diff file Expand all files Collapse all files

205
test/integration/freetext_editor_spec.mjs
View file

@ -3369,132 +3369,129 @@ describe("FreeText Editor", () => {
}); });
it("must check that pasting html just keep the text", async () => { it("must check that pasting html just keep the text", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [browserName, page] of pages) {
await switchToFreeText(page); await switchToFreeText(page);
const rect = await getRect(page, ".annotationEditorLayer"); const rect = await getRect(page, ".annotationEditorLayer");
let editorSelector = getEditorSelector(0); let editorSelector = getEditorSelector(0);
const data = "Hello PDF.js World !!"; const data = "Hello PDF.js World !!";
await page.mouse.click(rect.x + 100, rect.y + 100); await page.mouse.click(rect.x + 100, rect.y + 100);
await page.waitForSelector(editorSelector, { await page.waitForSelector(editorSelector, {
visible: true, visible: true,
}); });
await page.type(`${editorSelector} .internal`, data); await page.type(`${editorSelector} .internal`, data);
const editorRect = await getRect(page, editorSelector); const editorRect = await getRect(page, editorSelector);
// Commit. // Commit.
await page.keyboard.press("Escape"); await page.keyboard.press("Escape");
await page.waitForSelector(`${editorSelector} .overlay.enabled`); await page.waitForSelector(`${editorSelector} .overlay.enabled`);
const waitForTextChange = (previous, edSelector) => const waitForTextChange = (previous, edSelector) =>
page.waitForFunction( page.waitForFunction(
(prev, sel) => document.querySelector(sel).innerText !== prev, (prev, sel) => document.querySelector(sel).innerText !== prev,
{}, {},
previous, previous,
`${edSelector} .internal` `${edSelector} .internal`
);
const getText = edSelector =>
page.$eval(`${edSelector} .internal`, el => el.innerText.trimEnd());
await page.mouse.click(
editorRect.x + editorRect.width / 2,
editorRect.y + editorRect.height / 2,
{ count: 2 }
); );
await page.waitForSelector( const getText = edSelector =>
`${editorSelector} .overlay:not(.enabled)` page.$eval(`${edSelector} .internal`, el => el.innerText.trimEnd());
await page.mouse.click(
editorRect.x + editorRect.width / 2,
editorRect.y + editorRect.height / 2,
{ count: 2 }
);
await page.waitForSelector(`${editorSelector} .overlay:not(.enabled)`);
const select = position =>
page.evaluate(
(sel, pos) => {
const el = document.querySelector(sel);
document.getSelection().setPosition(el.firstChild, pos);
},
`${editorSelector} .internal`,
position
); );
const select = position => await select(0);
page.evaluate( await copyToClipboard(page, {
(sel, pos) => { "text/html": "<b>Bold Foo</b>",
const el = document.querySelector(sel); "text/plain": "Foo",
document.getSelection().setPosition(el.firstChild, pos); });
}, await pasteFromClipboard(page, `${editorSelector} .internal`);
`${editorSelector} .internal`,
position
);
await select(0); let lastText = data;
await copyToClipboard(page, {
"text/html": "<b>Bold Foo</b>",
"text/plain": "Foo",
});
await pasteFromClipboard(page, `${editorSelector} .internal`);
let lastText = data; await waitForTextChange(lastText, editorSelector);
let text = await getText(editorSelector);
lastText = `Foo${data}`;
expect(text).withContext(`In ${browserName}`).toEqual(lastText);
await waitForTextChange(lastText, editorSelector); await select(3);
let text = await getText(editorSelector); await copyToClipboard(page, {
lastText = `Foo${data}`; "text/html": "<b>Bold Bar</b><br><b>Oof</b>",
expect(text).withContext(`In ${browserName}`).toEqual(lastText); "text/plain": "Bar\nOof",
});
await pasteFromClipboard(page, `${editorSelector} .internal`);
await select(3); await waitForTextChange(lastText, editorSelector);
await copyToClipboard(page, { text = await getText(editorSelector);
"text/html": "<b>Bold Bar</b><br><b>Oof</b>", lastText = `FooBar\nOof${data}`;
"text/plain": "Bar\nOof", expect(text).withContext(`In ${browserName}`).toEqual(lastText);
});
await pasteFromClipboard(page, `${editorSelector} .internal`);
await waitForTextChange(lastText, editorSelector); await select(0);
text = await getText(editorSelector); await copyToClipboard(page, { "text/html": "<b>basic html</b>" });
lastText = `FooBar\nOof${data}`; await pasteFromClipboard(page, `${editorSelector} .internal`);
expect(text).withContext(`In ${browserName}`).toEqual(lastText);
await select(0); // Nothing should change, so it's hard to wait on something.
await copyToClipboard(page, { "text/html": "<b>basic html</b>" }); // eslint-disable-next-line no-restricted-syntax
await pasteFromClipboard(page, `${editorSelector} .internal`); await waitForTimeout(100);
// Nothing should change, so it's hard to wait on something. text = await getText(editorSelector);
// eslint-disable-next-line no-restricted-syntax expect(text).withContext(`In ${browserName}`).toEqual(lastText);
await waitForTimeout(100);
text = await getText(editorSelector); const getHTML = () =>
expect(text).withContext(`In ${browserName}`).toEqual(lastText); page.$eval(`${editorSelector} .internal`, el => el.innerHTML);
const prevHTML = await getHTML();
const getHTML = () => // Try to paste an image.
page.$eval(`${editorSelector} .internal`, el => el.innerHTML); await copyToClipboard(page, {
const prevHTML = await getHTML(); "image/png":
// 1x1 transparent png.
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
});
await pasteFromClipboard(page, `${editorSelector} .internal`);
// Try to paste an image. // Nothing should change, so it's hard to wait on something.
await copyToClipboard(page, { // eslint-disable-next-line no-restricted-syntax
"image/png": await waitForTimeout(100);
// 1x1 transparent png.
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
});
await pasteFromClipboard(page, `${editorSelector} .internal`);
// Nothing should change, so it's hard to wait on something. const html = await getHTML();
// eslint-disable-next-line no-restricted-syntax expect(html).withContext(`In ${browserName}`).toEqual(prevHTML);
await waitForTimeout(100);
const html = await getHTML(); // Commit.
expect(html).withContext(`In ${browserName}`).toEqual(prevHTML); await page.keyboard.press("Escape");
await page.waitForSelector(`${editorSelector} .overlay.enabled`);
// Commit. editorSelector = getEditorSelector(1);
await page.keyboard.press("Escape"); await page.mouse.click(rect.x + 200, rect.y + 200);
await page.waitForSelector(`${editorSelector} .overlay.enabled`); await page.waitForSelector(editorSelector, {
visible: true,
});
editorSelector = getEditorSelector(1); const fooBar = "Foo\nBar\nOof";
await page.mouse.click(rect.x + 200, rect.y + 200); await copyToClipboard(page, {
await page.waitForSelector(editorSelector, { "text/html": "<b>html</b>",
visible: true, "text/plain": fooBar,
}); });
await pasteFromClipboard(page, `${editorSelector} .internal`);
const fooBar = "Foo\nBar\nOof"; await waitForTextChange("", editorSelector);
await copyToClipboard(page, { text = await getText(editorSelector);
"text/html": "<b>html</b>", expect(text).withContext(`In ${browserName}`).toEqual(fooBar);
"text/plain": fooBar, }
});
await pasteFromClipboard(page, `${editorSelector} .internal`);
await waitForTextChange("", editorSelector);
text = await getText(editorSelector);
expect(text).withContext(`In ${browserName}`).toEqual(fooBar);
})
);
}); });
}); });

750
test/integration/stamp_editor_spec.mjs
View file

@ -258,160 +258,159 @@ describe("Stamp Editor", () => {
}); });
it("must check that the alt-text flow is correctly implemented", async () => { it("must check that the alt-text flow is correctly implemented", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [browserName, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
// Wait for the alt-text button to be visible. // Wait for the alt-text button to be visible.
const buttonSelector = `${getEditorSelector(0)} button.altText`; const buttonSelector = `${getEditorSelector(0)} button.altText`;
await page.waitForSelector(buttonSelector); await page.waitForSelector(buttonSelector);
// Click on the alt-text button. // Click on the alt-text button.
await page.click(buttonSelector); await page.click(buttonSelector);
// Wait for the alt-text dialog to be visible. // Wait for the alt-text dialog to be visible.
await page.waitForSelector("#altTextDialog", { visible: true }); await page.waitForSelector("#altTextDialog", { visible: true });
// Click on the alt-text editor. // Click on the alt-text editor.
const textareaSelector = "#altTextDialog textarea"; const textareaSelector = "#altTextDialog textarea";
await page.click(textareaSelector); await page.click(textareaSelector);
await page.type(textareaSelector, "Hello World"); await page.type(textareaSelector, "Hello World");
// Click on save button. // Click on save button.
const saveButtonSelector = "#altTextDialog #altTextSave"; const saveButtonSelector = "#altTextDialog #altTextSave";
await page.click(saveButtonSelector); await page.click(saveButtonSelector);
// Check that the canvas has an aria-describedby attribute. // Check that the canvas has an aria-describedby attribute.
await page.waitForSelector( await page.waitForSelector(
`${getEditorSelector(0)} canvas[aria-describedby]` `${getEditorSelector(0)} canvas[aria-describedby]`
); );
// Wait for the alt-text button to have the correct icon. // Wait for the alt-text button to have the correct icon.
await page.waitForSelector(`${buttonSelector}.done`); await page.waitForSelector(`${buttonSelector}.done`);
// Hover the button. // Hover the button.
await page.hover(buttonSelector); await page.hover(buttonSelector);
// Wait for the tooltip to be visible. // Wait for the tooltip to be visible.
const tooltipSelector = `${buttonSelector} .tooltip`; const tooltipSelector = `${buttonSelector} .tooltip`;
await page.waitForSelector(tooltipSelector, { visible: true }); await page.waitForSelector(tooltipSelector, { visible: true });
let tooltipText = await page.evaluate( let tooltipText = await page.evaluate(
sel => document.querySelector(`${sel}`).innerText, sel => document.querySelector(`${sel}`).innerText,
tooltipSelector tooltipSelector
); );
expect(tooltipText).toEqual("Hello World"); expect(tooltipText).toEqual("Hello World");
// Now we change the alt-text and check that the tooltip is updated. // Now we change the alt-text and check that the tooltip is updated.
await page.click(buttonSelector); await page.click(buttonSelector);
await page.waitForSelector("#altTextDialog", { visible: true }); await page.waitForSelector("#altTextDialog", { visible: true });
await page.evaluate(sel => { await page.evaluate(sel => {
document.querySelector(`${sel}`).value = ""; document.querySelector(`${sel}`).value = "";
}, textareaSelector); }, textareaSelector);
await page.click(textareaSelector); await page.click(textareaSelector);
await page.type(textareaSelector, "Dlrow Olleh"); await page.type(textareaSelector, "Dlrow Olleh");
await page.click(saveButtonSelector); await page.click(saveButtonSelector);
await page.waitForSelector(`${buttonSelector}.done`); await page.waitForSelector(`${buttonSelector}.done`);
await page.hover(buttonSelector); await page.hover(buttonSelector);
await page.waitForSelector(tooltipSelector, { visible: true }); await page.waitForSelector(tooltipSelector, { visible: true });
tooltipText = await page.evaluate( tooltipText = await page.evaluate(
sel => document.querySelector(`${sel}`).innerText, sel => document.querySelector(`${sel}`).innerText,
tooltipSelector tooltipSelector
); );
expect(tooltipText).toEqual("Dlrow Olleh"); expect(tooltipText).toEqual("Dlrow Olleh");
// Now we just check that cancel didn't change anything. // Now we just check that cancel didn't change anything.
await page.click(buttonSelector); await page.click(buttonSelector);
await page.waitForSelector("#altTextDialog", { visible: true }); await page.waitForSelector("#altTextDialog", { visible: true });
await page.evaluate(sel => { await page.evaluate(sel => {
document.querySelector(`${sel}`).value = ""; document.querySelector(`${sel}`).value = "";
}, textareaSelector); }, textareaSelector);
await page.click(textareaSelector); await page.click(textareaSelector);
await page.type(textareaSelector, "Hello PDF.js"); await page.type(textareaSelector, "Hello PDF.js");
const cancelButtonSelector = "#altTextDialog #altTextCancel"; const cancelButtonSelector = "#altTextDialog #altTextCancel";
await page.click(cancelButtonSelector); await page.click(cancelButtonSelector);
await page.waitForSelector(`${buttonSelector}.done`); await page.waitForSelector(`${buttonSelector}.done`);
await page.hover(buttonSelector); await page.hover(buttonSelector);
await page.waitForSelector(tooltipSelector, { visible: true }); await page.waitForSelector(tooltipSelector, { visible: true });
tooltipText = await page.evaluate( tooltipText = await page.evaluate(
sel => document.querySelector(`${sel}`).innerText, sel => document.querySelector(`${sel}`).innerText,
tooltipSelector tooltipSelector
); );
// The tooltip should still be "Dlrow Olleh". // The tooltip should still be "Dlrow Olleh".
expect(tooltipText).toEqual("Dlrow Olleh"); expect(tooltipText).toEqual("Dlrow Olleh");
// Now we switch to decorative. // Now we switch to decorative.
await page.click(buttonSelector); await page.click(buttonSelector);
await page.waitForSelector("#altTextDialog", { visible: true }); await page.waitForSelector("#altTextDialog", { visible: true });
const decorativeSelector = "#altTextDialog #decorativeButton"; const decorativeSelector = "#altTextDialog #decorativeButton";
await page.click(decorativeSelector); await page.click(decorativeSelector);
await page.click(saveButtonSelector); await page.click(saveButtonSelector);
await page.waitForSelector(`${buttonSelector}.done`); await page.waitForSelector(`${buttonSelector}.done`);
await page.hover(buttonSelector); await page.hover(buttonSelector);
await page.waitForSelector(tooltipSelector, { visible: true }); await page.waitForSelector(tooltipSelector, { visible: true });
tooltipText = await page.evaluate( tooltipText = await page.evaluate(
sel => document.querySelector(`${sel}`).innerText, sel => document.querySelector(`${sel}`).innerText,
tooltipSelector tooltipSelector
); );
expect(tooltipText).toEqual("Marked as decorative"); expect(tooltipText).toEqual("Marked as decorative");
// Now we switch back to non-decorative. // Now we switch back to non-decorative.
await page.click(buttonSelector); await page.click(buttonSelector);
await page.waitForSelector("#altTextDialog", { visible: true }); await page.waitForSelector("#altTextDialog", { visible: true });
const descriptionSelector = "#altTextDialog #descriptionButton"; const descriptionSelector = "#altTextDialog #descriptionButton";
await page.click(descriptionSelector); await page.click(descriptionSelector);
await page.click(saveButtonSelector); await page.click(saveButtonSelector);
await page.waitForSelector(`${buttonSelector}.done`); await page.waitForSelector(`${buttonSelector}.done`);
await page.hover(buttonSelector); await page.hover(buttonSelector);
await page.waitForSelector(tooltipSelector, { visible: true }); await page.waitForSelector(tooltipSelector, { visible: true });
tooltipText = await page.evaluate( tooltipText = await page.evaluate(
sel => document.querySelector(`${sel}`).innerText, sel => document.querySelector(`${sel}`).innerText,
tooltipSelector tooltipSelector
); );
expect(tooltipText).toEqual("Dlrow Olleh"); expect(tooltipText).toEqual("Dlrow Olleh");
// Now we remove the alt-text and check that the tooltip is removed. // Now we remove the alt-text and check that the tooltip is removed.
await page.click(buttonSelector); await page.click(buttonSelector);
await page.waitForSelector("#altTextDialog", { visible: true }); await page.waitForSelector("#altTextDialog", { visible: true });
await page.evaluate(sel => { await page.evaluate(sel => {
document.querySelector(`${sel}`).value = ""; document.querySelector(`${sel}`).value = "";
}, textareaSelector); }, textareaSelector);
await page.click(saveButtonSelector); await page.click(saveButtonSelector);
await page.waitForSelector(`${buttonSelector}:not(.done)`); await page.waitForSelector(`${buttonSelector}:not(.done)`);
await page.hover(buttonSelector); await page.hover(buttonSelector);
await page.evaluate( await page.evaluate(
sel => document.querySelector(sel) === null, sel => document.querySelector(sel) === null,
tooltipSelector tooltipSelector
); );
// We check that the alt-text button works correctly with the // We check that the alt-text button works correctly with the
// keyboard. // keyboard.
const handle = await page.evaluateHandle(sel => { const handle = await page.evaluateHandle(sel => {
document.getElementById("viewerContainer").focus(); document.getElementById("viewerContainer").focus();
return [ return [
new Promise(resolve => { new Promise(resolve => {
setTimeout(() => { setTimeout(() => {
const el = document.querySelector(sel); const el = document.querySelector(sel);
el.addEventListener("focus", resolve, { once: true }); el.addEventListener("focus", resolve, { once: true });
el.focus({ focusVisible: true }); el.focus({ focusVisible: true });
}, 0); }, 0);
}), }),
]; ];
}, buttonSelector); }, buttonSelector);
await awaitPromise(handle); await awaitPromise(handle);
await (browserName === "chrome" await (browserName === "chrome"
? page.waitForSelector(`${buttonSelector}:focus`) ? page.waitForSelector(`${buttonSelector}:focus`)
: page.waitForSelector(`${buttonSelector}:focus-visible`)); : page.waitForSelector(`${buttonSelector}:focus-visible`));
await page.keyboard.press("Enter"); await page.keyboard.press("Enter");
await page.waitForSelector("#altTextDialog", { visible: true }); await page.waitForSelector("#altTextDialog", { visible: true });
await page.keyboard.press("Escape"); await page.keyboard.press("Escape");
await (browserName === "chrome" await (browserName === "chrome"
? page.waitForSelector(`${buttonSelector}:focus`) ? page.waitForSelector(`${buttonSelector}:focus`)
: page.waitForSelector(`${buttonSelector}:focus-visible`)); : page.waitForSelector(`${buttonSelector}:focus-visible`));
}) }
);
}); });
}); });
@ -427,125 +426,124 @@ describe("Stamp Editor", () => {
}); });
it("must check that the dimensions change", async () => { it("must check that the dimensions change", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [browserName, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
const editorSelector = getEditorSelector(0); const editorSelector = getEditorSelector(0);
await page.click(editorSelector); await page.click(editorSelector);
await waitForSelectedEditor(page, editorSelector); await waitForSelectedEditor(page, editorSelector);
await page.waitForSelector( await page.waitForSelector(
`${editorSelector} .resizer.topLeft[tabindex="-1"]` `${editorSelector} .resizer.topLeft[tabindex="-1"]`
);
const getDims = async () => {
const [blX, blY, trX, trY] = await getFirstSerialized(
page,
x => x.rect
); );
return [trX - blX, trY - blY];
};
const getDims = async () => { const [width, height] = await getDims();
const [blX, blY, trX, trY] = await getFirstSerialized(
page,
x => x.rect
);
return [trX - blX, trY - blY];
};
const [width, height] = await getDims(); // Press Enter to enter in resize-with-keyboard mode.
await page.keyboard.press("Enter");
// Press Enter to enter in resize-with-keyboard mode. // The resizer must become keyboard focusable.
await page.keyboard.press("Enter"); await page.waitForSelector(
`${editorSelector} .resizer.topLeft[tabindex="0"]`
);
// The resizer must become keyboard focusable. let prevWidth = width;
await page.waitForSelector( let prevHeight = height;
`${editorSelector} .resizer.topLeft[tabindex="0"]`
);
let prevWidth = width; const waitForDimsChange = async (w, h) => {
let prevHeight = height;
const waitForDimsChange = async (w, h) => {
await page.waitForFunction(
(prevW, prevH) => {
const [x1, y1, x2, y2] =
window.PDFViewerApplication.pdfDocument.annotationStorage.serializable.map
.values()
.next().value.rect;
const newWidth = x2 - x1;
const newHeight = y2 - y1;
return newWidth !== prevW || newHeight !== prevH;
},
{},
w,
h
);
};
for (let i = 0; i < 40; i++) {
await page.keyboard.press("ArrowLeft");
await waitForDimsChange(prevWidth, prevHeight);
[prevWidth, prevHeight] = await getDims();
}
let [newWidth, newHeight] = await getDims();
expect(newWidth > width + 30)
.withContext(`In ${browserName}`)
.toEqual(true);
expect(newHeight > height + 30)
.withContext(`In ${browserName}`)
.toEqual(true);
for (let i = 0; i < 4; i++) {
await kbBigMoveRight(page);
await waitForDimsChange(prevWidth, prevHeight);
[prevWidth, prevHeight] = await getDims();
}
[newWidth, newHeight] = await getDims();
expect(Math.abs(newWidth - width) < 2)
.withContext(`In ${browserName}`)
.toEqual(true);
expect(Math.abs(newHeight - height) < 2)
.withContext(`In ${browserName}`)
.toEqual(true);
// Move the focus to the next resizer.
await page.keyboard.press("Tab");
await page.waitForFunction( await page.waitForFunction(
() => !!document.activeElement?.classList.contains("topMiddle") (prevW, prevH) => {
const [x1, y1, x2, y2] =
window.PDFViewerApplication.pdfDocument.annotationStorage.serializable.map
.values()
.next().value.rect;
const newWidth = x2 - x1;
const newHeight = y2 - y1;
return newWidth !== prevW || newHeight !== prevH;
},
{},
w,
h
); );
};
for (let i = 0; i < 40; i++) { for (let i = 0; i < 40; i++) {
await page.keyboard.press("ArrowUp"); await page.keyboard.press("ArrowLeft");
await waitForDimsChange(prevWidth, prevHeight); await waitForDimsChange(prevWidth, prevHeight);
[prevWidth, prevHeight] = await getDims(); [prevWidth, prevHeight] = await getDims();
} }
[, newHeight] = await getDims(); let [newWidth, newHeight] = await getDims();
expect(newHeight > height + 50) expect(newWidth > width + 30)
.withContext(`In ${browserName}`) .withContext(`In ${browserName}`)
.toEqual(true); .toEqual(true);
expect(newHeight > height + 30)
.withContext(`In ${browserName}`)
.toEqual(true);
for (let i = 0; i < 4; i++) { for (let i = 0; i < 4; i++) {
await kbBigMoveDown(page); await kbBigMoveRight(page);
await waitForDimsChange(prevWidth, prevHeight); await waitForDimsChange(prevWidth, prevHeight);
[prevWidth, prevHeight] = await getDims(); [prevWidth, prevHeight] = await getDims();
} }
[, newHeight] = await getDims(); [newWidth, newHeight] = await getDims();
expect(Math.abs(newHeight - height) < 2) expect(Math.abs(newWidth - width) < 2)
.withContext(`In ${browserName}`) .withContext(`In ${browserName}`)
.toEqual(true); .toEqual(true);
expect(Math.abs(newHeight - height) < 2)
.withContext(`In ${browserName}`)
.toEqual(true);
// Escape should remove the focus from the resizer. // Move the focus to the next resizer.
await page.keyboard.press("Escape"); await page.keyboard.press("Tab");
await page.waitForSelector( await page.waitForFunction(
`${editorSelector} .resizer.topLeft[tabindex="-1"]` () => !!document.activeElement?.classList.contains("topMiddle")
); );
await page.waitForFunction(
() => !document.activeElement?.classList.contains("resizer") for (let i = 0; i < 40; i++) {
); await page.keyboard.press("ArrowUp");
}) await waitForDimsChange(prevWidth, prevHeight);
); [prevWidth, prevHeight] = await getDims();
}
[, newHeight] = await getDims();
expect(newHeight > height + 50)
.withContext(`In ${browserName}`)
.toEqual(true);
for (let i = 0; i < 4; i++) {
await kbBigMoveDown(page);
await waitForDimsChange(prevWidth, prevHeight);
[prevWidth, prevHeight] = await getDims();
}
[, newHeight] = await getDims();
expect(Math.abs(newHeight - height) < 2)
.withContext(`In ${browserName}`)
.toEqual(true);
// Escape should remove the focus from the resizer.
await page.keyboard.press("Escape");
await page.waitForSelector(
`${editorSelector} .resizer.topLeft[tabindex="-1"]`
);
await page.waitForFunction(
() => !document.activeElement?.classList.contains("resizer")
);
}
}); });
}); });
@ -594,24 +592,23 @@ describe("Stamp Editor", () => {
}); });
it("must check that a stamp can be undone", async () => { it("must check that a stamp can be undone", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
const selector = getEditorSelector(0); const selector = getEditorSelector(0);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
await page.waitForSelector(selector); await page.waitForSelector(selector);
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
await page.waitForSelector(`${selector} button.delete`); await page.waitForSelector(`${selector} button.delete`);
await page.click(`${selector} button.delete`); await page.click(`${selector} button.delete`);
await waitForSerialized(page, 0); await waitForSerialized(page, 0);
await kbUndo(page); await kbUndo(page);
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
await page.waitForSelector(`${selector} canvas`); await page.waitForSelector(`${selector} canvas`);
}) }
);
}); });
}); });
@ -627,37 +624,36 @@ describe("Stamp Editor", () => {
}); });
it("must check that a stamp can be undone", async () => { it("must check that a stamp can be undone", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
const selector = getEditorSelector(0); const selector = getEditorSelector(0);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
await page.waitForSelector(selector); await page.waitForSelector(selector);
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
await page.waitForSelector(`${selector} button.delete`); await page.waitForSelector(`${selector} button.delete`);
await page.click(`${selector} button.delete`); await page.click(`${selector} button.delete`);
await waitForSerialized(page, 0); await waitForSerialized(page, 0);
const twoToFourteen = Array.from(new Array(13).keys(), n => n + 2); const twoToFourteen = Array.from(new Array(13).keys(), n => n + 2);
for (const pageNumber of twoToFourteen) { for (const pageNumber of twoToFourteen) {
const pageSelector = `.page[data-page-number = "${pageNumber}"]`; const pageSelector = `.page[data-page-number = "${pageNumber}"]`;
await scrollIntoView(page, pageSelector); await scrollIntoView(page, pageSelector);
} }
await kbUndo(page); await kbUndo(page);
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
const thirteenToOne = Array.from(new Array(13).keys(), n => 13 - n); const thirteenToOne = Array.from(new Array(13).keys(), n => 13 - n);
for (const pageNumber of thirteenToOne) { for (const pageNumber of thirteenToOne) {
const pageSelector = `.page[data-page-number = "${pageNumber}"]`; const pageSelector = `.page[data-page-number = "${pageNumber}"]`;
await scrollIntoView(page, pageSelector); await scrollIntoView(page, pageSelector);
} }
await page.waitForSelector(`${selector} canvas`); await page.waitForSelector(`${selector} canvas`);
}) }
);
}); });
}); });
@ -673,32 +669,31 @@ describe("Stamp Editor", () => {
}); });
it("must check that a stamp can be undone", async () => { it("must check that a stamp can be undone", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
const selector = getEditorSelector(0); const selector = getEditorSelector(0);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
await page.waitForSelector(selector); await page.waitForSelector(selector);
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
await page.waitForSelector(`${selector} button.delete`); await page.waitForSelector(`${selector} button.delete`);
await page.click(`${selector} button.delete`); await page.click(`${selector} button.delete`);
await waitForSerialized(page, 0); await waitForSerialized(page, 0);
const twoToOne = Array.from(new Array(13).keys(), n => n + 2).concat( const twoToOne = Array.from(new Array(13).keys(), n => n + 2).concat(
Array.from(new Array(13).keys(), n => 13 - n) Array.from(new Array(13).keys(), n => 13 - n)
); );
for (const pageNumber of twoToOne) { for (const pageNumber of twoToOne) {
const pageSelector = `.page[data-page-number = "${pageNumber}"]`; const pageSelector = `.page[data-page-number = "${pageNumber}"]`;
await scrollIntoView(page, pageSelector); await scrollIntoView(page, pageSelector);
} }
await kbUndo(page); await kbUndo(page);
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
await page.waitForSelector(`${selector} canvas`); await page.waitForSelector(`${selector} canvas`);
}) }
);
}); });
}); });
@ -714,44 +709,43 @@ describe("Stamp Editor", () => {
}); });
it("must check that a resized stamp has its canvas at the right position", async () => { it("must check that a resized stamp has its canvas at the right position", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
await page.waitForSelector(getEditorSelector(0)); await page.waitForSelector(getEditorSelector(0));
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
const serializedRect = await getFirstSerialized(page, x => x.rect); const serializedRect = await getFirstSerialized(page, x => x.rect);
const rect = await getRect(page, ".resizer.bottomRight"); const rect = await getRect(page, ".resizer.bottomRight");
const centerX = rect.x + rect.width / 2; const centerX = rect.x + rect.width / 2;
const centerY = rect.y + rect.height / 2; const centerY = rect.y + rect.height / 2;
await page.mouse.move(centerX, centerY); await page.mouse.move(centerX, centerY);
await page.mouse.down(); await page.mouse.down();
await page.mouse.move(centerX - 500, centerY - 500); await page.mouse.move(centerX - 500, centerY - 500);
await page.mouse.up(); await page.mouse.up();
await waitForEntryInStorage( await waitForEntryInStorage(
page, page,
"rect", "rect",
serializedRect, serializedRect,
(x, y) => x !== y (x, y) => x !== y
); );
const canvasRect = await getRect( const canvasRect = await getRect(
page, page,
`${getEditorSelector(0)} canvas` `${getEditorSelector(0)} canvas`
); );
const stampRect = await getRect(page, getEditorSelector(0)); const stampRect = await getRect(page, getEditorSelector(0));
expect( expect(
["x", "y", "width", "height"].every( ["x", "y", "width", "height"].every(
key => Math.abs(canvasRect[key] - stampRect[key]) <= 10 key => Math.abs(canvasRect[key] - stampRect[key]) <= 10
) )
).toBeTrue(); ).toBeTrue();
}) }
);
}); });
}); });
@ -775,27 +769,26 @@ describe("Stamp Editor", () => {
}); });
it("must check that the stamp has its canvas at the right position", async () => { it("must check that the stamp has its canvas at the right position", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
await page.waitForSelector(getEditorSelector(0)); await page.waitForSelector(getEditorSelector(0));
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
const canvasRect = await getRect( const canvasRect = await getRect(
page, page,
`${getEditorSelector(0)} canvas` `${getEditorSelector(0)} canvas`
); );
const stampRect = await getRect(page, getEditorSelector(0)); const stampRect = await getRect(page, getEditorSelector(0));
expect( expect(
["x", "y", "width", "height"].every( ["x", "y", "width", "height"].every(
key => Math.abs(canvasRect[key] - stampRect[key]) <= 10 key => Math.abs(canvasRect[key] - stampRect[key]) <= 10
) )
).toBeTrue(); ).toBeTrue();
}) }
);
}); });
}); });
@ -811,40 +804,35 @@ describe("Stamp Editor", () => {
}); });
it("must check that the pasted image has an alt text", async () => { it("must check that the pasted image has an alt text", async () => {
await Promise.all( // Run sequentially to avoid clipboard issues.
pages.map(async ([browserName, page]) => { for (const [browserName, page] of pages) {
await switchToStamp(page); await switchToStamp(page);
await copyImage(page, "../images/firefox_logo.png", 0); await copyImage(page, "../images/firefox_logo.png", 0);
await page.waitForSelector(getEditorSelector(0)); await page.waitForSelector(getEditorSelector(0));
await waitForSerialized(page, 1); await waitForSerialized(page, 1);
await applyFunctionToEditor( await applyFunctionToEditor(page, "pdfjs_internal_editor_0", editor => {
page, editor.altTextData = {
"pdfjs_internal_editor_0", altText: "Hello World",
editor => { decorative: false,
editor.altTextData = { };
altText: "Hello World", });
decorative: false, await page.waitForSelector(`${getEditorSelector(0)} .altText.done`);
};
}
);
await page.waitForSelector(`${getEditorSelector(0)} .altText.done`);
await copy(page); await copy(page);
await paste(page); await paste(page);
await page.waitForSelector(`${getEditorSelector(1)} .altText.done`); await page.waitForSelector(`${getEditorSelector(1)} .altText.done`);
await waitForSerialized(page, 2); await waitForSerialized(page, 2);
const serialized = await getSerialized( const serialized = await getSerialized(
page, page,
x => x.accessibilityData?.alt x => x.accessibilityData?.alt
); );
expect(serialized) expect(serialized)
.withContext(`In ${browserName}`) .withContext(`In ${browserName}`)
.toEqual(["Hello World", "Hello World"]); .toEqual(["Hello World", "Hello World"]);
}) }
);
}); });
}); });
}); });