@thinkwise/testwise 0.1.97 → 0.2.0-beta.0

package/Testwise.ts

@@ -1,6 +1,7 @@
 import { test as base } from '@playwright/test';
-import { test as bddBase } from 'playwright-bdd';
 import { Components, GoToDeepLink, LoginFeatures, UserSimulation } from './page-extensions/index.js';
+import { SubjectProvider } from './page-extensions/SubjectProvider.js';
+import { SubjectRegistry } from './page-extensions/SubjectRegistry.js';
 import { WaitEventHandler } from './page-extensions/WaitEventHandler.js';
 import { ClickOverride } from './page-overrides/ClickOverride.js';
 import { FillOverride } from './page-overrides/FillOverride.js';
@@ -10,7 +11,9 @@ function combineExtensions(baseTest: Test, ...extensions: { new (test: Test): {
   return extensions.reduce((test, Extension) => new Extension(test).test, baseTest);
 }
 
-const extensions = [
+export const test: Test = combineExtensions(
+  base,
+
   // Override section
   ClickOverride,
   FillOverride,
@@ -20,15 +23,7 @@ const extensions = [
   GoToDeepLink,
   LoginFeatures,
   UserSimulation,
-  WaitEventHandler
-];
-
-export const test: Test = combineExtensions(
-  base,
-  ...extensions
-);
-
-export const bddTest: Test = combineExtensions(
-  bddBase,
-  ...extensions
+  WaitEventHandler,
+  SubjectRegistry,
+  SubjectProvider
 );

package/artifact-builder/ArtifactManager.ts

@@ -0,0 +1,34 @@
+ 
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export class ArtifactManager {
+  private _backupPath: string;
+  private _artifactPath: string;
+
+  constructor() {
+    const _filename = fileURLToPath(import.meta.url);
+    const _dirname = path.dirname(_filename);
+    this._backupPath = path.resolve(_dirname, '..', '..', '..', 'backups', 'test-artifacts');
+    this._artifactPath = path.resolve(_dirname, '..', '..', 'test-artifacts');
+  }
+
+  performBackup() {
+    if (fs.existsSync(this._artifactPath)) {
+      fs.rmSync(this._backupPath, { recursive: true, force: true });
+      fs.cpSync(this._artifactPath, this._backupPath, { recursive: true });
+    }
+  }
+
+  backupExists(): boolean {
+    return fs.existsSync(this._backupPath);
+  }
+
+  restoreBackup(): void {
+    if (fs.existsSync(this._backupPath)) {
+      fs.rmSync(this._artifactPath, { recursive: true, force: true });
+      fs.cpSync(this._backupPath, this._artifactPath, { recursive: true });
+    }
+  }
+}

package/artifact-builder/InterfaceGenerator.ts

@@ -0,0 +1,183 @@
+ 
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PathResolver } from '../helpers/PathResolver.js';
+import { NamingHandler } from '../index.js';
+
+export class InterfaceGenerator {
+  private readonly _namingHandler: NamingHandler;
+  private _filename: string;
+  private _dirname: string;
+
+  constructor() {
+    this._namingHandler = new NamingHandler();
+    this._filename = fileURLToPath(import.meta.url);
+    this._dirname = path.dirname(this._filename);
+  }
+
+  public async generateScreenInterfacesFromSchemas() {
+    const screenOutputDirectory = path.resolve(this._dirname, '..', '..', 'test-artifacts/screens/');
+    this.verifyOutputDirectory(screenOutputDirectory);
+
+    const schemasDirectory = this.getScreenSchemaFilesPath();
+
+    await this.generateInterfacesFromSchemaFiles(schemasDirectory, SchemaType.Screen, screenOutputDirectory);
+    await this.runPrettierOnSpecifiedDirectory(screenOutputDirectory);
+
+    console.info('All screen schemas processed.');
+  }
+
+  public async generateSubjectInterfacesFromSchemas() {
+    const schemasDirectory = path.resolve(this._dirname, '../test-artifacts/schemas');
+    const subjectOutputDirectory = path.resolve(this._dirname, '..', '..', 'test-artifacts/subjects');
+
+    this.verifyGeneratedSubjectSchemasDirectory(schemasDirectory);
+    this.verifyOutputDirectory(subjectOutputDirectory);
+
+    await this.generateInterfacesFromSchemaFiles(schemasDirectory, SchemaType.Subject, subjectOutputDirectory);
+    await this.runPrettierOnSpecifiedDirectory(subjectOutputDirectory);
+
+    console.info('All subject schemas processed.');
+  }
+
+  private verifyGeneratedSubjectSchemasDirectory(directory: string) {
+    if (!fs.existsSync(directory)) {
+      console.error(`Schemas directory not found: ${directory}`);
+      return;
+    }
+  }
+
+  private verifyOutputDirectory(directory: string) {
+    if (!fs.existsSync(directory)) {
+      console.info(`Creating output directory: ${directory}`);
+      fs.mkdirSync(directory, { recursive: true });
+    }
+  }
+
+  private getGeneratedSubjectSchemas(schemasDirectory: string): string[] {
+    return fs.readdirSync(schemasDirectory).filter((f) => f.endsWith('.json'));
+  }
+
+  private verifySubjectComponentsDirectory(directory: string, subject: string) {
+    const componentsDirectory = path.join(directory, `${subject}/Components`);
+    if (!fs.existsSync(componentsDirectory)) {
+      fs.mkdirSync(componentsDirectory, { recursive: true });
+    }
+
+    return componentsDirectory;
+  }
+
+  private createInterfaceFromSchema(
+    schemasDirectory: string,
+    outputPath: string,
+    file: string,
+    isInterface: boolean = false
+  ): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `quicktype --just-types --lang typescript --src-lang schema --nice-property-names -o "${outputPath}" "${file}"`,
+        { cwd: schemasDirectory },
+        (error) => {
+          if (error) {
+            console.error(`Error processing ${file}:`, error.message);
+            reject(error);
+            return;
+          }
+          // This is an ugly patch to fix interface names after quicktype generation due to quicktype applying naming logic to acronyms that we can't switch off
+          try {
+            const fileName = path.basename(outputPath, '.ts');
+            const fileContent = fs.readFileSync(outputPath, 'utf-8');
+            const interfaceNameMatch = fileContent.match(new RegExp(`interface ${fileName}`, 'i'));
+
+            if (interfaceNameMatch) {
+              const correctInterfaceName = isInterface
+                ? this._namingHandler.generateScreenInterfaceName(file.slice(0, file.lastIndexOf('.')))
+                : this._namingHandler.snakeToPascalCase(file.slice(0, file.lastIndexOf('.')));
+              const updatedContent = fileContent.replace(
+                new RegExp(`interface ${interfaceNameMatch[0].split(' ')[1]}`),
+                `interface ${correctInterfaceName}`
+              );
+              fs.writeFileSync(outputPath, updatedContent, 'utf-8');
+            }
+          } catch (fsError) {
+            console.error(
+              `Error post-processing ${outputPath}:`,
+              fsError instanceof Error ? fsError.message : String(fsError)
+            );
+            reject(fsError);
+            return;
+          }
+          console.info(`Generated: ${outputPath}`);
+          resolve(true);
+        }
+      );
+    });
+  }
+
+  private async generateInterfacesFromSchemaFiles(
+    schemasDirectory: string,
+    schemaType: SchemaType,
+    outputPath: string
+  ): Promise<void> {
+    const schemaFiles: string[] = this.getGeneratedSubjectSchemas(schemasDirectory);
+
+    const quicktypePromises = schemaFiles.map((file) => {
+      return new Promise((resolve, reject) => {
+        const fileName = this._namingHandler.getPascalSubjectComponentName(file);
+
+        if (schemaType === SchemaType.Subject) {
+          const subject = this._namingHandler.getSubjectFromFileName(fileName);
+          const componentsDirectory = this.verifySubjectComponentsDirectory(outputPath, subject);
+          const perFileOutputPath = path.join(componentsDirectory, `${fileName}.ts`);
+          this.createInterfaceFromSchema(schemasDirectory, perFileOutputPath, file).then(resolve).catch(reject);
+        } else if (schemaType === SchemaType.Screen) {
+          const perFileOutputPath = path.join(outputPath, `I${fileName}.ts`);
+          this.createInterfaceFromSchema(schemasDirectory, perFileOutputPath, file, true).then(resolve).catch(reject);
+        } else {
+          reject(new Error(`Unsupported schema type: ${schemaType}`));
+        }
+      });
+    });
+
+    await Promise.all(quicktypePromises);
+  }
+
+  private async runPrettierOnSpecifiedDirectory(directory: string): Promise<void> {
+    const packageDir = path.resolve(this._dirname, '..');
+    const relativeDir = path.relative(packageDir, directory);
+
+    await new Promise((resolve, reject) => {
+      exec(
+        `npx prettier --write "${relativeDir}"`,
+        { cwd: packageDir },
+        (prettierError) => {
+          if (prettierError) {
+            console.error(`Prettier failed for ${directory}:`, prettierError.message);
+            reject(prettierError);
+            return;
+          }
+          console.info(`Formatted all files in: ${directory}`);
+          resolve(true);
+        }
+      );
+    });
+  }
+
+  public getScreenSchemaFilesPath(): string {
+    const directory = new PathResolver().getConsumerRootDirectory();
+
+    const screenSchemasPath = path.join(directory, 'seed-data/screen-schemas/');
+    if (!fs.existsSync(screenSchemasPath)) {
+      throw new Error(`Screen schemas directory not found at: ${screenSchemasPath}`);
+    }
+
+    return screenSchemasPath;
+  }
+}
+
+enum SchemaType {
+  Subject = 'Subject',
+  Screen = 'Screen'
+}

