appium-session-recorder 0.0.2 → 0.0.3

package/tests/cli/session-commands.test.ts

@@ -1,53 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { runSessionCreate, runSessionDelete } from '../../src/cli/commands/session';
-
-function jsonResponse(body: unknown, status = 200): Response {
-    return new Response(JSON.stringify(body), {
-        status,
-        headers: { 'Content-Type': 'application/json' },
-    });
-}
-
-describe('session commands', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    it('creates session from inline capabilities', async () => {
-        const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-            jsonResponse({
-                sessionId: 'abc123',
-                value: { capabilities: { platformName: 'iOS' } },
-            }),
-        );
-
-        const result = await runSessionCreate([
-            '--appium-url', 'http://127.0.0.1:4723',
-            '--caps-json', '{"platformName":"iOS","appium:automationName":"XCUITest"}',
-        ]);
-
-        expect(result.command).toBe('session.create');
-        expect((result.result as any).sessionId).toBe('abc123');
-
-        const [, options] = fetchMock.mock.calls[0];
-        const payload = JSON.parse(String(options?.body));
-        expect(payload.capabilities.alwaysMatch.platformName).toBe('iOS');
-    });
-
-    it('deletes existing session', async () => {
-        const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(jsonResponse({ value: null }));
-
-        const result = await runSessionDelete([
-            '--appium-url', 'http://127.0.0.1:4723',
-            '--session-id', 'abc123',
-        ]);
-
-        expect(result.command).toBe('session.delete');
-        expect((result.result as any).deleted).toBe(true);
-
-        expect(fetchMock).toHaveBeenCalledWith(
-            'http://127.0.0.1:4723/session/abc123',
-            expect.objectContaining({ method: 'DELETE' }),
-        );
-    });
-});

package/tests/core/selector-candidates.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateSelectorCandidates } from '../../src/core/selectors/generate-candidates';
-import type { ParsedElement } from '../../src/core/types';
-
-function createElement(overrides: Partial<ParsedElement>): ParsedElement {
-    return {
-        elementRef: 'ios:/XCUIElementTypeButton[1]',
-        index: 0,
-        platform: 'ios',
-        type: 'XCUIElementTypeButton',
-        xpath: '/XCUIElementTypeApplication[1]/XCUIElementTypeButton[1]',
-        name: '',
-        label: '',
-        value: '',
-        text: '',
-        resourceId: '',
-        contentDesc: '',
-        enabled: true,
-        visible: true,
-        accessible: true,
-        clickable: true,
-        x: 0,
-        y: 0,
-        width: 10,
-        height: 10,
-        attributes: {},
-        ...overrides,
-    };
-}
-
-describe('generateSelectorCandidates', () => {
-    it('generates iOS locator families', () => {
-        const element = createElement({
-            platform: 'ios',
-            name: 'loginBtn',
-            label: 'Log In',
-            type: 'XCUIElementTypeButton',
-        });
-
-        const candidates = generateSelectorCandidates(element);
-        const strategies = candidates.map(candidate => candidate.strategy);
-
-        expect(strategies).toContain('accessibility id');
-        expect(strategies).toContain('-ios predicate string');
-        expect(strategies).toContain('-ios class chain');
-        expect(strategies).toContain('xpath');
-        expect(strategies).toContain('class name');
-    });
-
-    it('generates Android-specific candidates', () => {
-        const element = createElement({
-            platform: 'android',
-            type: 'android.widget.Button',
-            text: 'Continue',
-            resourceId: 'com.example:id/continue',
-            contentDesc: 'continueButton',
-        });
-
-        const candidates = generateSelectorCandidates(element);
-
-        expect(candidates).toContainEqual({
-            strategy: 'id',
-            value: 'com.example:id/continue',
-            platform: 'android',
-        });
-
-        expect(candidates.some(candidate => candidate.strategy === '-android uiautomator')).toBe(true);
-        expect(candidates.some(candidate => candidate.strategy === 'accessibility id' && candidate.value === 'continueButton')).toBe(true);
-    });
-
-    it('always includes xpath and class name fallback', () => {
-        const element = createElement({
-            platform: 'unknown',
-            type: 'GenericButton',
-            xpath: '/Root[1]/GenericButton[1]',
-        });
-
-        const candidates = generateSelectorCandidates(element);
-
-        expect(candidates).toContainEqual({ strategy: 'xpath', value: '/Root[1]/GenericButton[1]', platform: 'generic' });
-        expect(candidates).toContainEqual({ strategy: 'class name', value: 'GenericButton', platform: 'generic' });
-    });
-});

