Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

test: Put test-functions.js helpers on window object #20833

Merged
merged 1 commit into from
Aug 6, 2024
Merged

test: Put test-functions.js helpers on window object #20833

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
191 changes: 94 additions & 97 deletions test/common/test-functions.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,12 +2,9 @@

/*
* These are routines used by our testing code.
*
* jQuery is not necessarily present. Don't rely on it
* for routine operations.
*/

function ph_select(sel) {
window.ph_select = function(sel) {
if (!window.Sizzle) {
return Array.from(document.querySelectorAll(sel));
}
Expand All @@ -20,95 +17,95 @@ function ph_select(sel) {
} else {
return Array.from(document.querySelectorAll(sel));
}
}
};

function ph_only(els, sel) {
window.ph_only = function(els, sel) {
if (els.length === 0)
throw new Error(sel + " not found");
if (els.length > 1)
throw new Error(sel + " is ambiguous");
return els[0];
}
};

function ph_find (sel) {
const els = ph_select(sel);
return ph_only(els, sel);
}
window.ph_find = function(sel) {
const els = window.ph_select(sel);
return window.ph_only(els, sel);
};

function ph_count(sel) {
const els = ph_select(sel);
window.ph_count = function(sel) {
const els = window.ph_select(sel);
return els.length;
}
};

function ph_count_check(sel, expected_num) {
return (ph_count(sel) == expected_num);
}
window.ph_count_check = function(sel, expected_num) {
return (window.ph_count(sel) == expected_num);
};

function ph_val (sel) {
const el = ph_find(sel);
window.ph_val = function(sel) {
const el = window.ph_find(sel);
if (el.value === undefined)
throw new Error(sel + " does not have a value");
return el.value;
}
};

function ph_set_val (sel, val) {
const el = ph_find(sel);
window.ph_set_val = function(sel, val) {
const el = window.ph_find(sel);
if (el.value === undefined)
throw new Error(sel + " does not have a value");
el.value = val;
const ev = new Event("change", { bubbles: true, cancelable: false });
el.dispatchEvent(ev);
}
};

function ph_has_val (sel, val) {
return ph_val(sel) == val;
}
window.ph_has_val = function(sel, val) {
return window.ph_val(sel) == val;
};

function ph_collected_text_is (sel, val) {
const els = ph_select(sel);
window.ph_collected_text_is = function(sel, val) {
const els = window.ph_select(sel);
const rest = els.map(el => {
if (el.textContent === undefined)
throw new Error(sel + " can not have text");
return el.textContent.replaceAll("\xa0", " ");
}).join("");
return rest === val;
}
};

function ph_text (sel) {
const el = ph_find(sel);
window.ph_text = function(sel) {
const el = window.ph_find(sel);
if (el.textContent === undefined)
throw new Error(sel + " can not have text");
// 0xa0 is a non-breakable space, which is a rendering detail of Chromium
// and awkward to handle in tests; turn it into normal spaces
return el.textContent.replaceAll("\xa0", " ");
}
};

function ph_attr (sel, attr) {
return ph_find(sel).getAttribute(attr);
}
window.ph_attr = function(sel, attr) {
return window.ph_find(sel).getAttribute(attr);
};

function ph_set_attr (sel, attr, val) {
const el = ph_find(sel);
window.ph_set_attr = function(sel, attr, val) {
const el = window.ph_find(sel);
if (val === null || val === undefined)
el.removeAttribute(attr);
else
el.setAttribute(attr, val);

const ev = new Event("change", { bubbles: true, cancelable: false });
el.dispatchEvent(ev);
}
};

function ph_has_attr (sel, attr, val) {
return ph_attr(sel, attr) == val;
}
window.ph_has_attr = function(sel, attr, val) {
return window.ph_attr(sel, attr) == val;
};

function ph_attr_contains (sel, attr, val) {
const a = ph_attr(sel, attr);
window.ph_attr_contains = function(sel, attr, val) {
const a = window.ph_attr(sel, attr);
return a && a.indexOf(val) > -1;
}
};

