qa360 2.2.1 → 2.2.13

package/core/src/pom/__tests__/loader.test.ts

@@ -1,378 +0,0 @@
-/**
- * QA360 POM Loader Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdir, rm, writeFile } from 'fs/promises';
-import { tmpdir } from 'os';
-import { resolve } from 'path';
-
-import { PageObjectLoader } from '../loader.js';
-import { BasePage } from '../base-page.js';
-import type { IPageObject } from '../types.js';
-
-// Mock page class for testing
-class MockPage extends BasePage {
-  constructor(baseUrl = '') {
-    super(baseUrl);
-  }
-
-  async navigate() { return Promise.resolve(); }
-  async waitForReady() { return Promise.resolve(); }
-  async isDisplayed() { return Promise.resolve(true); }
-}
-
-describe('PageObjectLoader', () => {
-  let testDir: string;
-  let loader: PageObjectLoader;
-
-  beforeEach(async () => {
-    testDir = resolve(tmpdir(), `pom-loader-test-${Date.now()}`);
-    await mkdir(testDir, { recursive: true });
-    loader = new PageObjectLoader({ cwd: testDir });
-  });
-
-  afterEach(async () => {
-    await rm(testDir, { recursive: true, force: true });
-  });
-
-  describe('Registry Management', () => {
-    it('should register and retrieve pages', () => {
-      const page: IPageObject = {
-        name: 'test',
-        url: '/test',
-        selectors: { button: '#button' },
-        navigate: async () => {},
-        waitForReady: async () => {},
-        isDisplayed: async () => true,
-        getUrl: () => '/test',
-      };
-
-      loader.register('test', page, {
-        name: 'test',
-        filePath: 'test.ts',
-        url: '/test',
-        selectors: { button: '#button' },
-        methods: [],
-      });
-
-      expect(loader.get('test')).toBe(page);
-      expect(loader.list()).toEqual(['test']);
-    });
-
-    it('should return undefined for non-existent page', () => {
-      expect(loader.get('nonexistent')).toBeUndefined();
-    });
-
-    it('should clear registry', () => {
-      const page: IPageObject = {
-        name: 'test',
-        url: '/test',
-        selectors: {},
-        navigate: async () => {},
-        waitForReady: async () => {},
-        isDisplayed: async () => true,
-        getUrl: () => '/test',
-      };
-
-      loader.register('test', page, {
-        name: 'test',
-        filePath: 'test.ts',
-        url: '/test',
-        selectors: {},
-        methods: [],
-      });
-
-      expect(loader.list()).toHaveLength(1);
-
-      loader.clear();
-
-      expect(loader.list()).toHaveLength(0);
-    });
-
-    it('should get page metadata', () => {
-      const page: IPageObject = {
-        name: 'test',
-        url: '/test',
-        selectors: { button: '#button' },
-        navigate: async () => {},
-        waitForReady: async () => {},
-        isDisplayed: async () => true,
-        getUrl: () => '/test',
-      };
-
-      const metadata = {
-        name: 'test',
-        filePath: 'test.ts',
-        url: '/test',
-        selectors: { button: '#button' },
-        methods: [],
-        description: 'Test page',
-      };
-
-      loader.register('test', page, metadata);
-
-      expect(loader.getMetadata('test')).toEqual(metadata);
-    });
-  });
-
-  describe('BasePage Helper Methods', () => {
-    it('should provide selector utilities', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: '/test',
-        selectors: {
-          username: '#username',
-          password: '#password',
-        },
-      });
-
-      expect(page.hasSelector('username')).toBe(true);
-      expect(page.hasSelector('nonexistent')).toBe(false);
-      expect(page.getSelectorNames()).toEqual(['username', 'password']);
-      expect(page.getSelector('username')).toBe('#username');
-    });
-
-    it('should throw error for non-existent selector', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: '/test',
-        selectors: {},
-      });
-
-      expect(() => page.getSelector('missing')).toThrow();
-    });
-
-    it('should resolve URLs correctly', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: '/test',
-        selectors: {},
-      });
-      page.setBaseUrl('https://example.com');
-
-      expect(page.getUrl()).toBe('https://example.com/test');
-      expect(page.getBaseUrl()).toBe('https://example.com');
-    });
-
-    it('should handle absolute URLs', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: 'https://other.com/page',
-        selectors: {},
-      });
-      page.setBaseUrl('https://example.com');
-
-      expect(page.getUrl()).toBe('https://other.com/page');
-    });
-
-    it('should build URLs with params', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: 'https://example.com/search',
-        selectors: {},
-      });
-
-      const url = page.buildUrl({ q: 'test', page: 1 });
-      expect(url).toContain('q=test');
-      expect(url).toContain('page=1');
-    });
-
-    it('should parse URL params', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: 'https://example.com/search?q=test&page=1',
-        selectors: {},
-      });
-
-      const params = page.getUrlParams();
-      expect(params.q).toBe('test');
-      expect(params.page).toBe('1');
-    });
-
-    it('should get path segments', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: 'https://example.com/api/v1/users',
-        selectors: {},
-      });
-
-      const segments = page.getPathSegments();
-      expect(segments).toEqual(['api', 'v1', 'users']);
-    });
-
-    it('should match URL patterns', () => {
-      const page = new MockPage();
-      Object.assign(page, {
-        name: 'test',
-        url: 'https://example.com/dashboard',
-        selectors: {},
-      });
-
-      expect(page.matchesUrl('/dashboard')).toBe(true);
-      expect(page.matchesUrl(/\/dashboard/)).toBe(true);
-      expect(page.matchesUrl('/login')).toBe(false);
-      expect(page.matchesUrl(/\/login/)).toBe(false);
-    });
-  });
-
-  describe('Page Validation', () => {
-    it('should validate correct page', async () => {
-      const page: IPageObject = {
-        name: 'valid',
-        url: '/valid',
-        selectors: { element: '.element' },
-        navigate: async () => {},
-        waitForReady: async () => {},
-        isDisplayed: async () => true,
-        getUrl: () => '/valid',
-      };
-
-      loader.register('valid', page, {
-        name: 'valid',
-        filePath: 'valid.ts',
-        url: '/valid',
-        selectors: { element: '.element' },
-        methods: [],
-      });
-
-      const result = await loader.validate('valid');
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should detect missing required properties', async () => {
-      const invalidPage = {
-        name: 'invalid',
-        url: '/invalid',
-        selectors: {},
-        navigate: async () => {},
-        // Missing waitForReady, isDisplayed, getUrl
-      } as IPageObject;
-
-      loader.register('invalid', invalidPage, {
-        name: 'invalid',
-        filePath: 'invalid.ts',
-        url: '/invalid',
-        selectors: {},
-        methods: [],
-      });
-
-      const result = await loader.validate('invalid');
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should validate non-existent page', async () => {
-      const result = await loader.validate('nonexistent');
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('Page object not found: nonexistent');
-    });
-  });
-
-  describe('JSON Export', () => {
-    it('should export registry as JSON', () => {
-      const page: IPageObject = {
-        name: 'export',
-        url: '/export',
-        selectors: { button: '#button' },
-        navigate: async () => {},
-        waitForReady: async () => {},
-        isDisplayed: async () => true,
-        getUrl: () => '/export',
-      };
-
-      loader.register('export', page, {
-        name: 'export',
-        filePath: 'export.ts',
-        url: '/export',
-        selectors: { button: '#button' },
-        methods: [],
-        description: 'Test page for export',
-      });
-
-      const json = loader.toJSON();
-
-      expect(json).toHaveProperty('export');
-      expect(json.export.name).toBe('export');
-      expect(json.export.description).toBe('Test page for export');
-    });
-
-    it('should export all metadata', () => {
-      loader.register('page1', {} as IPageObject, {
-        name: 'page1',
-        filePath: 'page1.ts',
-        url: '/page1',
-        selectors: {},
-        methods: [],
-      });
-
-      loader.register('page2', {} as IPageObject, {
-        name: 'page2',
-        filePath: 'page2.ts',
-        url: '/page2',
-        selectors: {},
-        methods: [],
-      });
-
-      const all = loader.getAllMetadata();
-
-      expect(all).toHaveLength(2);
-      expect(all.map(m => m.name)).toContain('page1');
-      expect(all.map(m => m.name)).toContain('page2');
-    });
-  });
-
-  describe('Pattern Matching', () => {
-    it('should convert glob to regex', () => {
-      const loader1 = new PageObjectLoader({ cwd: testDir });
-
-      // Test basic patterns
-      expect(() => loader1.loadFromDirectory('nonexistent', { pattern: '*.ts' })).not.toThrow();
-      expect(() => loader1.loadFromDirectory('nonexistent', { pattern: '**/*.page.ts' })).not.toThrow();
-    });
-  });
-
-  describe('Directory Loading', () => {
-    it('should handle non-existent directory gracefully', async () => {
-      const result = await loader.loadFromDirectory('non-existent');
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toContain('not found');
-    });
-
-    it('should handle empty directory', async () => {
-      const emptyDir = resolve(testDir, 'empty');
-      await mkdir(emptyDir, { recursive: true });
-
-      const result = await loader.loadFromDirectory('empty');
-
-      expect(result.valid).toBe(true);
-      expect(result.pagesCount).toBe(0);
-    });
-  });
-
-  describe('Singleton Instance', () => {
-    it('should provide default loader', async () => {
-      const { getDefaultLoader, resetDefaultLoader } = await import('../loader.js');
-
-      const loader1 = getDefaultLoader();
-      const loader2 = getDefaultLoader();
-
-      expect(loader1).toBe(loader2);
-
-      resetDefaultLoader();
-
-      const loader3 = getDefaultLoader();
-      expect(loader3).not.toBe(loader1);
-    });
-  });
-});