appium-session-recorder 0.0.2 → 0.0.3

package/src/ui/src/utils/__tests__/locators.test.ts

@@ -1,304 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateLocators } from '../locators';
-import type { ParsedElement } from '../../types';
-
-function createMockElement(overrides: Partial<ParsedElement> = {}): ParsedElement {
-    return {
-        type: 'XCUIElementTypeButton',
-        name: '',
-        label: '',
-        value: '',
-        enabled: true,
-        visible: true,
-        accessible: false,
-        x: 0,
-        y: 0,
-        width: 100,
-        height: 50,
-        xpath: '/Application[1]/Button[1]',
-        node: document.createElement('div') as unknown as Element,
-        ...overrides,
-    };
-}
-
-describe('generateLocators', () => {
-    describe('accessibility id locators', () => {
-        it('should generate accessibility id from name attribute', () => {
-            const element = createMockElement({ name: 'loginButton' });
-            const locators = generateLocators(element);
-
-            const accessibilityIdLocators = locators.filter(l => l.strategy === 'accessibility id');
-            expect(accessibilityIdLocators).toContainEqual({
-                strategy: 'accessibility id',
-                value: 'loginButton',
-            });
-        });
-
-        it('should generate accessibility id from label attribute', () => {
-            const element = createMockElement({ label: 'Login' });
-            const locators = generateLocators(element);
-
-            const accessibilityIdLocators = locators.filter(l => l.strategy === 'accessibility id');
-            expect(accessibilityIdLocators).toContainEqual({
-                strategy: 'accessibility id',
-                value: 'Login',
-            });
-        });
-
-        it('should not duplicate accessibility id if name and label are same', () => {
-            const element = createMockElement({ name: 'Login', label: 'Login' });
-            const locators = generateLocators(element);
-
-            const accessibilityIdLocators = locators.filter(l => l.strategy === 'accessibility id');
-            expect(accessibilityIdLocators).toHaveLength(1);
-        });
-
-        it('should generate both accessibility ids if name and label differ', () => {
-            const element = createMockElement({ name: 'loginBtn', label: 'Login' });
-            const locators = generateLocators(element);
-
-            const accessibilityIdLocators = locators.filter(l => l.strategy === 'accessibility id');
-            expect(accessibilityIdLocators).toHaveLength(2);
-            expect(accessibilityIdLocators).toContainEqual({
-                strategy: 'accessibility id',
-                value: 'loginBtn',
-            });
-            expect(accessibilityIdLocators).toContainEqual({
-                strategy: 'accessibility id',
-                value: 'Login',
-            });
-        });
-
-        it('should not generate accessibility id if name is empty', () => {
-            const element = createMockElement({ name: '' });
-            const locators = generateLocators(element);
-
-            const accessibilityIdFromName = locators.find(
-                l => l.strategy === 'accessibility id' && l.value === ''
-            );
-            expect(accessibilityIdFromName).toBeUndefined();
-        });
-    });
-
-    describe('xpath locator', () => {
-        it('should always include xpath locator', () => {
-            const element = createMockElement({ xpath: '/App[1]/Window[1]/Button[1]' });
-            const locators = generateLocators(element);
-
-            const xpathLocator = locators.find(l => l.strategy === 'xpath');
-            expect(xpathLocator).toEqual({
-                strategy: 'xpath',
-                value: '/App[1]/Window[1]/Button[1]',
-            });
-        });
-
-        it('should include xpath even when no other attributes present', () => {
-            const element = createMockElement({
-                name: '',
-                label: '',
-                xpath: '/root[1]',
-            });
-            const locators = generateLocators(element);
-
-            expect(locators.find(l => l.strategy === 'xpath')).toBeDefined();
-        });
-    });
-
-    describe('class name locator', () => {
-        it('should always include class name locator', () => {
-            const element = createMockElement({ type: 'XCUIElementTypeButton' });
-            const locators = generateLocators(element);
-
-            const classNameLocator = locators.find(l => l.strategy === 'class name');
-            expect(classNameLocator).toEqual({
-                strategy: 'class name',
-                value: 'XCUIElementTypeButton',
-            });
-        });
-
-        it('should handle Android class names', () => {
-            const element = createMockElement({ type: 'android.widget.Button' });
-            const locators = generateLocators(element);
-
-            const classNameLocator = locators.find(l => l.strategy === 'class name');
-            expect(classNameLocator).toEqual({
-                strategy: 'class name',
-                value: 'android.widget.Button',
-            });
-        });
-    });
-
-    describe('iOS predicate string locators', () => {
-        it('should generate predicate for name attribute', () => {
-            const element = createMockElement({ name: 'loginButton' });
-            const locators = generateLocators(element);
-
-            const predicateLocators = locators.filter(l => l.strategy === '-ios predicate string');
-            expect(predicateLocators).toContainEqual({
-                strategy: '-ios predicate string',
-                value: 'name == "loginButton"',
-            });
-        });
-
-        it('should generate predicate for label attribute', () => {
-            const element = createMockElement({ label: 'Login' });
-            const locators = generateLocators(element);
-
-            const predicateLocators = locators.filter(l => l.strategy === '-ios predicate string');
-            expect(predicateLocators).toContainEqual({
-                strategy: '-ios predicate string',
-                value: 'label == "Login"',
-            });
-        });
-
-        it('should generate both predicates if name and label are different', () => {
-            const element = createMockElement({ name: 'loginBtn', label: 'Login' });
-            const locators = generateLocators(element);
-
-            const predicateLocators = locators.filter(l => l.strategy === '-ios predicate string');
-            expect(predicateLocators).toHaveLength(2);
-        });
-
-        it('should not generate predicate if name is empty', () => {
-            const element = createMockElement({ name: '' });
-            const locators = generateLocators(element);
-
-            const namePredicates = locators.filter(
-                l => l.strategy === '-ios predicate string' && l.value.includes('name ==')
-            );
-            expect(namePredicates).toHaveLength(0);
-        });
-    });
-
-    describe('iOS class chain locator', () => {
-        it('should generate class chain for element with name', () => {
-            const element = createMockElement({
-                type: 'XCUIElementTypeButton',
-                name: 'loginButton',
-            });
-            const locators = generateLocators(element);
-
-            const classChainLocator = locators.find(l => l.strategy === '-ios class chain');
-            expect(classChainLocator).toEqual({
-                strategy: '-ios class chain',
-                value: '**/XCUIElementTypeButton[`name == "loginButton"`]',
-            });
-        });
-
-        it('should not generate class chain if name is empty', () => {
-            const element = createMockElement({ name: '' });
-            const locators = generateLocators(element);
-
-            const classChainLocator = locators.find(l => l.strategy === '-ios class chain');
-            expect(classChainLocator).toBeUndefined();
-        });
-    });
-
-    describe('complete locator generation', () => {
-        it('should generate all locators for element with all attributes', () => {
-            const element = createMockElement({
-                type: 'XCUIElementTypeButton',
-                name: 'submitBtn',
-                label: 'Submit',
-                xpath: '/App[1]/Button[1]',
-            });
-            const locators = generateLocators(element);
-
-            const strategies = locators.map(l => l.strategy);
-            expect(strategies).toContain('accessibility id');
-            expect(strategies).toContain('xpath');
-            expect(strategies).toContain('class name');
-            expect(strategies).toContain('-ios predicate string');
-            expect(strategies).toContain('-ios class chain');
-        });
-
-        it('should generate minimal locators for element with no optional attributes', () => {
-            const element = createMockElement({
-                name: '',
-                label: '',
-            });
-            const locators = generateLocators(element);
-
-            // Should only have xpath and class name
-            expect(locators).toHaveLength(2);
-            expect(locators.map(l => l.strategy)).toEqual(['xpath', 'class name']);
-        });
-
-        it('should preserve locator order', () => {
-            const element = createMockElement({
-                name: 'testBtn',
-                label: 'Test',
-                type: 'Button',
-                xpath: '/xpath',
-            });
-            const locators = generateLocators(element);
-
-            // Verify expected order based on implementation
-            const strategies = locators.map(l => l.strategy);
-            expect(strategies[0]).toBe('accessibility id'); // from name
-            expect(strategies[1]).toBe('accessibility id'); // from label
-            expect(strategies[2]).toBe('xpath');
-            expect(strategies[3]).toBe('class name');
-        });
-    });
-
-    describe('edge cases', () => {
-        it('should handle special characters in name', () => {
-            const element = createMockElement({ name: 'button-1_test' });
-            const locators = generateLocators(element);
-
-            expect(locators).toContainEqual({
-                strategy: 'accessibility id',
-                value: 'button-1_test',
-            });
-        });
-
-        it('should handle spaces in label', () => {
-            const element = createMockElement({ label: 'Log In Now' });
-            const locators = generateLocators(element);
-
-            expect(locators).toContainEqual({
-                strategy: 'accessibility id',
-                value: 'Log In Now',
-            });
-            expect(locators).toContainEqual({
-                strategy: '-ios predicate string',
-                value: 'label == "Log In Now"',
-            });
-        });
-
-        it('should handle quotes in name/label correctly in predicates', () => {
-            const element = createMockElement({ name: 'test"button' });
-            const locators = generateLocators(element);
-
-            // The current implementation doesn't escape quotes, but we verify it includes them
-            const predicate = locators.find(l => l.strategy === '-ios predicate string');
-            expect(predicate).toBeDefined();
-        });
-
-        it('should handle unicode characters', () => {
-            const element = createMockElement({ name: '登录按钮', label: 'ログイン' });
-            const locators = generateLocators(element);
-
-            expect(locators).toContainEqual({
-                strategy: 'accessibility id',
-                value: '登录按钮',
-            });
-            expect(locators).toContainEqual({
-                strategy: 'accessibility id',
-                value: 'ログイン',
-            });
-        });
-
-        it('should handle very long names', () => {
-            const longName = 'a'.repeat(1000);
-            const element = createMockElement({ name: longName });
-            const locators = generateLocators(element);
-
-            expect(locators).toContainEqual({
-                strategy: 'accessibility id',
-                value: longName,
-            });
-        });
-    });
-});

