@cuppet/core 1.0.1 → 1.0.2

package/README.md

@@ -12,43 +12,16 @@ npm install @cuppet/core
 
 ### Basic Setup
 
-```javascript
-const { BrowserManager, elementInteraction, dataStorage } = require('@cuppet/core');
+```bash
+yarn install
 ```
 
-### In your hooks.js
+### There is a predefined structure in place made available for testing changes. To execute the example test run:
 
-```javascript
-const { Before, After } = require('@cucumber/cucumber');
-const { BrowserManager, AppiumManager } = require('@cuppet/core');
-const config = require('config');
-
-Before(async function (testCase) {
-    const browserArgs = config.get('browserOptions.args');
-    const browserViewport = config.get('browserOptions.viewport.default');
-
-    const browserManager = new BrowserManager(browserViewport, browserArgs);
-    await browserManager.initialize();
-    this.browserManager = browserManager;
-    this.browser = browserManager.browser;
-    this.page = browserManager.page;
-});
+```bash
+yarn test
 ```
 
-### In your step definitions
-
-```javascript
-const { Given, When, Then } = require('@cucumber/cucumber');
-const { elementInteraction, mainFunctions } = require('@cuppet/core');
-
-Given('I am on the homepage', async function () {
-    await mainFunctions.visitPath(this.page, 'homepage');
-});
-
-When('I click the {string} button', async function (cssSelector) {
-    await elementInteraction.click(this.page, cssSelector);
-});
-```
 
 ## Available Components
 
