@thinkwise/testwise 0.1.97 → 0.2.0-beta.0

package/artifact-builder/SubjectGenerator.ts

@@ -0,0 +1,332 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DataRetriever, NamingHandler } from '../index.js';
+import type { ISubject } from '../interfaces/ISubject.js';
+import {
+  coreComponents,
+  type ScreenComponents,
+  type SubjectAgnosticComponents,
+  screenComponents
+} from '../types/Components.js';
+import { type LocatorType, SelectorBuilder } from './SelectorBuilder.js';
+
+export class SubjectGenerator {
+  private static readonly SUBJECTS_RELATIVE_PATH = 'test-artifacts/subjects';
+
+  private readonly _currentFilename: string;
+  private readonly _currentDirname: string;
+  private readonly _subjectsDirectory: string;
+  private readonly _namingHandler: NamingHandler;
+  private readonly _selectorBuilder: SelectorBuilder;
+
+  constructor() {
+    this._currentFilename = fileURLToPath(import.meta.url);
+    this._currentDirname = dirname(this._currentFilename);
+    this._subjectsDirectory = path.resolve(this._currentDirname, `../../${SubjectGenerator.SUBJECTS_RELATIVE_PATH}`);
+    this._namingHandler = new NamingHandler();
+    this._selectorBuilder = new SelectorBuilder();
+  }
+
+  public run(): void {
+    this.generateSubjectClasses();
+    this.indexGeneratedSubjects();
+  }
+
+  private generateSubjectClasses(): void {
+    const subjects: ISubject[] = new DataRetriever().getSubjectsToBuild();
+
+    subjects.forEach((subject) => {
+      this.createSubjectClass(subject);
+    });
+  }
+
+  private getAllSubjectFolders(): string[] {
+    return fs.readdirSync(this._subjectsDirectory).filter((file) => {
+      return fs.statSync(path.join(this._subjectsDirectory, file)).isDirectory();
+    });
+  }
+
+  private indexGeneratedSubjects(): void {
+    const subjectFolders = this.getAllSubjectFolders();
+
+    subjectFolders.forEach((folder) => {
+      const exportLines: string[] = [];
+      const subjectFolderPath = path.join(this._subjectsDirectory, folder);
+      const tsFiles = fs.readdirSync(subjectFolderPath).filter((file) => file.endsWith('.ts') && file !== 'index.ts');
+      const indexFile = path.join(subjectFolderPath, 'index.ts');
+
+      if(tsFiles.length === 0) return;
+
+      if (!fs.existsSync(indexFile)) {
+        fs.writeFileSync(indexFile, '', 'utf-8');
+      }
+
+      tsFiles.forEach((tsFile) => {
+        if (tsFile === 'index.ts') return;
+        
+        const className = tsFile.replace('.ts', '');
+        exportLines.push(`export { ${className} } from './${className}.js';`);
+      });
+
+      fs.writeFileSync(indexFile, exportLines.join('\n'), 'utf-8');
+    });
+  }
+
+  private createSubjectClass(subject: ISubject): void {
+    const screenInterfaceName = this._namingHandler.generateScreenInterfaceName(subject.screentype_id);
+    const screenInterfacePath = this.getScreenInterfacePath(screenInterfaceName);
+    const screenFileContent = fs.readFileSync(screenInterfacePath, 'utf-8');
+    const subjectFolderName = this._namingHandler.formatPascalCaseName(subject.subject);
+    const subjectFolderPath = this.getSubjectFolderRelativePath(subjectFolderName);
+
+    const subjectClass = {
+      content: `import type { Page } from '@playwright/test';\nimport { SubjectPageBase } from '../../index.js';\n`,
+      name: this._namingHandler.generateSubjectClassName(subject)
+    };
+    const componentDictionary: { name: string; type: SubjectAgnosticComponents; context: string }[] =
+      this.getAllComponentsFromInterface(screenFileContent, screenInterfaceName, subject) as {
+        name: string;
+        type: SubjectAgnosticComponents;
+        context: string;
+      }[];
+
+    this.addScreenInterfaceImport(subjectClass, screenInterfaceName);
+    this.removeComponentImports(subjectClass);
+    this.addCoreComponentImports(componentDictionary, subjectFolderName, subjectClass);
+    this.addClassExport(subjectClass, screenInterfaceName);
+    this.addComponentDeclarations(subjectClass, componentDictionary, subjectFolderName);
+    this.addConstructor(subjectClass, componentDictionary, subjectFolderName, subject);
+    this.addSubjectClassLineEndings(subjectClass);
+    this.verifyDirectoryExists(subjectFolderPath);
+    fs.writeFileSync(path.join(subjectFolderPath, `${subjectClass.name}.ts`), subjectClass.content, 'utf-8');
+  }
+
+  private getAllComponentsFromInterface(
+    screenFileContent: string,
+    screenInterfaceName: string,
+    subject: ISubject
+  ): { name: string; type: string; context: string }[] {
+    let componentDictionary: { name: string; type: string; context: string }[] = [];
+
+    const interfaceMatches = screenFileContent.match(
+      new RegExp(`export interface ${screenInterfaceName} {([\\s\\S]*?)}`)
+    );
+
+    if (interfaceMatches) {
+      const propertyMatches = interfaceMatches[1].match(/^\s*([a-zA-Z0-9_]+)\s*:\s*([a-zA-Z0-9_]+);/gm);
+      if (propertyMatches) {
+        componentDictionary = propertyMatches.map((line) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          const [_, name, type] = line.match(/^\s*([a-zA-Z0-9_]+)\s*:\s*([a-zA-Z0-9_]+);/) || [];
+          const context = this.generateComponentContextLocatorString(type as ScreenComponents, name, subject);
+
+          return { name, type, context };
+        });
+      }
+    }
+
+    return componentDictionary;
+  }
+
+  // ToDo: decide if this needs to move into a ContextGenerator class (depending on the complexity of context generation)
+  private generateComponentContextLocatorString(
+    componentType: ScreenComponents,
+    componentName: string,
+    subject: ISubject
+  ): string {
+    const componentId = this._namingHandler.getComponentIdFromName(componentName, componentType);
+    const screentypeId = subject.screentype_id.replace(/_/g, '-');
+    const locatorString = {
+      prefix: '',
+      suffix: '',
+      locatorType: 'getByTestId' as LocatorType
+    };
+
+    switch (componentType) {
+      case 'Form':
+      case 'Grid':
+      case 'Splitter':
+      case 'FilterForm':
+      case 'Scheduler':
+        locatorString.prefix = `screen__${screentypeId}__`;
+        break;
+      case 'ActionBar':
+      case 'CustomActionBar':
+        locatorString.prefix = '.';
+        locatorString.locatorType = 'locator';
+        break;
+      case 'Tab':
+        locatorString.prefix = '.Tab.';
+        locatorString.locatorType = 'locator';
+        break;
+      case 'DetailTabPage':
+        return `this.context`;
+    }
+
+    return `this.context.${locatorString.locatorType}('${locatorString.prefix}${componentId}${locatorString.suffix}')`;
+  }
+
+  private verifyDirectoryExists(directoryPath: string): void {
+    if (!fs.existsSync(directoryPath)) {
+      fs.mkdirSync(directoryPath, { recursive: true });
+    }
+  }
+
+  private getScreenInterfacePath(screenInterfaceName: string): string {
+    const screenInterfacePath = path.resolve(
+      this._currentDirname,
+      `../../test-artifacts/screens/${screenInterfaceName}.ts`
+    );
+
+    if (!fs.existsSync(screenInterfacePath)) {
+      throw new Error(`Screen interface file not found: ${screenInterfacePath}`);
+    }
+
+    return screenInterfacePath;
+  }
+
+  private getSubjectFolderRelativePath(subjectFolderName: string): string {
+    const subjectFolderPath = path.resolve(
+      this._currentDirname,
+      `../../${SubjectGenerator.SUBJECTS_RELATIVE_PATH}/${subjectFolderName}`
+    );
+    return subjectFolderPath;
+  }
+
+  private addCoreComponentImports(
+    componentDictionary: { name: string; type: SubjectAgnosticComponents }[],
+    subjectFolderName: string,
+    subjectClass: { content: string }
+  ): void {
+    const coreComponentImports = new Set<string>();
+
+    componentDictionary.forEach((component) => {
+      if (!screenComponents.includes(component.type)) return;
+
+      if (coreComponents.includes(component.type)) {
+        const importRegex = new RegExp(
+          `import \\{[^}]*\\b${component.type}\\b[^}]*\\} from '../../../components/index.js';`
+        );
+
+        if (importRegex.test(subjectClass.content)) {
+          return;
+        }
+
+        coreComponentImports.add(component.type);
+        return;
+      }
+
+      const componentName = component.type;
+      const componentImport = `import { type ${subjectFolderName}${componentName}, ${subjectFolderName}${componentName}Component } from './Components/${subjectFolderName}${componentName}.js';`;
+
+      if (!subjectClass.content.includes(componentImport)) {
+        subjectClass.content = `${componentImport}\n${subjectClass.content}`;
+      }
+    });
+
+    if (coreComponentImports.size > 0) {
+      subjectClass.content = `import { ${Array.from(coreComponentImports).join(', ')} } from '../../../components/index.js';\n${subjectClass.content}`;
+    }
+  }
+
+  private removeComponentImports(subjectClass: { content: string }): void {
+    subjectClass.content = subjectClass.content.replace(
+      /import \{[^}]+\} from '\.\.\/\.\.\/components\/index\.js';\n?/g,
+      ''
+    );
+  }
+
+  private addClassExport(subjectClass: { content: string; name: string }, screenInterfaceName: string): void {
+    subjectClass.content += `\nexport class ${subjectClass.name} extends SubjectPageBase implements ${screenInterfaceName} {\n`;
+  }
+
+  private addScreenInterfaceImport(subjectClass: { content: string }, screenInterfaceName: string): void {
+    if (subjectClass.content.includes(`import type { ${screenInterfaceName} }`)) {
+      return;
+    }
+
+    subjectClass.content = `import type { ${screenInterfaceName} } from '../../screens/index.js';\n${subjectClass.content}`;
+  }
+
+  private addComponentDeclarations(
+    subjectClass: { content: string },
+    componentDictionary: { name: string; type: SubjectAgnosticComponents }[],
+    subjectFolderName: string
+  ): void {
+    componentDictionary.forEach((component) => {
+      if (!screenComponents.includes(component.type)) return;
+
+      const propertyName = this._namingHandler.formatPropertyName(component.name);
+      if (coreComponents.includes(component.type)) {
+        subjectClass.content += `  ${propertyName}: ${component.type};\n`;
+        return;
+      }
+      const componentType = `${subjectFolderName}${component.type}`;
+      subjectClass.content += `  ${propertyName}: ${componentType};\n`;
+    });
+  }
+
+  private addConstructor(
+    subjectClass: { content: string },
+    componentDictionary: { name: string; type: SubjectAgnosticComponents; context: string }[],
+    subjectFolderName: string,
+    subject: ISubject
+  ): void {
+    const rootContextSelector = this._selectorBuilder.getPageContext(subject);
+
+    subjectClass.content += `\n  constructor(page: Page) {\n    super(page.locator('${rootContextSelector}'));\n`;
+
+    componentDictionary.forEach((component) => {
+      const propertyName = this._namingHandler.formatPropertyName(component.name);
+
+      if (!screenComponents.includes(component.type)) return;
+
+      if (coreComponents.includes(component.type)) {
+        subjectClass.content += `    this.${propertyName} = ${this.getComponentInitializer(component)};\n`;
+        return;
+      }
+
+      const componentName = component.type;
+      subjectClass.content += `    this.${propertyName} = new ${subjectFolderName}${componentName}Component(page, ${component.context});\n`;
+    });
+  }
+
+  private getComponentInitializer(component: { type: string; context: string }): string {
+    const componentNamePascal = this._namingHandler.formatPascalCaseName(component.type);
+
+    switch (component.type) {
+      case 'Cardlist':
+      case 'TaskTiles':
+      case 'PrefilterList':
+      case 'TaskBar':
+      case 'Chart':
+      case 'CubeViewBar':
+      case 'PivotGrid':
+      case 'PivotGridFieldList':
+      case 'Maps':
+      case 'ReportBar':
+      case 'ReportTiles':
+      case 'Preview':
+        return `new ${component.type}(page, this.context.locator('.${component.type}.${componentNamePascal}'))`;
+      case 'CombinedFilter':
+      case 'CustomActionBar':
+      case 'ActionBar':
+      case 'Splitter':
+      case 'DetailTabPage':
+      case 'Tab':
+      case 'FilterForm':
+      case 'Scheduler':
+        return `new ${component.type}(page, ${component.context})`;
+      case 'TreeView':
+        return `new ${component.type}(page, this.context.locator('.Tree.${componentNamePascal}'))`;
+      default:
+        throw new Error(`Unknown core component type: ${component.type}`);
+    }
+  }
+
+  private addSubjectClassLineEndings(subjectClass: { content: string }): void {
+    subjectClass.content += `  }\n}\n`;
+  }
+}

