qase-javascript-commons 2.3.5 → 2.3.6

package/README.md

@@ -58,6 +58,8 @@ All configuration options are listed in the table below:
 | Size of batch for sending test results                                                                                | `testops.batch.size`       | `QASE_TESTOPS_BATCH_SIZE`       | `200`                                   | No       | Any integer                |
 | Enable defects for failed test cases                                                                                  | `testops.defect`           | `QASE_TESTOPS_DEFECT`           | `False`                                 | No       | `True`, `False`            |
 | Enable/disable attachment uploads                                                                                     | `testops.uploadAttachments`        | `QASE_TESTOPS_UPLOAD_ATTACHMENTS`       | `true`                                  | No       | `True`, `False`            |
+| Configuration values to create/find in groups (format: `group1=value1,group2=value2`)                                | `testops.configurations.values`     | `QASE_TESTOPS_CONFIGURATIONS_VALUES`     | undefined                               | No       | Comma-separated key=value pairs |
+| Create configuration groups if they don't exist                                                                       | `testops.configurations.createIfNotExists` | `QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS` | `false`                          | No       | `True`, `False`            |
 
 ### Example `qase.config.json` config:
 
@@ -92,6 +94,19 @@ All configuration options are listed in the table below:
     "project": "<project_code>",
     "batch": {
       "size": 100
+    },
+    "configurations": {
+      "values": [
+        {
+          "name": "group1",
+          "value": "value1"
+        },
+        {
+          "name": "group2", 
+          "value": "value2"
+        }
+      ],
+      "createIfNotExists": true
     }
   }
 }

package/changelog.md

@@ -1,3 +1,9 @@
+# qase-javascript-commons@2.3.6
+
+## What's new
+
+Added support for configurations in the test run.
+
 # qase-javascript-commons@2.3.5
 
 ## What's new

package/dist/client/clientV1.d.ts

