@cuppet/core 2.0.1 → 2.0.3

package/features/app/hooks.js

@@ -102,7 +102,7 @@ Before(async function (testCase) {
 
 // executed after every test
 After(async function (testCase) {
-    if (testCase.result.status === Status.FAILED) {
+    if (testCase.result?.status !== Status.PASSED) {
         console.log(`Scenario: '${testCase.pickle.name}' - has failed...\r\n`);
     }
 

package/features/app/managers/kafkaManager.js

@@ -50,9 +50,9 @@ class KafkaManager {
      */
     async initialize() {
         try {
-            // Create Kafka instance
+            // Create Kafka instance (no actual connection yet)
             this.kafka = new Kafka(this.options);
-            console.log(`Successfully connected to Kafka`);
+            console.log('Kafka client instance created successfully.');
             this.isInitialized = true;
         } catch (error) {
             throw new Error(`Failed to initialize Kafka client: ${error.message}`);
@@ -68,9 +68,16 @@ class KafkaManager {
         if (!this.isInitialized) {
             throw new Error('Kafka client not initialized. Call initialize() first.');
         }
-        this.producer = this.kafka.producer(producerOptions);
-        await this.producer.connect();
-        return this.producer;
+
+        try {
+            this.producer = this.kafka.producer(producerOptions);
+            await this.producer.connect();
+            console.log('Producer connected successfully to Kafka broker');
+            return this.producer;
+        } catch (error) {
+            this.producer = null;
+            throw new Error(`Failed to connect producer to Kafka broker: ${error.message}`);
+        }
     }
 
     /**
@@ -87,9 +94,15 @@ class KafkaManager {
             consumerOptions.groupId = `cuppet-test-${Math.random().toString(16).slice(2, 8)}`;
         }
 
-        this.consumer = this.kafka.consumer(consumerOptions);
-        await this.consumer.connect();
-        return this.consumer;
+        try {
+            this.consumer = this.kafka.consumer(consumerOptions);
+            await this.consumer.connect();
+            console.log('Consumer connected successfully to Kafka broker');
+            return this.consumer;
+        } catch (error) {
+            this.consumer = null;
+            throw new Error(`Failed to connect consumer to Kafka broker: ${error.message}`);
+        }
     }
 
     /**
@@ -106,13 +119,18 @@ class KafkaManager {
      * @returns {Promise<void>}
      */
     async sendMessage(topic, message = {}) {
-        if (!this.producer) {
-            await this.createProducer();
+        try {
+            if (!this.producer) {
+                await this.createProducer();
+            }
+            await this.producer.send({
+                topic,
+                messages: [message],
+            });
+            console.log(`Message sent successfully to topic: ${topic}`);
+        } catch (error) {
+            throw new Error(`Failed to send message to topic '${topic}': ${error.message}`);
         }
-        await this.producer.send({
-            topic,
-            messages: [message],
-        });
     }
 
     /** Subscribe to a topic
@@ -120,24 +138,41 @@ class KafkaManager {
      * @returns {Promise<Object>} - Object with topic, partition, and message properties
      */
     async subscribeToTopics(topics = []) {
-        if (!this.consumer) {
-            await this.createConsumer();
+        try {
+            if (!this.consumer) {
+                await this.createConsumer();
+            }
+            await this.consumer.subscribe({
+                topics: topics,
+            });
+            console.log(`Successfully subscribed to topics: ${topics.join(', ')}`);
+        } catch (error) {
+            throw new Error(`Failed to subscribe to topics [${topics.join(', ')}]: ${error.message}`);
         }
-        await this.consumer.subscribe({
-            topics: topics,
-        });
     }
 
     /** Consume a message from a topic
      * @returns {Promise<Object>} - Object with topic, partition, and message properties
      */
     async consumeMessage() {
-        return new Promise((resolve) => {
-            this.consumer.run({
-                eachMessage: async ({ topic, partition, message }) => {
-                    resolve({ topic, partition, message });
-                },
-            });
+        if (!this.consumer) {
+            throw new Error('Consumer not initialized. Call subscribeToTopics() first.');
+        }
+
+        return new Promise((resolve, reject) => {
+            this.consumer
+                .run({
+                    eachMessage: async ({ topic, partition, message }) => {
+                        try {
+                            resolve({ topic, partition, message });
+                        } catch (error) {
+                            reject(new Error(`Failed to process consumed message: ${error.message}`));
+                        }
+                    },
+                })
+                .catch((error) => {
+                    reject(new Error(`Failed to consume message: ${error.message}`));
+                });
         });
     }
 
@@ -145,8 +180,18 @@ class KafkaManager {
      * @returns {Promise<void>}
      */
     async disconnect() {
-        await this.consumer.stop();
-        await this.consumer.disconnect();
+        if (!this.consumer) {
+            console.log('No consumer to disconnect');
+            return;
+        }
+
+        try {
+            await this.consumer.stop();
+            await this.consumer.disconnect();
+            console.log('Consumer disconnected successfully');
+        } catch (error) {
+            throw new Error(`Failed to disconnect consumer: ${error.message}`);
+        }
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cuppet/core",
-    "version": "2.0.1",
+    "version": "2.0.3",
     "description": "Core testing framework components for Cuppet - BDD framework based on Cucumber and Puppeteer",
     "main": "index.js",
     "files": [
@@ -31,7 +31,7 @@
     "dependencies": {
         "@supercharge/strings": "^2.0.0",
         "@wdio/globals": "9.17.0",
-        "appium": "3.0.1",
+        "appium": "3.1.2",
         "appium-uiautomator2-driver": "5.0",
         "axios": "^1.11.0",
         "backstopjs": "^6.3.25",
@@ -55,14 +55,14 @@
         "@html-eslint/parser": "^0.43.0",
         "@semantic-release/changelog": "^6.0.3",
         "@semantic-release/git": "^10.0.1",
-        "@semantic-release/github": "^11.0.3",
-        "@semantic-release/npm": "^12.0.1",
+        "@semantic-release/github": "^12.0.2",
+        "@semantic-release/npm": "^13.1.3",
         "config": "^4.1.0",
         "eslint": "^9.29.0",
         "eslint-config-prettier": "^10.1.5",
         "eslint-plugin-prettier": "^5.5.1",
         "prettier": "^3.6.1",
-        "semantic-release": "^24.2.5"
+        "semantic-release": "^25.0.2"
     },
     "scripts": {
         "test": "cucumber-js features/tests/example.feature",

package/src/apiFunctions.js

@@ -124,6 +124,9 @@ module.exports = {
             return this.response;
         } catch (error) {
             console.log('Request has failed, use response code step definition to validate the response!');
+            if (!error.response) {
+                throw new Error(`Request failed with: ${error}`);
+            }
             return (this.response = error.response);
         }
     },
@@ -168,8 +171,9 @@ module.exports = {
             current = current[keys[i]];
         }
 
+        const castedValue = helper.castPrimitiveType(value);
         // Set the final value
-        current[keys[keys.length - 1]] = value;
+        current[keys[keys.length - 1]] = castedValue;
         return this.request;
     },