package/tests/core/selector-scoring.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { rankSelectorCandidates } from '../../src/core/selectors/score-candidates';
-import type { ParsedElement, SelectorCandidate } from '../../src/core/types';
-
-function createElement(overrides: Partial<ParsedElement>): ParsedElement {
-    return {
-        elementRef: 'ios:/XCUIElementTypeButton[1]',
-        index: 0,
-        platform: 'ios',
-        type: 'XCUIElementTypeButton',
-        xpath: '/XCUIElementTypeApplication[1]/XCUIElementTypeButton[1]',
-        name: 'loginBtn',
-        label: 'Log In',
-        value: '',
-        text: '',
-        resourceId: '',
-        contentDesc: '',
-        enabled: true,
-        visible: true,
-        accessible: true,
-        clickable: true,
-        x: 0,
-        y: 0,
-        width: 10,
-        height: 10,
-        attributes: {},
-        ...overrides,
-    };
-}
-
-describe('rankSelectorCandidates', () => {
-    it('prioritizes unique high-confidence selectors', () => {
-        const target = createElement({ name: 'loginBtn', xpath: '/Root[1]/Button[1]' });
-        const sibling = createElement({
-            elementRef: 'ios:/XCUIElementTypeButton[2]',
-            index: 1,
-            name: 'secondaryBtn',
-            xpath: '/Root[1]/Button[2]',
-        });
-
-        const candidates: SelectorCandidate[] = [
-            { strategy: 'class name', value: 'XCUIElementTypeButton', platform: 'generic' },
-            { strategy: 'accessibility id', value: 'loginBtn', platform: 'ios' },
-        ];
-
-        const ranked = rankSelectorCandidates(target, [target, sibling], candidates);
-
-        expect(ranked[0].strategy).toBe('accessibility id');
-        expect(ranked[0].reasons).toContain('UNIQUE_MATCH');
-        expect(ranked[1].reasons).toContain('MULTIPLE_MATCHES');
-    });
-
-    it('applies dynamic token penalty', () => {
-        const target = createElement({ name: 'user_123456789' });
-        const candidates: SelectorCandidate[] = [
-            { strategy: 'accessibility id', value: 'user_123456789', platform: 'ios' },
-        ];
-
-        const ranked = rankSelectorCandidates(target, [target], candidates);
-
-        expect(ranked[0].reasons).toContain('DYNAMIC_TOKEN_PENALTY');
-    });
-
-    it('marks no-match selectors', () => {
-        const target = createElement({ xpath: '/Root[1]/Button[1]' });
-        const candidates: SelectorCandidate[] = [
-            { strategy: 'xpath', value: '/Root[1]/Button[99]', platform: 'generic' },
-        ];
-
-        const ranked = rankSelectorCandidates(target, [target], candidates);
-
-        expect(ranked[0].matchCount).toBe(0);
-        expect(ranked[0].reasons).toContain('NO_MATCH');
-    });
-});