@@ -11,6 +11,7 @@ export declare class ClientV1 implements IClient {
     private readonly runClient;
     private readonly environmentClient;
     private readonly attachmentClient;
+    private readonly configurationClient;
     constructor(logger: LoggerInterface, config: TestOpsOptionsType, environment: string | undefined);
     private createApiConfig;
     uploadResults(_runId: number, _results: TestResultType[]): Promise<void>;
@@ -20,6 +21,33 @@ export declare class ClientV1 implements IClient {
     private prepareAttachmentData;
     private getEnvironmentId;
     private prepareRunObject;
+    /**
+     * Get all configuration groups with their configurations
+     * @returns Promise<ConfigurationGroup[]> Array of configuration groups
+     * @private
+     */
+    private getConfigurations;
+    /**
+     * Create a configuration group
+     * @param title Group title
+     * @returns Promise<number | undefined> Created group ID
+     * @private
+     */
+    private createConfigurationGroup;
+    /**
+     * Create a configuration in a group
+     * @param title Configuration title
+     * @param groupId Group ID
+     * @returns Promise<number | undefined> Created configuration ID
+     * @private
+     */
+    private createConfiguration;
+    /**
+     * Handle configuration creation based on config settings
+     * @returns Promise<number[]> Array of configuration IDs
+     * @private
+     */
+    private handleConfigurations;
     /**
      * Process error and throw QaseError
      * @param {Error | AxiosError} error

package/dist/client/clientV1.js

@@ -31,6 +31,7 @@ class ClientV1 {
     runClient;
     environmentClient;
     attachmentClient;
+    configurationClient;
     constructor(logger, config, environment) {
         this.logger = logger;
         this.config = config;
@@ -40,6 +41,7 @@ class ClientV1 {
         this.runClient = new qase_api_client_1.RunsApi(apiConfig);
         this.environmentClient = new qase_api_client_1.EnvironmentsApi(apiConfig);
         this.attachmentClient = new qase_api_client_1.AttachmentsApi(apiConfig);
+        this.configurationClient = new qase_api_client_1.ConfigurationsApi(apiConfig);
     }
     createApiConfig() {
         const apiConfig = new qase_api_client_1.Configuration({ apiKey: this.config.api.token, formDataCtor: form_data_1.default });
@@ -59,8 +61,13 @@ class ClientV1 {
             return this.config.run.id;
         }
         try {
+            // Handle configurations if provided
+            let configurationIds = [];
+            if (this.config.configurations) {
+                configurationIds = await this.handleConfigurations();
+            }
             const environmentId = await this.getEnvironmentId();
-            const runObject = this.prepareRunObject(environmentId);
+            const runObject = this.prepareRunObject(environmentId, configurationIds);
             this.logger.logDebug(`Creating test run: ${JSON.stringify(runObject)}`);
             const { data } = await this.runClient.createRun(this.config.project, runObject);
             if (!data.result?.id) {
@@ -129,7 +136,7 @@ class ClientV1 {
         const { data } = await this.environmentClient.getEnvironments(this.config.project, undefined, this.environment, 100);
         return data.result?.entities?.find((env) => env.slug === this.environment)?.id;
     }
-    prepareRunObject(environmentId) {
+    prepareRunObject(environmentId, configurationIds) {
         const runObject = {
             title: this.config.run.title ?? `Automated run ${new Date().toISOString()}`,
             description: this.config.run.description ?? '',
@@ -144,8 +151,137 @@ class ClientV1 {
         if (this.config.plan.id) {
             runObject.plan_id = this.config.plan.id;
         }
+        if (configurationIds && configurationIds.length > 0) {
+            runObject.configurations = configurationIds;
+        }
         return runObject;
     }
+    /**
+     * Get all configuration groups with their configurations
+     * @returns Promise<ConfigurationGroup[]> Array of configuration groups
+     * @private
+     */
+    async getConfigurations() {
+        try {
+            const { data } = await this.configurationClient.getConfigurations(this.config.project);
+            const entities = data.result?.entities ?? [];
+            // Convert API response to domain model
+            return entities.map(group => ({
+                id: group.id ?? 0,
+                title: group.title ?? '',
+                configurations: group.configurations?.map(config => ({
+                    id: config.id ?? 0,
+                    title: config.title ?? ''
+                })) ?? []
+            }));
+        }
+        catch (error) {
+            throw this.processError(error, 'Error getting configurations');
+        }
+    }
+    /**
+     * Create a configuration group
+     * @param title Group title
+     * @returns Promise<number | undefined> Created group ID
+     * @private
+     */
+    async createConfigurationGroup(title) {
+        try {
+            const group = { title };
+            const { data } = await this.configurationClient.createConfigurationGroup(this.config.project, group);
+            return data.result?.id;
+        }
+        catch (error) {
+            throw this.processError(error, 'Error creating configuration group');
+        }
+    }
+    /**
+     * Create a configuration in a group
+     * @param title Configuration title
+     * @param groupId Group ID
+     * @returns Promise<number | undefined> Created configuration ID
+     * @private
+     */
+    async createConfiguration(title, groupId) {
+        try {
+            const config = { title, group_id: groupId };
+            const { data } = await this.configurationClient.createConfiguration(this.config.project, config);
+            return data.result?.id;
+        }
+        catch (error) {
+            throw this.processError(error, 'Error creating configuration');
+        }
+    }
+    /**
+     * Handle configuration creation based on config settings
+     * @returns Promise<number[]> Array of configuration IDs
+     * @private
+     */
+    async handleConfigurations() {
+        if (!this.config.configurations?.values.length) {
+            return [];
+        }
+        const configurationIds = [];
+        try {
+            // Get existing configuration groups
+            const existingGroups = await this.getConfigurations();
+            for (const configValue of this.config.configurations.values) {
+                const { name: groupName, value: configName } = configValue;
+                // Find existing group or create new one
+                const group = existingGroups.find(g => g.title === groupName);
+                let groupId;
+                if (group) {
+                    groupId = group.id;
+                    this.logger.logDebug(`Found existing configuration group: ${groupName}`);
+                }
+                else {
+                    if (this.config.configurations.createIfNotExists) {
+                        const newGroupId = await this.createConfigurationGroup(groupName);
+                        if (newGroupId) {
+                            groupId = newGroupId;
+                            this.logger.logDebug(`Created new configuration group: ${groupName} with ID: ${groupId}`);
+                        }
+                        else {
+                            this.logger.logDebug(`Failed to create configuration group: ${groupName}, skipping`);
+                            continue;
+                        }
+                    }
+                    else {
+                        this.logger.logDebug(`Configuration group not found: ${groupName}, skipping`);
+                        continue;
+                    }
+                }
+                if (groupId) {
+                    // Check if configuration already exists in the group
+                    const existingConfig = group?.configurations.find(c => c.title === configName);
+                    if (!existingConfig) {
+                        // Check if we should create configuration if it doesn't exist
+                        if (this.config.configurations.createIfNotExists) {
+                            const configId = await this.createConfiguration(configName, groupId);
+                            if (configId) {
+                                configurationIds.push(configId);
+                            }
+                            this.logger.logDebug(`Created configuration: ${configName} in group: ${groupName}`);
+                        }
+                        else {
+                            this.logger.logDebug(`Configuration not found: ${configName} in group: ${groupName}, skipping`);
+                        }
+                    }
+                    else {
+                        if (existingConfig.id) {
+                            configurationIds.push(existingConfig.id);
+                        }
+                        this.logger.logDebug(`Configuration already exists: ${configName} in group: ${groupName}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.logError('Error handling configurations:', error);
+            // Don't throw error to avoid blocking test run creation
+        }
+        return configurationIds;
+    }
     /**
      * Process error and throw QaseError
      * @param {Error | AxiosError} error

package/dist/config/config-validation-schema.d.ts

@@ -1,6 +1,177 @@
-import { JSONSchemaType } from 'ajv';
-import { ConfigType } from './config-type';
+import { ModeEnum } from '../options';
+import { DriverEnum, FormatEnum } from '../writer';
 /**
  * @type {JSONSchemaType<ConfigType>}
  */
-export declare const configValidationSchema: JSONSchemaType<ConfigType>;
+export declare const configValidationSchema: {
+    type: string;
+    properties: {
+        mode: {
+            type: string;
+            enum: ModeEnum[];
+            nullable: boolean;
+        };
+        fallback: {
+            type: string;
+            enum: ModeEnum[];
+            nullable: boolean;
+        };
+        debug: {
+            type: string;
+            nullable: boolean;
+        };
+        environment: {
+            type: string;
+            nullable: boolean;
+        };
+        captureLogs: {
+            type: string;
+            nullable: boolean;
+        };
+        rootSuite: {
+            type: string;
+            nullable: boolean;
+        };
+        testops: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                api: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        token: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        host: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                project: {
+                    type: string;
+                    nullable: boolean;
+                };
+                uploadAttachments: {
+                    type: string;
+                    nullable: boolean;
+                };
+                run: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        id: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        title: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        description: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        complete: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        tags: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                            nullable: boolean;
+                        };
+                    };
+                };
+                plan: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        id: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                batch: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        size: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                defect: {
+                    type: string;
+                    nullable: boolean;
+                };
+                configurations: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        values: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    name: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                    value: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        createIfNotExists: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        report: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                driver: {
+                    type: string;
+                    enum: DriverEnum[];
+                    nullable: boolean;
+                };
+                connections: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        local: {
+                            type: string;
+                            nullable: boolean;
+                            properties: {
+                                path: {
+                                    type: string;
+                                    nullable: boolean;
+                                };
+                                format: {
+                                    type: string;
+                                    enum: FormatEnum[];
+                                    nullable: boolean;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/dist/config/config-validation-schema.js

@@ -114,6 +114,34 @@ exports.configValidationSchema = {
                     type: 'boolean',
                     nullable: true,
                 },
+                configurations: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        values: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    name: {
+                                        type: 'string',
+                                        nullable: true,
+                                    },
+                                    value: {
+                                        type: 'string',
+                                        nullable: true,
+                                    },
+                                },
+                                required: ['name', 'value'],
+                            },
+                        },
+                        createIfNotExists: {
+                            type: 'boolean',
+                            nullable: true,
+                        },
+                    },
+                    required: ['values'],
+                },
             },
         },
         report: {

package/dist/env/env-enum.d.ts

@@ -46,6 +46,13 @@ export declare enum EnvPlanEnum {
 export declare enum EnvBatchEnum {
     size = "QASE_TESTOPS_BATCH_SIZE"
 }
+/**
+ * @enum {string}
+ */
+export declare enum EnvConfigurationsEnum {
+    values = "QASE_TESTOPS_CONFIGURATIONS_VALUES",
+    createIfNotExists = "QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS"
+}
 /**
  * @enum {string}
  */

package/dist/env/env-enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvLocalEnum = exports.EnvBatchEnum = exports.EnvPlanEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
+exports.EnvLocalEnum = exports.EnvConfigurationsEnum = exports.EnvBatchEnum = exports.EnvPlanEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
 /**
  * @enum {string}
  */
@@ -55,6 +55,14 @@ var EnvBatchEnum;
 (function (EnvBatchEnum) {
     EnvBatchEnum["size"] = "QASE_TESTOPS_BATCH_SIZE";
 })(EnvBatchEnum || (exports.EnvBatchEnum = EnvBatchEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvConfigurationsEnum;
+(function (EnvConfigurationsEnum) {
+    EnvConfigurationsEnum["values"] = "QASE_TESTOPS_CONFIGURATIONS_VALUES";
+    EnvConfigurationsEnum["createIfNotExists"] = "QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS";
+})(EnvConfigurationsEnum || (exports.EnvConfigurationsEnum = EnvConfigurationsEnum = {}));
 /**
  * @enum {string}
  */

package/dist/env/env-to-config.js

@@ -34,6 +34,13 @@ const envToConfig = (env) => ({
             size: env[env_enum_1.EnvBatchEnum.size],
         },
         defect: env[env_enum_1.EnvTestOpsEnum.defect],
+        configurations: env[env_enum_1.EnvConfigurationsEnum.values] ? {
+            values: env[env_enum_1.EnvConfigurationsEnum.values].split(',').map(item => {
+                const [name, value] = item.split('=');
+                return { name: (name ?? '').trim(), value: value ? value.trim() : '' };
+            }),
+            createIfNotExists: env[env_enum_1.EnvConfigurationsEnum.createIfNotExists],
+        } : undefined,
     },
     report: {
         connections: {

package/dist/env/env-type.d.ts

@@ -1,4 +1,4 @@
-import { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, EnvPlanEnum, EnvBatchEnum } from './env-enum';
+import { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, EnvPlanEnum, EnvBatchEnum, EnvConfigurationsEnum } from './env-enum';
 import { ModeEnum } from '../options';
 import { FormatEnum } from '../writer';
 export interface EnvType {
@@ -20,6 +20,8 @@ export interface EnvType {
     [EnvRunEnum.tags]?: string;
     [EnvPlanEnum.id]?: number;
     [EnvBatchEnum.size]?: number;
+    [EnvConfigurationsEnum.values]?: string;
+    [EnvConfigurationsEnum.createIfNotExists]?: boolean;
     [EnvLocalEnum.path]?: string;
     [EnvLocalEnum.format]?: `${FormatEnum}`;
 }

package/dist/env/env-validation-schema.js

@@ -84,6 +84,14 @@ exports.envValidationSchema = {
             type: 'number',
             nullable: true,
         },
+        [env_enum_1.EnvConfigurationsEnum.values]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvConfigurationsEnum.createIfNotExists]: {
+            type: 'boolean',
+            nullable: true,
+        },
         [env_enum_1.EnvLocalEnum.path]: {
             type: 'string',
             nullable: true,

package/dist/models/config/TestOpsOptionsType.d.ts

@@ -6,6 +6,15 @@ export interface TestOpsOptionsType {
     plan: TestOpsPlanType;
     batch?: TestOpsBatchType;
     defect?: boolean | undefined;
+    configurations?: TestOpsConfigurationType | undefined;
+}
+export interface TestOpsConfigurationType {
+    values: TestOpsConfigurationValueType[];
+    createIfNotExists?: boolean | undefined;
+}
+export interface TestOpsConfigurationValueType {
+    name: string;
+    value: string;
 }
 export interface TestOpsRunType {
     id?: number | undefined;

package/dist/models/configuration.d.ts

@@ -0,0 +1,12 @@
+export interface ConfigurationGroup {
+    id: number;
+    title: string;
+    configurations: ConfigurationItem[];
+}
+export interface ConfigurationItem {
+    id: number;
+    title: string;
+}
+export interface ConfigurationGroupResponse {
+    groups: ConfigurationGroup[];
+}

package/dist/models/configuration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/index.d.ts

@@ -5,3 +5,4 @@ export { StepStatusEnum } from './step-execution';
 export { Attachment } from './attachment';
 export { Report } from './report';
 export { CompoundError } from './error';
+export { ConfigurationGroup, ConfigurationItem, ConfigurationGroupResponse } from './configuration';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.3.5",
+  "version": "2.3.6",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",