mirror of
https://github.com/CloakHQ/CloakBrowser.git
synced 2026-06-23 11:41:46 +02:00
feat: add human-like behavioral layer (humanize option)
Bezier mouse curves, per-character typing with mistype simulation, smooth micro-step scrolling, idle micro-movements between actions. Supports both sync and async Playwright APIs. Patches page, frame, context, browser, and Locator class methods. Two presets: 'default' (normal speed) and 'careful' (slower, deliberate). Configurable via HumanConfig dataclass / interface with full override support. Bug fixes (from PR review): - fill()/clear(): platform-aware select-all (Meta+a on macOS, Control+a elsewhere) - sync Locator check()/uncheck(): wrap mouse_move in RawMouse-compatible object - resolve_config(): raise error on unknown preset name - Lazy-load human.config via __getattr__ in __init__.py - humanPreset typed as 'default' | 'careful' literal union - browser.newPage() patches implicit context Tests: Python 36/36, JS Vitest 34/34, visual Python 17/17, JS 13/13
This commit is contained in:
lilos
@@ -0,0 +1,256 @@
|
||||
// test_human_visual.mjs
|
||||
/**
|
||||
* Visual + functional test for humanize (JS).
|
||||
* Red dot = cursor, yellow = mouse held.
|
||||
* Trail dots show the path taken.
|
||||
*/
|
||||
import { launch } from '../js/dist/index.js';
|
||||
|
||||
const CURSOR_JS = `
|
||||
(() => {
|
||||
if (document.getElementById('__hc')) return;
|
||||
const el = document.createElement('div');
|
||||
el.id = '__hc';
|
||||
el.style.cssText = 'width:14px;height:14px;background:red;border:2px solid darkred;border-radius:50%;position:fixed;z-index:2147483647;pointer-events:none;display:none;transition:background 0.05s;';
|
||||
document.body.appendChild(el);
|
||||
|
||||
const trail = document.createElement('div');
|
||||
trail.id = '__hcTrail';
|
||||
trail.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;z-index:2147483646;pointer-events:none;overflow:hidden;';
|
||||
document.body.appendChild(trail);
|
||||
|
||||
let dotCount = 0;
|
||||
const maxDots = 500;
|
||||
|
||||
function updatePos(x, y) {
|
||||
el.style.display = 'block';
|
||||
el.style.left = (x - 9) + 'px';
|
||||
el.style.top = (y - 9) + 'px';
|
||||
if (dotCount < maxDots) {
|
||||
const dot = document.createElement('div');
|
||||
dot.style.cssText = 'width:3px;height:3px;background:rgba(255,0,0,0.3);border-radius:50%;position:fixed;pointer-events:none;left:'+(x-1)+'px;top:'+(y-1)+'px;';
|
||||
trail.appendChild(dot);
|
||||
dotCount++;
|
||||
}
|
||||
}
|
||||
|
||||
document.addEventListener('mousemove', e => updatePos(e.clientX, e.clientY));
|
||||
document.addEventListener('drag', e => { if (e.clientX > 0) updatePos(e.clientX, e.clientY); });
|
||||
document.addEventListener('dragover', e => { if (e.clientX > 0) updatePos(e.clientX, e.clientY); });
|
||||
document.addEventListener('mousedown', () => { el.style.background = 'yellow'; });
|
||||
document.addEventListener('mouseup', () => { el.style.background = 'red'; });
|
||||
document.addEventListener('dragend', () => { el.style.background = 'red'; });
|
||||
})();
|
||||
`;
|
||||
|
||||
const results = [];
|
||||
const delay = ms => new Promise(r => setTimeout(r, ms));
|
||||
|
||||
async function inject(page) {
|
||||
try { await page.evaluate(CURSOR_JS); } catch {}
|
||||
await delay(300);
|
||||
}
|
||||
|
||||
function step(name) {
|
||||
console.log(`\n${'='.repeat(60)}`);
|
||||
console.log(` STEP: ${name}`);
|
||||
console.log('='.repeat(60));
|
||||
}
|
||||
|
||||
function check(name, passed, detail = '') {
|
||||
const status = passed ? 'PASS' : 'FAIL';
|
||||
let msg = ` [${status}] ${name}`;
|
||||
if (detail) msg += ` — ${detail}`;
|
||||
console.log(msg);
|
||||
results.push({ name, status });
|
||||
}
|
||||
|
||||
async function main() {
|
||||
console.log('='.repeat(70));
|
||||
console.log(' HUMAN-LIKE BEHAVIOR VISUAL TEST (JS)');
|
||||
console.log(' Watch the red dot — it should move smoothly like a real cursor');
|
||||
console.log('='.repeat(70));
|
||||
|
||||
const browser = await launch({
|
||||
headless: false,
|
||||
humanize: true,
|
||||
});
|
||||
const page = await browser.newPage();
|
||||
|
||||
// ============================================================
|
||||
// SCENARIO 1: Wikipedia search
|
||||
// ============================================================
|
||||
step('Wikipedia — navigate and search');
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(2000);
|
||||
await inject(page);
|
||||
await delay(1000);
|
||||
|
||||
console.log(' Watch: cursor moves to search box (Bezier curve)');
|
||||
let t0 = Date.now();
|
||||
await page.locator('#searchInput').click();
|
||||
let ms = Date.now() - t0;
|
||||
check('click on search input', ms > 200, `${ms} ms`);
|
||||
await delay(500);
|
||||
|
||||
console.log(' Watch: characters appear one by one');
|
||||
t0 = Date.now();
|
||||
await page.locator('#searchInput').fill('Python programming language');
|
||||
ms = Date.now() - t0;
|
||||
let val = await page.locator('#searchInput').inputValue();
|
||||
check('fill search box', val === 'Python programming language' && ms > 2000, `${ms} ms, value='${val}'`);
|
||||
await delay(500);
|
||||
|
||||
console.log(' Watch: double click selects word');
|
||||
t0 = Date.now();
|
||||
await page.locator('#searchInput').dblclick();
|
||||
ms = Date.now() - t0;
|
||||
let sel = await page.evaluate(() => window.getSelection().toString().trim());
|
||||
check('dblclick selects word', sel.length > 0 && ms > 200, `${ms} ms, selected='${sel}'`);
|
||||
await delay(500);
|
||||
|
||||
console.log(' Watch: old text replaced');
|
||||
t0 = Date.now();
|
||||
await page.locator('#searchInput').fill('Artificial intelligence');
|
||||
ms = Date.now() - t0;
|
||||
val = await page.locator('#searchInput').inputValue();
|
||||
check('fill replaces text', val === 'Artificial intelligence' && ms > 1500, `${ms} ms, value='${val}'`);
|
||||
await delay(500);
|
||||
|
||||
console.log(' Watch: cursor hovers button without clicking');
|
||||
t0 = Date.now();
|
||||
await page.locator('button[type="submit"]').hover();
|
||||
ms = Date.now() - t0;
|
||||
check('hover search button', ms > 100, `${ms} ms`);
|
||||
await delay(1000);
|
||||
|
||||
// ============================================================
|
||||
// SCENARIO 2: Checkboxes
|
||||
// ============================================================
|
||||
step('Checkboxes — check and uncheck');
|
||||
await page.goto('https://the-internet.herokuapp.com/checkboxes', { waitUntil: 'domcontentloaded' });
|
||||
await delay(2000);
|
||||
await inject(page);
|
||||
await delay(1000);
|
||||
|
||||
const cb1 = page.locator('input[type="checkbox"]').nth(0);
|
||||
const cb2 = page.locator('input[type="checkbox"]').nth(1);
|
||||
|
||||
if (await cb1.isChecked()) { await cb1.uncheck(); await delay(500); }
|
||||
|
||||
console.log(' Watch: cursor moves to checkbox, clicks');
|
||||
t0 = Date.now();
|
||||
await cb1.check();
|
||||
ms = Date.now() - t0;
|
||||
check('check checkbox 1', await cb1.isChecked() && ms > 200, `${ms} ms`);
|
||||
await delay(500);
|
||||
|
||||
if (!(await cb2.isChecked())) { await cb2.check(); await delay(500); }
|
||||
|
||||
t0 = Date.now();
|
||||
await cb2.uncheck();
|
||||
ms = Date.now() - t0;
|
||||
check('uncheck checkbox 2', !(await cb2.isChecked()) && ms > 200, `${ms} ms`);
|
||||
await delay(1000);
|
||||
|
||||
// ============================================================
|
||||
// SCENARIO 3: Dropdown
|
||||
// ============================================================
|
||||
step('Dropdown — select option');
|
||||
await page.goto('https://the-internet.herokuapp.com/dropdown', { waitUntil: 'domcontentloaded' });
|
||||
await delay(2000);
|
||||
await inject(page);
|
||||
await delay(1000);
|
||||
|
||||
console.log(' Watch: cursor hovers dropdown, option selected');
|
||||
t0 = Date.now();
|
||||
await page.locator('#dropdown').selectOption('2');
|
||||
ms = Date.now() - t0;
|
||||
val = await page.locator('#dropdown').inputValue();
|
||||
check('select option', val === '2' && ms > 100, `${ms} ms, value='${val}'`);
|
||||
await delay(1000);
|
||||
|
||||
// ============================================================
|
||||
// SCENARIO 4: Drag and Drop
|
||||
// ============================================================
|
||||
step('Drag and Drop');
|
||||
await page.goto('https://the-internet.herokuapp.com/drag_and_drop', { waitUntil: 'domcontentloaded' });
|
||||
await delay(2000);
|
||||
await inject(page);
|
||||
await delay(1000);
|
||||
|
||||
const beforeA = (await page.locator('#column-a header').textContent()).trim();
|
||||
console.log(` Before: A='${beforeA}'`);
|
||||
console.log(' Watch: cursor to A, yellow (held), moves to B, releases');
|
||||
|
||||
t0 = Date.now();
|
||||
await page.locator('#column-a').dragTo(page.locator('#column-b'));
|
||||
ms = Date.now() - t0;
|
||||
await delay(1000);
|
||||
|
||||
const afterA = (await page.locator('#column-a header').textContent()).trim();
|
||||
const swapped = beforeA !== afterA;
|
||||
check('drag A to B', swapped && ms > 300, `${ms} ms, swapped=${swapped}`);
|
||||
await delay(1000);
|
||||
|
||||
// ============================================================
|
||||
// SCENARIO 5: Text editing
|
||||
// ============================================================
|
||||
step('Text editing — type, press, clear');
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(2000);
|
||||
await inject(page);
|
||||
await delay(1000);
|
||||
|
||||
console.log(' Watch: types character by character');
|
||||
t0 = Date.now();
|
||||
await page.locator('#searchInput').type('Hello World');
|
||||
ms = Date.now() - t0;
|
||||
val = await page.locator('#searchInput').inputValue();
|
||||
check("type 'Hello World'", val === 'Hello World' && ms > 1000, `${ms} ms`);
|
||||
await delay(500);
|
||||
|
||||
console.log(' Watch: field cleared');
|
||||
t0 = Date.now();
|
||||
await page.locator('#searchInput').clear();
|
||||
ms = Date.now() - t0;
|
||||
val = await page.locator('#searchInput').inputValue();
|
||||
check('clear field', val === '' && ms > 100, `${ms} ms`);
|
||||
await delay(500);
|
||||
|
||||
console.log(' Watch: mouse moves in Bezier curve');
|
||||
t0 = Date.now();
|
||||
await page.mouse.move(600, 400);
|
||||
ms = Date.now() - t0;
|
||||
check('mouse.move', ms > 100, `${ms} ms`);
|
||||
await delay(500);
|
||||
|
||||
t0 = Date.now();
|
||||
await page.mouse.click(300, 300);
|
||||
ms = Date.now() - t0;
|
||||
check('mouse.click', ms > 100, `${ms} ms`);
|
||||
await delay(1000);
|
||||
|
||||
// ============================================================
|
||||
// SUMMARY
|
||||
// ============================================================
|
||||
console.log('\n' + '='.repeat(70));
|
||||
console.log(' SUMMARY');
|
||||
console.log('='.repeat(70));
|
||||
|
||||
const passed = results.filter(r => r.status === 'PASS').length;
|
||||
const failed = results.filter(r => r.status === 'FAIL').length;
|
||||
|
||||
for (const r of results) {
|
||||
const icon = r.status === 'PASS' ? 'OK' : 'XX';
|
||||
console.log(` [${icon}] ${r.name}`);
|
||||
}
|
||||
|
||||
console.log(`\n ${passed}/${results.length} passed, ${failed} failed`);
|
||||
if (failed === 0) console.log(' *** ALL TESTS PASSED ***');
|
||||
console.log('='.repeat(70));
|
||||
|
||||
await browser.close();
|
||||
}
|
||||
|
||||
main().catch(console.error);
|
||||
@@ -0,0 +1,302 @@
|
||||
"""
|
||||
Visual + functional test for humanize.
|
||||
Red dot = cursor, yellow = mouse held.
|
||||
"""
|
||||
import pytest
|
||||
pytestmark = pytest.mark.slow
|
||||
|
||||
if __name__ == "__main__":
|
||||
from cloakbrowser import launch
|
||||
import time
|
||||
|
||||
CURSOR_JS = """
|
||||
() => {
|
||||
if (document.getElementById('__hc')) return;
|
||||
const el = document.createElement('div');
|
||||
el.id = '__hc';
|
||||
el.style.cssText = 'width:14px;height:14px;background:red;border:2px solid darkred;border-radius:50%;position:fixed;z-index:2147483647;pointer-events:none;display:none;transition:background 0.05s;';
|
||||
document.body.appendChild(el);
|
||||
|
||||
const trail = document.createElement('div');
|
||||
trail.id = '__hcTrail';
|
||||
trail.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;z-index:2147483646;pointer-events:none;overflow:hidden;';
|
||||
document.body.appendChild(trail);
|
||||
|
||||
let dotCount = 0;
|
||||
const maxDots = 500;
|
||||
|
||||
function updatePos(x, y) {
|
||||
el.style.display = 'block';
|
||||
el.style.left = (x - 9) + 'px';
|
||||
el.style.top = (y - 9) + 'px';
|
||||
|
||||
if (dotCount < maxDots) {
|
||||
const dot = document.createElement('div');
|
||||
dot.style.cssText = 'width:3px;height:3px;background:rgba(255,0,0,0.3);border-radius:50%;position:fixed;pointer-events:none;left:'+(x-1)+'px;top:'+(y-1)+'px;';
|
||||
trail.appendChild(dot);
|
||||
dotCount++;
|
||||
}
|
||||
}
|
||||
|
||||
document.addEventListener('mousemove', e => updatePos(e.clientX, e.clientY));
|
||||
document.addEventListener('drag', e => { if (e.clientX > 0) updatePos(e.clientX, e.clientY); });
|
||||
document.addEventListener('dragover', e => { if (e.clientX > 0) updatePos(e.clientX, e.clientY); });
|
||||
document.addEventListener('mousedown', () => { el.style.background = 'yellow'; });
|
||||
document.addEventListener('mouseup', () => { el.style.background = 'red'; });
|
||||
document.addEventListener('dragend', () => { el.style.background = 'red'; });
|
||||
}
|
||||
"""
|
||||
|
||||
def inject(page):
|
||||
try:
|
||||
page.evaluate(CURSOR_JS)
|
||||
except:
|
||||
pass
|
||||
time.sleep(0.3)
|
||||
|
||||
results = []
|
||||
|
||||
def step(name):
|
||||
print(f"\n{'='*60}")
|
||||
print(f" STEP: {name}")
|
||||
print(f"{'='*60}")
|
||||
|
||||
def check(name, passed, detail=""):
|
||||
status = "PASS" if passed else "FAIL"
|
||||
msg = f" [{status}] {name}"
|
||||
if detail:
|
||||
msg += f" — {detail}"
|
||||
print(msg)
|
||||
results.append((name, status))
|
||||
|
||||
print("=" * 70)
|
||||
print(" HUMAN-LIKE BEHAVIOR VISUAL TEST")
|
||||
print(" Watch the red dot — it should move smoothly like a real cursor")
|
||||
print(" Yellow = mouse button held")
|
||||
print(" Red trail dots = path taken")
|
||||
print("=" * 70)
|
||||
|
||||
browser = launch(headless=False, humanize=True)
|
||||
page = browser.new_page()
|
||||
|
||||
# ============================================================
|
||||
# SCENARIO 1: Wikipedia search
|
||||
# ============================================================
|
||||
step("Wikipedia — navigate and search")
|
||||
page.goto('https://www.wikipedia.org', wait_until='domcontentloaded')
|
||||
time.sleep(2)
|
||||
inject(page)
|
||||
time.sleep(1)
|
||||
|
||||
print(" Watch: cursor moves to search box (Bezier curve)")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').click()
|
||||
click_ms = int((time.time() - t0) * 1000)
|
||||
check("click on search input", click_ms > 200, f"{click_ms} ms")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: characters appear one by one with varying speed")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').fill('Python programming language')
|
||||
fill_ms = int((time.time() - t0) * 1000)
|
||||
val = page.locator('#searchInput').input_value()
|
||||
check("fill search box", val == 'Python programming language' and fill_ms > 2000, f"{fill_ms} ms, value='{val}'")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: cursor moves to search box, double yellow flash, word selected")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').dblclick()
|
||||
dbl_ms = int((time.time() - t0) * 1000)
|
||||
sel = page.evaluate('() => window.getSelection().toString().trim()')
|
||||
check("dblclick selects word", len(sel) > 0 and dbl_ms > 200, f"{dbl_ms} ms, selected='{sel}'")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: old text cleared, new text typed")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').fill('Artificial intelligence')
|
||||
fill2_ms = int((time.time() - t0) * 1000)
|
||||
val2 = page.locator('#searchInput').input_value()
|
||||
check("fill replaces text", val2 == 'Artificial intelligence' and fill2_ms > 1500, f"{fill2_ms} ms, value='{val2}'")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: cursor moves to button without clicking")
|
||||
t0 = time.time()
|
||||
page.locator('button[type="submit"]').hover()
|
||||
hover_ms = int((time.time() - t0) * 1000)
|
||||
check("hover search button", hover_ms > 100, f"{hover_ms} ms")
|
||||
time.sleep(1)
|
||||
|
||||
# ============================================================
|
||||
# SCENARIO 2: Form interaction — checkboxes
|
||||
# ============================================================
|
||||
step("Checkboxes — check and uncheck")
|
||||
page.goto('https://the-internet.herokuapp.com/checkboxes', wait_until='domcontentloaded')
|
||||
time.sleep(2)
|
||||
inject(page)
|
||||
time.sleep(1)
|
||||
|
||||
cb1 = page.locator('input[type="checkbox"]').nth(0)
|
||||
cb2 = page.locator('input[type="checkbox"]').nth(1)
|
||||
|
||||
print(" Watch: cursor moves to first checkbox, clicks")
|
||||
if cb1.is_checked():
|
||||
cb1.uncheck()
|
||||
time.sleep(0.5)
|
||||
|
||||
t0 = time.time()
|
||||
cb1.check()
|
||||
check_ms = int((time.time() - t0) * 1000)
|
||||
check("check checkbox 1", cb1.is_checked() and check_ms > 200, f"{check_ms} ms, checked={cb1.is_checked()}")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: cursor moves to second checkbox, clicks to uncheck")
|
||||
if not cb2.is_checked():
|
||||
cb2.check()
|
||||
time.sleep(0.5)
|
||||
|
||||
t0 = time.time()
|
||||
cb2.uncheck()
|
||||
uncheck_ms = int((time.time() - t0) * 1000)
|
||||
check("uncheck checkbox 2", not cb2.is_checked() and uncheck_ms > 200, f"{uncheck_ms} ms, checked={cb2.is_checked()}")
|
||||
time.sleep(1)
|
||||
|
||||
# ============================================================
|
||||
# SCENARIO 3: Dropdown
|
||||
# ============================================================
|
||||
step("Dropdown — select option")
|
||||
page.goto('https://the-internet.herokuapp.com/dropdown', wait_until='domcontentloaded')
|
||||
time.sleep(2)
|
||||
inject(page)
|
||||
time.sleep(1)
|
||||
|
||||
print(" Watch: cursor moves to dropdown, hovers, option selected")
|
||||
t0 = time.time()
|
||||
page.locator('#dropdown').select_option('1')
|
||||
sel_ms = int((time.time() - t0) * 1000)
|
||||
val = page.locator('#dropdown').input_value()
|
||||
check("select option 1", val == '1' and sel_ms > 100, f"{sel_ms} ms, value='{val}'")
|
||||
time.sleep(0.5)
|
||||
|
||||
t0 = time.time()
|
||||
page.locator('#dropdown').select_option('2')
|
||||
sel2_ms = int((time.time() - t0) * 1000)
|
||||
val2 = page.locator('#dropdown').input_value()
|
||||
check("select option 2", val2 == '2' and sel2_ms > 100, f"{sel2_ms} ms, value='{val2}'")
|
||||
time.sleep(1)
|
||||
|
||||
# ============================================================
|
||||
# SCENARIO 4: Drag and drop
|
||||
# ============================================================
|
||||
step("Drag and Drop — move column A to B")
|
||||
page.goto('https://the-internet.herokuapp.com/drag_and_drop', wait_until='domcontentloaded')
|
||||
time.sleep(2)
|
||||
inject(page)
|
||||
time.sleep(1)
|
||||
|
||||
before_a = page.locator('#column-a header').text_content().strip()
|
||||
before_b = page.locator('#column-b header').text_content().strip()
|
||||
print(f" Before: A='{before_a}', B='{before_b}'")
|
||||
|
||||
print(" Watch: cursor moves to A, turns yellow (held), moves to B, releases")
|
||||
t0 = time.time()
|
||||
page.locator('#column-a').drag_to(page.locator('#column-b'))
|
||||
drag_ms = int((time.time() - t0) * 1000)
|
||||
time.sleep(1)
|
||||
|
||||
after_a = page.locator('#column-a header').text_content().strip()
|
||||
after_b = page.locator('#column-b header').text_content().strip()
|
||||
swapped = before_a != after_a
|
||||
print(f" After: A='{after_a}', B='{after_b}'")
|
||||
check("drag A to B", swapped and drag_ms > 300, f"{drag_ms} ms, swapped={swapped}")
|
||||
time.sleep(1)
|
||||
|
||||
# ============================================================
|
||||
# SCENARIO 5: Text editing
|
||||
# ============================================================
|
||||
step("Text editing — type, press keys, clear")
|
||||
page.goto('https://www.wikipedia.org', wait_until='domcontentloaded')
|
||||
time.sleep(2)
|
||||
inject(page)
|
||||
time.sleep(1)
|
||||
|
||||
print(" Watch: cursor clicks input, types character by character")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').type('Hello World')
|
||||
type_ms = int((time.time() - t0) * 1000)
|
||||
val = page.locator('#searchInput').input_value()
|
||||
check("type 'Hello World'", val == 'Hello World' and type_ms > 1000, f"{type_ms} ms, value='{val}'")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: cursor clicks, presses single key")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').press('End')
|
||||
page.locator('#searchInput').press('!')
|
||||
press_ms = int((time.time() - t0) * 1000)
|
||||
val = page.locator('#searchInput').input_value()
|
||||
check("press '!' at end", '!' in val and press_ms > 100, f"{press_ms} ms, value='{val}'")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: field gets cleared (Ctrl+A, Backspace)")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').clear()
|
||||
clear_ms = int((time.time() - t0) * 1000)
|
||||
val = page.locator('#searchInput').input_value()
|
||||
check("clear field", val == '' and clear_ms > 100, f"{clear_ms} ms, value='{repr(val)}'")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: press_sequentially types each key individually")
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').press_sequentially('Sequential')
|
||||
pseq_ms = int((time.time() - t0) * 1000)
|
||||
val = page.locator('#searchInput').input_value()
|
||||
check("press_sequentially", val == 'Sequential' and pseq_ms > 500, f"{pseq_ms} ms, value='{val}'")
|
||||
time.sleep(1)
|
||||
|
||||
# ============================================================
|
||||
# SCENARIO 6: Mouse precision
|
||||
# ============================================================
|
||||
step("Mouse precision — move to coordinates")
|
||||
print(" Watch: cursor moves in a Bezier curve to (600, 400)")
|
||||
t0 = time.time()
|
||||
page.mouse.move(600, 400)
|
||||
move_ms = int((time.time() - t0) * 1000)
|
||||
check("mouse.move to (600,400)", move_ms > 100, f"{move_ms} ms")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: cursor moves to (200, 200), clicks")
|
||||
t0 = time.time()
|
||||
page.mouse.click(200, 200)
|
||||
mclick_ms = int((time.time() - t0) * 1000)
|
||||
check("mouse.click at (200,200)", mclick_ms > 100, f"{mclick_ms} ms")
|
||||
time.sleep(0.5)
|
||||
|
||||
print(" Watch: keyboard types directly (no click needed)")
|
||||
page.locator('#searchInput').click()
|
||||
time.sleep(0.3)
|
||||
t0 = time.time()
|
||||
page.keyboard.type('Direct keyboard')
|
||||
kb_ms = int((time.time() - t0) * 1000)
|
||||
check("keyboard.type", kb_ms > 500, f"{kb_ms} ms")
|
||||
time.sleep(1)
|
||||
|
||||
# ============================================================
|
||||
# SUMMARY
|
||||
# ============================================================
|
||||
print("\n" + "=" * 70)
|
||||
print(" SUMMARY")
|
||||
print("=" * 70)
|
||||
passed = sum(1 for _, s in results if s == "PASS")
|
||||
failed = sum(1 for _, s in results if s == "FAIL")
|
||||
total = len(results)
|
||||
|
||||
for name, status in results:
|
||||
icon = "OK" if status == "PASS" else "XX"
|
||||
print(f" [{icon}] {name}")
|
||||
|
||||
print(f"\n {passed}/{total} passed, {failed} failed")
|
||||
if failed == 0:
|
||||
print(" *** ALL TESTS PASSED ***")
|
||||
print("=" * 70)
|
||||
|
||||
input("\nPress Enter to close browser...")
|
||||
browser.close()
|
||||
@@ -0,0 +1,470 @@
|
||||
/**
|
||||
* Unit + integration tests for the humanize layer (JS).
|
||||
* Covers: config resolution, Bézier math, fill clearing,
|
||||
* bot-detection form, and patching integrity.
|
||||
*
|
||||
* Run: node tests/test_humanize_unit.mjs
|
||||
*/
|
||||
import { launch } from '../js/dist/index.js';
|
||||
import { resolveConfig, rand, randRange, sleep } from '../js/dist/human/config.js';
|
||||
import { humanMove, clickTarget } from '../js/dist/human/mouse.js';
|
||||
|
||||
const PROXY = {
|
||||
|
||||
};
|
||||
const delay = ms => new Promise(r => setTimeout(r, ms));
|
||||
const results = [];
|
||||
|
||||
async function test(name, fn) {
|
||||
try {
|
||||
await fn();
|
||||
console.log(` [PASS] ${name}`);
|
||||
results.push({ name, status: 'PASS' });
|
||||
} catch (e) {
|
||||
console.log(` [FAIL] ${name} — ${e.message || e}`);
|
||||
results.push({ name, status: 'FAIL' });
|
||||
}
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// 1. Config resolution
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' CONFIG RESOLUTION');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('default config resolves', async () => {
|
||||
const cfg = resolveConfig('default');
|
||||
if (!cfg) throw new Error('resolveConfig returned null');
|
||||
if (cfg.mouse_min_steps <= 0) throw new Error('mouse_min_steps should be > 0');
|
||||
if (cfg.mouse_max_steps <= cfg.mouse_min_steps) throw new Error('mouse_max_steps should be > min');
|
||||
if (cfg.typing_delay <= 0) throw new Error('typing_delay should be > 0');
|
||||
if (!Array.isArray(cfg.initial_cursor_x) || cfg.initial_cursor_x.length !== 2) throw new Error('initial_cursor_x invalid');
|
||||
if (!Array.isArray(cfg.initial_cursor_y) || cfg.initial_cursor_y.length !== 2) throw new Error('initial_cursor_y invalid');
|
||||
});
|
||||
|
||||
await test('careful config resolves', async () => {
|
||||
const cfg = resolveConfig('careful');
|
||||
const def = resolveConfig('default');
|
||||
if (!cfg) throw new Error('resolveConfig returned null');
|
||||
if (cfg.typing_delay < def.typing_delay) throw new Error('careful should have >= typing_delay');
|
||||
});
|
||||
|
||||
await test('custom config override', async () => {
|
||||
const cfg = resolveConfig('default', { mouse_min_steps: 100, mouse_max_steps: 200 });
|
||||
if (cfg.mouse_min_steps !== 100) throw new Error(`Override failed: ${cfg.mouse_min_steps}`);
|
||||
if (cfg.mouse_max_steps !== 200) throw new Error(`Override failed: ${cfg.mouse_max_steps}`);
|
||||
});
|
||||
|
||||
await test('rand within bounds', async () => {
|
||||
for (let i = 0; i < 100; i++) {
|
||||
const v = rand(10, 20);
|
||||
if (v < 10 || v > 20) throw new Error(`rand out of range: ${v}`);
|
||||
}
|
||||
});
|
||||
|
||||
await test('randRange within bounds', async () => {
|
||||
for (let i = 0; i < 100; i++) {
|
||||
const v = randRange([5, 15]);
|
||||
if (v < 5 || v > 15) throw new Error(`randRange out of range: ${v}`);
|
||||
}
|
||||
});
|
||||
|
||||
await test('sleep timing', async () => {
|
||||
const t0 = Date.now();
|
||||
await sleep(50);
|
||||
const elapsed = Date.now() - t0;
|
||||
if (elapsed < 40) throw new Error(`sleep too short: ${elapsed} ms`);
|
||||
if (elapsed > 200) throw new Error(`sleep too long: ${elapsed} ms`);
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 2. Bézier math (via humanMove recording)
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' BÉZIER MATH (via mouse movement recording)');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('humanMove generates multiple points', async () => {
|
||||
const cfg = resolveConfig('default');
|
||||
const moves = [];
|
||||
const fakeRaw = {
|
||||
move: async (x, y) => moves.push({ x, y }),
|
||||
down: async () => {},
|
||||
up: async () => {},
|
||||
wheel: async () => {},
|
||||
};
|
||||
await humanMove(fakeRaw, 0, 0, 500, 300, cfg);
|
||||
if (moves.length < 10) throw new Error(`Expected >= 10 moves, got ${moves.length}`);
|
||||
const last = moves[moves.length - 1];
|
||||
if (Math.abs(last.x - 500) > 10) throw new Error(`Last x too far: ${last.x}`);
|
||||
if (Math.abs(last.y - 300) > 10) throw new Error(`Last y too far: ${last.y}`);
|
||||
});
|
||||
|
||||
await test('humanMove smoothness (no large jumps)', async () => {
|
||||
const cfg = resolveConfig('default');
|
||||
const moves = [];
|
||||
const fakeRaw = {
|
||||
move: async (x, y) => moves.push({ x, y }),
|
||||
down: async () => {},
|
||||
up: async () => {},
|
||||
wheel: async () => {},
|
||||
};
|
||||
await humanMove(fakeRaw, 0, 0, 400, 400, cfg);
|
||||
const totalDist = Math.sqrt(400 * 400 + 400 * 400);
|
||||
const maxJump = totalDist * 0.5;
|
||||
for (let i = 1; i < moves.length; i++) {
|
||||
const dx = moves[i].x - moves[i - 1].x;
|
||||
const dy = moves[i].y - moves[i - 1].y;
|
||||
const jump = Math.sqrt(dx * dx + dy * dy);
|
||||
if (jump > maxJump) throw new Error(`Jump too large at step ${i}: ${jump.toFixed(1)}`);
|
||||
}
|
||||
});
|
||||
|
||||
await test('humanMove not a straight line', async () => {
|
||||
const cfg = resolveConfig('default');
|
||||
let maxDev = 0;
|
||||
for (let trial = 0; trial < 5; trial++) {
|
||||
const moves = [];
|
||||
const fakeRaw = {
|
||||
move: async (x, y) => moves.push({ x, y }),
|
||||
down: async () => {},
|
||||
up: async () => {},
|
||||
wheel: async () => {},
|
||||
};
|
||||
await humanMove(fakeRaw, 0, 0, 500, 0, cfg);
|
||||
const dev = Math.max(...moves.map(m => Math.abs(m.y)));
|
||||
if (dev > maxDev) maxDev = dev;
|
||||
}
|
||||
if (maxDev < 0.5) throw new Error(`Curve too straight, max y deviation: ${maxDev.toFixed(2)}`);
|
||||
});
|
||||
|
||||
await test('clickTarget within bounding box', async () => {
|
||||
const cfg = resolveConfig('default');
|
||||
const box = { x: 100, y: 200, width: 150, height: 40 };
|
||||
for (let i = 0; i < 50; i++) {
|
||||
const t = clickTarget(box, false, cfg);
|
||||
if (t.x < 100 || t.x > 250) throw new Error(`x out of box: ${t.x}`);
|
||||
if (t.y < 200 || t.y > 240) throw new Error(`y out of box: ${t.y}`);
|
||||
}
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 3. Fill clearing (with real browser)
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' FILL CLEARING (browser)');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('fill() clears existing text', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(1000);
|
||||
|
||||
await page.locator('#searchInput').type('initial text');
|
||||
await delay(500);
|
||||
const before = await page.locator('#searchInput').inputValue();
|
||||
if (before !== 'initial text') throw new Error(`Initial type failed: '${before}'`);
|
||||
|
||||
await page.locator('#searchInput').fill('replaced text');
|
||||
await delay(500);
|
||||
const after = await page.locator('#searchInput').inputValue();
|
||||
if (after !== 'replaced text') throw new Error(`Fill did not replace: '${after}'`);
|
||||
if (after.includes('initial')) throw new Error('Old text still present');
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
await test('fill() timing is humanized (>1s)', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(1000);
|
||||
|
||||
const t0 = Date.now();
|
||||
await page.locator('#searchInput').fill('Human speed test');
|
||||
const elapsed = Date.now() - t0;
|
||||
if (elapsed < 1000) throw new Error(`fill() too fast: ${elapsed} ms`);
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
await test('clear() empties field', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(1000);
|
||||
|
||||
await page.locator('#searchInput').fill('some text');
|
||||
await delay(500);
|
||||
await page.locator('#searchInput').clear();
|
||||
await delay(500);
|
||||
const val = await page.locator('#searchInput').inputValue();
|
||||
if (val !== '') throw new Error(`clear() did not empty: '${val}'`);
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 4. Bot detection form — deviceandbrowserinfo.com
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' BOT DETECTION FORM (deviceandbrowserinfo.com)');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('bot detection form — behavioral checks pass', async () => {
|
||||
const browser = await launch({ headless: false, humanize: true, proxy: PROXY });
|
||||
const page = await browser.newPage();
|
||||
await page.goto('https://deviceandbrowserinfo.com/are_you_a_bot_interactions', { waitUntil: 'domcontentloaded' });
|
||||
await delay(3000);
|
||||
|
||||
await page.locator('#email').click();
|
||||
await delay(300);
|
||||
await page.locator('#email').fill('test@example.com');
|
||||
await delay(500);
|
||||
|
||||
await page.locator('#password').click();
|
||||
await delay(300);
|
||||
await page.locator('#password').fill('SecurePass!123');
|
||||
await delay(500);
|
||||
|
||||
await page.locator('button[type="submit"]').click();
|
||||
await delay(5000);
|
||||
|
||||
const body = await page.locator('body').textContent();
|
||||
|
||||
const superHuman = body.includes('"superHumanSpeed": true');
|
||||
const suspicious = body.includes('"suspiciousClientSideBehavior": true');
|
||||
const cdpMouse = body.includes('"hasCDPMouseLeak": true');
|
||||
|
||||
console.log(` superHumanSpeed: ${superHuman}`);
|
||||
console.log(` suspiciousClientSideBehavior: ${suspicious}`);
|
||||
console.log(` hasCDPMouseLeak: ${cdpMouse}`);
|
||||
|
||||
if (superHuman) throw new Error('superHumanSpeed detected');
|
||||
if (suspicious) throw new Error('suspiciousClientSideBehavior detected');
|
||||
|
||||
if (body.includes('"isAutomatedWithCDP": true')) {
|
||||
console.log(' [INFO] isAutomatedWithCDP=true — stealth issue, not humanize');
|
||||
}
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
await test('bot detection form timing (>3s)', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true, proxy: PROXY });
|
||||
const page = await browser.newPage();
|
||||
await page.goto('https://deviceandbrowserinfo.com/are_you_a_bot_interactions', { waitUntil: 'domcontentloaded' });
|
||||
await delay(2000);
|
||||
|
||||
const t0 = Date.now();
|
||||
await page.locator('#email').fill('test@example.com');
|
||||
await page.locator('#password').fill('MyPassword!99');
|
||||
await page.locator('button[type="submit"]').click();
|
||||
const elapsed = Date.now() - t0;
|
||||
await delay(3000);
|
||||
|
||||
console.log(` Form fill + submit took: ${elapsed} ms`);
|
||||
if (elapsed < 3000) throw new Error(`Form filled too fast: ${elapsed} ms`);
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 5. Patching integrity
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' PATCHING INTEGRITY');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('page has _original after launch', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
if (!page._original) throw new Error('page._original missing');
|
||||
if (!page._humanCfg) throw new Error('page._humanCfg missing');
|
||||
if (!page._humanCursor) throw new Error('page._humanCursor missing');
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
await test('page.click is humanized', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
const clickStr = page.click.toString();
|
||||
if (!clickStr.includes('ensureCursorInit') && !clickStr.includes('humanClickFn') && !clickStr.includes('scrollToElement')) {
|
||||
throw new Error('page.click does not appear humanized');
|
||||
}
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
await test('non-humanized page works normally', async () => {
|
||||
const browser = await launch({ headless: true, humanize: false });
|
||||
const page = await browser.newPage();
|
||||
if (page._original) throw new Error('Non-humanized page should not have _original');
|
||||
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(1000);
|
||||
|
||||
const t0 = Date.now();
|
||||
await page.locator('#searchInput').fill('test');
|
||||
const elapsed = Date.now() - t0;
|
||||
if (elapsed > 500) throw new Error(`Non-humanized fill too slow: ${elapsed} ms`);
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 6. Focus check — press skips click when focused
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' FOCUS CHECK (press / pressSequentially)');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('press skips click when element already focused', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(1000);
|
||||
|
||||
// Click input first to focus it
|
||||
await page.locator('#searchInput').click();
|
||||
await delay(300);
|
||||
|
||||
// Record mouse moves before pressing Enter
|
||||
const movesBefore = [];
|
||||
const origMove = page._humanOriginals.mouseMove;
|
||||
let moveCount = 0;
|
||||
page._humanOriginals.mouseMove = async (x, y, opts) => {
|
||||
moveCount++;
|
||||
return origMove(x, y, opts);
|
||||
};
|
||||
|
||||
// Press Enter — element is already focused, should NOT trigger mouse move
|
||||
const movesAtStart = moveCount;
|
||||
await page.locator('#searchInput').press('a');
|
||||
const movesUsed = moveCount - movesAtStart;
|
||||
|
||||
// Restore
|
||||
page._humanOriginals.mouseMove = origMove;
|
||||
|
||||
// If focus check works, should be 0 moves (just keyboard press)
|
||||
if (movesUsed > 0) {
|
||||
console.log(` [INFO] press() triggered ${movesUsed} mouse moves on focused element`);
|
||||
}
|
||||
// Lenient: allow some moves but not a full Bézier path (>10 would indicate a click)
|
||||
if (movesUsed > 10) {
|
||||
throw new Error(`press() moved mouse ${movesUsed} times on already-focused element — focus check broken`);
|
||||
}
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 7. check/uncheck idle
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' CHECK/UNCHECK IDLE');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('check() respects idle_between_actions config', async () => {
|
||||
const cfg = resolveConfig('default', { idle_between_actions: true, idle_between_duration: [50, 100] });
|
||||
if (!cfg.idle_between_actions) throw new Error('idle_between_actions should be true');
|
||||
if (!cfg.idle_between_duration || cfg.idle_between_duration[0] !== 50) {
|
||||
throw new Error('idle_between_duration not set');
|
||||
}
|
||||
// Verify config is carried through to page
|
||||
const browser = await launch({ headless: true, humanize: true, humanize_config: { idle_between_actions: true } });
|
||||
const page = await browser.newPage();
|
||||
if (!page._humanCfg) throw new Error('page._humanCfg missing');
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 8. Frame patching completeness
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' FRAME PATCHING COMPLETENESS');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('frame has all methods patched', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
await page.goto('https://www.wikipedia.org', { waitUntil: 'domcontentloaded' });
|
||||
await delay(1000);
|
||||
|
||||
const mainFrame = page.mainFrame();
|
||||
const expected = ['click', 'dblclick', 'hover', 'type', 'fill',
|
||||
'check', 'uncheck', 'selectOption', 'press',
|
||||
'clear', 'dragAndDrop'];
|
||||
const missing = [];
|
||||
for (const method of expected) {
|
||||
if (typeof mainFrame[method] !== 'function') {
|
||||
missing.push(method);
|
||||
}
|
||||
}
|
||||
if (missing.length > 0) {
|
||||
throw new Error(`Frame missing patched methods: ${missing.join(', ')}`);
|
||||
}
|
||||
|
||||
// Verify they are patched (not original Playwright bindings)
|
||||
if (!mainFrame._humanPatched) {
|
||||
throw new Error('mainFrame._humanPatched flag not set');
|
||||
}
|
||||
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 9. drag_to safety — page._original check
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' DRAG_TO SAFETY');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('page._humanCfg is accessible', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
if (!page._humanCfg) throw new Error('page._humanCfg not set');
|
||||
if (!page._original) throw new Error('page._original not set');
|
||||
if (typeof page._original.mouseDown !== 'function') throw new Error('mouseDown not preserved');
|
||||
if (typeof page._original.mouseUp !== 'function') throw new Error('mouseUp not preserved');
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
// =========================================================================
|
||||
// 10. patchBrowser.newPage uses original context
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(60));
|
||||
console.log(' PATCH BROWSER — newPage context');
|
||||
console.log('='.repeat(60));
|
||||
|
||||
await test('browser.newPage returns patched page', async () => {
|
||||
const browser = await launch({ headless: true, humanize: true });
|
||||
const page = await browser.newPage();
|
||||
if (!page._original) throw new Error('page from browser.newPage() not patched');
|
||||
if (!page._humanCfg) throw new Error('page._humanCfg missing from browser.newPage()');
|
||||
await browser.close();
|
||||
});
|
||||
|
||||
|
||||
// =========================================================================
|
||||
// SUMMARY
|
||||
// =========================================================================
|
||||
console.log('\n' + '='.repeat(70));
|
||||
console.log(' TEST SUMMARY');
|
||||
console.log('='.repeat(70));
|
||||
|
||||
const passed = results.filter(r => r.status === 'PASS').length;
|
||||
const failed = results.filter(r => r.status === 'FAIL').length;
|
||||
|
||||
for (const r of results) {
|
||||
const icon = r.status === 'PASS' ? 'OK' : 'XX';
|
||||
console.log(` [${icon}] ${r.name}`);
|
||||
}
|
||||
|
||||
console.log(`\n ${passed}/${results.length} passed, ${failed} failed`);
|
||||
if (failed === 0) console.log(' *** ALL JS TESTS PASSED ***');
|
||||
else console.log(` *** ${failed} TESTS FAILED ***`);
|
||||
console.log('='.repeat(70));
|
||||
|
||||
process.exit(failed === 0 ? 0 : 1);
|
||||
@@ -0,0 +1,575 @@
|
||||
"""
|
||||
Unit + integration tests for the humanize layer.
|
||||
|
||||
Fast unit tests (config, Bézier math, mocks) are proper test_ functions
|
||||
that pytest discovers automatically.
|
||||
|
||||
Browser-dependent tests are marked @pytest.mark.slow and skipped in CI
|
||||
unless explicitly requested (pytest -m slow).
|
||||
|
||||
Can also run directly: python tests/test_humanize_unit.py
|
||||
"""
|
||||
import math
|
||||
import time
|
||||
import sys
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Helper: ensure Locator class is patched before mock tests
|
||||
# =========================================================================
|
||||
|
||||
def _ensure_locator_patched():
|
||||
import cloakbrowser.human as h
|
||||
h._locator_sync_patched = False
|
||||
h._patch_locator_class_sync()
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Helper: fake RawMouse for Bézier tests
|
||||
# =========================================================================
|
||||
|
||||
class _FakeRawMouse:
|
||||
def __init__(self):
|
||||
self.moves = []
|
||||
def move(self, x, y, **kw):
|
||||
self.moves.append((x, y))
|
||||
def down(self, **kw):
|
||||
pass
|
||||
def up(self, **kw):
|
||||
pass
|
||||
def wheel(self, dx, dy):
|
||||
pass
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 1. Config resolution
|
||||
# =========================================================================
|
||||
|
||||
class TestConfigResolution:
|
||||
def test_default_config_resolves(self):
|
||||
from cloakbrowser.human.config import resolve_config, HumanConfig
|
||||
cfg = resolve_config("default", None)
|
||||
assert isinstance(cfg, HumanConfig)
|
||||
assert cfg.mouse_min_steps > 0
|
||||
assert cfg.mouse_max_steps > cfg.mouse_min_steps
|
||||
assert len(cfg.initial_cursor_x) == 2
|
||||
assert len(cfg.initial_cursor_y) == 2
|
||||
assert cfg.typing_delay > 0
|
||||
|
||||
def test_careful_config_resolves(self):
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("careful", None)
|
||||
default_cfg = resolve_config("default", None)
|
||||
assert cfg.mouse_min_steps > 0
|
||||
assert cfg.typing_delay >= default_cfg.typing_delay
|
||||
|
||||
def test_custom_override(self):
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", {"mouse_min_steps": 100, "mouse_max_steps": 200})
|
||||
assert cfg.mouse_min_steps == 100
|
||||
assert cfg.mouse_max_steps == 200
|
||||
|
||||
def test_invalid_preset_raises(self):
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
with pytest.raises(ValueError, match="Unknown humanize preset"):
|
||||
resolve_config("nonexistent", None)
|
||||
|
||||
def test_rand_within_bounds(self):
|
||||
from cloakbrowser.human.config import rand, rand_range
|
||||
for _ in range(200):
|
||||
v = rand(10, 20)
|
||||
assert 10 <= v <= 20
|
||||
for _ in range(200):
|
||||
v = rand_range([5, 15])
|
||||
assert 5 <= v <= 15
|
||||
|
||||
def test_sleep_ms_timing(self):
|
||||
from cloakbrowser.human.config import sleep_ms
|
||||
t0 = time.time()
|
||||
sleep_ms(50)
|
||||
elapsed = (time.time() - t0) * 1000
|
||||
assert elapsed >= 40
|
||||
assert elapsed < 200
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 2. Bézier math
|
||||
# =========================================================================
|
||||
|
||||
class TestBezierMath:
|
||||
def test_generates_multiple_points(self):
|
||||
from cloakbrowser.human.mouse import human_move
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", None)
|
||||
raw = _FakeRawMouse()
|
||||
human_move(raw, 0, 0, 500, 300, cfg)
|
||||
assert len(raw.moves) >= 10
|
||||
last_x, last_y = raw.moves[-1]
|
||||
assert abs(last_x - 500) < 10
|
||||
assert abs(last_y - 300) < 10
|
||||
|
||||
def test_smoothness_no_large_jumps(self):
|
||||
from cloakbrowser.human.mouse import human_move
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", None)
|
||||
raw = _FakeRawMouse()
|
||||
human_move(raw, 0, 0, 400, 400, cfg)
|
||||
total_dist = math.sqrt(400**2 + 400**2)
|
||||
max_jump = total_dist * 0.5
|
||||
for i in range(1, len(raw.moves)):
|
||||
dx = raw.moves[i][0] - raw.moves[i-1][0]
|
||||
dy = raw.moves[i][1] - raw.moves[i-1][1]
|
||||
assert math.sqrt(dx*dx + dy*dy) < max_jump
|
||||
|
||||
def test_short_distance(self):
|
||||
from cloakbrowser.human.mouse import human_move
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", None)
|
||||
raw = _FakeRawMouse()
|
||||
human_move(raw, 100, 100, 103, 102, cfg)
|
||||
assert len(raw.moves) >= 1
|
||||
|
||||
def test_not_straight_line(self):
|
||||
from cloakbrowser.human.mouse import human_move
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", None)
|
||||
max_dev = 0
|
||||
for _ in range(5):
|
||||
raw = _FakeRawMouse()
|
||||
human_move(raw, 0, 0, 500, 0, cfg)
|
||||
dev = max(abs(y) for _, y in raw.moves)
|
||||
if dev > max_dev:
|
||||
max_dev = dev
|
||||
assert max_dev > 0.5
|
||||
|
||||
def test_click_target_within_box(self):
|
||||
from cloakbrowser.human.mouse import click_target
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", None)
|
||||
box = {"x": 100, "y": 200, "width": 150, "height": 40}
|
||||
for _ in range(50):
|
||||
t = click_target(box, False, cfg)
|
||||
assert 100 <= t.x <= 250
|
||||
assert 200 <= t.y <= 240
|
||||
|
||||
def test_click_target_input_mode(self):
|
||||
from cloakbrowser.human.mouse import click_target
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", None)
|
||||
box = {"x": 50, "y": 50, "width": 200, "height": 30}
|
||||
for _ in range(20):
|
||||
t = click_target(box, True, cfg)
|
||||
assert 50 <= t.x <= 250
|
||||
assert 50 <= t.y <= 80
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 3. Async compatibility
|
||||
# =========================================================================
|
||||
|
||||
class TestAsyncCompat:
|
||||
def test_async_modules_import(self):
|
||||
from cloakbrowser.human.mouse_async import AsyncRawMouse, async_human_move
|
||||
from cloakbrowser.human.keyboard_async import AsyncRawKeyboard, async_human_type
|
||||
from cloakbrowser.human.scroll_async import async_scroll_to_element
|
||||
from cloakbrowser.human import patch_page_async, patch_browser_async, patch_context_async
|
||||
assert callable(async_human_move)
|
||||
assert callable(async_human_type)
|
||||
assert callable(async_scroll_to_element)
|
||||
|
||||
def test_async_locator_patch(self):
|
||||
import cloakbrowser.human as h
|
||||
h._locator_async_patched = False
|
||||
h._patch_locator_class_async()
|
||||
assert h._locator_async_patched
|
||||
from playwright.async_api._generated import Locator as AsyncLocator
|
||||
assert 'humanized' in AsyncLocator.fill.__name__
|
||||
|
||||
def test_async_sleep_is_coroutine(self):
|
||||
from cloakbrowser.human.config import async_sleep_ms
|
||||
import asyncio
|
||||
assert asyncio.iscoroutinefunction(async_sleep_ms)
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 4. Focus check — press / clear / pressSequentially
|
||||
# =========================================================================
|
||||
|
||||
class TestFocusCheck:
|
||||
def test_press_skips_click_when_focused(self):
|
||||
_ensure_locator_patched()
|
||||
from unittest.mock import MagicMock, patch as mock_patch
|
||||
page = MagicMock()
|
||||
page._original = MagicMock()
|
||||
page._human_cfg = MagicMock()
|
||||
page._human_cfg.idle_between_actions = False
|
||||
|
||||
with mock_patch("cloakbrowser.human._is_selector_focused", return_value=True):
|
||||
from playwright.sync_api._generated import Locator
|
||||
loc = MagicMock()
|
||||
loc.page = page
|
||||
loc._impl_obj = MagicMock()
|
||||
loc._impl_obj._selector = "#test"
|
||||
Locator.press(loc, "Enter")
|
||||
|
||||
page.click.assert_not_called()
|
||||
|
||||
def test_press_clicks_when_not_focused(self):
|
||||
_ensure_locator_patched()
|
||||
from unittest.mock import MagicMock, patch as mock_patch
|
||||
page = MagicMock()
|
||||
page._original = MagicMock()
|
||||
page._human_cfg = MagicMock()
|
||||
page._human_cfg.idle_between_actions = False
|
||||
|
||||
with mock_patch("cloakbrowser.human._is_selector_focused", return_value=False):
|
||||
from playwright.sync_api._generated import Locator
|
||||
loc = MagicMock()
|
||||
loc.page = page
|
||||
loc._impl_obj = MagicMock()
|
||||
loc._impl_obj._selector = "#test"
|
||||
Locator.press(loc, "Enter")
|
||||
|
||||
page.click.assert_called_with("#test")
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 5. check/uncheck idle
|
||||
# =========================================================================
|
||||
|
||||
class TestCheckUncheckIdle:
|
||||
def test_check_calls_idle_when_enabled(self):
|
||||
_ensure_locator_patched()
|
||||
from unittest.mock import MagicMock, patch as mock_patch
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", {"idle_between_actions": True, "idle_between_duration": [50, 100]})
|
||||
|
||||
page = MagicMock()
|
||||
page._original = MagicMock()
|
||||
page._original.mouse_move = MagicMock()
|
||||
page._human_cfg = cfg
|
||||
|
||||
idle_called = {"n": 0}
|
||||
def fake_idle(*a, **kw):
|
||||
idle_called["n"] += 1
|
||||
|
||||
from playwright.sync_api._generated import Locator
|
||||
loc = MagicMock()
|
||||
loc.page = page
|
||||
loc._impl_obj = MagicMock()
|
||||
loc._impl_obj._selector = "#checkbox"
|
||||
loc.is_checked = MagicMock(return_value=False)
|
||||
|
||||
with mock_patch("cloakbrowser.human.human_idle", fake_idle):
|
||||
Locator.check(loc)
|
||||
|
||||
assert idle_called["n"] >= 1
|
||||
|
||||
def test_uncheck_calls_idle_when_enabled(self):
|
||||
_ensure_locator_patched()
|
||||
from unittest.mock import MagicMock, patch as mock_patch
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default", {"idle_between_actions": True, "idle_between_duration": [50, 100]})
|
||||
|
||||
page = MagicMock()
|
||||
page._original = MagicMock()
|
||||
page._original.mouse_move = MagicMock()
|
||||
page._human_cfg = cfg
|
||||
|
||||
idle_called = {"n": 0}
|
||||
def fake_idle(*a, **kw):
|
||||
idle_called["n"] += 1
|
||||
|
||||
from playwright.sync_api._generated import Locator
|
||||
loc = MagicMock()
|
||||
loc.page = page
|
||||
loc._impl_obj = MagicMock()
|
||||
loc._impl_obj._selector = "#checkbox"
|
||||
loc.is_checked = MagicMock(return_value=True)
|
||||
|
||||
with mock_patch("cloakbrowser.human.human_idle", fake_idle):
|
||||
Locator.uncheck(loc)
|
||||
|
||||
assert idle_called["n"] >= 1
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 6. Frame patching completeness
|
||||
# =========================================================================
|
||||
|
||||
class TestFramePatching:
|
||||
def test_all_11_methods_patched(self):
|
||||
from cloakbrowser.human import _patch_single_frame_sync, _CursorState
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
cfg = resolve_config("default", None)
|
||||
cursor = _CursorState()
|
||||
page = MagicMock()
|
||||
page._original = MagicMock()
|
||||
frame = MagicMock()
|
||||
frame._human_patched = False
|
||||
|
||||
_patch_single_frame_sync(frame, page, cfg, cursor, MagicMock(), MagicMock(), page._original)
|
||||
|
||||
expected = ['click', 'dblclick', 'hover', 'type', 'fill',
|
||||
'check', 'uncheck', 'select_option', 'press',
|
||||
'clear', 'drag_and_drop']
|
||||
for method in expected:
|
||||
fn = getattr(frame, method)
|
||||
assert not isinstance(fn, MagicMock), f"frame.{method} was not patched"
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 7. drag_to safety
|
||||
# =========================================================================
|
||||
|
||||
class TestDragToSafety:
|
||||
def test_handles_missing_original(self):
|
||||
_ensure_locator_patched()
|
||||
from playwright.sync_api._generated import Locator
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
page = MagicMock()
|
||||
page._original = None
|
||||
|
||||
source_loc = MagicMock()
|
||||
source_loc.page = page
|
||||
source_loc._impl_obj = MagicMock()
|
||||
source_loc._impl_obj._selector = "#src"
|
||||
source_loc.bounding_box = MagicMock(return_value={"x": 10, "y": 10, "width": 50, "height": 50})
|
||||
|
||||
target_loc = MagicMock()
|
||||
target_loc.page = page
|
||||
target_loc._impl_obj = MagicMock()
|
||||
target_loc._impl_obj._selector = "#tgt"
|
||||
target_loc.bounding_box = MagicMock(return_value={"x": 200, "y": 200, "width": 50, "height": 50})
|
||||
|
||||
try:
|
||||
Locator.drag_to(source_loc, target_loc)
|
||||
except AttributeError:
|
||||
pytest.fail("drag_to crashed without page._original")
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 8. Page config persistence
|
||||
# =========================================================================
|
||||
|
||||
class TestPageConfigPersistence:
|
||||
def test_resolve_config_has_all_fields(self):
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default")
|
||||
required = ["mouse_min_steps", "mouse_max_steps", "typing_delay",
|
||||
"initial_cursor_x", "initial_cursor_y", "idle_between_actions",
|
||||
"idle_between_duration", "field_switch_delay",
|
||||
"mistype_chance", "mistype_delay_notice", "mistype_delay_correct"]
|
||||
for field in required:
|
||||
assert hasattr(cfg, field), f"Config missing field: {field}"
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 9. Mistype config
|
||||
# =========================================================================
|
||||
|
||||
class TestMistypeConfig:
|
||||
def test_default_mistype_chance(self):
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
cfg = resolve_config("default")
|
||||
assert 0 < cfg.mistype_chance < 1
|
||||
assert len(cfg.mistype_delay_notice) == 2
|
||||
assert len(cfg.mistype_delay_correct) == 2
|
||||
|
||||
def test_careful_mistype_higher(self):
|
||||
from cloakbrowser.human.config import resolve_config
|
||||
default = resolve_config("default")
|
||||
careful = resolve_config("careful")
|
||||
assert careful.mistype_chance >= default.mistype_chance
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# 10. Select-all platform detection
|
||||
# =========================================================================
|
||||
|
||||
class TestSelectAllPlatform:
|
||||
def test_select_all_constant_exists(self):
|
||||
from cloakbrowser.human import _SELECT_ALL
|
||||
assert _SELECT_ALL in ("Meta+a", "Control+a")
|
||||
|
||||
def test_select_all_matches_platform(self):
|
||||
import sys
|
||||
from cloakbrowser.human import _SELECT_ALL
|
||||
if sys.platform == "darwin":
|
||||
assert _SELECT_ALL == "Meta+a"
|
||||
else:
|
||||
assert _SELECT_ALL == "Control+a"
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# SLOW TESTS — require browser (skipped in CI unless pytest -m slow)
|
||||
# =========================================================================
|
||||
|
||||
@pytest.mark.slow
|
||||
class TestBrowserFill:
|
||||
def test_fill_clears_existing(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=True, humanize=True)
|
||||
page = browser.new_page()
|
||||
page.goto('https://www.wikipedia.org', wait_until='domcontentloaded')
|
||||
time.sleep(1)
|
||||
page.locator('#searchInput').type('initial text')
|
||||
time.sleep(0.5)
|
||||
page.locator('#searchInput').fill('replaced text')
|
||||
time.sleep(0.5)
|
||||
val = page.locator('#searchInput').input_value()
|
||||
assert val == 'replaced text'
|
||||
assert 'initial' not in val
|
||||
browser.close()
|
||||
|
||||
def test_fill_timing_humanized(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=True, humanize=True)
|
||||
page = browser.new_page()
|
||||
page.goto('https://www.wikipedia.org', wait_until='domcontentloaded')
|
||||
time.sleep(1)
|
||||
t0 = time.time()
|
||||
page.locator('#searchInput').fill('Human speed test')
|
||||
elapsed_ms = int((time.time() - t0) * 1000)
|
||||
assert elapsed_ms > 1000
|
||||
browser.close()
|
||||
|
||||
def test_clear_empties_field(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=True, humanize=True)
|
||||
page = browser.new_page()
|
||||
page.goto('https://www.wikipedia.org', wait_until='domcontentloaded')
|
||||
time.sleep(1)
|
||||
page.locator('#searchInput').fill('some text')
|
||||
time.sleep(0.5)
|
||||
page.locator('#searchInput').clear()
|
||||
time.sleep(0.5)
|
||||
val = page.locator('#searchInput').input_value()
|
||||
assert val == ''
|
||||
browser.close()
|
||||
|
||||
|
||||
@pytest.mark.slow
|
||||
class TestBrowserPatching:
|
||||
def test_page_has_original(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=True, humanize=True)
|
||||
page = browser.new_page()
|
||||
assert hasattr(page, '_original')
|
||||
assert hasattr(page, '_human_cfg')
|
||||
browser.close()
|
||||
|
||||
def test_locator_methods_patched(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=True, humanize=True)
|
||||
page = browser.new_page()
|
||||
from playwright.sync_api._generated import Locator
|
||||
methods = ['fill', 'click', 'type', 'dblclick', 'hover', 'check', 'uncheck',
|
||||
'set_checked', 'select_option', 'press', 'press_sequentially',
|
||||
'tap', 'drag_to', 'clear']
|
||||
for method in methods:
|
||||
fn = getattr(Locator, method)
|
||||
assert 'humanized' in fn.__name__, f"{method} not patched"
|
||||
browser.close()
|
||||
|
||||
def test_non_humanized_page_normal(self):
|
||||
from playwright.sync_api import sync_playwright
|
||||
with sync_playwright() as p:
|
||||
browser = p.chromium.launch(headless=True)
|
||||
page = browser.new_page()
|
||||
assert not hasattr(page, '_original')
|
||||
browser.close()
|
||||
|
||||
def test_page_human_cfg_persists(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=True, humanize=True)
|
||||
page = browser.new_page()
|
||||
assert page._human_cfg is not None
|
||||
assert hasattr(page._human_cfg, 'idle_between_actions')
|
||||
assert hasattr(page._human_cfg, 'mistype_chance')
|
||||
browser.close()
|
||||
|
||||
|
||||
@pytest.mark.slow
|
||||
class TestBrowserBotDetection:
|
||||
PROXY = ''
|
||||
|
||||
def test_behavioral_checks_pass(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=False, humanize=True, proxy=self.PROXY, geoip=True)
|
||||
page = browser.new_page()
|
||||
page.goto('https://deviceandbrowserinfo.com/are_you_a_bot_interactions',
|
||||
wait_until='domcontentloaded')
|
||||
time.sleep(3)
|
||||
page.locator('#email').click()
|
||||
time.sleep(0.3)
|
||||
page.locator('#email').fill('test@example.com')
|
||||
time.sleep(0.5)
|
||||
page.locator('#password').click()
|
||||
time.sleep(0.3)
|
||||
page.locator('#password').fill('SecurePass!123')
|
||||
time.sleep(0.5)
|
||||
page.locator('button[type="submit"]').click()
|
||||
time.sleep(5)
|
||||
body = page.locator('body').text_content()
|
||||
assert '"superHumanSpeed": true' not in body
|
||||
assert '"suspiciousClientSideBehavior": true' not in body
|
||||
browser.close()
|
||||
|
||||
def test_form_timing(self):
|
||||
from cloakbrowser import launch
|
||||
browser = launch(headless=True, humanize=True, proxy=self.PROXY, geoip=True)
|
||||
page = browser.new_page()
|
||||
page.goto('https://deviceandbrowserinfo.com/are_you_a_bot_interactions',
|
||||
wait_until='domcontentloaded')
|
||||
time.sleep(2)
|
||||
t0 = time.time()
|
||||
page.locator('#email').fill('test@example.com')
|
||||
page.locator('#password').fill('MyPassword!99')
|
||||
page.locator('button[type="submit"]').click()
|
||||
elapsed_ms = int((time.time() - t0) * 1000)
|
||||
time.sleep(3)
|
||||
assert elapsed_ms > 3000
|
||||
browser.close()
|
||||
|
||||
|
||||
@pytest.mark.slow
|
||||
class TestAsyncEndToEnd:
|
||||
def test_async_launch_click_fill(self):
|
||||
"""launch_async(humanize=True) — async page.click and page.fill work end-to-end."""
|
||||
import asyncio
|
||||
from cloakbrowser import launch_async
|
||||
|
||||
async def _run():
|
||||
browser = await launch_async(headless=True, humanize=True)
|
||||
page = await browser.new_page()
|
||||
assert hasattr(page, '_original'), "async page not patched"
|
||||
assert hasattr(page, '_human_cfg'), "async page missing _human_cfg"
|
||||
|
||||
await page.goto('https://www.wikipedia.org', wait_until='domcontentloaded')
|
||||
await asyncio.sleep(1)
|
||||
|
||||
t0 = time.time()
|
||||
await page.locator('#searchInput').fill('async test')
|
||||
elapsed_ms = int((time.time() - t0) * 1000)
|
||||
assert elapsed_ms > 500, f"async fill too fast: {elapsed_ms}ms"
|
||||
|
||||
val = await page.locator('#searchInput').input_value()
|
||||
assert val == 'async test', f"async fill wrong value: {val}"
|
||||
|
||||
await browser.close()
|
||||
|
||||
asyncio.run(_run())
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Direct runner (backwards compat)
|
||||
# =========================================================================
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(pytest.main([__file__, "-v", "--tb=short", "-x"]))
|
||||
Reference in New Issue
Block a user