@testspectra/matchers 1.0.69 → 1.1.0-rc.0

package/dist/__tests__/matcher-contracts.test.js

@@ -0,0 +1,498 @@
+import { describe, it, expect, vi } from 'vitest';
+// Helper polling simulation resembling worker.ts pollCondition
+async function pollCondition(fn, timeoutMs = 100, intervalMs = 10) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            if (await fn())
+                return true;
+        }
+        catch { }
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    try {
+        return await fn();
+    }
+    catch {
+        return false;
+    }
+}
+// Factory to create a test SingleElementProxy backed by simulated DOM element state
+function createTestElementProxy(selector, state) {
+    const proxy = {
+        selector,
+        async isDisplayed() {
+            return state.displayed ?? true;
+        },
+        async isExisting() {
+            return state.existing ?? true;
+        },
+        async isEnabled() {
+            return state.enabled ?? true;
+        },
+        async isSelected() {
+            return state.selected ?? false;
+        },
+        async isFocused() {
+            return state.focused ?? false;
+        },
+        async getText() {
+            return state.text ?? '';
+        },
+        async getValue() {
+            return state.value ?? '';
+        },
+        async getAttribute(name) {
+            return state.attributes?.[name] ?? null;
+        },
+        async getCSSProperty(property) {
+            return { property, value: state.css?.[property] ?? '', parsed: {} };
+        },
+        async click() { },
+        async doubleClick() { },
+        async rightClick() { },
+        async hover() { },
+        async focus() { },
+        async clear() { },
+        async type(_text) { },
+        async select(_option) { },
+        async selectByAttribute(_attribute, _value) { },
+        async selectByValue(_value) { },
+        async selectByIndex(_index) { },
+        async selectByVisibleText(_text) { },
+        async dragDrop(_destination) { },
+        async scrollIntoView() { },
+        async swipe(_options) { },
+        async longPress(_options) { },
+        async waitForElement(_timeoutMs) { },
+        async waitForExist(_timeoutMs) { },
+        async waitForDisplayed(_timeoutMs) { },
+        async waitForEnabled(_timeoutMs) { },
+        // Matcher implementations identical to worker.ts logic
+        async shouldBeVisible() {
+            const ok = await pollCondition(async () => await this.isDisplayed());
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to be visible`);
+        },
+        async shouldNotBeVisible() {
+            const ok = await pollCondition(async () => !(await this.isDisplayed()));
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to be visible`);
+        },
+        async shouldExist() {
+            const ok = await pollCondition(async () => await this.isExisting());
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to exist in DOM`);
+        },
+        async shouldNotExist() {
+            const ok = await pollCondition(async () => !(await this.isExisting()));
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to exist in DOM`);
+        },
+        async shouldBeEnabled() {
+            const ok = await pollCondition(async () => await this.isEnabled());
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to be enabled`);
+        },
+        async shouldBeDisabled() {
+            const ok = await pollCondition(async () => !(await this.isEnabled()));
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to be disabled`);
+        },
+        async shouldBeChecked() {
+            const ok = await pollCondition(async () => await this.isSelected());
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to be checked`);
+        },
+        async shouldNotBeChecked() {
+            const ok = await pollCondition(async () => !(await this.isSelected()));
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to be checked`);
+        },
+        async shouldBeFocused() {
+            const ok = await pollCondition(async () => await this.isFocused());
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to be focused`);
+        },
+        async shouldNotBeFocused() {
+            const ok = await pollCondition(async () => !(await this.isFocused()));
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to be focused`);
+        },
+        async shouldHaveText(expected) {
+            let actual = '';
+            const ok = await pollCondition(async () => {
+                actual = await this.getText();
+                if (expected instanceof RegExp)
+                    return expected.test(actual);
+                return actual === String(expected) || actual.trim() === String(expected).trim();
+            });
+            if (!ok) {
+                if (expected instanceof RegExp)
+                    throw new Error(`Expected element "${selector}" text to match ${expected}, but got "${actual}"`);
+                throw new Error(`Expected element "${selector}" to have text "${expected}", but got "${actual}"`);
+            }
+        },
+        async shouldNotHaveText(expected) {
+            let actual = '';
+            const ok = await pollCondition(async () => {
+                actual = await this.getText();
+                if (expected instanceof RegExp)
+                    return !expected.test(actual);
+                return actual !== String(expected) && actual.trim() !== String(expected).trim();
+            });
+            if (!ok) {
+                if (expected instanceof RegExp)
+                    throw new Error(`Expected element "${selector}" text not to match ${expected}`);
+                throw new Error(`Expected element "${selector}" not to have text "${expected}"`);
+            }
+        },
+        async shouldContainText(substring) {
+            let actual = '';
+            const ok = await pollCondition(async () => {
+                actual = await this.getText();
+                return actual.includes(String(substring));
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to contain text "${substring}", but got "${actual}"`);
+        },
+        async shouldNotContainText(substring) {
+            let actual = '';
+            const ok = await pollCondition(async () => {
+                actual = await this.getText();
+                return !actual.includes(String(substring));
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to contain text "${substring}"`);
+        },
+        async shouldHaveValue(value) {
+            let actual = '';
+            const ok = await pollCondition(async () => {
+                actual = await this.getValue();
+                return actual === String(value);
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to have value "${value}", but got "${actual}"`);
+        },
+        async shouldNotHaveValue(value) {
+            const ok = await pollCondition(async () => {
+                const actual = await this.getValue();
+                return actual !== String(value);
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to have value "${value}"`);
+        },
+        async shouldContainValue(value) {
+            let actual = '';
+            const ok = await pollCondition(async () => {
+                actual = await this.getValue();
+                return actual.includes(String(value));
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to contain value "${value}", but got "${actual}"`);
+        },
+        async shouldNotContainValue(value) {
+            const ok = await pollCondition(async () => {
+                const actual = await this.getValue();
+                return !actual.includes(String(value));
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to contain value "${value}"`);
+        },
+        async shouldHaveClass(className) {
+            const ok = await pollCondition(async () => state.classes?.includes(className) ?? false);
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to have class "${className}"`);
+        },
+        async shouldNotHaveClass(className) {
+            const ok = await pollCondition(async () => !(state.classes?.includes(className) ?? false));
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to have class "${className}"`);
+        },
+        async shouldHaveAttribute(name, value) {
+            let actual = null;
+            const ok = await pollCondition(async () => {
+                actual = await this.getAttribute(name);
+                if (value !== undefined)
+                    return actual === String(value);
+                return actual !== null;
+            });
+            if (!ok) {
+                if (value !== undefined)
+                    throw new Error(`Expected element "${selector}" to have attribute "${name}" = "${value}", but got "${actual}"`);
+                throw new Error(`Expected element "${selector}" to have attribute "${name}"`);
+            }
+        },
+        async shouldNotHaveAttribute(name) {
+            const ok = await pollCondition(async () => {
+                const actual = await this.getAttribute(name);
+                return actual === null;
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to have attribute "${name}"`);
+        },
+        async shouldHaveCss(property, value) {
+            let actualCss = '';
+            const ok = await pollCondition(async () => {
+                const css = await this.getCSSProperty(property);
+                actualCss = css.value;
+                return actualCss === value;
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" to have CSS "${property}" = "${value}", but got "${actualCss}"`);
+        },
+        async shouldNotHaveCss(property, value) {
+            const ok = await pollCondition(async () => {
+                const css = await this.getCSSProperty(property);
+                return css.value !== value;
+            });
+            if (!ok)
+                throw new Error(`Expected element "${selector}" not to have CSS "${property}" = "${value}"`);
+        },
+    };
+    return proxy;
+}
+// Factory to create a test CollectionProxy backed by simulated count
+function createTestCollectionProxy(selector, itemsCount) {
+    return {
+        selector,
+        async count() {
+            return itemsCount;
+        },
+        get length() {
+            return this.count();
+        },
+        first() {
+            return createTestElementProxy(`${selector}:first-child`, {});
+        },
+        last() {
+            return createTestElementProxy(`${selector}:last-child`, {});
+        },
+        nth(index) {
+            return createTestElementProxy(`${selector}:nth-child(${index})`, {});
+        },
+        async shouldHaveLength(expected) {
+            let actual = 0;
+            const ok = await pollCondition(async () => {
+                actual = await this.count();
+                return actual === expected;
+            });
+            if (!ok)
+                throw new Error(`Expected collection "${selector}" count to equal ${expected}, but got ${actual}`);
+        },
+        async shouldNotHaveLength(expected) {
+            const ok = await pollCondition(async () => {
+                const actual = await this.count();
+                return actual !== expected;
+            });
+            if (!ok)
+                throw new Error(`Expected collection "${selector}" count not to equal ${expected}`);
+        },
+        async shouldHaveLengthGreaterThan(expected) {
+            let actual = 0;
+            const ok = await pollCondition(async () => {
+                actual = await this.count();
+                return actual > expected;
+            });
+            if (!ok)
+                throw new Error(`Expected collection "${selector}" count to be greater than ${expected}, but got ${actual}`);
+        },
+        async shouldHaveLengthLessThan(expected) {
+            let actual = 0;
+            const ok = await pollCondition(async () => {
+                actual = await this.count();
+                return actual < expected;
+            });
+            if (!ok)
+                throw new Error(`Expected collection "${selector}" count to be less than ${expected}, but got ${actual}`);
+        },
+        async shouldBeEmpty() {
+            let actual = 0;
+            const ok = await pollCondition(async () => {
+                actual = await this.count();
+                return actual === 0;
+            });
+            if (!ok)
+                throw new Error(`Expected collection "${selector}" to be empty, but got ${actual}`);
+        },
+        async shouldNotBeEmpty() {
+            const ok = await pollCondition(async () => {
+                const actual = await this.count();
+                return actual > 0;
+            });
+            if (!ok)
+                throw new Error(`Expected collection "${selector}" not to be empty`);
+        },
+    };
+}
+describe('Worker Matchers & Static Actions Verification Suite', () => {
+    describe('Single Element Visibility & Existence Matchers', () => {
+        it('passes shouldBeVisible when element is displayed, fails and throws when not displayed', async () => {
+            const visibleEl = createTestElementProxy('#btn-visible', { displayed: true });
+            await expect(visibleEl.shouldBeVisible()).resolves.toBeUndefined();
+            const hiddenEl = createTestElementProxy('#btn-hidden', { displayed: false });
+            await expect(hiddenEl.shouldBeVisible()).rejects.toThrow('Expected element "#btn-hidden" to be visible');
+        });
+        it('passes shouldNotBeVisible when element is hidden, fails and throws when displayed', async () => {
+            const hiddenEl = createTestElementProxy('#btn-hidden', { displayed: false });
+            await expect(hiddenEl.shouldNotBeVisible()).resolves.toBeUndefined();
+            const visibleEl = createTestElementProxy('#btn-visible', { displayed: true });
+            await expect(visibleEl.shouldNotBeVisible()).rejects.toThrow('Expected element "#btn-visible" not to be visible');
+        });
+        it('passes shouldExist when element is in DOM, fails and throws when missing', async () => {
+            const domEl = createTestElementProxy('#card', { existing: true });
+            await expect(domEl.shouldExist()).resolves.toBeUndefined();
+            const missingEl = createTestElementProxy('#missing-card', { existing: false });
+            await expect(missingEl.shouldExist()).rejects.toThrow('Expected element "#missing-card" to exist in DOM');
+        });
+        it('passes shouldNotExist when element is missing, fails and throws when element exists', async () => {
+            const missingEl = createTestElementProxy('#missing-card', { existing: false });
+            await expect(missingEl.shouldNotExist()).resolves.toBeUndefined();
+            const domEl = createTestElementProxy('#card', { existing: true });
+            await expect(domEl.shouldNotExist()).rejects.toThrow('Expected element "#card" not to exist in DOM');
+        });
+    });
+    describe('Single Element State Matchers (Enabled, Checked, Focused)', () => {
+        it('verifies shouldBeEnabled and shouldBeDisabled strictly', async () => {
+            const enabledEl = createTestElementProxy('#submit-btn', { enabled: true });
+            await expect(enabledEl.shouldBeEnabled()).resolves.toBeUndefined();
+            await expect(enabledEl.shouldBeDisabled()).rejects.toThrow('Expected element "#submit-btn" to be disabled');
+            const disabledEl = createTestElementProxy('#disabled-btn', { enabled: false });
+            await expect(disabledEl.shouldBeDisabled()).resolves.toBeUndefined();
+            await expect(disabledEl.shouldBeEnabled()).rejects.toThrow('Expected element "#disabled-btn" to be enabled');
+        });
+        it('verifies shouldBeChecked and shouldNotBeChecked strictly', async () => {
+            const checkedCheckbox = createTestElementProxy('#agree', { selected: true });
+            await expect(checkedCheckbox.shouldBeChecked()).resolves.toBeUndefined();
+            await expect(checkedCheckbox.shouldNotBeChecked()).rejects.toThrow('Expected element "#agree" not to be checked');
+            const uncheckedCheckbox = createTestElementProxy('#disagree', { selected: false });
+            await expect(uncheckedCheckbox.shouldNotBeChecked()).resolves.toBeUndefined();
+            await expect(uncheckedCheckbox.shouldBeChecked()).rejects.toThrow('Expected element "#disagree" to be checked');
+        });
+        it('verifies shouldBeFocused and shouldNotBeFocused strictly', async () => {
+            const focusedInput = createTestElementProxy('#email-input', { focused: true });
+            await expect(focusedInput.shouldBeFocused()).resolves.toBeUndefined();
+            await expect(focusedInput.shouldNotBeFocused()).rejects.toThrow('Expected element "#email-input" not to be focused');
+            const unfocusedInput = createTestElementProxy('#password-input', { focused: false });
+            await expect(unfocusedInput.shouldNotBeFocused()).resolves.toBeUndefined();
+            await expect(unfocusedInput.shouldBeFocused()).rejects.toThrow('Expected element "#password-input" to be focused');
+        });
+    });
+    describe('Content Matchers (Text, Value, Classes, Attributes, CSS)', () => {
+        it('strictly checks text equality and fails on mismatch', async () => {
+            const textEl = createTestElementProxy('#heading', { text: 'Welcome to TestSpectra' });
+            await expect(textEl.shouldHaveText('Welcome to TestSpectra')).resolves.toBeUndefined();
+            await expect(textEl.shouldHaveText(/Welcome to \w+/)).resolves.toBeUndefined();
+            await expect(textEl.shouldContainText('TestSpectra')).resolves.toBeUndefined();
+            // Negative assertions
+            await expect(textEl.shouldNotHaveText('Goodbye')).resolves.toBeUndefined();
+            await expect(textEl.shouldNotContainText('Cypress')).resolves.toBeUndefined();
+            // Failing conditions MUST throw and not falsely pass
+            await expect(textEl.shouldHaveText('Wrong Text')).rejects.toThrow('Expected element "#heading" to have text "Wrong Text", but got "Welcome to TestSpectra"');
+            await expect(textEl.shouldContainText('Selenium')).rejects.toThrow('Expected element "#heading" to contain text "Selenium", but got "Welcome to TestSpectra"');
+            await expect(textEl.shouldNotHaveText('Welcome to TestSpectra')).rejects.toThrow('Expected element "#heading" not to have text "Welcome to TestSpectra"');
+            await expect(textEl.shouldNotContainText('TestSpectra')).rejects.toThrow('Expected element "#heading" not to contain text "TestSpectra"');
+        });
+        it('strictly checks input values and fails on mismatch', async () => {
+            const inputEl = createTestElementProxy('#username', { value: 'admin_testspectra' });
+            await expect(inputEl.shouldHaveValue('admin_testspectra')).resolves.toBeUndefined();
+            await expect(inputEl.shouldContainValue('admin_')).resolves.toBeUndefined();
+            await expect(inputEl.shouldNotHaveValue('guest')).resolves.toBeUndefined();
+            await expect(inputEl.shouldNotContainValue('root')).resolves.toBeUndefined();
+            await expect(inputEl.shouldHaveValue('wrong_user')).rejects.toThrow('Expected element "#username" to have value "wrong_user", but got "admin_testspectra"');
+            await expect(inputEl.shouldNotHaveValue('admin_testspectra')).rejects.toThrow('Expected element "#username" not to have value "admin_testspectra"');
+        });
+        it('strictly checks classes and attributes', async () => {
+            const badge = createTestElementProxy('#status-badge', {
+                classes: ['badge', 'badge-success', 'active'],
+                attributes: { id: 'status-badge', 'data-role': 'indicator', disabled: 'false' },
+                css: { color: 'rgb(0, 128, 0)' },
+            });
+            await expect(badge.shouldHaveClass('badge-success')).resolves.toBeUndefined();
+            await expect(badge.shouldNotHaveClass('badge-danger')).resolves.toBeUndefined();
+            await expect(badge.shouldHaveAttribute('data-role', 'indicator')).resolves.toBeUndefined();
+            await expect(badge.shouldNotHaveAttribute('data-unknown')).resolves.toBeUndefined();
+            await expect(badge.shouldHaveCss('color', 'rgb(0, 128, 0)')).resolves.toBeUndefined();
+            // Fails when class/attribute is missing or incorrect
+            await expect(badge.shouldHaveClass('badge-danger')).rejects.toThrow('Expected element "#status-badge" to have class "badge-danger"');
+            await expect(badge.shouldNotHaveClass('badge-success')).rejects.toThrow('Expected element "#status-badge" not to have class "badge-success"');
+            await expect(badge.shouldHaveAttribute('data-role', 'wrong-val')).rejects.toThrow('Expected element "#status-badge" to have attribute "data-role" = "wrong-val", but got "indicator"');
+            await expect(badge.shouldNotHaveAttribute('data-role')).rejects.toThrow('Expected element "#status-badge" not to have attribute "data-role"');
+        });
+    });
+    describe('Collection Matchers ($$ / Spectra.getAll)', () => {
+        it('strictly checks collection lengths and emptiness', async () => {
+            const items = createTestCollectionProxy('.post-item', 5);
+            await expect(items.shouldHaveLength(5)).resolves.toBeUndefined();
+            await expect(items.shouldHaveLengthGreaterThan(3)).resolves.toBeUndefined();
+            await expect(items.shouldHaveLengthLessThan(10)).resolves.toBeUndefined();
+            await expect(items.shouldNotBeEmpty()).resolves.toBeUndefined();
+            // Failing conditions MUST throw
+            await expect(items.shouldHaveLength(0)).rejects.toThrow('Expected collection ".post-item" count to equal 0, but got 5');
+            await expect(items.shouldHaveLengthGreaterThan(10)).rejects.toThrow('Expected collection ".post-item" count to be greater than 10, but got 5');
+            await expect(items.shouldHaveLengthLessThan(3)).rejects.toThrow('Expected collection ".post-item" count to be less than 3, but got 5');
+            await expect(items.shouldBeEmpty()).rejects.toThrow('Expected collection ".post-item" to be empty, but got 5');
+            const emptyItems = createTestCollectionProxy('.empty-list', 0);
+            await expect(emptyItems.shouldBeEmpty()).resolves.toBeUndefined();
+            await expect(emptyItems.shouldNotBeEmpty()).rejects.toThrow('Expected collection ".empty-list" not to be empty');
+        });
+    });
+    describe('Spectra Static Automation API (Single Global Object)', () => {
+        it('correctly maps Spectra static methods to underlying actions without error', async () => {
+            const elementMock = createTestElementProxy('#test-btn', { text: 'Click Me', value: 'hello' });
+            const clickSpy = vi.spyOn(elementMock, 'click');
+            const typeSpy = vi.spyOn(elementMock, 'type');
+            const clearSpy = vi.spyOn(elementMock, 'clear');
+            const mockSpectra = {
+                get: (target) => (typeof target === 'string' ? elementMock : target),
+                getAll: (selector) => createTestCollectionProxy(selector, 2),
+                navigate: async (_url) => { },
+                back: async () => { },
+                forward: async () => { },
+                refresh: async () => { },
+                setViewport: async (_w, _h) => { },
+                wait: async (ms) => {
+                    await new Promise((r) => setTimeout(r, ms));
+                },
+                click: async (target) => {
+                    const el = typeof target === 'string' ? elementMock : target;
+                    await el.click();
+                },
+                doubleClick: async () => { },
+                rightClick: async () => { },
+                type: async (target, text) => {
+                    const el = typeof target === 'string' ? elementMock : target;
+                    await el.type(text);
+                },
+                clear: async (target) => {
+                    const el = typeof target === 'string' ? elementMock : target;
+                    await el.clear();
+                },
+                select: async () => { },
+                hover: async () => { },
+                dragDrop: async () => { },
+                scrollIntoView: async () => { },
+                scroll: async () => { },
+                swipe: async () => { },
+                longPress: async () => { },
+                pressKey: async () => { },
+                waitForElement: async () => { },
+                intercept: async () => ({ respondWith: async () => { }, callCount: () => 0 }),
+                clearMocks: () => { },
+                browser: {},
+            };
+            // Test actions call underlying proxy methods
+            await mockSpectra.click('#test-btn');
+            expect(clickSpy).toHaveBeenCalled();
+            await mockSpectra.type('#test-btn', 'Test input');
+            expect(typeSpy).toHaveBeenCalledWith('Test input');
+            await mockSpectra.clear('#test-btn');
+            expect(clearSpy).toHaveBeenCalled();
+            // Test wait execution timing
+            const start = Date.now();
+            await mockSpectra.wait(20);
+            const elapsed = Date.now() - start;
+            expect(elapsed).toBeGreaterThanOrEqual(15);
+        });
+    });
+});

package/dist/__tests__/matchers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/matchers.test.js

@@ -0,0 +1,161 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Spectra, SingleElementRunner, MultiElementRunner, installPrototypes } from '../index.js';
+describe('Matchers Assertion Library & Receiver API', () => {
+    describe('SingleElementRunner - 26 Receiver Assertion Methods', () => {
+        it('should queue visibility and DOM existence assertions', () => {
+            const runner = new SingleElementRunner('#hero');
+            runner.shouldBeVisible().shouldNotBeVisible().shouldExist().shouldNotExist();
+            const assertions = runner._assertions;
+            expect(assertions).toHaveLength(4);
+            expect(assertions[0].matcher).toBe('be.visible');
+            expect(assertions[1].matcher).toBe('not.be.visible');
+            expect(assertions[2].matcher).toBe('exist');
+            expect(assertions[3].matcher).toBe('not.exist');
+        });
+        it('should queue interactivity and state assertions', () => {
+            const runner = new SingleElementRunner('#btn');
+            runner
+                .shouldBeClickable()
+                .shouldNotBeClickable()
+                .shouldBeEnabled()
+                .shouldBeDisabled()
+                .shouldBeChecked()
+                .shouldNotBeChecked()
+                .shouldBeFocused()
+                .shouldNotBeFocused();
+            const assertions = runner._assertions;
+            expect(assertions).toHaveLength(8);
+            expect(assertions[0].matcher).toBe('be.clickable');
+            expect(assertions[1].matcher).toBe('not.be.clickable');
+            expect(assertions[2].matcher).toBe('be.enabled');
+            expect(assertions[3].matcher).toBe('be.disabled');
+            expect(assertions[4].matcher).toBe('be.checked');
+            expect(assertions[5].matcher).toBe('not.be.checked');
+            expect(assertions[6].matcher).toBe('be.focused');
+            expect(assertions[7].matcher).toBe('not.be.focused');
+        });
+        it('should queue text and value assertions with arguments', () => {
+            const runner = new SingleElementRunner('#input');
+            runner
+                .shouldHaveText('Welcome')
+                .shouldNotHaveText('Goodbye')
+                .shouldContainText('come')
+                .shouldNotContainText('bye')
+                .shouldHaveValue('admin')
+                .shouldNotHaveValue('guest')
+                .shouldContainValue('adm')
+                .shouldNotContainValue('gst');
+            const assertions = runner._assertions;
+            expect(assertions).toHaveLength(8);
+            expect(assertions[0]).toEqual({ target: '#input', matcher: 'have.text', args: ['Welcome'] });
+            expect(assertions[1]).toEqual({ target: '#input', matcher: 'not.have.text', args: ['Goodbye'] });
+            expect(assertions[2]).toEqual({ target: '#input', matcher: 'contain.text', args: ['come'] });
+            expect(assertions[3]).toEqual({ target: '#input', matcher: 'not.contain.text', args: ['bye'] });
+            expect(assertions[4]).toEqual({ target: '#input', matcher: 'have.value', args: ['admin'] });
+            expect(assertions[5]).toEqual({ target: '#input', matcher: 'not.have.value', args: ['guest'] });
+            expect(assertions[6]).toEqual({ target: '#input', matcher: 'contain.value', args: ['adm'] });
+            expect(assertions[7]).toEqual({ target: '#input', matcher: 'not.contain.value', args: ['gst'] });
+        });
+        it('should queue attribute, class, and CSS assertions', () => {
+            const runner = new SingleElementRunner('#card');
+            runner
+                .shouldHaveAttribute('data-testid', 'test-card')
+                .shouldNotHaveAttribute('disabled')
+                .shouldHaveClass('active')
+                .shouldNotHaveClass('hidden')
+                .shouldHaveCss('color', 'red')
+                .shouldNotHaveCss('display', 'none');
+            const assertions = runner._assertions;
+            expect(assertions).toHaveLength(6);
+            expect(assertions[0]).toEqual({ target: '#card', matcher: 'have.attr', args: ['data-testid', 'test-card'] });
+            expect(assertions[1]).toEqual({ target: '#card', matcher: 'not.have.attr', args: ['disabled'] });
+            expect(assertions[2]).toEqual({ target: '#card', matcher: 'have.class', args: ['active'] });
+            expect(assertions[3]).toEqual({ target: '#card', matcher: 'not.have.class', args: ['hidden'] });
+            expect(assertions[4]).toEqual({ target: '#card', matcher: 'have.css', args: ['color', 'red'] });
+            expect(assertions[5]).toEqual({ target: '#card', matcher: 'not.have.css', args: ['display', 'none'] });
+        });
+    });
+    describe('SingleElementRunner - Actions', () => {
+        it('should support action method chaining and label assignment', () => {
+            const runner = new SingleElementRunner('#target');
+            expect(runner.click()).toBe(runner);
+            expect(runner._actionPayload.key).toBe('click');
+            expect(runner.doubleClick()).toBe(runner);
+            expect(runner._actionPayload.key).toBe('doubleClick');
+            expect(runner.rightClick()).toBe(runner);
+            expect(runner._actionPayload.key).toBe('rightClick');
+            expect(runner.scrollIntoView()).toBe(runner);
+            expect(runner._actionPayload.key).toBe('scrollIntoView');
+            expect(runner.dragDrop('#dest')).toBe(runner);
+            expect(runner._actionPayload.key).toBe('dragDrop');
+        });
+        it('should support action to semantic assertion chaining', () => {
+            const runner = new SingleElementRunner('#login-btn');
+            runner.click().shouldNotBeVisible();
+            expect(runner._actionPayload.key).toBe('click');
+            const assertions = runner._assertions;
+            expect(assertions).toHaveLength(1);
+            expect(assertions[0].matcher).toBe('not.be.visible');
+        });
+    });
+    describe('MultiElementRunner - 6 Collection Receiver Assertions', () => {
+        it('should queue all 6 collection assertions', () => {
+            const runner = new MultiElementRunner('.product-item');
+            runner
+                .shouldHaveLength(4)
+                .shouldNotHaveLength(0)
+                .shouldHaveLengthGreaterThan(2)
+                .shouldHaveLengthLessThan(10)
+                .shouldBeEmpty()
+                .shouldNotBeEmpty();
+            const assertions = runner._assertions;
+            expect(assertions).toHaveLength(6);
+            expect(assertions[0]).toEqual({ matcher: 'have.length', args: [4] });
+            expect(assertions[1]).toEqual({ matcher: 'not.have.length', args: [0] });
+            expect(assertions[2]).toEqual({ matcher: 'have.length.greaterThan', args: [2] });
+            expect(assertions[3]).toEqual({ matcher: 'have.length.lessThan', args: [10] });
+            expect(assertions[4]).toEqual({ matcher: 'be.empty', args: [] });
+            expect(assertions[5]).toEqual({ matcher: 'not.be.empty', args: [] });
+        });
+        it('should navigate collection items with first, last, eq', () => {
+            const collection = Spectra.getAll('.list-item');
+            const first = collection.first();
+            const last = collection.last();
+            const second = collection.eq(1);
+            expect(first).toBeInstanceOf(SingleElementRunner);
+            expect(last).toBeInstanceOf(SingleElementRunner);
+            expect(second).toBeInstanceOf(SingleElementRunner);
+        });
+    });
+    describe('Spectra.browser - Context Assertions & Utilities', () => {
+        it('should expose all browser assertions and utilities', () => {
+            expect(typeof Spectra.browser.shouldHaveUrl).toBe('function');
+            expect(typeof Spectra.browser.shouldContainUrl).toBe('function');
+            expect(typeof Spectra.browser.shouldHaveTitle).toBe('function');
+            expect(typeof Spectra.browser.shouldContainTitle).toBe('function');
+            expect(typeof Spectra.browser.shouldBePageLoaded).toBe('function');
+            expect(typeof Spectra.browser.shouldHaveNoConsoleErrors).toBe('function');
+            expect(typeof Spectra.browser.clearCookies).toBe('function');
+            expect(typeof Spectra.browser.clearLocalStorage).toBe('function');
+        });
+    });
+    describe('Prototypes & Promise Unwrapping', () => {
+        it('should install receiver methods on mock WebdriverIO browser', () => {
+            const addedCommands = {};
+            const mockBrowser = {
+                addCommand: vi.fn((name, fn) => {
+                    addedCommands[name] = fn;
+                }),
+            };
+            installPrototypes(mockBrowser);
+            expect(mockBrowser.addCommand).toHaveBeenCalled();
+            expect(addedCommands['should']).toBeUndefined();
+            expect(addedCommands['shouldBeVisible']).toBeDefined();
+            expect(addedCommands['shouldHaveText']).toBeDefined();
+            expect(addedCommands['shouldHaveLength']).toBeUndefined(); // collection only
+            expect(addedCommands['shouldHaveUrl']).toBeDefined();
+            // Check Promise.prototype has shouldBeVisible attached
+            expect(typeof Promise.prototype.shouldBeVisible).toBe('function');
+        });
+    });
+});