package/tests/core/xml-parser.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseSource } from '../../src/core/xml/parse-source';
-
-describe('parseSource', () => {
-    it('parses iOS source with normalized metadata', () => {
-        const xml = `
-            <AppiumAUT type="XCUIElementTypeApplication" name="MyApp" enabled="true" visible="true">
-                <XCUIElementTypeWindow type="XCUIElementTypeWindow" enabled="true" visible="true">
-                    <XCUIElementTypeButton type="XCUIElementTypeButton" name="loginButton" label="Log In" enabled="true" visible="true" x="20" y="400" width="350" height="44" clickable="true" />
-                </XCUIElementTypeWindow>
-            </AppiumAUT>
-        `;
-
-        const parsed = parseSource(xml);
-
-        expect(parsed.platform).toBe('ios');
-        expect(parsed.elements.length).toBe(3);
-
-        const button = parsed.elements.find(element => element.type === 'XCUIElementTypeButton');
-        expect(button).toBeDefined();
-        expect(button?.name).toBe('loginButton');
-        expect(button?.label).toBe('Log In');
-        expect(button?.x).toBe(20);
-        expect(button?.width).toBe(350);
-        expect(button?.elementRef).toMatch(/^ios:/);
-    });
-
-    it('parses Android bounds and strategy attributes', () => {
-        const xml = `
-            <hierarchy>
-                <android.widget.FrameLayout class="android.widget.FrameLayout" bounds="[0,0][1080,2400]">
-                    <android.widget.Button class="android.widget.Button" text="Continue" content-desc="continueButton" resource-id="com.example:id/continue" bounds="[50,1900][1030,2050]" enabled="true" visible="true" clickable="true" />
-                </android.widget.FrameLayout>
-            </hierarchy>
-        `;
-
-        const parsed = parseSource(xml);
-
-        expect(parsed.platform).toBe('android');
-
-        const button = parsed.elements.find(element => element.type === 'android.widget.Button');
-        expect(button).toBeDefined();
-        expect(button?.resourceId).toBe('com.example:id/continue');
-        expect(button?.contentDesc).toBe('continueButton');
-        expect(button?.x).toBe(50);
-        expect(button?.y).toBe(1900);
-        expect(button?.width).toBe(980);
-        expect(button?.height).toBe(150);
-    });
-
-    it('returns empty result for invalid XML', () => {
-        const parsed = parseSource('not xml');
-        expect(parsed.platform).toBe('unknown');
-        expect(parsed.elements).toEqual([]);
-    });
-});

package/tests/server/appium-client.test.ts