package/artifact-builder/SubjectRegistration.ts

@@ -0,0 +1,136 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export class SubjectRegistration {
+  private static readonly SUBJECTS_RELATIVE_PATH = 'test-artifacts/subjects';
+  private static readonly IMPORT_MATCH_REGEX = /import .*'\.\.\/test-artifacts\/subjects\/index\.js';\n?/g;
+
+  private readonly _currentFilename: string;
+  private readonly _currentDirname: string;
+  private readonly _subjectTypePath: string;
+  private readonly _subjectsIndexDirectory: string;
+  private readonly _subjectBuilderPath: string;
+
+  constructor() {
+    this._currentFilename = fileURLToPath(import.meta.url);
+    this._currentDirname = dirname(this._currentFilename);
+    this._subjectTypePath = path.resolve(this._currentDirname, '../../page-extensions/SubjectRegistry.ts');
+    this._subjectsIndexDirectory = path.resolve(
+      this._currentDirname,
+      `../../${SubjectRegistration.SUBJECTS_RELATIVE_PATH}/index.ts`
+    );
+    this._subjectBuilderPath = path.resolve(this._currentDirname, '../../page-extensions/SubjectProvider.ts');
+  }
+
+  public run(): void {
+    this.registerGeneratedSubjectsAsSubjectTypes();
+    this.registerGeneratedSubjectsUnderPageGet();
+  }
+
+  private registerGeneratedSubjectsAsSubjectTypes(): void {
+    const subjectList = this.getAllSubjects();
+    const subjectTypeImportsAndExports = this.getSubjectTypesImportsAndExports(subjectList);
+    const subject = { content: this.setSubjectTypeContent() };
+
+    this.removeExistingSubjectTypeDefinition(subject);
+    this.removeAllImportsFromSubjectIndex(subject);
+
+    subject.content = subjectTypeImportsAndExports + subject.content;
+    fs.writeFileSync(this._subjectTypePath, subject.content, 'utf-8');
+  }
+
+  private registerGeneratedSubjectsUnderPageGet(): void {
+    const subjectNames = this.getAllSubjects();
+    const subjectBuilder = { content: fs.readFileSync(this._subjectBuilderPath, 'utf-8') };
+
+    this.removeSubjectBuilderImports(subjectBuilder);
+    this.removeSubjectBuilderSubjectDefinition(subjectBuilder);
+    this.addSubjectBuilderImports(subjectNames, subjectBuilder);
+    this.addSubjectBuilderSubjectDefinition(subjectNames, subjectBuilder);
+
+    fs.writeFileSync(this._subjectBuilderPath, subjectBuilder.content, 'utf-8');
+  }
+
+  private removeExistingSubjectTypeDefinition(subject: { content: string }): void {
+    const subjectDefinitionMatchRegex: RegExp = /export\s+type\s+SubjectType\s*=\s*{[^}]*};?/m;
+
+    if (subject.content) {
+      subject.content = subject.content.replace(subjectDefinitionMatchRegex, '');
+    }
+  }
+
+  private setSubjectTypeContent(): string {
+    return fs.readFileSync(this._subjectTypePath, 'utf-8');
+  }
+
+  private removeAllImportsFromSubjectIndex(subject: { content: string }): void {
+    if (subject.content) {
+      subject.content = subject.content.replace(SubjectRegistration.IMPORT_MATCH_REGEX, '');
+    }
+  }
+
+  private getSubjectTypesImportsAndExports(subjectList: string[]): string {
+    const importLine = `import type { ${subjectList.join(', ')} } from '../${SubjectRegistration.SUBJECTS_RELATIVE_PATH}/index.js';`;
+    const subjectTypeEntries = subjectList.map((name) => `  ${name}: typeof ${name};`).join('\n    ');
+    const newSubjectTypes = `${importLine}
+
+  export type SubjectType = {
+  ${subjectTypeEntries}
+  };
+  `;
+
+    return newSubjectTypes;
+  }
+
+  private getAllSubjects(): string[] {
+    const subjectsDir = path.resolve(this._currentDirname, '../../test-artifacts/subjects');
+
+    const subjectFolders = fs.readdirSync(subjectsDir).filter((file) => {
+      return fs.statSync(path.join(subjectsDir, file)).isDirectory();
+    });
+
+    const subjectNames: string[] = [];
+
+    subjectFolders.forEach((folder) => {
+      const folderPath = path.join(subjectsDir, folder);
+      const tsFiles = fs.readdirSync(folderPath).filter((file) => file.endsWith('.ts'));
+
+      tsFiles.forEach((tsFile) => {
+        const classContent = fs.readFileSync(path.join(folderPath, tsFile), 'utf-8');
+        const classMatches = classContent.matchAll(/export\s+class\s+(\w+)/g);
+        for (const match of classMatches) {
+          subjectNames.push(match[1]);
+        }
+      });
+    });
+    return subjectNames;
+  }
+
+  private addSubjectBuilderSubjectDefinition(subjectNames: string[], subjectBuilder: { content: string }): void {
+    const pageSubjectDefinition = `page.subject = {\n${subjectNames.map((name) => `    ${name},`).join('\n')}\n};\n`;
+
+    subjectBuilder.content = subjectBuilder.content.replace(
+      /(\/\/ page\.subject definition goes here\n)/,
+      `$1        ${pageSubjectDefinition}        `
+    );
+  }
+
+  private removeSubjectBuilderSubjectDefinition(subjectBuilder: { content: string }): void {
+    subjectBuilder.content = subjectBuilder.content.replace(/page\.subject\s*=\s*{[\s\S]*?};\s*/m, '');
+  }
+
+  private addSubjectBuilderImports(subjectNames: string[], subjectBuilder: { content: string }): void {
+    const importLine = `import { ${subjectNames.join(', ')} } from '../${SubjectRegistration.SUBJECTS_RELATIVE_PATH}/index.js';`;
+
+    subjectBuilder.content = subjectBuilder.content.replace(
+      /(import type { Test } from '\.\.\/types\/Test\.js';)/,
+      `$1\n${importLine}`
+    );
+  }
+
+  private removeSubjectBuilderImports(subjectBuilder: { content: string }): void {
+    subjectBuilder.content = subjectBuilder.content.replace(SubjectRegistration.IMPORT_MATCH_REGEX, '');
+  }
+}