@@ -77,23 +50,24 @@ When('I click the {string} button', async function (cssSelector) {
 
 The cuppet-core package includes pre-built step definitions that you can use in your main project. Here are several ways to integrate them:
 
-### Option 1: Import and use directly in your step definition files
-
-```javascript
-// In your project's step definition file (e.g., mySteps.js)
-const { Given, When, Then } = require('@cucumber/cucumber');
-const { stepDefinitions } = require('@cuppet/core');
+### Option 1: Import and use directly in your cucumber based project
 
-// Use the pre-built step definitions
-const { generalSteps, helperSteps, apiSteps } = stepDefinitions;
+Make sure your Cucumber configuration includes the step definition paths:
 
-// You can now use the step definitions directly
-Given('I am on the homepage', generalSteps.givenIAmOnTheHomepage);
-When('I click the login button', helperSteps.whenIClickTheLoginButton);
-Then('I should see the dashboard', generalSteps.thenIShouldSeeTheDashboard);
+```javascript
+// cucumber.js
+module.exports = {
+    default: {
+        requireModule: ['@cuppet/core'],
+        require: [
+            'node_modules/@cuppet/core/features/app/stepDefinitions/*.js',
+            'features/step-definitions/**/*.js', // Your project's step definitions
+        ],
+    },
+};
 ```
 
-### Option 2: Import step definitions separately
+### Option 2: Import step definitions on bulk or separately and override them
 
 ```javascript
 // Import step definitions directly
@@ -102,25 +76,30 @@ const stepDefinitions = require('@cuppet/core/stepDefinitions');
 // Or import specific step definition modules
 const generalSteps = require('@cuppet/core/features/app/stepDefinitions/generalSteps');
 const apiSteps = require('@cuppet/core/features/app/stepDefinitions/apiSteps');
+const { Then } = require('@cucumber/cucumber');
+
+Then('the response should be an {string}', async function (type) {
+    console.log("Add your new custom logic", type)
+});
 ```
 
-### Option 3: Extend and customize step definitions
+### Option 3: Extend or customize step definitions
 
 ```javascript
 // In your project's step definition file
 const { Given, When, Then } = require('@cucumber/cucumber');
-const { stepDefinitions } = require('@cuppet/core');
+const generalSteps = require('@cuppet/core/features/app/stepDefinitions/generalSteps');
 
 // Extend the base step definitions with your custom logic
-Given('I am logged in as {string}', async function (userType) {
+Given('I am logged in as {string}', async function (userName) {
     // Your custom login logic
     await this.page.goto('https://your-app.com/login');
-    await this.page.fill('[data-testid="username"]', userType);
+    await this.page.fill('[data-testid="username"]', userName);
     await this.page.fill('[data-testid="password"]', 'password');
     await this.page.click('[data-testid="login-button"]');
 
-    // Then use the base step definition
-    await stepDefinitions.generalSteps.thenIShouldSeeTheDashboard.call(this);
+    // Then use a base step definition
+    await generalSteps.['I follow {string}'].call(this,userName);
 });
 ```
 
@@ -134,201 +113,11 @@ Given('I am logged in as {string}', async function (userType) {
 - `iframeSteps` - Iframe handling steps
 - `ifVisibleSteps` - Conditional visibility steps
 - `lighthouseSteps` - Performance testing steps
-- `pageElements` - Page element management
-- `pageElementsConfig` - Page element configuration
-- `pageElementsJson` - JSON-based page elements
+- `pageElements` - Page element testing
+- `pageElementsConfig` - Page element testing with values from config
+- `pageElementsJson` - Page element testing with values from locally stored JSON file
 - `visualRegressionSteps` - Visual regression testing steps
 
-### Cucumber Configuration
-
-Make sure your Cucumber configuration includes the step definition paths:
-
-```javascript
-// cucumber.js
-module.exports = {
-    default: {
-        requireModule: ['@cuppet/core'],
-        require: [
-            'node_modules/@cuppet/core/features/app/stepDefinitions/*.js',
-            'features/step-definitions/**/*.js', // Your project's step definitions
-        ],
-    },
-};
-```
-
-## Practical Examples
-
-Here are real-world examples of how to use, override, and extend step definitions from cuppet-core:
-
-### 1. Direct Usage - Use existing steps as-is
-
-```javascript
-// In your step definition file
-const { Given, When, Then } = require('@cucumber/cucumber');
-const { stepDefinitions } = require('@cuppet/core');
-
-const { generalSteps, helperSteps } = stepDefinitions;
-
-// Use them directly
-Given('I go to homepage', async function () {
-    await generalSteps['I go to {string}'].call(this, 'homepage');
-});
-
-When('I wait for page to load', async function () {
-    await helperSteps['I wait for {string} seconds'].call(this, '3');
-});
-```
-
-### 2. Override - Replace with your custom logic
-
-```javascript
-// Override the default login step for your specific application
-Given('I log in', async function () {
-    // Your custom login logic
-    await this.page.goto('https://myapp.com/login');
-    await this.page.fill('#email', 'test@example.com');
-    await this.page.fill('#password', 'password123');
-    await this.page.click('#login-button');
-    await this.page.waitForNavigation();
-});
-
-// Override navigation with your base URL
-Given('I go to {string}', async function (path) {
-    const baseUrl = 'https://myapp.com';
-    await this.page.goto(`${baseUrl}/${path}`);
-});
-```
-
-### 3. Extend - Add custom logic before/after existing steps
-
-```javascript
-// Add logging to existing steps
-Given('I go to {string} with logging', async function (path) {
-    console.log(`Navigating to: ${path}`);
-
-    // Use the original step
-    await generalSteps['I go to {string}'].call(this, path);
-
-    console.log(`Successfully navigated to: ${path}`);
-});
-
-// Add validation after navigation
-Given('I go to {string} and verify page loaded', async function (path) {
-    // Use the original step
-    await generalSteps['I go to {string}'].call(this, path);
-
-    // Add custom validation
-    await this.page.waitForSelector('[data-testid="page-content"]');
-});
-```
-
-### 4. Composite Steps - Combine multiple existing steps
-
-```javascript
-// Create a setup step that combines multiple existing steps
-Given('I set up test environment', async function () {
-    // Clear data
-    await helperSteps['I clear the json file'].call(this);
-
-    // Set viewport
-    await generalSteps['I set viewport size to {string}'].call(this, '1920x1080');
-
-    // Navigate to setup page
-    await generalSteps['I go to {string}'].call(this, 'setup');
-
-    // Wait for setup to complete
-    await helperSteps['I wait for {string} seconds'].call(this, '2');
-});
-
-// Create role-specific login steps
-Given('I am logged in as {string}', async function (userType) {
-    const credentials = {
-        admin: { username: 'admin', password: 'admin123' },
-        user: { username: 'user', password: 'user123' },
-    };
-
-    const user = credentials[userType];
-    await generalSteps['I log in as {string} {string}'].call(this, user.username, user.password);
-});
-```
-
-### 5. Error Handling - Wrap existing steps with retry logic
-
-```javascript
-// Create a retry wrapper for navigation
-Given('I go to {string} with retry', async function (path) {
-    const maxRetries = 3;
-
-    for (let i = 0; i < maxRetries; i++) {
-        try {
-            await generalSteps['I go to {string}'].call(this, path);
-            return; // Success, exit the loop
-        } catch (error) {
-            console.log(`Navigation attempt ${i + 1} failed: ${error.message}`);
-
-            if (i === maxRetries - 1) {
-                throw error; // Re-throw on last attempt
-            }
-
-            // Wait before retry
-            await helperSteps['I wait for {string} seconds'].call(this, '2');
-        }
-    }
-});
-```
-
-### 6. Utility Functions - Create reusable helpers
-
-```javascript
-// Create utility functions that use existing steps
-const stepUtils = {
-    async loginWithRetry(page, username, password, maxRetries = 3) {
-        for (let i = 0; i < maxRetries; i++) {
-            try {
-                await stepDefinitions.generalSteps['I log in as {string} {string}'].call({ page }, username, password);
-                return true;
-            } catch (error) {
-                console.log(`Login attempt ${i + 1} failed`);
-                if (i === maxRetries - 1) throw error;
-                await stepDefinitions.helperSteps['I wait for {string} seconds'].call({ page }, '2');
-            }
-        }
-    },
-};
-
-// Use the utility functions
-Given('I log in with retry mechanism', async function () {
-    await stepUtils.loginWithRetry(this.page, 'testuser', 'testpass');
-});
-```
-
-### 7. Feature-Specific Steps - Create steps for your application
-
-```javascript
-// E-commerce specific steps
-Given('I add {string} to cart', async function (productName) {
-    // Navigate to product page
-    await generalSteps['I go to {string}'].call(this, `products/${productName}`);
-
-    // Add to cart logic
-    await this.page.click('[data-testid="add-to-cart"]');
-    await helperSteps['I wait for {string} seconds'].call(this, '1');
-});
-
-// User management specific steps
-Given('I create a new user account', async function () {
-    await generalSteps['I go to {string}'].call(this, 'register');
-
-    // Fill registration form
-    await this.page.fill('[data-testid="username"]', 'newuser');
-    await this.page.fill('[data-testid="email"]', 'newuser@example.com');
-    await this.page.fill('[data-testid="password"]', 'password123');
-    await this.page.click('[data-testid="register-button"]');
-
-    await helperSteps['I wait for {string} seconds'].call(this, '2');
-});
-```
-
 ## Project-Specific Components
 
 The following components should be created in your project as they are specific to your application:

package/features/app/multilingualStrings/multilingualStrings.js

@@ -1,288 +1,20 @@
 module.exports = {
-    multilingualStrings: function (lang, property) {
+    multilingualStrings: function (lang) {
         const translations = {
             de: {
                 Submit: 'Einreichen',
                 Delete: 'Löschen',
                 Run: 'Laufen',
                 everywhere: 'nachgesehen',
-                'use current location': 'Standort nutzen',
-                'advanced search': 'Erweiterte Suche',
-                'we looked': 'Wir haben überall',
-                'but could not find your page.': 'aber die gewünsche Seite nicht gefunden',
-                '03 March 2021': '03 März 2021',
-                apply: 'jetzt bewerben',
-                "You haven't applied recently.": 'Sie haben sich in letzter Zeit nicht beworben.',
-                'my applications': 'Meine Bewerbungen',
-                'you have not saved any jobs yet': 'Sie haben sich bisher keine Stellenanzeigen gemerkt',
-                'you are applying for this job:': 'Bewerbung',
-            },
-            nl: {
-                'we looked': 'we zochten',
-                everywhere: 'overal',
-                'but could not find your page.': 'maar konden de pagina niet vinden.',
-                'Page not found': 'Pagina niet gevonden',
-                '03 March 2021': '03 maart 2021',
-            },
-            pt: {
-                '03 March 2021': '03 março 2021',
-            },
-            ar: {
-                'advanced search': 'búsqueda avanzada',
-                'use current location': 'usar ubicación actual',
-                'we looked': 'buscamos por',
-                everywhere: 'todas partes',
-                'but could not find your page.': 'pero no pudimos encontrar tu página',
-                '03 March 2021': '03 marzo 2021',
-            },
-            pl: {
-                'advanced search': 'wyszukiwanie zaawansowane',
-                'use current location': 'użyj aktualnej lokalizacji',
-                'we looked': 'szukaliśmy',
-                everywhere: 'wszędzie',
-                'but could not find your page.': 'ale nie mogliśmy znaleźć tej strony.',
-                '03 March 2021': '03 Marzec 2021',
-                'work from home jobs': 'tylko praca zdalna',
-                'remote  jobs found for you': 'zdalne oferty pracy znalezione dla Ciebie',
-            },
-            cs: {
-                'advanced search': 'podrobné vyhledávání',
-                'use current location': 'použít současnou polohu',
-                'we looked': 'Hledali jsme',
-                everywhere: 'všude,',
-                'but could not find your page.': 'ale danou stránku jsme bohužel nenašli.',
-                '03 March 2021': '03 Březen 2021',
-            },
-            cl: {
-                'advanced search': 'búsqueda avanzada',
-                'use current location': 'usar ubicación actual',
-                'we looked': 'buscamos por',
-                everywhere: 'todas partes',
-                'but could not find your page.': 'pero no pudimos encontrar tu página',
-                '03 March 2021': '03 marzo 2021',
-                'work from home jobs': 'solo empleos por teletrabajo',
-                'remote  jobs found for you': 'teletrabajo trabajos para ti',
-            },
-            ro: {
-                'advanced search': 'căutare avansată',
-                'use current location': 'utilizați locația curentă',
-                'we looked': 'ne-am uitat',
-                everywhere: 'pretutindeni',
-                'but could not find your page.': 'dar nu v-am putut găsi pagina.',
-                '03 March 2021': '03 Martie 2021',
-                apply: 'aplică',
-            },
-            hu: {
-                'advanced search': 'haladó keresés',
-                'use current location': 'használja a jelenlegi helyszínt',
-                'we looked': 'mindenhol',
-                everywhere: 'kerestük',
-                'but could not find your page.': 'de nem sikerült betölteni a keresett oldalt',
-                '03 March 2021': '03 március 2021',
-                apply: 'jelentkezem',
-            },
-            es: {
-                'advanced search': 'búsqueda avanzada',
-                'use current location': 'usar ubicación actual',
-                'we looked': 'buscamos por',
-                everywhere: 'todas partes',
-                'but could not find your page.': 'pero no pudimos encontrar tu página',
-                '03 March 2021': '03 Marcha 2021',
-            },
-            it: {
-                'advanced search': 'ricerca avanzata',
-                'use current location': 'usa la posizione attuale',
-                'we looked': 'abbiamo guardato',
-                everywhere: 'da tutte le parti',
-                'but could not find your page.': 'ma non sono riuscito a trovare la tua pagina.',
-                '03 March 2021': '03 Marzo 2021',
-                "You haven't applied recently.": 'Non hai candidature recenti.',
-                'my applications': 'le mie candidature',
-                'you have not saved any jobs yet': 'non hai ancora salvato le tue offerte preferite',
-                'you are applying for this job:': 'ti stai candidando a questa offerta',
-            },
-            'de-ch': {
-                'advanced search': 'fortgeschrittene Suche',
-                'use current location': 'Standort verwenden',
-                'we looked': 'wir haben nachgeschaut',
-                everywhere: 'überall',
-                'but could not find your page.': 'aber konnten deine Seite nicht finden',
-                '03 March 2021': '03 März 2021',
-                apply: 'bewerben',
-            },
-            'pt-br': {
-                'advanced search': 'pesquisa avançada',
-                'use current location': 'usar localização atual',
-                'we looked': 'nós procuramos',
-                everywhere: 'em todo os lugares',
-                'but could not find your page.': 'mas não conseguimos encontrar o que está sendo buscado',
-                '03 March 2021': '03 Marchar 2021',
-            },
-            nb: {
-                'advanced search': 'utvidet søk',
-                'use current location': 'bruk stedet du befinner deg på nå',
-                'we looked': 'vi har lett',
-                everywhere: 'over alt',
-                'but could not find your page.': 'men vi kunne dessverre ikke finne siden du leter etter',
-                '03 March 2021': '03 mars 2021',
-            },
-            el: {
-                'advanced search': 'σύνθετη αναζήτηση',
-                'use current location': 'χρησιμοποίησε την τρέχουσα τοποθεσία μου',
-                'we looked': 'ψάξαμε',
-                everywhere: 'παντού',
-                'but could not find your page.': 'αλλά δεν μπορέσαμε να βρούμε τη σελίδα που αναζητάς.',
-                '03 March 2021': '03 Μαρτίου 2021',
-                apply: 'κάνε την αίτησή σου',
-                'work from home jobs': 'αποκλειστικά εξ αποστάσεως εργασία',
-                'remote  jobs found for you': 'remote θέσεις εργασίας βρέθηκαν για σένα',
-            },
-            fr: {
-                'advanced search': 'recherche avancée',
-                'use current location': 'à proximité',
-                'we looked': 'nous avons regardé',
-                everywhere: 'partout',
-                'but could not find your page.': 'mais nous ne trouvons pas cette page.',
-                '03 March 2021': '3 mars 2021',
-                apply: 'postuler',
-                "You haven't applied recently.": 'aucune candidature à ce jour',
-                'my applications': 'candidatures',
-                'you have not saved any jobs yet': "pour l'instant, aucune offre sélectionnée",
-                'you are applying for this job:': 'vous postulez à cette offre:',
-            },
-            cn: {
-                'advanced search': '高级搜索',
-                'use current location': '使用当前位置',
-                'we looked': '我们搜索了',
-                everywhere: '所有类目',
-                'but could not find your page.': '但未查到您要找的页面',
-                '03 March 2021': '03 三月 2021',
-            },
-            tr: {
-                'advanced search': 'gelişmiş arama',
-                'use current location': 'mevcut konumu kullan',
-                'we looked': 'her yere',
-                everywhere: 'baktık',
-                'but could not find your page.': 'ama bulamadık',
-                '03 March 2021': '03 mart 2021',
-                apply: 'başvur',
             },
             da: {
                 'advanced search': 'avanceret søgning',
-                'use current location': 'brug nuværende lokalitet',
-                'we looked': 'vi har ledt',
-                everywhere: 'overalt',
-                'but could not find your page.': 'men kunne ikke finde din side.',
-                '03 March 2021': '03 marts 2021',
-                apply: 'ansøg',
-                'my applications': 'mine ansøgninger',
-                'you have not saved any jobs yet': 'du har ingen gemte job endnu',
-                'you are applying for this job:': 'du ansøger nu dette job',
             },
             sv: {
                 'advanced search': 'avancerat sök',
-                'use current location': 'använd nuvarande plats',
-                'we looked': 'vi har sökt ',
-                everywhere: 'överallt',
-                'but could not find your page.': 'men kan inte hitta sidan.',
-                '03 March 2021': '03 Mars 2021',
-                "You haven't applied recently.": 'Du har inte ansökt till något jobb ännu',
-                'my applications': 'mina ansökningar',
-                'you have not saved any jobs yet': 'du har inte sparat några jobb ännu.',
-                'view 3 more': 'se 3 till',
-                'view 6 more': 'se 6 till',
-                'thank you for your application': 'tack för din ansökan',
-                'the application process.': 'ansökningsprocessen.',
-                'See what comes ahead in the application process': 'Se vad som händer härnäst i ansökningsprocessen',
-                'applying is easy.': 'att ansöka är enkelt.',
-                'you get a confirmation email.': 'du får ett bekräftelsemejl.',
-                "We'll now evaluate your application": 'Nu kommer vi snart att utvärdera hur',
-                'your profile matches the job': 'din profil passar för jobbet.',
-                "We'll contact you for some additional information.":
-                    'Vi kommer att kontakta dig för kompletterande information.',
-                'unsupported file type': 'filtypen stöds ej',
-                'we only allow files up to 3 mb, please try again':
-                    'vi tillåter endast filer upp till 3 mb, vänligen prova igen',
-                'You have successfully updated your resume details': 'Ditt CV är uppdaterat',
-                'add files': 'lägg till filer',
-                'Log out': 'Logga ut',
-                'login to your account': 'logga in',
-                'You removed the job from your saved jobs': 'Du tog bort jobbet från dina sparade jobb',
-                'delete account': 'radera konto',
-                'You have successfully deleted your account. A confirmation email has been sent.':
-                    'Du har raderat ditt konto. Ett bekräftelsemail har skickats.',
-                'We do not recognize the combination of this e-mail address':
-                    'Vi känner inte igen den här kombinationen av e-postadress och lösenord',
-                'We are taking action to delete your data from our system.':
-                    'We are taking action to delete your data from our system.',
-                'show job alerts': 'visa jobbvarningar',
-                daily: 'dagligen',
-                'You have successfully updated your job alert.': 'Jobbevakningen har uppdaterats.',
-                'yes, delete': 'ja, radera',
-                'You have successfully deleted your job alert.': 'Jobbevakningen är raderad.',
-                'continue as guest': 'fortsätt som gäst',
-                "You'll start receiving emails": 'u kommer att börja få e-postmeddelanden',
-                'manage your job alerts': 'hantera dina jobbevakningar',
-                weekly: 'varje vecka',
-                'notification by email': 'notifieras via email',
-                'clear all': 'rensa allt',
-                'be the first to know about interesting jobs': 'be the first to know about interesting jobs',
-                'phone numbers': 'telefonnummer',
-                'You can add up to two phone numbers to your profile': 'Du kan lägga till upp till två telefonnummer',
-                'add phone number': 'lägg till telefonnummer',
-                'You have successfully updated your phone number': 'du har uppdaterat dina telefonuppgifter',
-                primary: 'primär',
-                Mobile: 'Mobile',
-                Landline: 'Landline',
-                'You have successfully deleted your phone number': 'du har raderat dina telefonuppgifter',
-                'phone number is invalid': 'number är ogiltigt.',
-                address: 'adress',
-                'successfully updated your address details': 'successfully updated your address details',
-                'You can add up to two addresses to your profile': 'Du kan lägga till upp till två adresser',
-                'add address': 'lägg till adress',
-                Primary: 'primär',
-                Bulgaria: 'Bulgarien',
-                secondary: 'sekundär',
-                'no results': 'inget resultat',
-                'You have successfully updated your name details': 'Dina uppgifter är uppdaterade',
-                Albania: 'Albanien',
-                'add education': 'lägg till utbildning',
-                'You have successfully updated your education details': 'Din utbildningsinformation är uppdaterad',
-                'please fill in the degree name': 'ange utbildningsnamn',
-                'please fill in the degree type': 'ange utbildningstyp',
-                'please fill in the institution / training facility / school': 'ange utbildningsinstans',
-                'please fill in the city': 'ange ort',
-                'please fill in the country': 'ange land',
-                'please fill in the start date': 'ange startdatum',
-                'please fill in the end date': 'ange slutdatum',
-                'You have successfully deleted your education details': 'Din utbildningsinformation är borttagen',
-                'add new work experience': 'lägg till ny arbetslivserfarenhet',
-                'You have successfully updated your work experience details': 'Din arbetslivserfarenhet är uppdaterad',
-                'You have successfully deleted your work experience details': 'Din arbetslivserfarenhet är borttagen',
-                'add certifications': 'lägg till certifiering',
-                'You have successfully updated your certification details':
-                    'Dina certifieringar och intyg är uppdaterade',
-                'You have successfully deleted your certification details':
-                    'Dina certifieringsinställningar har raderats',
-                'You have successfully updated your skills details': 'Din kompetens är uppdaterad',
-                'You have successfully deleted your skills details': 'Din kompetens är borttagen',
-                'You have successfully updated your links details.': 'Länkar är uppdaterade',
-                other: 'annat',
-                'You have successfully deleted your link record': 'Länken är borttagen',
-                'email address': 'e-postadress',
-                'United Kingdom of Great Britain and Northern Ireland': 'Bulgarien',
-                march: 'mars',
-                French: 'Swedish',
-                work: 'jobb',
-                Monthly: 'Månadsvis',
-                'I prefer remote work': 'Jag föredrar att arbeta på distans',
-                'Work preferences have successfully been updated': 'Jobbpreferenser är uppdaterade',
-                '$ 2500 per month': 'SEK 2500 per month',
-                'Value unspecified': 'välj',
-                select: 'välj',
             },
         };
-        // the ?. is used to not throw error for languages which do not have added translations
-        return translations[lang]?.[property];
+        // Return all translations for the given language, or undefined if not found
+        return translations[lang];
     },
 };

package/features/app/stepDefinitions/generalSteps.js

@@ -45,7 +45,8 @@ Given('I log in as {string} {string}', async function (username, password) {
     await navigationPromise;
 });
 Given('I follow {string}', async function (text) {
-    await utils.followLink(this.page, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.followLink(this.page, resolvedText);
 });
 Given('I reload the page', async function () {
     await main.reloadPage(this.page);
@@ -89,7 +90,8 @@ Given('I set viewport size to {string}', async function (resolution) {
 });
 Then('I {string} the alert dialog with text {string}', async function (action, expectedText) {
     const accept = action.toLowerCase() === 'accept' ? true : false;
-    await main.handleAlert(this.page, accept, expectedText);
+    const resolvedText = this.mlStrings ? this.mlStrings[expectedText] : expectedText;
+    await main.handleAlert(this.page, accept, resolvedText);
 });
 
 Then('I {string} the alert dialog', async function (action) {

package/features/app/stepDefinitions/ifVisibleSteps.js

@@ -6,7 +6,8 @@ Then('I should see {string} if visible', async function (text) {
     if (config.has('skipSteps') && config.get('skipSteps') === text) {
         return true;
     }
-    await utils.seeTextByXpath(this.page, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.seeTextByXpath(this.page, resolvedText);
 });
 When('I type {string} in {string} if visible', async function (text, cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;

package/features/app/stepDefinitions/iframeSteps.js

@@ -3,15 +3,16 @@ const utils = require('../../../src/elementInteraction');
 const dataStorage = require('../../../src/dataStorage');
 
 Then('I should see {string} in iframe {string}', async function (text, frameSelector) {
-    const result = await dataStorage.checkForVariable(text);
+    const resolvedText = this.mlStrings[text] ?? text;
     let frame = await utils.getFrameBySelector(this.page, frameSelector);
-    await utils.seeTextByXpath(frame, result);
+    await utils.seeTextByXpath(frame, resolvedText);
 });
 Then(
     'I wait for the text {string} to appear within {string} seconds in iframe {string}',
     async function (text, time, frameSelector) {
         let frame = await utils.getFrameBySelector(this.page, frameSelector);
-        await utils.seeTextByXpath(frame, text, time * 1000);
+        const resolvedText = this.mlStrings[text] ?? text;
+        await utils.seeTextByXpath(frame, resolvedText, time * 1000);
     }
 );
 When('I click on element {string} in iframe with selector {string}', async function (elementSelector, frameSelector) {
@@ -20,7 +21,8 @@ When('I click on element {string} in iframe with selector {string}', async funct
 });
 When('I click on the text {string} in iframe with selector {string}', async function (text, frameSelector) {
     let frame = await utils.getFrameBySelector(this.page, frameSelector);
-    await utils.clickByText(frame, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.clickByText(frame, resolvedText);
 });
 When(
     'I type {string} in {string} field in iframe with selector {string}',
@@ -33,7 +35,8 @@ When(
     'I click on the text {string} in iframe with selector {string} and follow the new tab',
     async function (text, frameSelector) {
         let frame = await utils.getFrameBySelector(this.page, frameSelector);
-        this.page = await utils.clickLinkOpenNewTab(this.browser, frame, text, true);
+        const resolvedText = this.mlStrings[text] ?? text;
+        this.page = await utils.clickLinkOpenNewTab(this.browser, frame, resolvedText, true);
     }
 );
 When(
@@ -48,7 +51,8 @@ When(
     'I store the string matching the {string} pattern from the {string} text in iframe {string}',
     async function (pattern, text, frameSelector) {
         let frame = await utils.getFrameBySelector(this.page, frameSelector);
-        await dataStorage.storeTextFromPattern(frame, pattern, text);
+        const resolvedText = this.mlStrings[text] ?? text;
+        await dataStorage.storeTextFromPattern(frame, pattern, resolvedText);
     }
 );
 Then(

package/features/app/stepDefinitions/pageElements.js

@@ -23,10 +23,12 @@ When('I click on all the elements with selector {string}', async function (cssSe
     await utils.clickAllElements(this.page, selector);
 });
 When('I click on the text {string}', async function (text) {
-    await utils.clickByText(this.page, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.clickByText(this.page, resolvedText);
 });
 When('I click on the text {string} in the {string} region', async function (text, region) {
-    await utils.clickTextInRegion(this.page, text, region);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.clickTextInRegion(this.page, resolvedText, region);
 });
 
 Then('I should see {string} in {string}', async function (value, cssSelector) {
@@ -35,7 +37,8 @@ Then('I should see {string} in {string}', async function (value, cssSelector) {
 });
 
 Then('I should see {string} in {string} region', async function (text, region) {
-    await utils.seeTextInRegion(this.page, text, region);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.seeTextInRegion(this.page, resolvedText, region);
 });
 
 Then('I should see the element with selector {string}', async function (cssSelector) {
@@ -59,13 +62,16 @@ Then('I wait for element with {string} selector to appear within {string} second
     await utils.seeElement(this.page, selector, true, time * 1000);
 });
 Then('I should not see {string}', async function (text) {
-    await utils.notSeeText(this.page, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.notSeeText(this.page, resolvedText);
 });
 Then('I wait for the text {string} to appear within {string} seconds', async function (text, time) {
-    await utils.seeTextByXpath(this.page, text, time * 1000);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.seeTextByXpath(this.page, resolvedText, time * 1000);
 });
 Then('I wait for the text {string} to disappear within {string} seconds', async function (text, time) {
-    await utils.disappearText(this.page, text, time * 1000);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.disappearText(this.page, resolvedText, time * 1000);
 });
 Then('I upload the {string} in {string} field', async function (fileName, cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;
@@ -95,9 +101,10 @@ Then('I select {string} from {string}', async function (value, cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;
     await utils.selectOptionByValue(this.page, selector, value);
 });
-Then('I select text {string} from {string}', async function (value, cssSelector) {
+Then('I select text {string} from {string}', async function (text, cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;
-    await utils.selectOptionByText(this.page, selector, value);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.selectOptionByText(this.page, selector, resolvedText);
 });
 
 Then('I check if link {string} has href {string}', async function (text, href) {
@@ -118,7 +125,8 @@ Then(
 Then(
     'I check if element with text {string} has attribute {string} with {string} value',
     async function (text, attribute, value) {
-        await utils.validateValueOfElementAttributeByText(this.page, text, attribute, value);
+        const resolvedText = this.mlStrings[text] ?? text;
+        await utils.validateValueOfElementAttributeByText(this.page, resolvedText, attribute, value);
     }
 );
 Then('I upload {string} file to dropzone {string} field', async function (file, cssSelector) {
@@ -126,28 +134,34 @@ Then('I upload {string} file to dropzone {string} field', async function (file,
     await utils.uploadToDropzone(this.page, file, selector);
 });
 Then('I should see {string} in the schema markup of the page', async function (text) {
-    await utils.validateTextInSchemaOrg(this.page, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.validateTextInSchemaOrg(this.page, resolvedText);
 });
 Then('I should not see {string} in the schema markup of the page', async function (text) {
-    await utils.validateTextNotInSchemaOrg(this.page, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.validateTextNotInSchemaOrg(this.page, resolvedText);
 });
 Then('I should see {string} in page scripts', async function (text) {
-    await utils.validateTextInScript(this.page, text);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.validateTextInScript(this.page, resolvedText);
 });
 Then('I should {string} see {string} in the {string} accordion', async function (isVisible, text, cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;
     if (isVisible === 'not') {
         isVisible = false;
     }
-    await utils.textVisibilityInAccordion(this.page, selector, text, Boolean(isVisible));
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.textVisibilityInAccordion(this.page, selector, resolvedText, Boolean(isVisible));
 });
 Then('I select the first autocomplete option for {string} on the {string} field', async function (text, cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;
-    await utils.selectOptionFirstAutocomplete(this.page, text, selector);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.selectOptionFirstAutocomplete(this.page, resolvedText, selector);
 });
 Then('I select {string} from chosen {string}', async function (text, cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;
-    await utils.selectOptionFromChosen(this.page, text, selector);
+    const resolvedText = this.mlStrings[text] ?? text;
+    await utils.selectOptionFromChosen(this.page, resolvedText, selector);
 });
 
 Then('I set date {string} in flatpickr with selector {string}', async function (date, cssSelector) {
@@ -186,7 +200,8 @@ Given('I check if checkbox options with locator {string} are not in alphabetical
     await utils.iCheckIfCheckboxOptionsAreInAlphabeticalOrder(this.page, selector, false);
 });
 When('I click on the text {string} and follow the new tab', async function (text) {
-    this.page = await utils.clickLinkOpenNewTab(this.browser, this.page, text, true);
+    const resolvedText = this.mlStrings[text] ?? text;
+    this.page = await utils.clickLinkOpenNewTab(this.browser, this.page, resolvedText, true);
 });
 When('I click on the element {string} and follow the new tab', async function (cssSelector) {
     const selector = this.commonFields[cssSelector] ?? cssSelector;

package/features/app/world.js

@@ -1,5 +1,7 @@
 const { setWorldConstructor, setDefaultTimeout } = require('@cucumber/cucumber');
+const config = require('config');
 const commonFields = require('./commonComponents/commonFields');
+const strings = require('./multilingualStrings/multilingualStrings');
 
 setDefaultTimeout(120 * 1000);
 
@@ -8,10 +10,16 @@ class World {
     constructor({ attach }) {
         this.attach = attach;
         this.commonFields = commonFields;
+        this.enableMlSupport();
     }
 
-    fixSonar() {
-        console.log('Sample function to fix empty class.');
+    enableMlSupport() {
+        const lang = config.has('language') ? config.get('language') : null;
+        if (lang) {
+            this.mlStrings = strings.multilingualStrings(lang) ?? {};
+        } else {
+            this.mlStrings = {};
+        }
     }
 }
 setWorldConstructor(World);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cuppet/core",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "description": "Core testing framework components for Cuppet - BDD framework based on Cucumber and Puppeteer",
     "main": "index.js",
     "files": [

package/src/elementInteraction.js

@@ -169,15 +169,14 @@ module.exports = {
      * Click on the text of a link and expect it to open in a new tab. target="_blank"
      * @param {Browser} browser
      * @param {Page} page
-     * @param value - either text or css selector
+     * @param value - text of link
      * @param xpath - flag, whether to use xpath or not
      * @returns {Promise<Object>}
      */
     clickLinkOpenNewTab: async function (browser, page, value, xpath = true) {
         let objectToClick;
         if (xpath) {
-            const result = await helper.getMultilingualString(value);
-            objectToClick = await page.waitForSelector('xpath/' + `//body//*[text()[contains(.,'${result}')]]`);
+            objectToClick = await page.waitForSelector('xpath/' + `//body//*[text()[contains(.,'${value}')]]`);
         } else {
             objectToClick = await page.waitForSelector(value);
         }
@@ -303,12 +302,11 @@ module.exports = {
      * @returns {Promise<void>}
      */
     validateValueOfElementAttributeByText: async function (page, text, attribute, value) {
-        const result = await helper.getMultilingualString(text);
-        const selector = 'xpath/' + `//body//*[text()[contains(.,'${result}')]]`;
+        const selector = 'xpath/' + `//body//*[text()[contains(.,'${text}')]]`;
         await page.waitForSelector(selector);
         const attrValue = await page.$eval(selector, (el, attribute) => el.getAttribute(attribute), attribute);
         if (value !== attrValue) {
-            throw new Error(`The provided text "${result}" doesn't match element which attribute has value: ${value}.`);
+            throw new Error(`The provided text "${text}" doesn't match element which attribute has value: ${value}.`);
         }
     },
 
@@ -359,7 +357,6 @@ module.exports = {
      * @returns {Promise<void>}
      */
     seeTextByXpath: async function (page, text, time = 6000) {
-        let result = await helper.getMultilingualString(text);
         const options = {
             visible: true, // Wait for the element to be visible (default: false)
             timeout: time, // Maximum time to wait in milliseconds (default: 30000)
@@ -370,9 +367,9 @@ module.exports = {
             });
         }
         try {
-            await page.waitForSelector('xpath/' + `//body//*[text()[contains(.,"${result}")]]`, options);
+            await page.waitForSelector('xpath/' + `//body//*[text()[contains(.,"${text}")]]`, options);
         } catch (error) {
-            throw new Error(`Could not find text : ${result}. The error thrown is: ${error}`);
+            throw new Error(`Could not find text : ${text}. The error thrown is: ${error}`);
         }
     },
 
@@ -385,14 +382,13 @@ module.exports = {
      * @returns {Promise<void>}
      */
     seeTextByElementHandle: async function (page, selector, text) {
-        const result = await helper.getMultilingualString(text);
         await page.waitForSelector(selector);
         let textContent = await page.$eval(selector, (element) => element.textContent.trim());
         if (!textContent) {
             textContent = await page.$eval(selector, (element) => element.value.trim());
         }
-        if (textContent !== result) {
-            throw new Error(`Expected ${result} text, but found ${textContent} instead.`);
+        if (textContent !== text) {
+            throw new Error(`Expected ${text} text, but found ${textContent} instead.`);
         }
     },
 
@@ -406,13 +402,12 @@ module.exports = {
      */
     seeTextInRegion: async function (page, text, region) {
         const regionClass = await helper.getRegion(page, region);
-        const result = await helper.getMultilingualString(text);
         try {
             await page.waitForSelector(
-                'xpath/' + `//*[contains(@class,'${regionClass}') and .//text()[contains(.,"${result}")]]`
+                'xpath/' + `//*[contains(@class,'${regionClass}') and .//text()[contains(.,"${text}")]]`
             );
         } catch {
-            throw new Error(`Cannot find ${result} in ${regionClass}!`);
+            throw new Error(`Cannot find ${text} in ${regionClass}!`);
         }
     },
 
@@ -425,8 +420,7 @@ module.exports = {
      */
     hoverTextInRegion: async function (page, text, region) {
         const regionClass = await helper.getRegion(page, region);
-        const result = await helper.getMultilingualString(text);
-        const selector = 'xpath/' + `//*[@class='${regionClass}']//*[text()='${result}']`;
+        const selector = 'xpath/' + `//*[@class='${regionClass}']//*[text()='${text}']`;
         try {
             const element = await page.waitForSelector(selector);
             const parentElementHandle = await page.evaluateHandle((el) => el.parentElement, element);
@@ -443,8 +437,7 @@ module.exports = {
      * @returns {Promise<void>}
      */
     notSeeText: async function (page, text) {
-        let result = await helper.getMultilingualString(text);
-        const isTextInDom = await page.$('xpath/' + `//*[text()[contains(.,'${result}')]]`);
+        const isTextInDom = await page.$('xpath/' + `//*[text()[contains(.,'${text}')]]`);
         // isVisible() is used for the cases where the text is in the DOM, but not visible
         // If you need to NOT have it in the DOM - use notSeeElement() or extend this step with flag
         const visibility = await isTextInDom?.isVisible();
@@ -461,7 +454,6 @@ module.exports = {
      * @returns {Promise<void>}
      */
     validateTextInField: async function (page, text, selector) {
-        let result = await helper.getMultilingualString(text);
         let value = '';
         await page.waitForSelector(selector);
         try {
@@ -475,8 +467,8 @@ module.exports = {
         } catch (error) {
             throw new Error(error);
         }
-        if (value !== result) {
-            throw new Error(`Value of element ${value} does not match the text ${result}`);
+        if (value !== text) {
+            throw new Error(`Value of element ${value} does not match the text ${text}`);
         }
     },
 
@@ -489,7 +481,6 @@ module.exports = {
      * @returns {Promise<void>}
      */
     textVisibilityInAccordion: async function (page, cssSelector, text, isVisible) {
-        let result = await helper.getMultilingualString(text);
         const el = await page.$(cssSelector);
         if (el) {
             const isShown = await (await page.evaluateHandle((el) => el.clientHeight, el)).jsonValue();
@@ -498,9 +489,9 @@ module.exports = {
             }
             if (isShown) {
                 const textValue = await (await page.evaluateHandle((el) => el.textContent.trim(), el)).jsonValue();
-                if (isVisible && textValue !== result) {
-                    throw new Error(`Element text: ${textValue} does not match the expected: ${result}!`);
-                } else if (!isVisible && textValue === result) {
+                if (isVisible && textValue !== text) {
+                    throw new Error(`Element text: ${textValue} does not match the expected: ${text}!`);
+                } else if (!isVisible && textValue === text) {
                     throw new Error(`Element text: ${textValue} is visible but it should not be!`);
                 }
             }
@@ -518,14 +509,13 @@ module.exports = {
      * @returns {Promise<void>}
      */
     disappearText: async function (page, text, time) {
-        let result = await helper.getMultilingualString(text);
         const options = {
             visible: true, // Wait for the element to be visible (default: false)
             timeout: 250, // 250ms and for that reason time is multiplied by 4 to add up to a full second.
         };
         for (let i = 0; i < time * 4; i++) {
             try {
-                await page.waitForSelector('xpath/' + `//*[text()[contains(.,'${result}')]]`, options);
+                await page.waitForSelector('xpath/' + `//*[text()[contains(.,'${text}')]]`, options);
             } catch {
                 console.log(`Element disappeared in ${time * 4}.`);
                 break;
@@ -543,11 +533,10 @@ module.exports = {
      */
     clickTextInRegion: async function (page, text, region) {
         const regionClass = await helper.getRegion(page, region);
-        const result = await helper.getMultilingualString(text);
         await page.waitForSelector('xpath/' + `//*[@class='${regionClass}']`);
         const elements =
-            (await page.$$('xpath/' + `//*[@class='${regionClass}']//*[text()='${result}']`)) ||
-            (await page.$$('xpath/' + `//*[@class='${regionClass}']//*[contains(text(),'${result}')]`));
+            (await page.$$('xpath/' + `//*[@class='${regionClass}']//*[text()='${text}']`)) ||
+            (await page.$$('xpath/' + `//*[@class='${regionClass}']//*[contains(text(),'${text}')]`));
 
         if (!elements?.[0]) {
             throw new Error('Element not found!');
@@ -608,18 +597,17 @@ module.exports = {
      * Put value in a field. It directly places the text like Ctrl+V(Paste) will do it.
      * @param {Page} page
      * @param selector
-     * @param data
+     * @param text
      * @param skip
      * @returns {Promise<boolean>}
      */
-    fillField: async function (page, selector, data, skip = false) {
-        let result = await helper.getMultilingualString(data);
+    fillField: async function (page, selector, text, skip = false) {
         const skipped = await this.customWaitForSkippableElement(page, selector, skip);
         if (skipped) {
             return true;
         }
         try {
-            await page.$eval(selector, (el, name) => (el.value = name), result);
+            await page.$eval(selector, (el, name) => (el.value = name), text);
             await new Promise(function (resolve) {
                 setTimeout(resolve, 500);
             });
@@ -637,7 +625,6 @@ module.exports = {
      * @returns {Promise<boolean>}
      */
     typeInField: async function (page, selector, text, skip = false) {
-        let result = await helper.getMultilingualString(text);
         const skipped = await this.customWaitForSkippableElement(page, selector, skip);
         if (skipped) {
             return true;
@@ -650,7 +637,7 @@ module.exports = {
                 setTimeout(resolve, 150);
             });
             try {
-                await page.type(selector, result, { delay: 250 });
+                await page.type(selector, text, { delay: 250 });
             } catch (error) {
                 throw new Error(`Cannot type into field due to ${error}`);
             }
@@ -745,14 +732,13 @@ module.exports = {
      * @returns {Promise<void>}
      */
     selectOptionByText: async function (page, selector, text) {
-        let result = await helper.getMultilingualString(text);
         await page.waitForSelector(selector);
-        const objectToSelect = await page.$('xpath/' + `//body//*[contains(text(), '${result}')]`);
+        const objectToSelect = await page.$('xpath/' + `//body//*[contains(text(), '${text}')]`);
         if (objectToSelect) {
             const value = await (await objectToSelect.getProperty('value')).jsonValue();
             await page.select(selector, value);
         } else {
-            throw new Error(`Could not find option with text: ${result}`);
+            throw new Error(`Could not find option with text: ${text}`);
         }
     },
 
@@ -894,18 +880,17 @@ module.exports = {
      * Sets value into codemirror field
      * @param {Page} page
      * @param cssSelector
-     * @param value
+     * @param text
      * @returns {Promise<void>}
      */
-    setValueInCodeMirrorField: async function (page, cssSelector, value) {
-        let result = await helper.getMultilingualString(value);
+    setValueInCodeMirrorField: async function (page, cssSelector, text) {
         await page.waitForSelector(cssSelector);
         try {
             const jsCode = `
             (function () {
                 const textArea = document.querySelector('${cssSelector}');
                 let editor = CodeMirror.fromTextArea(textArea);
-                editor.getDoc().setValue("${result}");
+                editor.getDoc().setValue("${text}");
             })();
             `;
             await page.evaluate(jsCode);

package/src/helperFunctions.js

@@ -43,23 +43,6 @@ module.exports = {
         await page.waitForFunction(jsCode);
     },
 
-    /**
-     * Returns the translated variant of the inputted text or the text itself if there isn't a translation.
-     * @param text
-     * @returns {Promise<string>}
-     */
-    getMultilingualString: async function (text) {
-        const lang = config.has('language') ? config.get('language') : null;
-        let result;
-        if (lang) {
-            let string = strings.multilingualStrings(lang, text);
-            result = string ?? text;
-        } else {
-            result = text;
-        }
-        return result;
-    },
-
     /**
      * Retrieves the class name of an element based on a property in the config json.
      * You can set directly the full class, partial or ID, but mind that it always resolves to