@@ -1,229 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { AppiumClient } from '../../src/server/appium-client';
-
-describe('AppiumClient', () => {
-    let client: AppiumClient;
-    const mockAppiumUrl = 'http://localhost:4723';
-
-    beforeEach(() => {
-        client = new AppiumClient(mockAppiumUrl);
-        vi.stubGlobal('fetch', vi.fn());
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    describe('constructor', () => {
-        it('should create client with provided appium URL', () => {
-            const customClient = new AppiumClient('http://custom:8080');
-            expect(customClient).toBeInstanceOf(AppiumClient);
-        });
-    });
-
-    describe('fetchFromAppium', () => {
-        it('should fetch data from correct URL', async () => {
-            const mockResponse = { value: 'screenshot_data' };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            await client.fetchFromAppium('session123', 'screenshot');
-
-            expect(fetch).toHaveBeenCalledWith(
-                'http://localhost:4723/session/session123/screenshot'
-            );
-        });
-
-        it('should return value from response', async () => {
-            const mockResponse = { value: 'screenshot_data' };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'screenshot');
-
-            expect(result).toBe('screenshot_data');
-        });
-
-        it('should return null if response has no value property', async () => {
-            const mockResponse = { data: 'something_else' };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'screenshot');
-
-            expect(result).toBeNull();
-        });
-
-        it('should return null if response is null', async () => {
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(null),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'screenshot');
-
-            expect(result).toBeNull();
-        });
-
-        it('should return null on fetch error', async () => {
-            vi.mocked(fetch).mockRejectedValue(new Error('Network error'));
-
-            const result = await client.fetchFromAppium('session123', 'screenshot');
-
-            expect(result).toBeNull();
-        });
-
-        it('should return null on JSON parse error', async () => {
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockRejectedValue(new Error('Invalid JSON')),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'screenshot');
-
-            expect(result).toBeNull();
-        });
-
-        it('should handle different endpoints', async () => {
-            const mockResponse = { value: '<xml>source</xml>' };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            await client.fetchFromAppium('session456', 'source');
-
-            expect(fetch).toHaveBeenCalledWith(
-                'http://localhost:4723/session/session456/source'
-            );
-        });
-
-        it('should handle value being an object', async () => {
-            const mockValue = { element: 'id123', attributes: { visible: true } };
-            const mockResponse = { value: mockValue };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'element');
-
-            expect(result).toEqual(mockValue);
-        });
-
-        it('should handle value being an array', async () => {
-            const mockValue = [{ id: '1' }, { id: '2' }];
-            const mockResponse = { value: mockValue };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'elements');
-
-            expect(result).toEqual(mockValue);
-        });
-
-        it('should handle value being empty string', async () => {
-            const mockResponse = { value: '' };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'endpoint');
-
-            expect(result).toBe('');
-        });
-
-        it('should handle value being false', async () => {
-            const mockResponse = { value: false };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'enabled');
-
-            expect(result).toBe(false);
-        });
-
-        it('should handle value being zero', async () => {
-            const mockResponse = { value: 0 };
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as Response);
-
-            const result = await client.fetchFromAppium('session123', 'count');
-
-            expect(result).toBe(0);
-        });
-    });
-
-    describe('captureState', () => {
-        it('should fetch both screenshot and source in parallel', async () => {
-            const screenshotResponse = { value: 'base64_screenshot' };
-            const sourceResponse = { value: '<xml>page source</xml>' };
-
-            vi.mocked(fetch)
-                .mockResolvedValueOnce({
-                    json: vi.fn().mockResolvedValue(screenshotResponse),
-                } as unknown as Response)
-                .mockResolvedValueOnce({
-                    json: vi.fn().mockResolvedValue(sourceResponse),
-                } as unknown as Response);
-
-            const result = await client.captureState('session123');
-
-            expect(fetch).toHaveBeenCalledTimes(2);
-            expect(result.screenshot).toBe('base64_screenshot');
-            expect(result.source).toBe('<xml>page source</xml>');
-        });
-
-        it('should return undefined screenshot if fetch fails', async () => {
-            vi.mocked(fetch)
-                .mockRejectedValueOnce(new Error('Network error'))
-                .mockResolvedValueOnce({
-                    json: vi.fn().mockResolvedValue({ value: '<xml>source</xml>' }),
-                } as unknown as Response);
-
-            const result = await client.captureState('session123');
-
-            expect(result.screenshot).toBeNull();
-            expect(result.source).toBe('<xml>source</xml>');
-        });
-
-        it('should return undefined source if fetch fails', async () => {
-            vi.mocked(fetch)
-                .mockResolvedValueOnce({
-                    json: vi.fn().mockResolvedValue({ value: 'base64_screenshot' }),
-                } as unknown as Response)
-                .mockRejectedValueOnce(new Error('Network error'));
-
-            const result = await client.captureState('session123');
-
-            expect(result.screenshot).toBe('base64_screenshot');
-            expect(result.source).toBeNull();
-        });
-
-        it('should return both undefined if both fetches fail', async () => {
-            vi.mocked(fetch).mockRejectedValue(new Error('Network error'));
-
-            const result = await client.captureState('session123');
-
-            expect(result.screenshot).toBeNull();
-            expect(result.source).toBeNull();
-        });
-
-        it('should call correct endpoints', async () => {
-            vi.mocked(fetch).mockResolvedValue({
-                json: vi.fn().mockResolvedValue({ value: 'data' }),
-            } as unknown as Response);
-
-            await client.captureState('session789');
-
-            expect(fetch).toHaveBeenCalledWith(
-                'http://localhost:4723/session/session789/screenshot'
-            );
-            expect(fetch).toHaveBeenCalledWith(
-                'http://localhost:4723/session/session789/source'
-            );
-        });
-    });
-});