@cuppet/core 1.1.5 → 1.2.1

package/features/app/hooks.js

@@ -1,6 +1,7 @@
 const { BeforeAll, AfterAll, Before, After, AfterStep, Status } = require('@cucumber/cucumber');
 const BrowserManager = require('./browserManager');
 const AppiumManager = require('./appiumManager');
+const MqttManager = require('./mqttManager');
 const fs = require('fs');
 const config = require('config');
 const dataStore = require('../../src/dataStorage');
@@ -62,10 +63,21 @@ Before(async function (testCase) {
     // Get Appium capabilities from config
     const appiumCapabilities = config.get('appiumCapabilities');
 
-    // Check if the test is tagged with @appium to either use Appium or Chromium
+    // Check if the test is tagged with @appium, @mqtt or neither
     const arrayTags = testCase.pickle.tags;
-    const found = arrayTags.find((item) => item.name === '@appium');
-    if (!found) {
+    const appiumTag = arrayTags.find((item) => item.name === '@appium');
+    const mqttTag = arrayTags.find((item) => item.name === '@mqtt');
+    const apiTag = arrayTags.find((item) => item.name === '@api');
+
+    // Initialize MQTT Manager if @mqtt tag is present
+    if (mqttTag) {
+        const mqttManager = new MqttManager();
+        await mqttManager.initialize();
+        this.mqttManager = mqttManager;
+    }
+
+    // Initialize browser unless it's API-only or MQTT-only test
+    if (!appiumTag && !apiTag && !mqttTag) {
         const browserManager = new BrowserManager(browserViewport, browserArgs, credentials);
         await browserManager.initialize();
 
@@ -74,7 +86,7 @@ Before(async function (testCase) {
         this.browser = browserManager.browser;
         this.page = browserManager.page;
         this.scenarioName = testCase.pickle.name;
-    } else {
+    } else if (appiumTag) {
         const appiumManager = new AppiumManager(appiumCapabilities);
         await appiumManager.initialize();
         this.appiumManager = appiumManager;
@@ -87,6 +99,14 @@ After(async function (testCase) {
     if (testCase.result.status === Status.FAILED) {
         console.log(`Scenario: '${testCase.pickle.name}' - has failed...\r\n`);
     }
+
+    // Cleanup MQTT connection if present
+    if (this.mqttManager) {
+        await this.mqttManager.stop();
+        this.mqttManager = null;
+    }
+
+    // Cleanup browser/appium connections
     if (this.browser) {
         await this.browserManager.stop();
     } else if (this.appiumDriver) {

package/features/app/mqttManager.js

@@ -0,0 +1,291 @@
+const mqtt = require('mqtt');
+const config = require('config');
+
+/**
+ * MqttManager class for managing MQTT client lifecycle
+ * Follows the same pattern as BrowserManager and AppiumManager
+ */
+class MqttManager {
+    constructor(brokerUrl = null, options = {}) {
+        this.client = null;
+        this.brokerUrl =
+            brokerUrl || (config.has('mqtt.brokerUrl') ? config.get('mqtt.brokerUrl') : 'mqtt://localhost:1883');
+        this.options = this.prepareOptions(options);
+        this.messageBuffer = new Map(); // Store messages by topic
+        this.subscriptions = new Set(); // Track active subscriptions
+    }
+
+    /**
+     * Prepare MQTT connection options from config or provided options
+     * @param {Object} customOptions - Custom options to override config
+     * @returns {Object} - MQTT connection options
+     */
+    prepareOptions(customOptions) {
+        const defaultOptions = {
+            clientId: config.has('mqtt.clientId')
+                ? config.get('mqtt.clientId')
+                : `cuppet-test-${Math.random().toString(16).slice(2, 8)}`,
+            clean: config.has('mqtt.cleanSession') ? config.get('mqtt.cleanSession') : true,
+            connectTimeout: config.has('mqtt.connectTimeout') ? config.get('mqtt.connectTimeout') : 5000,
+            keepalive: config.has('mqtt.keepalive') ? config.get('mqtt.keepalive') : 60,
+        };
+
+        // Add username and password if provided in config
+        if (config.has('mqtt.username')) {
+            defaultOptions.username = config.get('mqtt.username');
+        }
+        if (config.has('mqtt.password')) {
+            defaultOptions.password = config.get('mqtt.password');
+        }
+
+        // Merge with custom options
+        return { ...defaultOptions, ...customOptions };
+    }
+
+    /**
+     * Initialize MQTT client and connect to broker
+     * @returns {Promise<void>}
+     */
+    async initialize() {
+        return new Promise((resolve, reject) => {
+            try {
+                console.log(`Connecting to MQTT broker: ${this.brokerUrl}`);
+                this.client = mqtt.connect(this.brokerUrl, this.options);
+
+                let settled = false; // Guard against multiple resolve/reject calls
+
+                // Centralized cleanup function
+                const cleanup = () => {
+                    clearTimeout(timeoutId);
+                    this.client.removeListener('connect', onConnect);
+                    this.client.removeListener('error', onError);
+                };
+
+                // Declare timeout first
+                const timeoutId = setTimeout(() => {
+                    if (!settled) {
+                        settled = true;
+                        cleanup();
+                        this.client.end(true);
+                        reject(new Error(`MQTT connection timeout after ${this.options.connectTimeout}ms`));
+                    }
+                }, this.options.connectTimeout);
+
+                const onConnect = () => {
+                    if (!settled) {
+                        settled = true;
+                        cleanup();
+                        console.log(`Successfully connected to MQTT broker: ${this.brokerUrl}`);
+                        this.setupMessageHandler();
+                        resolve();
+                    }
+                };
+
+                const onError = (error) => {
+                    if (!settled) {
+                        settled = true;
+                        cleanup();
+                        console.error(`MQTT connection error: ${error.message}`);
+                        this.client.end(true);
+                        reject(error);
+                    }
+                };
+
+                this.client.once('connect', onConnect);
+                this.client.once('error', onError);
+            } catch (error) {
+                if (this.client) {
+                    this.client.end(true);
+                }
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * Setup message handler to buffer incoming messages
+     * @private
+     */
+    setupMessageHandler() {
+        this.client.on('message', (topic, message) => {
+            console.log(`Received message on topic: ${topic}`);
+
+            // Store message in buffer for the specific topic
+            if (!this.messageBuffer.has(topic)) {
+                this.messageBuffer.set(topic, []);
+            }
+
+            const messageData = {
+                topic: topic,
+                message: message.toString(),
+                timestamp: Date.now(),
+                raw: message,
+            };
+
+            this.messageBuffer.get(topic).push(messageData);
+        });
+    }
+
+    /**
+     * Subscribe to a topic or topics
+     * @param {string|string[]} topic - Topic or array of topics to subscribe to
+     * @param {Object} options - Subscription options (qos, etc.)
+     * @returns {Promise<void>}
+     */
+    async subscribe(topic, options = { qos: 0 }) {
+        return new Promise((resolve, reject) => {
+            this.client.subscribe(topic, options, (error, granted) => {
+                if (error) {
+                    console.error(`Failed to subscribe to ${topic}: ${error.message}`);
+                    reject(error);
+                } else {
+                    const topics = Array.isArray(topic) ? topic : [topic];
+                    topics.forEach((t) => this.subscriptions.add(t));
+                    console.log(`Successfully subscribed to: ${JSON.stringify(granted)}`);
+                    resolve(granted);
+                }
+            });
+        });
+    }
+
+    /**
+     * Unsubscribe from a topic or topics
+     * @param {string|string[]} topic - Topic or array of topics to unsubscribe from
+     * @returns {Promise<void>}
+     */
+    async unsubscribe(topic) {
+        return new Promise((resolve, reject) => {
+            this.client.unsubscribe(topic, (error) => {
+                if (error) {
+                    console.error(`Failed to unsubscribe from ${topic}: ${error.message}`);
+                    reject(error);
+                } else {
+                    const topics = Array.isArray(topic) ? topic : [topic];
+                    topics.forEach((t) => this.subscriptions.delete(t));
+                    console.log(`Successfully unsubscribed from: ${topic}`);
+                    resolve();
+                }
+            });
+        });
+    }
+
+    /**
+     * Publish a message to a topic
+     * @param {string} topic - Topic to publish to
+     * @param {string|Buffer} message - Message to publish
+     * @param {Object} options - Publish options (qos, retain, etc.)
+     * @returns {Promise<void>}
+     */
+    async publish(topic, message, options = { qos: 0, retain: false }) {
+        return new Promise((resolve, reject) => {
+            this.client.publish(topic, message, options, (error) => {
+                if (error) {
+                    console.error(`Failed to publish to ${topic}: ${error.message}`);
+                    reject(error);
+                } else {
+                    console.log(`Successfully published to: ${topic}`);
+                    resolve();
+                }
+            });
+        });
+    }
+
+    /**
+     * Get messages from buffer for a specific topic
+     * @param {string} topic - Topic to get messages for
+     * @returns {Array} - Array of messages
+     */
+    getMessages(topic) {
+        return this.messageBuffer.get(topic) || [];
+    }
+
+    /**
+     * Get the latest message from buffer for a specific topic
+     * @param {string} topic - Topic to get latest message for
+     * @returns {Object|null} - Latest message or null
+     */
+    getLatestMessage(topic) {
+        const messages = this.getMessages(topic);
+        return messages.length > 0 ? messages[messages.length - 1] : null;
+    }
+
+    /**
+     * Clear message buffer for a specific topic or all topics
+     * @param {string|null} topic - Topic to clear or null to clear all
+     * @returns {<void>}
+     */
+    clearMessageBuffer(topic = null) {
+        if (topic) {
+            this.messageBuffer.delete(topic);
+            console.log(`Cleared message buffer for topic: ${topic}`);
+        } else {
+            this.messageBuffer.clear();
+            console.log('Cleared all message buffers');
+        }
+    }
+
+    /**
+     * Wait for a message on a specific topic with timeout
+     * @param {string} topic - Topic to wait for message on
+     * @param {number} timeoutSeconds - Timeout in seconds
+     * @returns {Promise<Object>} - Resolves with message when received
+     */
+    async waitForMessage(topic, timeoutSeconds = 10) {
+        const timeoutMs = timeoutSeconds * 1000;
+        const startTime = Date.now();
+
+        return new Promise((resolve, reject) => {
+            const checkInterval = setInterval(() => {
+                const latestMessage = this.getLatestMessage(topic);
+
+                if (latestMessage && latestMessage.timestamp >= startTime) {
+                    clearInterval(checkInterval);
+                    resolve(latestMessage);
+                } else if (Date.now() - startTime > timeoutMs) {
+                    clearInterval(checkInterval);
+                    reject(new Error(`Timeout waiting for message on topic: ${topic} after ${timeoutSeconds} seconds`));
+                }
+            }, 100); // Check every 100ms
+        });
+    }
+
+    /**
+     * Check if client is connected
+     * @returns {boolean}
+     */
+    isConnected() {
+        return this.client && this.client.connected;
+    }
+
+    /**
+     * Stop the MQTT client and cleanup
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.client && this.client.connected) {
+                console.log('Disconnecting from MQTT broker...');
+
+                // Unsubscribe from all topics
+                if (this.subscriptions.size > 0) {
+                    const topicsArray = Array.from(this.subscriptions);
+                    this.client.unsubscribe(topicsArray);
+                }
+
+                // Clear buffers
+                this.messageBuffer.clear();
+                this.subscriptions.clear();
+
+                // End connection
+                this.client.end(false, () => {
+                    console.log('MQTT client disconnected');
+                    resolve();
+                });
+            } else {
+                resolve();
+            }
+        });
+    }
+}
+
+module.exports = MqttManager;

package/features/app/stepDefinitions/helperSteps.js

@@ -77,3 +77,8 @@ Given('I switch back to original window', async function () {
 Given('I switch to {string} tab', async function (tabNumber) {
     this.page = await helper.switchToTab(this.browser, tabNumber);
 });
+
+Then('I generate UUID and store it in {string} variable', async function (variable) {
+    const uuid = helper.generateRandomUuid();
+    await dataStorage.iStoreVariableWithValueToTheJsonFile(uuid, variable);
+});

package/features/app/stepDefinitions/mqttSteps.js

@@ -0,0 +1,168 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const mqttFunctions = require('../../../src/mqttFunctions');
+
+/**
+ * MQTT Step Definitions
+ * These steps integrate with the hook-managed MQTT connection
+ */
+
+/**
+ * Subscribe to an MQTT topic
+ * @example When I subscribe to MQTT topic "devices/sensor1/telemetry"
+ * @example When I subscribe to MQTT topic "devices/+/data" with QoS 1
+ */
+When('I subscribe to MQTT topic {string}', async function (topic) {
+    await mqttFunctions.subscribeToTopic(this.mqttManager, topic, 0);
+});
+
+When('I subscribe to MQTT topic {string} with QoS {int}', async function (topic, qos) {
+    await mqttFunctions.subscribeToTopic(this.mqttManager, topic, qos);
+});
+
+/**
+ * Unsubscribe from an MQTT topic
+ * @example When I unsubscribe from MQTT topic "devices/sensor1/telemetry"
+ */
+When('I unsubscribe from MQTT topic {string}', async function (topic) {
+    await mqttFunctions.unsubscribeFromTopic(this.mqttManager, topic);
+});
+
+/**
+ * Publish a message to an MQTT topic
+ * @example When I publish "Hello World" to MQTT topic "test/message"
+ * @example When I publish "%savedVariable%" to MQTT topic "devices/sensor1/command"
+ */
+When('I publish {string} to MQTT topic {string}', async function (message, topic) {
+    await mqttFunctions.publishMessage(this.mqttManager, message, topic, 0, false);
+});
+
+/**
+ * Publish a message with QoS and retain options
+ * @example When I publish "Alert" to MQTT topic "alerts/critical" with QoS 1 and retain true
+ */
+When(
+    'I publish {string} to MQTT topic {string} with QoS {int} and retain {word}',
+    async function (message, topic, qos, retain) {
+        const retainFlag = retain === 'true';
+        await mqttFunctions.publishMessage(this.mqttManager, message, topic, qos, retainFlag);
+    }
+);
+
+/**
+ * Publish a JSON message to an MQTT topic
+ * @example When I publish JSON '{"temperature": 25, "humidity": 60}' to MQTT topic "sensors/room1"
+ */
+When('I publish JSON {string} to MQTT topic {string}', async function (jsonMessage, topic) {
+    await mqttFunctions.publishJsonMessage(this.mqttManager, jsonMessage, topic, 0, false);
+});
+
+/**
+ * Wait for and validate message reception on a topic
+ * @example Then I should receive a message on MQTT topic "devices/sensor1/response" within 5 seconds
+ * @example Then I should receive a message on MQTT topic "alerts/+/critical" within 10 seconds
+ */
+Then('I should receive a message on MQTT topic {string} within {int} seconds', async function (topic, timeout) {
+    await mqttFunctions.validateMessageReceived(this.mqttManager, topic, timeout);
+});
+
+Then('I should receive a message on MQTT topic {string}', async function (topic) {
+    await mqttFunctions.validateMessageReceived(this.mqttManager, topic, 10);
+});
+
+/**
+ * Validate the content of the latest message on a topic
+ * @example Then the MQTT message on topic "test/echo" should equal "Hello World"
+ */
+Then('the MQTT message on topic {string} should equal {string}', async function (topic, expectedContent) {
+    await mqttFunctions.validateMessageContent(this.mqttManager, topic, expectedContent);
+});
+
+/**
+ * Validate that the message contains a substring
+ * @example Then the MQTT message on topic "logs/app" should contain "ERROR"
+ */
+Then('the MQTT message on topic {string} should contain {string}', async function (topic, substring) {
+    await mqttFunctions.validateMessageContains(this.mqttManager, topic, substring);
+});
+
+/**
+ * Validate JSON message property value
+ * @example Then the MQTT message on topic "sensors/temp" should have property "temperature" with value "25"
+ * @example Then the MQTT message on topic "data/user" should have property "user.name" with value "John"
+ */
+Then(
+    'the MQTT message on topic {string} should have property {string} with value {string}',
+    async function (topic, property, expectedValue) {
+        await mqttFunctions.validateJsonProperty(this.mqttManager, topic, property, expectedValue);
+    }
+);
+
+/**
+ * Validate JSON message property type
+ * @example Then the MQTT message on topic "sensors/data" property "temperature" should be a "number"
+ */
+Then(
+    'the MQTT message on topic {string} property {string} should be a {string}',
+    async function (topic, property, type) {
+        await mqttFunctions.validateJsonPropertyType(this.mqttManager, topic, property, type);
+    }
+);
+
+/**
+ * Remember a JSON property value from MQTT message
+ * @example Then I remember the MQTT message property "id" from topic "devices/sensor1/response" as "deviceId"
+ * @example Then I remember the MQTT message property "data.temperature" from topic "sensors/temp" as "currentTemp"
+ */
+Then(
+    'I remember the MQTT message property {string} from topic {string} as {string}',
+    async function (property, topic, variableName) {
+        await mqttFunctions.rememberJsonProperty(this.mqttManager, topic, property, variableName);
+    }
+);
+
+/**
+ * Remember the entire message content
+ * @example Then I remember the MQTT message from topic "test/data" as "lastMessage"
+ */
+Then('I remember the MQTT message from topic {string} as {string}', async function (topic, variableName) {
+    await mqttFunctions.rememberMessage(this.mqttManager, topic, variableName);
+});
+
+/**
+ * Clear message buffer for a topic
+ * @example When I clear the MQTT message buffer for topic "test/messages"
+ * @example When I clear all MQTT message buffers
+ */
+When('I clear the MQTT message buffer for topic {string}', async function (topic) {
+    await mqttFunctions.clearMessageBuffer(this.mqttManager, topic);
+});
+
+When('I clear all MQTT message buffers', async function () {
+    await mqttFunctions.clearMessageBuffer(this.mqttManager, null);
+});
+
+/**
+ * Validate message count on a topic
+ * @example Then I should have received 3 messages on MQTT topic "test/counter"
+ */
+Then('I should have received {int} messages on MQTT topic {string}', async function (expectedCount, topic) {
+    await mqttFunctions.validateMessageCount(this.mqttManager, topic, expectedCount);
+});
+
+/**
+ * Optional: Explicit connect/disconnect steps for advanced scenarios
+ * These are not needed if using the @mqtt tag (connection is automatic)
+ */
+Given('I connect to MQTT broker {string}', async function (brokerUrl) {
+    const MqttManager = require('../mqttManager');
+    const mqttManager = new MqttManager(brokerUrl);
+    await mqttManager.initialize();
+    this.mqttManager = mqttManager;
+});
+
+Given('I disconnect from MQTT broker', async function () {
+    if (this.mqttManager) {
+        await this.mqttManager.stop();
+        this.mqttManager = null;
+    }
+});

package/features/tests/example-lighthouse.feature

@@ -0,0 +1,7 @@
+ Feature: Open DEMO QA (as base site) and run performance tests
+  
+  Scenario: Light house performance test
+    Given I go to "/"
+    Then I save the path of the current page
+    And I generate lighthouse report for the saved page
+

package/features/tests/example-mobile.feature

@@ -0,0 +1,9 @@
+@appium
+Feature: Click elements on mobile device
+  Scenario: Open settings page and click on a specific setting
+    Given I go to "com.google.android.youtube" app package and ".HomeActivity" activity
+    And I click on the element "id=com.android.permissioncontroller:id/permission_deny_button" on mobile
+    And I wait for "2" seconds
+    Then I scroll to the element 'text("Reject all")' on mobile
+    Then I click on the element '.text("Reject all")' on mobile
+    Then I click on the element '.description("Search")' on mobile

package/features/tests/example-pa11y.feature

@@ -0,0 +1,6 @@
+ Feature: Open DEMO QA (as base site) run accessibility tests
+
+  Scenario: Pa11y accessibility test
+    Given I go to "/"
+    Then I save the path of the current page
+    And I validate the saved page accessibility

package/features/tests/example-visual-test.feature

@@ -0,0 +1,5 @@
+ Feature: Open DEMO QA and run visual tests
+
+  Scenario: Backstop visual test 
+    And I generate reference screenshot for "https://demoqa.com/elements"
+    Then I compare "https://demoqa.com/elements" to reference screenshot

package/features/tests/mqttExample.feature

@@ -0,0 +1,48 @@
+@mqtt
+Feature: MQTT Testing Examples
+  Test MQTT messaging functionality using Cucumber and mqtt.js
+
+  Background:
+    Given I subscribe to MQTT topic "test/echo"
+    And I subscribe to MQTT topic "sensors/temperature"
+
+  Scenario: Simple message publish and receive
+    When I publish "Hello MQTT World" to MQTT topic "test/echo"
+    Then I should receive a message on MQTT topic "test/echo" within 5 seconds
+    And the MQTT message on topic "test/echo" should equal "Hello MQTT World"
+
+  Scenario: JSON message with property validation
+    When I publish JSON '{"temperature": 25.5, "humidity": 60, "unit": "celsius"}' to MQTT topic "sensors/temperature"
+    Then I should receive a message on MQTT topic "sensors/temperature" within 5 seconds
+    And the MQTT message on topic "sensors/temperature" should have property "temperature" with value "25.5"
+    And the MQTT message on topic "sensors/temperature" should have property "unit" with value "celsius"
+    And the MQTT message on topic "sensors/temperature" property "temperature" should be a "number"
+    And the MQTT message on topic "sensors/temperature" property "humidity" should be a "number"
+
+  Scenario: Store and reuse MQTT message data
+    Given I subscribe to MQTT topic "devices/sensor-001/status"
+    When I publish JSON '{"deviceId": "sensor-001", "status": "active"}' to MQTT topic "devices/sensor-001/status"
+    Then I should receive a message on MQTT topic "devices/sensor-001/status" within 5 seconds
+    And I remember the MQTT message property "deviceId" from topic "devices/sensor-001/status" as "savedDeviceId"
+    And I publish "Command for %savedDeviceId%" to MQTT topic "devices/commands"
+
+  Scenario: Test message with QoS and retain
+    When I publish "Critical Alert" to MQTT topic "alerts/critical" with QoS 1 and retain true
+    And I subscribe to MQTT topic "alerts/critical" with QoS 1
+    Then I should receive a message on MQTT topic "alerts/critical" within 5 seconds
+    And the MQTT message on topic "alerts/critical" should contain "Critical"
+
+  Scenario: Validate message count
+    When I clear the MQTT message buffer for topic "test/counter"
+    And I subscribe to MQTT topic "test/counter"
+    And I publish "Message 1" to MQTT topic "test/counter"
+    And I publish "Message 2" to MQTT topic "test/counter"
+    And I publish "Message 3" to MQTT topic "test/counter"
+    And I wait for "1" seconds
+    Then I should have received 3 messages on MQTT topic "test/counter"
+
+  Scenario: Wildcard topic subscription
+    When I subscribe to MQTT topic "devices/+/telemetry"
+    And I publish JSON '{"device": "sensor1", "value": 100}' to MQTT topic "devices/sensor1/telemetry"
+    Then I should receive a message on MQTT topic "devices/sensor1/telemetry" within 5 seconds
+    And the MQTT message on topic "devices/sensor1/telemetry" should have property "device" with value "sensor1"

package/index.js

@@ -7,6 +7,7 @@ const dataStorage = require('./src/dataStorage');
 const mainFunctions = require('./src/mainFunctions');
 const helperFunctions = require('./src/helperFunctions');
 const apiFunctions = require('./src/apiFunctions');
+const mqttFunctions = require('./src/mqttFunctions');
 const appiumTesting = require('./src/appiumTesting');
 const accessibilityTesting = require('./src/accessibilityTesting');
 const lighthouse = require('./src/lighthouse');
@@ -15,6 +16,7 @@ const visualRegression = require('./src/visualRegression');
 // Export managers
 const BrowserManager = require('./features/app/browserManager');
 const AppiumManager = require('./features/app/appiumManager');
+const MqttManager = require('./features/app/mqttManager');
 
 // Export step definitions
 const stepDefinitions = require('./stepDefinitions');
@@ -26,6 +28,7 @@ module.exports = {
     mainFunctions,
     helperFunctions,
     apiFunctions,
+    mqttFunctions,
     appiumTesting,
     accessibilityTesting,
     lighthouse,
@@ -34,6 +37,7 @@ module.exports = {
     // Managers
     BrowserManager,
     AppiumManager,
+    MqttManager,
 
     // Step definitions
     stepDefinitions,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cuppet/core",
-    "version": "1.1.5",
+    "version": "1.2.1",
     "description": "Core testing framework components for Cuppet - BDD framework based on Cucumber and Puppeteer",
     "main": "index.js",
     "files": [
@@ -17,6 +17,8 @@
         "cucumber",
         "puppeteer",
         "appium",
+        "mqtt",
+        "iot",
         "automation",
         "e2e"
     ],
@@ -32,15 +34,17 @@
         "appium": "3.0.1",
         "appium-uiautomator2-driver": "5.0",
         "axios": "^1.11.0",
-        "backstopjs": "^6.3.23",
+        "backstopjs": "^6.3.25",
         "chai": "6.0.1",
         "lighthouse": "^12.8.0",
         "mime": "^3.0.0",
         "mime-types": "^3.0.1",
         "moment": "^2.30.1",
+        "mqtt": "^5.11.3",
         "pa11y": "^9.0.0",
         "pa11y-reporter-html": "^2.0.0",
         "puppeteer": "^24.0.1",
+        "uuid": "^13.0.0",
         "webdriverio": "9.12.7",
         "xml2js": "^0.6.2"
     },
@@ -60,7 +64,14 @@
         "semantic-release": "^24.2.5"
     },
     "scripts": {
-        "test": "cucumber-js features/tests",
+        "test": "cucumber-js features/tests/example.feature",
+        "run:visual": "cucumber-js features/tests/example-visual-test.feature",
+        "run:pa11y": "cucumber-js features/tests/example-pa11y.feature",
+        "run:lighthouse": "cucumber-js features/tests/example-lighthouse.feature",
+        "run:mqtt": "cucumber-js features/tests/mqttExample.feature",
+        "run:mobile": "cucumber-js features/tests/example-mobile.feature",
+        "run:accessibility": "cucumber-js features/tests/example-accessibility.feature",
+        "run:performance": "cucumber-js features/tests/example-performance.feature",
         "postinstall": "node postinstall.js",
         "lint:check": "eslint .",
         "format:check": "prettier --check .",

package/src/apiFunctions.js

@@ -1,6 +1,7 @@
 const axios = require('axios');
 const config = require('config');
 const storage = require('./dataStorage');
+const helper = require('./helperFunctions');
 const xml2js = require('xml2js');
 const assert = require('chai').assert;
 const fs = require('fs');
@@ -201,7 +202,7 @@ module.exports = {
      * @returns {Promise<void>}
      */
     propertyHasValue: async function (property, expectedValue) {
-        const actualValue = await this.getPropertyValue(property);
+        const actualValue = await helper.getPropertyValue(this.response.data, property);
         assert.strictEqual(actualValue, expectedValue, `Property "${property}" does not have the expected value`);
     },
 
@@ -214,28 +215,10 @@ module.exports = {
      * @returns {Promise<void>}
      */
     iRememberVariable: async function (property, variable) {
-        const propValue = await this.getPropertyValue(property);
+        const propValue = await helper.getPropertyValue(this.response.data, property);
         await storage.iStoreVariableWithValueToTheJsonFile(propValue, variable);
     },
 
-    /**
-     * Go through the response object and return the value of specific property
-     * @param property - name of the property. For nested structure use -> parent.child1.child2 etc.
-     * @returns {Promise<*>}
-     */
-    getPropertyValue: async function (property) {
-        const response = this.response.data;
-        const keys = property.split('.');
-        let value = response;
-        for (let key of keys) {
-            value = value[key];
-        }
-        if (!value) {
-            throw new Error(`Value with property: ${property} is not found!`);
-        }
-        return value;
-    },
-
     /**
      * Load custom json file and make a request body from it
      * @param path

package/src/helperFunctions.js

@@ -4,6 +4,8 @@
  * @typedef {import('puppeteer').Browser} Browser
  */
 const config = require('config');
+const { v4: uuidv4 } = require('uuid');
+
 module.exports = {
     /**
      * Waits for a keypress event to continue the test execution.
@@ -32,6 +34,33 @@ module.exports = {
             .substring(2, length + 2);
     },
 
+    /**
+     * Generate random v4 UUID
+     * @example 123e4567-e89b-12d3-a456-426614174000
+     * @returns {string}
+     */
+    generateRandomUuid: function () {
+        return uuidv4();
+    },
+
+    /**
+     * Iterate through  json object and return the value of specific property
+     * @param object - the json object to iterate through
+     * @param property - name of the property. For nested structure use -> parent.child1.child2 etc.
+     * @returns {*}
+     */
+    getPropertyValue: function (object, property) {
+        const keys = property.split('.');
+        let value = object;
+        for (let key of keys) {
+            if (value === undefined || value === null) {
+                throw new Error(`Property path "${property}" not found in object`);
+            }
+            value = value[key];
+        }
+        return value;
+    },
+
     /**
      * Wait until AJAX request is completed
      * @param {Page} page
@@ -162,4 +191,28 @@ module.exports = {
         let pathName = newUrl.pathname;
         return pathName.replace(/[^a-z0-9]/gi, '_').toLowerCase();
     },
+
+    /**
+     * Convert string representations of primitive types to their actual types
+     * Handles: "null" -> null, "true" -> true, "false" -> false, "undefined" -> undefined, numeric strings -> numbers
+     * @param {*} value - The value to convert
+     * @returns {*} - The converted value or original value if no conversion needed
+     */
+    castPrimitiveType: function (value) {
+        if (typeof value === 'string') {
+            if (value === 'null') {
+                return null;
+            } else if (value === 'true') {
+                return true;
+            } else if (value === 'false') {
+                return false;
+            } else if (value === 'undefined') {
+                return undefined;
+            } else if (!isNaN(value) && value.trim() !== '') {
+                // Convert numeric strings to numbers
+                return Number(value);
+            }
+        }
+        return value;
+    },
 };

package/src/mqttFunctions.js

@@ -0,0 +1,285 @@
+const assert = require('chai').assert;
+const storage = require('./dataStorage');
+const helper = require('./helperFunctions');
+
+/**
+ * MQTT Functions Module
+ * Provides core MQTT testing operations following the same pattern as Puppeteer and Appium functions
+ */
+module.exports = {
+    /**
+     * Prepare topic by replacing variables
+     * @param {string} topic - Topic with potential variables
+     * @returns {Promise<string>} - Resolved topic
+     */
+    prepareTopic: async function (topic) {
+        return await storage.checkForMultipleVariables(topic);
+    },
+
+    /**
+     * Prepare message by replacing variables
+     * @param {string} message - Message with potential variables
+     * @returns {Promise<string>} - Resolved message
+     */
+    prepareMessage: async function (message) {
+        return await storage.checkForMultipleVariables(message);
+    },
+
+    /**
+     * Subscribe to a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to subscribe to
+     * @param {number} qos - Quality of Service level (0, 1, or 2)
+     * @returns {Promise<void>}
+     */
+    subscribeToTopic: async function (mqttManager, topic, qos = 0) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        await mqttManager.subscribe(resolvedTopic, { qos });
+    },
+
+    /**
+     * Unsubscribe from a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to unsubscribe from
+     * @returns {Promise<void>}
+     */
+    unsubscribeFromTopic: async function (mqttManager, topic) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        await mqttManager.unsubscribe(resolvedTopic);
+    },
+
+    /**
+     * Publish a message to a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} message - Message to publish
+     * @param {string} topic - Topic to publish to
+     * @param {number} qos - Quality of Service level (0, 1, or 2)
+     * @param {boolean} retain - Whether to retain the message
+     * @returns {Promise<void>}
+     */
+    publishMessage: async function (mqttManager, message, topic, qos = 0, retain = false) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        const resolvedMessage = await this.prepareMessage(message);
+        await mqttManager.publish(resolvedTopic, resolvedMessage, { qos, retain });
+    },
+
+    /**
+     * Publish a JSON message to a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} jsonString - JSON string to publish
+     * @param {string} topic - Topic to publish to
+     * @param {number} qos - Quality of Service level
+     * @param {boolean} retain - Whether to retain the message
+     * @returns {Promise<void>}
+     */
+    publishJsonMessage: async function (mqttManager, jsonString, topic, qos = 0, retain = false) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        const resolvedJson = await this.prepareMessage(jsonString);
+
+        // Validate JSON
+        try {
+            JSON.parse(resolvedJson);
+        } catch (error) {
+            throw new Error(`Invalid JSON message: ${error.message}`);
+        }
+
+        await mqttManager.publish(resolvedTopic, resolvedJson, { qos, retain });
+    },
+
+    /**
+     * Wait for a message on a specific topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to wait for message on
+     * @param {number} timeoutSeconds - Timeout in seconds
+     * @returns {Promise<Object>} - Message object
+     */
+    waitForMessage: async function (mqttManager, topic, timeoutSeconds = 10) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        return await mqttManager.waitForMessage(resolvedTopic, timeoutSeconds);
+    },
+
+    /**
+     * Get the latest message from a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to get message from
+     * @returns {Promise<Object>} - Latest message object
+     */
+    getLatestMessage: async function (mqttManager, topic) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        const message = mqttManager.getLatestMessage(resolvedTopic);
+
+        if (!message) {
+            throw new Error(`No messages received on topic: ${resolvedTopic}`);
+        }
+
+        return message;
+    },
+
+    /**
+     * Parse message as JSON
+     * @param {Object} messageObj - Message object from buffer
+     * @returns {Object} - Parsed JSON object
+     */
+    parseMessageAsJson: function (messageObj) {
+        try {
+            return JSON.parse(messageObj.message);
+        } catch (error) {
+            throw new Error(`Failed to parse message as JSON: ${error.message}`);
+        }
+    },
+
+    /**
+     * Validate that a message was received on a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to check
+     * @param {number} timeoutSeconds - Timeout in seconds
+     * @returns {Promise<Object>} - Message object
+     */
+    validateMessageReceived: async function (mqttManager, topic, timeoutSeconds = 10) {
+        const message = await this.waitForMessage(mqttManager, topic, timeoutSeconds);
+        assert.isDefined(message, `No message received on topic: ${topic}`);
+        return message;
+    },
+
+    /**
+     * Validate message content equals expected value
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to check message on
+     * @param {string} expectedContent - Expected message content
+     * @returns {Promise<void>}
+     */
+    validateMessageContent: async function (mqttManager, topic, expectedContent) {
+        const resolvedExpected = await storage.checkForSavedVariable(expectedContent);
+        const message = await this.getLatestMessage(mqttManager, topic);
+        assert.strictEqual(
+            message.message,
+            resolvedExpected,
+            `Message content does not match. Expected: ${resolvedExpected}, Actual: ${message.message}`
+        );
+    },
+
+    /**
+     * Validate message contains a substring
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to check message on
+     * @param {string} substring - Substring to search for
+     * @returns {Promise<void>}
+     */
+    validateMessageContains: async function (mqttManager, topic, substring) {
+        const resolvedSubstring = await storage.checkForSavedVariable(substring);
+        const message = await this.getLatestMessage(mqttManager, topic);
+        assert.include(
+            message.message,
+            resolvedSubstring,
+            `Message does not contain expected substring: ${resolvedSubstring}`
+        );
+    },
+
+    /**
+     * Validate JSON message property has expected value
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to get message from
+     * @param {string} property - Property path (e.g., "data.temperature")
+     * @param {string} expectedValue - Expected value
+     * @returns {Promise<void>}
+     */
+    validateJsonProperty: async function (mqttManager, topic, property, expectedValue) {
+        let resolvedExpected = await storage.checkForSavedVariable(expectedValue);
+        resolvedExpected = helper.castPrimitiveType(resolvedExpected);
+
+        const message = await this.getLatestMessage(mqttManager, topic);
+        const jsonData = this.parseMessageAsJson(message);
+        const value = helper.getPropertyValue(jsonData, property);
+
+        assert.strictEqual(
+            value,
+            resolvedExpected,
+            `The value of the property "${property}" does not match: Expected: ${resolvedExpected}, Actual: ${value}`
+        );
+    },
+
+    /**
+     * Validate JSON message property type
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to get message from
+     * @param {string} property - Property path
+     * @param {string} type - Expected type (string, number, boolean, object, array)
+     * @returns {Promise<void>}
+     */
+    validateJsonPropertyType: async function (mqttManager, topic, property, type) {
+        const message = await this.getLatestMessage(mqttManager, topic);
+        const jsonData = this.parseMessageAsJson(message);
+        const value = helper.getPropertyValue(jsonData, property);
+        assert.typeOf(value, type, `Property "${property}" is not of type ${type}`);
+    },
+
+    /**
+     * Remember a property value from JSON message
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to get message from
+     * @param {string} property - Property path
+     * @param {string} variableName - Variable name to store value
+     * @returns {Promise<void>}
+     */
+    rememberJsonProperty: async function (mqttManager, topic, property, variableName) {
+        const message = await this.getLatestMessage(mqttManager, topic);
+        const jsonData = this.parseMessageAsJson(message);
+        const value = helper.getPropertyValue(jsonData, property);
+        await storage.iStoreVariableWithValueToTheJsonFile(value, variableName);
+    },
+
+    /**
+     * Remember the entire message content
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to get message from
+     * @param {string} variableName - Variable name to store message
+     * @returns {Promise<void>}
+     */
+    rememberMessage: async function (mqttManager, topic, variableName) {
+        const message = await this.getLatestMessage(mqttManager, topic);
+        await storage.iStoreVariableWithValueToTheJsonFile(message.message, variableName);
+    },
+
+    /**
+     * Clear message buffer for a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to clear buffer for (or null for all)
+     * @returns {Promise<void>}
+     */
+    clearMessageBuffer: async function (mqttManager, topic = null) {
+        if (topic) {
+            const resolvedTopic = await this.prepareTopic(topic);
+            mqttManager.clearMessageBuffer(resolvedTopic);
+        } else {
+            mqttManager.clearMessageBuffer();
+        }
+    },
+
+    /**
+     * Get message count for a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to get message count for
+     * @returns {Promise<number>} - Number of messages
+     */
+    getMessageCount: async function (mqttManager, topic) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        return (await mqttManager.getMessages(resolvedTopic)).length;
+    },
+
+    /**
+     * Validate message count on a topic
+     * @param {object} mqttManager - MQTT manager instance
+     * @param {string} topic - Topic to check
+     * @param {number} expectedCount - Expected number of messages
+     * @returns {Promise<void>}
+     */
+    validateMessageCount: async function (mqttManager, topic, expectedCount) {
+        const resolvedTopic = await this.prepareTopic(topic);
+        const actualCount = await this.getMessageCount(mqttManager, resolvedTopic);
+        assert.strictEqual(
+            actualCount,
+            expectedCount,
+            `Expected ${expectedCount} messages on topic "${topic}", but found ${actualCount}`
+        );
+    },
+};

package/stepDefinitions.js

@@ -10,6 +10,7 @@ module.exports = {
     iframeSteps: require('./features/app/stepDefinitions/iframeSteps'),
     ifVisibleSteps: require('./features/app/stepDefinitions/ifVisibleSteps'),
     lighthouseSteps: require('./features/app/stepDefinitions/lighthouseSteps'),
+    mqttSteps: require('./features/app/stepDefinitions/mqttSteps'),
     pageElements: require('./features/app/stepDefinitions/pageElements'),
     pageElementsConfig: require('./features/app/stepDefinitions/pageElementsConfig'),
     pageElementsJson: require('./features/app/stepDefinitions/pageElementsJson'),