package/src/ui/src/utils/__tests__/xml-parser.test.ts

@@ -1,326 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseXmlSource } from '../xml-parser';
-
-describe('parseXmlSource', () => {
-    describe('basic parsing', () => {
-        it('should parse empty XML', () => {
-            const xml = '<root></root>';
-            const result = parseXmlSource(xml);
-
-            expect(result).toHaveLength(1);
-            expect(result[0].type).toBe('root');
-        });
-
-        it('should parse XML with type attribute', () => {
-            const xml = '<root type="XCUIElementTypeApplication"></root>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].type).toBe('XCUIElementTypeApplication');
-        });
-
-        it('should use tagName when type attribute is missing', () => {
-            const xml = '<CustomElement></CustomElement>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].type).toBe('CustomElement');
-        });
-    });
-
-    describe('element attributes', () => {
-        it('should parse name attribute', () => {
-            const xml = '<element name="LoginButton"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].name).toBe('LoginButton');
-        });
-
-        it('should parse label attribute', () => {
-            const xml = '<element label="Login"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].label).toBe('Login');
-        });
-
-        it('should parse value attribute', () => {
-            const xml = '<element value="test@example.com"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].value).toBe('test@example.com');
-        });
-
-        it('should parse enabled attribute', () => {
-            const xml = '<element enabled="true"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].enabled).toBe(true);
-        });
-
-        it('should parse visible attribute', () => {
-            const xml = '<element visible="true"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].visible).toBe(true);
-        });
-
-        it('should parse accessible attribute', () => {
-            const xml = '<element accessible="true"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].accessible).toBe(true);
-        });
-
-        it('should default boolean attributes to false', () => {
-            const xml = '<element></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].enabled).toBe(false);
-            expect(result[0].visible).toBe(false);
-            expect(result[0].accessible).toBe(false);
-        });
-
-        it('should default string attributes to empty string', () => {
-            const xml = '<element></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].name).toBe('');
-            expect(result[0].label).toBe('');
-            expect(result[0].value).toBe('');
-        });
-    });
-
-    describe('coordinates', () => {
-        it('should parse x, y, width, height attributes', () => {
-            const xml = '<element x="100" y="200" width="50" height="30"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].x).toBe(100);
-            expect(result[0].y).toBe(200);
-            expect(result[0].width).toBe(50);
-            expect(result[0].height).toBe(30);
-        });
-
-        it('should default coordinates to 0', () => {
-            const xml = '<element></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].x).toBe(0);
-            expect(result[0].y).toBe(0);
-            expect(result[0].width).toBe(0);
-            expect(result[0].height).toBe(0);
-        });
-
-        it('should handle negative coordinates', () => {
-            const xml = '<element x="-10" y="-20"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].x).toBe(-10);
-            expect(result[0].y).toBe(-20);
-        });
-    });
-
-    describe('xpath generation', () => {
-        it('should generate xpath for root element', () => {
-            const xml = '<root></root>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].xpath).toBe('/root[1]');
-        });
-
-        it('should generate xpath with type attribute', () => {
-            const xml = '<root type="XCUIElementTypeApplication"></root>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].xpath).toBe('/XCUIElementTypeApplication[1]');
-        });
-
-        it('should generate nested xpath', () => {
-            const xml = `
-                <app type="Application">
-                    <window type="Window">
-                        <button type="Button"></button>
-                    </window>
-                </app>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result[0].xpath).toBe('/Application[1]');
-            expect(result[1].xpath).toBe('/Application[1]/Window[1]');
-            expect(result[2].xpath).toBe('/Application[1]/Window[1]/Button[1]');
-        });
-
-        it('should generate xpath with sibling indexing', () => {
-            const xml = `
-                <app type="Application">
-                    <button type="Button"></button>
-                    <button type="Button"></button>
-                    <button type="Button"></button>
-                </app>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result[1].xpath).toBe('/Application[1]/Button[1]');
-            expect(result[2].xpath).toBe('/Application[1]/Button[2]');
-            expect(result[3].xpath).toBe('/Application[1]/Button[3]');
-        });
-
-        it('should handle mixed child types', () => {
-            const xml = `
-                <app type="Application">
-                    <button type="Button"></button>
-                    <text type="Text"></text>
-                    <button type="Button"></button>
-                </app>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result[1].xpath).toBe('/Application[1]/Button[1]');
-            expect(result[2].xpath).toBe('/Application[1]/Text[1]');
-            expect(result[3].xpath).toBe('/Application[1]/Button[2]');
-        });
-    });
-
-    describe('nested elements', () => {
-        it('should parse all nested elements', () => {
-            const xml = `
-                <app type="Application">
-                    <window type="Window">
-                        <view type="View">
-                            <button type="Button"></button>
-                            <text type="Text"></text>
-                        </view>
-                    </window>
-                </app>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result).toHaveLength(5);
-            expect(result.map(e => e.type)).toEqual([
-                'Application',
-                'Window',
-                'View',
-                'Button',
-                'Text',
-            ]);
-        });
-
-        it('should preserve element order (depth-first)', () => {
-            const xml = `
-                <root>
-                    <a>
-                        <b></b>
-                    </a>
-                    <c></c>
-                </root>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result.map(e => e.type)).toEqual(['root', 'a', 'b', 'c']);
-        });
-    });
-
-    describe('real-world Appium XML', () => {
-        it('should parse iOS page source', () => {
-            const xml = `
-                <AppiumAUT type="XCUIElementTypeApplication" name="MyApp" label="" enabled="true" visible="true">
-                    <XCUIElementTypeWindow type="XCUIElementTypeWindow" enabled="true" visible="true" x="0" y="0" width="390" height="844">
-                        <XCUIElementTypeOther type="XCUIElementTypeOther" enabled="true" visible="true" x="0" y="0" width="390" height="844">
-                            <XCUIElementTypeButton type="XCUIElementTypeButton" name="loginButton" label="Log In" enabled="true" visible="true" x="20" y="400" width="350" height="44">
-                            </XCUIElementTypeButton>
-                        </XCUIElementTypeOther>
-                    </XCUIElementTypeWindow>
-                </AppiumAUT>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result).toHaveLength(4);
-
-            const button = result.find(e => e.type === 'XCUIElementTypeButton');
-            expect(button).toBeDefined();
-            expect(button!.name).toBe('loginButton');
-            expect(button!.label).toBe('Log In');
-            expect(button!.enabled).toBe(true);
-            expect(button!.visible).toBe(true);
-            expect(button!.x).toBe(20);
-            expect(button!.y).toBe(400);
-            expect(button!.width).toBe(350);
-            expect(button!.height).toBe(44);
-        });
-
-        it('should parse Android page source', () => {
-            const xml = `
-                <hierarchy type="android.widget.FrameLayout">
-                    <android.widget.LinearLayout type="android.widget.LinearLayout" x="0" y="0" width="1080" height="2400">
-                        <android.widget.Button type="android.widget.Button" name="" label="" value="" enabled="true" visible="true" x="100" y="500" width="200" height="80">
-                        </android.widget.Button>
-                    </android.widget.LinearLayout>
-                </hierarchy>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result).toHaveLength(3);
-            expect(result.map(e => e.type)).toEqual([
-                'android.widget.FrameLayout',
-                'android.widget.LinearLayout',
-                'android.widget.Button',
-            ]);
-        });
-    });
-
-    describe('edge cases', () => {
-        it('should handle empty document', () => {
-            const xml = '';
-            // parseXmlSource expects valid XML, empty string may produce error
-            // In real usage, empty strings are filtered out before calling
-            const result = parseXmlSource(xml);
-            // DOMParser will create an error document or empty result
-            expect(Array.isArray(result)).toBe(true);
-        });
-
-        it('should handle deeply nested elements', () => {
-            const xml = `
-                <level1 type="L1">
-                    <level2 type="L2">
-                        <level3 type="L3">
-                            <level4 type="L4">
-                                <level5 type="L5">
-                                </level5>
-                            </level4>
-                        </level3>
-                    </level2>
-                </level1>
-            `;
-            const result = parseXmlSource(xml);
-
-            expect(result).toHaveLength(5);
-            expect(result[4].xpath).toBe('/L1[1]/L2[1]/L3[1]/L4[1]/L5[1]');
-        });
-
-        it('should handle elements with special characters in attributes', () => {
-            const xml = '<element name="Button &amp; Text" label="Click &lt;here&gt;"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].name).toBe('Button & Text');
-            expect(result[0].label).toBe('Click <here>');
-        });
-
-        it('should handle many sibling elements', () => {
-            let children = '';
-            for (let i = 0; i < 100; i++) {
-                children += `<item type="Item" name="item${i}"></item>`;
-            }
-            const xml = `<root>${children}</root>`;
-            const result = parseXmlSource(xml);
-
-            expect(result).toHaveLength(101); // root + 100 items
-            expect(result[100].xpath).toBe('/root[1]/Item[100]');
-        });
-
-        it('should include node reference in result', () => {
-            const xml = '<element name="TestElement"></element>';
-            const result = parseXmlSource(xml);
-
-            expect(result[0].node).toBeDefined();
-            expect(result[0].node instanceof Element).toBe(true);
-        });
-    });
-});

package/src/ui/src/utils/locators.ts

@@ -1,14 +0,0 @@
-import { generateLegacyLocators } from '../../../core/selectors/generate-candidates';
-import type { ParsedElement, Locator } from '../types';
-
-export function generateLocators(element: ParsedElement): Locator[] {
-    return generateLegacyLocators({
-        type: element.type,
-        name: element.name,
-        label: element.label,
-        xpath: element.xpath,
-    }).map(locator => ({
-        strategy: locator.strategy,
-        value: locator.value,
-    }));
-}

package/src/ui/src/utils/xml-parser.ts

@@ -1,45 +0,0 @@
-import type { ParsedElement } from '../types';
-
-export function parseXmlSource(xmlString: string): ParsedElement[] {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(xmlString, 'text/xml');
-    const elements: ParsedElement[] = [];
-
-    function traverse(node: Element, xpath = '', index = 0) {
-        if (node.nodeType !== 1) return;
-
-        const type = node.getAttribute('type') || node.tagName;
-        const x = parseInt(node.getAttribute('x') || '0');
-        const y = parseInt(node.getAttribute('y') || '0');
-        const width = parseInt(node.getAttribute('width') || '0');
-        const height = parseInt(node.getAttribute('height') || '0');
-
-        const currentXpath = xpath + '/' + type + '[' + (index + 1) + ']';
-
-        elements.push({
-            type,
-            name: node.getAttribute('name') || '',
-            label: node.getAttribute('label') || '',
-            value: node.getAttribute('value') || '',
-            enabled: node.getAttribute('enabled') === 'true',
-            visible: node.getAttribute('visible') === 'true',
-            accessible: node.getAttribute('accessible') === 'true',
-            x, y, width, height,
-            xpath: currentXpath,
-            node
-        });
-
-        const childCounts: Record<string, number> = {};
-        for (const child of Array.from(node.children)) {
-            const childType = child.getAttribute('type') || child.tagName;
-            childCounts[childType] = (childCounts[childType] || 0);
-            traverse(child as Element, currentXpath, childCounts[childType]);
-            childCounts[childType]++;
-        }
-    }
-
-    if (doc.documentElement) {
-        traverse(doc.documentElement);
-    }
-    return elements;
-}