function ph_mouse(sel, type, x, y, btn, ctrlKey, shiftKey, altKey, metaKey) {
const el = ph_find(sel);
window.ph_mouse = function(sel, type, x, y, btn, ctrlKey, shiftKey, altKey, metaKey) {
const el = window.ph_find(sel);

/* The element has to be visible, and not collapsed */
if (el.offsetWidth <= 0 && el.offsetHeight <= 0 && el.tagName != 'svg')
Expand Down Expand Up @@ -160,48 +157,48 @@ function ph_mouse(sel, type, x, y, btn, ctrlKey, shiftKey, altKey, metaKey) {
/* It really had to work */
if (!processed)
throw new Error(sel + " is disabled or somehow doesn't process events");
}
};

function ph_get_checked (sel) {
const el = ph_find(sel);
window.ph_get_checked = function(sel) {
const el = window.ph_find(sel);
if (el.checked === undefined)
throw new Error(sel + " is not checkable");

return el.checked;
}
};

function ph_set_checked (sel, val) {
const el = ph_find(sel);
window.ph_set_checked = function(sel, val) {
const el = window.ph_find(sel);
if (el.checked === undefined)
throw new Error(sel + " is not checkable");

if (el.checked != val)
ph_mouse(sel, "click", 0, 0, 0);
}
window.ph_mouse(sel, "click", 0, 0, 0);
};

function ph_is_visible (sel) {
const el = ph_find(sel);
window.ph_is_visible = function(sel) {
const el = window.ph_find(sel);
return el.tagName == "svg" || ((el.offsetWidth > 0 || el.offsetHeight > 0) && !(el.style.visibility == "hidden" || el.style.display == "none"));
}
};

function ph_is_present(sel) {
const els = ph_select(sel);
window.ph_is_present = function(sel) {
const els = window.ph_select(sel);
return els.length > 0;
}
};

function ph_in_text (sel, text) {
return ph_text(sel).indexOf(text) != -1;
}
window.ph_in_text = function(sel, text) {
return window.ph_text(sel).indexOf(text) != -1;
};

function ph_text_is (sel, text) {
return ph_text(sel) == text;
}
window.ph_text_is = function(sel, text) {
return window.ph_text(sel) == text;
};

function ph_text_matches (sel, pattern) {
return ph_text(sel).match(pattern);
}
window.ph_text_matches = function(sel, pattern) {
return window.ph_text(sel).match(pattern);
};

function ph_go(href) {
window.ph_go = function(href) {
if (href.indexOf("#") === 0) {
window.location.hash = href;
} else {
Expand All @@ -213,25 +210,25 @@ function ph_go(href) {
};
window.parent.postMessage("\n" + JSON.stringify(control), "*");
}
}
};

function ph_focus(sel) {
ph_find(sel).focus();
}
window.ph_focus = function(sel) {
window.ph_find(sel).focus();
};

function ph_scrollIntoViewIfNeeded(sel) {
ph_find(sel).scrollIntoViewIfNeeded();
}
window.ph_scrollIntoViewIfNeeded = function(sel) {
window.ph_find(sel).scrollIntoViewIfNeeded();
};

function ph_blur(sel) {
ph_find(sel).blur();
}
window.ph_blur = function(sel) {
window.ph_find(sel).blur();
};

function ph_blur_active() {
window.ph_blur_active = function() {
const elt = window.document.activeElement;
if (elt)
elt.blur();
}
};

class PhWaitCondTimeout extends Error {
constructor(description) {
Expand All @@ -244,7 +241,7 @@ class PhWaitCondTimeout extends Error {
}
}

function ph_wait_cond(cond, timeout, error_description) {
window.ph_wait_cond = function(cond, timeout, error_description) {
return new Promise((resolve, reject) => {
// poll every 100 ms for now; FIXME: poll less often and re-check on mutations using
// https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
Expand All @@ -269,7 +266,7 @@ function ph_wait_cond(cond, timeout, error_description) {
}
step();
});
}
};

function currentFrameAbsolutePosition() {
let currentWindow = window;
Expand Down Expand Up @@ -307,27 +304,27 @@ function flatten(array_of_arrays) {
return [];
}

function ph_selector_clips(sels) {
window.ph_selector_clips = function(sels) {
const f = currentFrameAbsolutePosition();
const elts = flatten(sels.map(ph_select));
const elts = flatten(sels.map(window.ph_select));
return elts.map(e => {
const r = e.getBoundingClientRect();
return { x: r.x + f.x, y: r.y + f.y, width: r.width, height: r.height, scale: 1 };
});
}
};

function ph_element_clip(sel) {
ph_find(sel); // just to make sure it is not ambiguous
return ph_selector_clips([sel])[0];
}
window.ph_element_clip = function(sel) {
window.ph_find(sel); // just to make sure it is not ambiguous
return window.ph_selector_clips([sel])[0];
};

function ph_count_animations(sel) {
return ph_find(sel).getAnimations({ subtree: true }).length;
}
window.ph_count_animations = function(sel) {
return window.ph_find(sel).getAnimations({ subtree: true }).length;
};

function ph_set_texts(new_texts) {
window.ph_set_texts = function(new_texts) {
for (const sel in new_texts) {
const elts = ph_select(sel);
const elts = window.ph_select(sel);
if (elts.length == 0)
throw new Error(sel + " not found");
for (let elt of elts) {
Expand Down Expand Up @@ -357,4 +354,4 @@ function ph_set_texts(new_texts) {
}
}
}
}
};