@thinkwise/testwise 0.2.0-beta.3 → 0.2.4

package/Testwise.ts

@@ -1,6 +1,6 @@
 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';
@@ -11,9 +11,7 @@ function combineExtensions(baseTest: Test, ...extensions: { new (test: Test): {
   return extensions.reduce((test, Extension) => new Extension(test).test, baseTest);
 }
 
-export const test: Test = combineExtensions(
-  base,
-
+const extensions = [
   // Override section
   ClickOverride,
   FillOverride,
@@ -24,6 +22,9 @@ export const test: Test = combineExtensions(
   LoginFeatures,
   UserSimulation,
   WaitEventHandler,
-  SubjectRegistry,
-  SubjectProvider
-);
+  SubjectRegistry
+];
+
+export const test: Test = combineExtensions(base, ...extensions);
+
+export const bddTest: Test = combineExtensions(bddBase, ...extensions);

package/artifact-builder/ArtifactManager.ts

@@ -1,4 +1,3 @@
- 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';

package/artifact-builder/InterfaceGenerator.ts

@@ -1,20 +1,22 @@
- 
-import { exec } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import * as prettier from 'prettier';
+import { FetchingJSONSchemaStore, InputData, JSONSchemaInput, quicktype } from 'quicktype-core';
 import { PathResolver } from '../helpers/PathResolver.js';
-import { NamingHandler } from '../index.js';
+import { DataRetriever, NamingHandler } from '../index.js';
 
 export class InterfaceGenerator {
   private readonly _namingHandler: NamingHandler;
   private _filename: string;
   private _dirname: string;
+  private _screensToBuild: string[];
 
   constructor() {
     this._namingHandler = new NamingHandler();
     this._filename = fileURLToPath(import.meta.url);
     this._dirname = path.dirname(this._filename);
+    this._screensToBuild = new DataRetriever().getScreensToBuild();
   }
 
   public async generateScreenInterfacesFromSchemas() {
@@ -24,7 +26,6 @@ export class InterfaceGenerator {
     const schemasDirectory = this.getScreenSchemaFilesPath();
 
     await this.generateInterfacesFromSchemaFiles(schemasDirectory, SchemaType.Screen, screenOutputDirectory);
-    await this.runPrettierOnSpecifiedDirectory(screenOutputDirectory);
 
     console.info('All screen schemas processed.');
   }
@@ -37,21 +38,18 @@ export class InterfaceGenerator {
     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 });
     }
   }
@@ -69,51 +67,58 @@ export class InterfaceGenerator {
     return componentsDirectory;
   }
 
-  private createInterfaceFromSchema(
+  private async 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);
-        }
-      );
-    });
+    try {
+      const baseFileName = file.slice(0, file.lastIndexOf('.'));
+      const correctInterfaceName = isInterface
+        ? this._namingHandler.generateScreenInterfaceName(baseFileName)
+        : this._namingHandler.snakeToPascalCase(baseFileName);
+
+      const schemaPath = path.join(schemasDirectory, file);
+      const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+
+      const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+      await schemaInput.addSource({
+        name: correctInterfaceName,
+        schema: schemaContent
+      });
+
+      const inputData = new InputData();
+      inputData.addInput(schemaInput);
+
+      const result = await quicktype({
+        inputData,
+        lang: 'typescript',
+        rendererOptions: { 'just-types': 'true', 'nice-property-names': 'true' }
+      });
+
+      let updatedContent = result.lines.join('\n');
+
+      updatedContent = updatedContent.replace(/interface\s+\w+/, `interface ${correctInterfaceName}`);
+
+      const formattedContent = await prettier.format(updatedContent, {
+        parser: 'typescript',
+        singleQuote: true,
+        semi: true,
+        trailingComma: 'all'
+      });
+
+      fs.writeFileSync(outputPath, formattedContent, 'utf-8');
+
+      return true;
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error processing ${file}:`, error.message);
+      } else {
+        console.error(`Error processing ${file}:`, error);
+      }
+      throw error;
+    }
   }
 
   private async generateInterfacesFromSchemaFiles(
@@ -123,46 +128,31 @@ export class InterfaceGenerator {
   ): 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}`));