package/artifact-builder/ModelDataBuilder.ts

@@ -0,0 +1,177 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** biome-ignore-all lint/style/noNonNullAssertion: Because I can */
+/** biome-ignore-all lint/suspicious/noExplicitAny: Because I can */
+import axios from 'axios';
+import type { IProperty } from '../interfaces/IProperty.js';
+import { testwiseConfig } from '../services/ConfigBuilder.js';
+import { DataRetriever } from './helpers/DataRetriever.js';
+
+type Subjects = {
+  subject: string;
+  variant: string;
+  screentype_context: string;
+  screentype_id: 'main' | 'detail' | 'zoom' | 'popup';
+  properties?: IProperty[];
+};
+
+const serviceUrl: string = testwiseConfig().get<string>('environmentSettings.serviceUrl')!.replace(/\/$/, '');
+const metaEndpoint: string = testwiseConfig()
+  .get<string>('environmentSettings.metaEndpoint')!
+  .replace(/^\//, '')
+  .replace(/\/$/, '');
+const authUser: string = testwiseConfig().get<string>('environmentSettings.authUser')!;
+const authUserPassword: string = testwiseConfig().get<string>('environmentSettings.authUserPassword')!;
+
+const axiosInstance = axios.create({
+  baseURL: serviceUrl,
+  headers: {
+    Authorization: `Basic ${Buffer.from(`${authUser}:${authUserPassword}`).toString('base64')}`,
+    accept: '*/*'
+  }
+});
+
+const guiApplId: number = await getGuiApplId();
+
+export async function buildSubjects() {
+  const response = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_tab?$filter=gui_appl_id%20eq%20${guiApplId}`);
+
+  const rawTabs: any[] = response.data?.value || [];
+
+  const subjectArray: Subjects[] = rawTabs.flatMap((tab: any) => {
+    const base = {
+      subject: tab.tab_id,
+      variant: tab.tab_variant_id
+    };
+
+    return [
+      { ...base, screentype_id: tab.main_screen_type_id, screentype_context: 'main' },
+      { ...base, screentype_id: tab.detail_screen_type_id, screentype_context: 'detail' },
+      { ...base, screentype_id: tab.zoom_screen_type_id, screentype_context: 'zoom' },
+      { ...base, screentype_id: tab.popup_screen_type_id, screentype_context: 'popup' }
+    ];
+  }).filter(item => item.screentype_id !== "not_visible_in_gui");
+
+  const colResponse = await axiosInstance.get(
+    `/iam/${metaEndpoint}/i_ui_col?$filter=gui_appl_id%20eq%20${guiApplId}`
+  );
+
+  const allProperties: IPropertyWithSubjectIdentifiers[] = colResponse.data?.value.map((col: any) => ({
+    subject: col.tab_id,
+    variant: col.tab_variant_id,
+    col: col.col_id,
+    control_type: col.control_id || ''
+  }));
+
+  for (const subject of subjectArray) {
+    const matchingProperties = allProperties.filter(
+      (prop) => prop.subject === subject.subject && prop.variant === subject.variant
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    subject.properties = matchingProperties.map(({ subject, variant, ...rest }) => rest);
+  }
+
+  const seedDataDirectory = new DataRetriever().getSeedDataDirectory();
+
+  const fs = await import('node:fs').then(mod => mod.promises);
+  const path = await import('node:path');
+
+  const seedDataPath = path.join(seedDataDirectory, 'subjects.json');
+  await fs.writeFile(seedDataPath, JSON.stringify(subjectArray, null, 2), 'utf-8');
+  console.log(`Seed data written to ${seedDataPath}`);
+}
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+export async function buildScreens() {
+  const response = await axiosInstance.get(
+    `/iam/${metaEndpoint}/i_ui_screen_component?$filter=gui_appl_id eq ${guiApplId}`
+  );
+
+  const rawComponents = response.data?.value || [];
+  const screenMap = new Map<string, any>();
+
+  for (const item of rawComponents) {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const { screen_type_id, screen_component_id, screen_component_type_id } = item;
+
+    if (screen_component_id.includes(':')) continue;
+
+    if (!screenMap.has(screen_type_id)) {
+      screenMap.set(screen_type_id, { ScreenTypeId: screen_type_id, Components: [] });
+    }
+
+    screenMap.get(screen_type_id).Components.push({
+      ScreenComponentId: screen_component_id,
+      ScreenComponentType: screen_component_type_id
+    });
+  }
+
+  const seedDataDirectory = new DataRetriever().getSeedDataDirectory();
+  const outputDir = path.join(seedDataDirectory, 'screen-schemas');
+  await fs.mkdir(outputDir, { recursive: true });
+
+  for (const [screenTypeId, screenData] of screenMap.entries()) {
+    const usedTypes = new Set<string>();
+    const properties: Record<string, any> = {};
+    const required: string[] = [];
+
+    for (const comp of screenData.Components) {
+      const type = comp.ScreenComponentType;
+      properties[comp.ScreenComponentId] = { "$ref": `#/definitions/${type}` };
+      required.push(comp.ScreenComponentId);
+      usedTypes.add(type);
+    }
+
+    const schema = {
+      title: `I_${screenTypeId}`,
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false,
+      definitions: Array.from(usedTypes).reduce((acc, type) => {
+        acc[type] = {
+          type: "object",
+          properties: { temp: { type: "string" } },
+          required: ["temp"],
+          additionalProperties: false
+        };
+        return acc;
+      }, {} as any)
+    };
+
+    await fs.writeFile(
+      path.join(outputDir, `${screenTypeId}.json`),
+      JSON.stringify(schema, null, 2)
+    );
+  }
+  console.log('Screen schemas generated successfully.');
+}
+
+async function getGuiApplId(): Promise<number> {
+  const guiApplAlias = testwiseConfig().get<string>('environmentSettings.guiApplAlias');
+
+  if (guiApplAlias) {
+    const response = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_gui_appl`);
+    const guiAppl = response.data?.value.find((appl: any) => {
+      const currentAlias = appl?.gui_appl_alias?.toString();
+      const targetAlias = guiApplAlias?.toString();
+      
+      return currentAlias === targetAlias;
+    });
+
+    if (guiAppl) {
+      return guiAppl.gui_appl_id;
+    } else {
+      throw new Error(`No GUI Application found for GUI Application Alias: ${guiApplAlias}`);
+    }
+  } else {
+    throw new Error('GUI Application Alias is not defined in the configuration.');
+  }
+}
+
+interface IPropertyWithSubjectIdentifiers extends IProperty {
+  subject: string;
+  variant: string;
+}

package/artifact-builder/ModelDataRefiner.ts

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DataRetriever } from '../index.js';
+import type { IRegisteredSubjects } from '../interfaces/IRegisteredSubjects.js';
+
+export class ModelDataRefiner {
+  private _dataRetriever = new DataRetriever();
+
+  public run() {
+    const seedDataDir = this._dataRetriever.getSeedDataDirectory();
+    const registeredSubjects : IRegisteredSubjects[] | null = this._dataRetriever.getRegisteredSubjects();
+
+    if (!registeredSubjects || registeredSubjects.length === 0) {
+      console.error('No registered subjects found.');
+      return;
+    }
+
+    const subjects = this._dataRetriever.getSubjectsSeedData();
+
+    const subjectsToBuild = subjects.filter(subject =>
+      registeredSubjects.some(registered => 
+        registered.subject === subject.subject && 
+        (registered.variant != null ? registered.variant === subject.variant : subject.variant === '') &&
+        registered.screen_type === subject.screentype_context
+      )
+    );
+
+    const subjectsToBuildPath = path.resolve(seedDataDir, 'subjectsToBuild.json');
+    fs.writeFileSync(subjectsToBuildPath, JSON.stringify(subjectsToBuild, null, 2));
+    console.log(`Created subjectsToBuild.json with ${subjectsToBuild.length} subjects.`);
+
+    const screensToBuild = Array.from(new Set(subjectsToBuild.map(subject => subject.screentype_id)));
+
+    const screensToBuildPath = path.resolve(seedDataDir, 'screensToBuild.json');
+    fs.writeFileSync(screensToBuildPath, JSON.stringify(screensToBuild, null, 2));
+    console.log(`Created screensToBuild.json with ${screensToBuild.length} screens.`);
+  }
+}

package/artifact-builder/SchemaGenerator.ts

@@ -0,0 +1,134 @@
+ 
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DataRetriever } from '../index.js';
+import type { ISubject } from '../interfaces/ISubject.js';
+import type { SubjectComponents } from '../types/Components.js';
+import { NamingHandler } from './helpers/NamingHandler.js';
+
+const currentFilename = fileURLToPath(import.meta.url);
+const currentDirname = dirname(currentFilename);
+
+export class SchemaGenerator {
+  private _namingHandler: NamingHandler;
+  private _dataRetriever: DataRetriever;
+
+  constructor() {
+    this._namingHandler = new NamingHandler();
+    this._dataRetriever = new DataRetriever();
+  }
+
+  public generateSchema() {
+    const schemasDir = path.resolve(currentDirname, '../dist/test-artifacts/schemas');
+
+    if (!fs.existsSync(schemasDir)) {
+      fs.mkdirSync(schemasDir, { recursive: true });
+    }
+
+    const subjects = this._dataRetriever.getSubjectsToBuild();
+
+    for (const subject of subjects) {
+      this.createSubjectSchema(subject);
+    }
+  }
+
+  public iSubjectToJson(value: ISubject): string {
+    return JSON.stringify(value);
+  }
+
+  // Changes start here
+  private createSubjectSchema(subject: ISubject): void {
+    const screen = { content: this.getScreenContent(subject.screentype_id) };
+    const componentsToProcess = this.getComponentsToProcess(screen);
+
+    for (const component of componentsToProcess) {
+      switch (component) {
+        case 'Form':
+          this.createComponentSchema(subject, 'Form');
+          console.log(`Generated Form schema for subject: ${subject.subject}`);
+          break;
+        case 'Grid':
+          this.createComponentSchema(subject, 'Grid');
+          console.log(`Generated Grid schema for subject: ${subject.subject}`);
+          break;
+      }
+    }
+  }
+
+  private getComponentsToProcess(screen: { content: string }): string[] {
+    const componentsToProcess: string[] = [];
+    const subjectBasedComponents: string[] = ['Form', 'Grid'];
+
+    const importRegex = /import type \{([\s\S]*?)\} from ['"]\.\.\/\.\.\/components\/index\.js['"];?/;
+    const importMatches = importRegex.exec(screen.content);
+
+    if (importMatches?.[1]) {
+      const importedComponents = importMatches[1].split(',').map((component) => component.trim());
+      importedComponents.forEach((component) => {
+        if (subjectBasedComponents.includes(component)) {
+          componentsToProcess.push(component);
+        }
+      });
+    }
+
+    return componentsToProcess;
+  }
+
+  private getScreenContent(screenTypeId: string): string {
+    const screenFileName = this._namingHandler.formatPascalCaseName(screenTypeId);
+    const _filename = fileURLToPath(import.meta.url);
+    const _dirname = path.dirname(_filename);
+    const screenLocation = path.resolve(_dirname, '..', '..', 'test-artifacts/screens/');
+
+    return fs.readFileSync(path.join(screenLocation, `I${screenFileName}.ts`), 'utf-8');
+  }
+
+  private createComponentSchema(subject: ISubject, componentType: SubjectComponents): void {
+    const interfaceName = `${subject.subject}_${componentType.toLowerCase()}`;
+    const schemasDir = path.join(currentDirname, '..', '..', 'dist/test-artifacts/schemas');
+    const fileName = `${this._namingHandler.snakeToPascalCase(interfaceName)}.json`;
+    
+    if (fs.existsSync(path.join(schemasDir, fileName))) {
+      return;
+    }
+
+    // biome-ignore lint/suspicious/noExplicitAny: reason 42
+    const componentSchema: any = {
+      title: interfaceName,
+      type: 'object',
+      properties: {},
+      required: [],
+      additionalProperties: false,
+      definitions: {
+        Locator: {
+          type: 'object',
+          properties: {
+            selector: { type: 'string' }
+          },
+          required: ['selector'],
+          additionalProperties: false
+        }
+      }
+    };
+
+    subject.properties.forEach((property) => {
+      const componentTypeSuffix = this._namingHandler.getElementSuffixFromControlTypeAndComponentType(
+        property.control_type,
+        componentType
+      );
+      const fieldName = `${property.col}_${componentTypeSuffix.toLocaleLowerCase()}`;
+
+      componentSchema.properties[fieldName] = { $ref: '#/definitions/Locator' };
+      componentSchema.required.push(fieldName);
+    });
+
+    if (!fs.existsSync(schemasDir)) {
+      fs.mkdirSync(schemasDir, { recursive: true });
+    }
+
+    fs.writeFileSync(path.join(schemasDir, fileName), JSON.stringify(componentSchema, null, 2));
+  }
+}