package/artifact-builder/helpers/DataRetriever.ts

@@ -0,0 +1,64 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { PathResolver } from '../../helpers/PathResolver.js';
+import type { IRegisteredSubjects } from '../../interfaces/IRegisteredSubjects.js';
+import type { ISubject } from '../../interfaces/ISubject.js';
+
+export class DataRetriever {
+  private _consumerRootDirectory: string = new PathResolver().getConsumerRootDirectory();
+
+  public getSubjectsSeedData(): ISubject[] {
+    const seedPath = path.join(this._consumerRootDirectory, 'seed-data/subjects.json');
+    if (!fs.existsSync(seedPath)) {
+      console.error(`Seed data file not found at: ${seedPath}`);
+    }
+
+    const json = fs.readFileSync(seedPath, 'utf-8');
+    return this.toISubject(json) as unknown as ISubject[];
+  }
+
+  public getRegisteredSubjects(): IRegisteredSubjects[] | null {
+    const registeredSubjectsPath = path.join(this._consumerRootDirectory, 'seed-data/registeredSubjects.json');
+    if (!fs.existsSync(registeredSubjectsPath)) {
+      console.error(`Seed data file not found at: ${registeredSubjectsPath}`);
+      return null;
+    }
+
+    const json = fs.readFileSync(registeredSubjectsPath, 'utf-8');
+    return this.toIRegisteredSubjects(json) as unknown as IRegisteredSubjects[];
+  }
+
+  public getSubjectsToBuild(): ISubject[] {
+    const subjectsToBuildPath = path.join(this._consumerRootDirectory, 'seed-data/subjectsToBuild.json');
+    if (!fs.existsSync(subjectsToBuildPath)) {
+      console.error(`subjectsToBuild.json not found at: ${subjectsToBuildPath}. Using all subjects as fallback.`);
+
+      return this.getSubjectsSeedData();
+    }
+
+    const json = fs.readFileSync(subjectsToBuildPath, 'utf-8');
+    return this.toISubject(json) as unknown as ISubject[];
+  }
+
+  public getScreensToBuild(): string[] {
+    const screensToBuildPath = path.join(this._consumerRootDirectory, 'seed-data/screensToBuild.json');
+    if (!fs.existsSync(screensToBuildPath)) {
+      console.error(`screensToBuild.json not found at: ${screensToBuildPath}. Using all screens as fallback.`);
+    }
+
+    const json = fs.readFileSync(screensToBuildPath, 'utf-8');
+    return JSON.parse(json) as string[];
+  }
+
+  public getSeedDataDirectory(): string {
+    return path.join(this._consumerRootDirectory, 'seed-data');
+  }
+
+  private toISubject(json: string): ISubject {
+    return JSON.parse(json);
+  }
+
+  private toIRegisteredSubjects(json: string): IRegisteredSubjects {
+    return JSON.parse(json);
+  }
+}