-        }
-      });
-    });
+    const tasks = schemaFiles.map(async (file) => {
+      const fileName = this._namingHandler.getPascalSubjectComponentName(file);
 
-    await Promise.all(quicktypePromises);
-  }
+      if (schemaType === SchemaType.Subject) {
+        const subject = this._namingHandler.getSubjectFromFileName(fileName);
+        const componentsDirectory = this.verifySubjectComponentsDirectory(outputPath, subject);
+        const perFileOutputPath = path.join(componentsDirectory, `${fileName}.ts`);
+        return this.createInterfaceFromSchema(schemasDirectory, perFileOutputPath, file);
+      }
+
+      if (schemaType === SchemaType.Screen) {
+        const fileNameSnakeCase = this._namingHandler.pascalToSnakeCase(fileName);
 
-  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);
+        if (this._screensToBuild.length > 0 && !this._screensToBuild.includes(fileNameSnakeCase)) {
+          return Promise.resolve(true);
         }
-      );
+
+        const perFileOutputPath = path.join(outputPath, `I${fileName}.ts`);
+        return this.createInterfaceFromSchema(schemasDirectory, perFileOutputPath, file, true);
+      }
+
+      throw new Error(`Unsupported schema type: ${schemaType}`);
     });
+
+    await Promise.all(tasks);
   }
 
   public getScreenSchemaFilesPath(): string {

package/artifact-builder/ModelDataBuilder.ts

@@ -1,11 +1,13 @@
 /* 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 * as fs from 'node:fs/promises';
+import * as path from 'node:path';
 import type { IProperty } from '../interfaces/IProperty.js';
-import { testwiseConfig } from '../services/ConfigBuilder.js';
+import { indiciumApi } from '../services/IndiciumApi.service.js';
 import { DataRetriever } from './helpers/DataRetriever.js';
 
+// ToDo: move this to a types folder
 type Subjects = {
   subject: string;
   variant: string;
@@ -14,82 +16,92 @@ type Subjects = {
   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");
+  if (!(await indiciumApi.canConnectToProject())) {
+    console.log('Cannot connect to Indicium API. Aborting subject build.');
+    return;
+  }
 
-  const colResponse = await axiosInstance.get(
-    `/iam/${metaEndpoint}/i_ui_col?$filter=gui_appl_id%20eq%20${guiApplId}`
-  );
+  const rawTables: any[] = await indiciumApi.getAllTables();
+
+  const subjects: Subjects[] = rawTables
+    .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.popup_screen_type_id, screentype_context: 'popup' },
+        { ...base, screentype_id: tab.zoom_screen_type_id, screentype_context: 'zoom' }
+      ];
+    })
+    .filter((item) => item.screentype_id !== 'not_visible_in_gui');
+
+  const screentypeOrder = ['main', 'detail', 'popup', 'zoom'];
+
+  subjects.sort((a, b) => {
+    return (
+      a.subject.localeCompare(b.subject) ||
+      a.variant.localeCompare(b.variant) ||
+      screentypeOrder.indexOf(a.screentype_context) - screentypeOrder.indexOf(b.screentype_context)
+    );
+  });
 
-  const allProperties: IPropertyWithSubjectIdentifiers[] = colResponse.data?.value.map((col: any) => ({
+  const allProperties: IPropertyWithSubjectIdentifiers[] = (await indiciumApi.getAllColumns()).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) {
+  for (const subject of subjects) {
     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);
+    subject.properties = matchingProperties
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .map(({ subject, variant, ...rest }) => rest)
+      .sort((a, b) => a.col.localeCompare(b.col));
   }
 
-  const seedDataDirectory = new DataRetriever().getSeedDataDirectory();
+  const subjectsWithLookupsSet = await setLookupDropdowns(subjects);
 
-  const fs = await import('node:fs').then(mod => mod.promises);
-  const path = await import('node:path');
+  const seedDataDirectory = new DataRetriever().getSeedDataDirectory();
 
   const seedDataPath = path.join(seedDataDirectory, 'subjects.json');
-  await fs.writeFile(seedDataPath, JSON.stringify(subjectArray, null, 2), 'utf-8');
+  await fs.writeFile(seedDataPath, JSON.stringify(subjectsWithLookupsSet, null, 2), 'utf-8');
   console.log(`Seed data written to ${seedDataPath}`);
 }
 
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
+async function setLookupDropdowns(subjects: Subjects[]): Promise<Subjects[]> {
+  const lookupMappings: any[] = await indiciumApi.getLookups();
+
+  for (const mapping of lookupMappings) {
+    const targetSubject = subjects.find(
+      (subj) => subj.subject === mapping.tab_id && subj.variant === mapping.tab_variant_id
+    );
+
+    const targetProperty = targetSubject?.properties?.find((prop) => prop.col === mapping.col_id);
+
+    if (targetProperty) {
+      targetProperty.control_type = 'LOOKUP_DROPDOWN';
+    }
+  }
+
+  return subjects;
+}
 
 export async function buildScreens() {
-  const response = await axiosInstance.get(
-    `/iam/${metaEndpoint}/i_ui_screen_component?$filter=gui_appl_id eq ${guiApplId}`
-  );
+  if (!(await indiciumApi.canConnectToProject())) {
+    console.log('Cannot connect to Indicium API. Aborting screen build.');
+    return;
+  }
 
-  const rawComponents = response.data?.value || [];
+  const rawComponents = await indiciumApi.getScreenComponents();
   const screenMap = new Map<string, any>();
 
   for (const item of rawComponents) {
@@ -119,59 +131,35 @@ export async function buildScreens() {
 
     for (const comp of screenData.Components) {
       const type = comp.ScreenComponentType;
-      properties[comp.ScreenComponentId] = { "$ref": `#/definitions/${type}` };
+      properties[comp.ScreenComponentId] = { $ref: `#/definitions/${type}` };
       required.push(comp.ScreenComponentId);
       usedTypes.add(type);
     }
 
     const schema = {
       title: `I_${screenTypeId}`,
-      type: "object",
+      type: 'object',
       properties,
       required,
       additionalProperties: false,
       definitions: Array.from(usedTypes).reduce((acc, type) => {
         acc[type] = {
-          type: "object",
-          properties: { temp: { type: "string" } },
-          required: ["temp"],
+          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)
-    );
+    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.');
-  }
-}
-
+// ToDo: move this to a interfaces folder
 interface IPropertyWithSubjectIdentifiers extends IProperty {
   subject: string;
   variant: string;
-}
+}

package/artifact-builder/ModelDataRefiner.ts

@@ -8,31 +8,36 @@ export class ModelDataRefiner {
 
   public run() {
     const seedDataDir = this._dataRetriever.getSeedDataDirectory();
-    const registeredSubjects : IRegisteredSubjects[] | null = this._dataRetriever.getRegisteredSubjects();
+    const subjectsToBuildPath = path.resolve(seedDataDir, 'subjectsToBuild.json');
+    const screensToBuildPath = path.resolve(seedDataDir, 'screensToBuild.json');
+    const registeredSubjects: IRegisteredSubjects[] | null = this._dataRetriever.getRegisteredSubjects();
 
     if (!registeredSubjects || registeredSubjects.length === 0) {
-      console.error('No registered subjects found.');
+      console.info('No registered subjects found.');
+
+      if (fs.existsSync(screensToBuildPath)) fs.unlinkSync(screensToBuildPath);
+      if (fs.existsSync(subjectsToBuildPath)) fs.unlinkSync(subjectsToBuildPath);
+
       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 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 screensToBuildList = 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.`);
+    fs.writeFileSync(screensToBuildPath, JSON.stringify(screensToBuildList, null, 2));
+    console.log(`Created screensToBuild.json with ${screensToBuildList.length} screens.`);
   }
-}
+}

package/artifact-builder/SchemaGenerator.ts

@@ -1,4 +1,3 @@
- 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -48,11 +47,9 @@ export class SchemaGenerator {
       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;
       }
     }
@@ -90,7 +87,7 @@ export class SchemaGenerator {
     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;
     }

package/artifact-builder/ScreenInterfaceRefiner.ts

@@ -13,8 +13,6 @@ export class ScreenInterfaceRefiner {
   }
 
   public refine() {
-    console.log('Refining interfaces in:', this._screensDirectory);
-
     const screenFiles = this.getAllScreenInterfaceFiles();
 
     screenFiles.forEach((screenFile) => {
@@ -34,9 +32,6 @@ export class ScreenInterfaceRefiner {
         this.formatContent(screen);
 
         fs.writeFileSync(filePath, screen.content, 'utf-8');
-        console.log(`Refined interfaces in: ${screenFile}`);
-      } else {
-        console.log(`No additional interfaces to refine in: ${screenFile}`);
       }
 
       this.indexScreenInterface(screenFile);

package/artifact-builder/SelectorBuilder.ts

@@ -53,7 +53,14 @@ export class SelectorBuilder {
   }
 
   public getPageLocatorString(property: string, componentName: SubjectComponents): string {
-    const elementId = this._namingHandler.getIdFromElementName(property);
+    let elementId = this._namingHandler.getIdFromElementName(
+      property,
+      componentName,
+      this._namingHandler.getElementTypeFromElementName(property)
+    );
+
+    if (componentName === 'Grid') elementId = elementId.replace(/-/g, '_');
+
     const selectorPrefix = this.getDefaultPrefix(componentName);
     const defaultSuffix = this.getDefaultSuffix(componentName);
     const selectorSuffix = this.determineSelectorSuffix(property, componentName) || defaultSuffix;