@sap_oss/wdio-qmate-service 1.0.0

package/test/core/dataExchange/specs/import.spec.js

@@ -0,0 +1,144 @@
+/** 
+ * Regression testing of data import, checks if data loaded into browser.params.import
+ * match the actual data in the files. 
+ */
+
+// using chai assertion framework in this spec (instead of the default which is "jest"),
+// since jest is not available inside the outer "describe" block
+const { assert } = require("chai");
+
+const utils = require("../utils.js");
+
+describe("Import Data", function () {
+
+  // load the actual files for comparison against data imported by import, export module in
+  // importExportData.js 
+  // Refer to config.import.js
+  // params : {
+  //   import: {            // Verzeichnis Pfad             
+  //     myFolder1: "./data/my/folder/data/qs9",
+  //     myFolder2: "data/another/folder/data/anotherFolder",
+  //     myMissingFolder: "./data/my/folder/missing",
+  //     // Eine Datei Pfad (Best Practice should be the same as the script) .....             
+  //     yourPrefixSpecName: "./data/my/folder/data/qs9/data.json",
+  //     missingFile: "./data/my/folder/missingFile.json",
+  //     invalidJsonFile: "./data/my/folder/invalid.json",
+  //     uiUser: "./data/my/folder/data/qs9/webUser.json",
+  //     emptyObject: "./data/my/folder/data/qs9/empty.json"
+  //   },
+  // }
+  const myFolder1 = "./data/my/folder/data/qs9";
+  const myFolder2 = "data/another/folder/data/anotherFolder";
+  const yourPrefixSpecName = "./data/my/folder/data/qs9/data.json";
+  const uiUser = "./data/my/folder/data/qs9/webUser.json";
+
+  // regression test to check that data has been imported in 
+  // beforeSession hook
+  // check if data is available in "describe" and not in "it" block
+  assert(browser.params.import.myFolder1, "myFolder1 not imported");
+  assert(browser.params.import.myFolder2, "myFolder2 not imported");
+
+  it("step 1: check presence of import config params", async function () {
+
+    // folders and valid json files should be loaded
+    // missing or inaccessible folders, non-json files, and invalid json files
+    // should not be loaded
+    await common.assertion.expectDefined(browser.params.import.myFolder1);
+    await common.assertion.expectDefined(browser.params.import.myFolder2);
+    await common.assertion.expectUndefined(browser.params.import.myMissingFolder);
+    await common.assertion.expectDefined(browser.params.import.yourPrefixSpecName);
+    await common.assertion.expectUndefined(browser.params.import.missingFile);
+    await common.assertion.expectUndefined(browser.params.import.invalidJsonFile);
+    await common.assertion.expectDefined(browser.params.import.uiUser);
+    await common.assertion.expectEqual(browser.params.import.emptyObject === null, true);
+
+  });
+
+  it("step 2: check if files in 'myFolder1' folder are read", async function () {
+    // check if json files and subfolders in myFolder1 (i.e. "./data/my/folder/data/qs9")
+    // are read and added to browser.params.import.myFolder1
+    await utils.checkImportFolder(myFolder1, "myFolder1");
+
+  });
+
+  it("step 3: check if files in 'myFolder2' folder are read", async function () {
+    // check if json files and subfolders in myFolder2 (i.e. "data/another/folder/data/anotherFolder")
+    // are read and added to browser.params.import.myFolder2
+    await utils.checkImportFolder(myFolder2, "myFolder2");
+
+  });
+  it("step 4: check imported data from 'myFolder1'", async function () {
+    // check if json data in  file purchaseRequisition.json in myFolder1 (i.e. "./data/my/folder/data/qs9")
+    // has been read and added to browser.params.import.myFolder1.purchaseRequisition
+    await utils.checkImportedData(myFolder1, ["myFolder1"], "purchaseRequisition");
+
+  });
+  it("step 5: check imported data from 'myFolder2'", async function () {
+    // check if json data in  file purchaseRequisition_HI.json in myFolder2 (i.e. "data/another/folder/data/anotherFolder")
+    // has been read and added to browser.params.import.myFolder2.purchaseRequisition_HI
+    await utils.checkImportedData(myFolder2, ["myFolder2"], "purchaseRequisition_HI");
+
+  });
+  it("step 6: check imported data for file 'yourPrefixSpecName'", async function () {
+    // check if json data in  file pointed to by "yourPrefixSpecName" (i.e. "./data/my/folder/data/qs9/data.json")
+    // has been read and added to browser.params.import.yourPrefixSpecName
+    await utils.checkImportedDataFromFile(yourPrefixSpecName, "yourPrefixSpecName");
+
+  });
+  it("step 7: check imported data for file 'uiUser'", async function () {
+    // check if json data in  file pointed to by "uiUser" (i.e. "./data/my/folder/data/qs9/webUser.json")
+    // has been read and added to browser.params.import.uiUser
+    await utils.checkImportedDataFromFile(uiUser, "uiUser");
+
+  });
+  it("step 8: check invalid json is not loaded", async function () {
+    await common.assertion.expectUndefined(browser.params.import["invalidJsonFile"]);
+
+  });
+  it("step 9: check missing file is not loaded", async function () {
+    await common.assertion.expectUndefined(browser.params.import["missingFile"]);
+
+  });
+  it("step 10: check missing folder is not loaded", async function () {
+    await common.assertion.expectUndefined(browser.params.import["missingFolder"]);
+
+  });
+  it("step 11: check files in subfolder are loaded", async function () {
+    // check if data in LimitPurchaseOrder.json in subfolder "data/another/folder/data/anotherFolder/subfolder" has
+    // been read and is available in browser.params.import.myFolder2.subfolder.LimitPurchaseOrder
+    await utils.checkImportedData(myFolder2, ["myFolder2", "subfolder"], "LimitPurchaseOrder");
+
+    // check if data in PurchaseOrderWithScheduline.json in subfolder "data/another/folder/data/anotherFolder/subfolder" has
+    // been read and is available in browser.params.import.myFolder2.subfolder.PurchaseOrderWithScheduline
+    await utils.checkImportedData(myFolder2, ["myFolder2", "subfolder"], "PurchaseOrderWithScheduline");
+
+  });
+
+  it("step 12: check if JSON file with array is loaded", async function () {
+    // check if data in PurchaseOrderItems.json in subfolder "data/another/folder/data/anotherFolder/subfolder" has
+    // been read and is available in browser.params.import.myFolder2.subfolder.PurchaseOrderItems
+    await utils.checkImportedData(myFolder2, ["myFolder2", "subfolder"], "PurchaseOrderItems");
+
+    // check if this is an array
+    const poItems = browser.params.import.myFolder2.subfolder.PurchaseOrderItems;
+    await common.assertion.expectEqual(Array.isArray(poItems), true);
+  });
+
+  it("step 13: check if subfolders with special characters in their names are loaded", async function () {
+
+    await common.assertion.expectDefined(browser.params.import.myFolder2["purchase-orders"]);
+
+  });
+  it("step 14: check files with special characters in their names are loaded", async function () {
+    // check if data in Limit-Purchase-Order.json in subfolder "data/another/folder/data/anotherFolder/purchase-orders" has
+    // been read and is available in browser.params.import.myFolder2["purchase-orders"]["Limit-Purchase-Order"]
+    await utils.checkImportedData(myFolder2, ["myFolder2", "purchase-orders"], "Limit-Purchase-Order");
+
+    // check if data in ServicePurchaseOrder.2Items.json in subfolder "data/another/folder/data/anotherFolder/purchase-orders" has
+    // been read and is available in browser.params.import.myFolder2["purchase-orders"]["ServicePurchaseOrder.2Items"]
+
+    await utils.checkImportedData(myFolder2, ["myFolder2", "purchase-orders"], "ServicePurchaseOrder.2Items");
+
+  });
+
+});

package/test/core/dataExchange/specs/importExport.spec.js

@@ -0,0 +1,196 @@
+/**
+ * Regression testing 
+ * Use imported data to fill forms, and export test data
+ */
+const formUtils = {
+  textSelector: {
+    "elementProperties": {
+      "viewName": "sap.m.sample.InputTypes.V",
+      "metadata": "sap.m.Input",
+      "type": "Text"
+    }
+  },
+  emailSelector: {
+    "elementProperties": {
+      "viewName": "sap.m.sample.InputTypes.V",
+      "metadata": "sap.m.Input",
+      "type": "Email"
+    }
+  },
+  telephoneSelector: {
+    "elementProperties": {
+      "viewName": "sap.m.sample.InputTypes.V",
+      "metadata": "sap.m.Input",
+      "type": "Tel"
+    }
+  },
+  numberSelector: {
+    "elementProperties": {
+      "viewName": "sap.m.sample.InputTypes.V",
+      "metadata": "sap.m.Input",
+      "type": "Number"
+    }
+  },
+  urlSelector: {
+    "elementProperties": {
+      "viewName": "sap.m.sample.InputTypes.V",
+      "metadata": "sap.m.Input",
+      "type": "Url"
+    }
+  },
+  fillForm: async function (description, userData) {
+    await ui5.element.waitForAll(this.textSelector);
+    await ui5.userInteraction.fill(this.textSelector, description);
+    await ui5.userInteraction.fill(this.emailSelector, userData.email);
+    await ui5.userInteraction.fill(this.telephoneSelector, userData.telephone);
+    await ui5.userInteraction.fill(this.numberSelector, userData.amount);
+    await ui5.userInteraction.fill(this.urlSelector, userData.website);
+  },
+  clearForm: async function () {
+    await ui5.userInteraction.clear(this.textSelector);
+    await ui5.userInteraction.clear(this.emailSelector);
+    await ui5.userInteraction.clear(this.telephoneSelector);
+    await ui5.userInteraction.clear(this.numberSelector);
+    await ui5.userInteraction.clear(this.urlSelector);
+  }
+};
+
+
+describe("Import and Export using UI", function () {
+
+
+  // config params
+  // import: {           //import data            
+  //   myUserPrefix: "./data/ui/user.json",
+  //   userDataFolder: "./data/ui",
+  //   uiUser: "./data/ui/webUser.json",
+  // },
+  // export: {             //Export             
+  //   exportData: "./data/ui/export/exportedUser.json",
+  //   webUser : "./data/ui/export/exportedWebUser.json"
+  // }, 
+  it("step 1: use data loaded into myUserPrefix", async function () {
+
+    // uses data from file pointed to by myUserPrefix
+    //   myUserPrefix: "./data/ui/user.json",
+    await ui5.navigation.navigateToApplication("", false);
+    const acceptCookiesButton = {
+      "elementProperties": {
+        "viewName": "sap.ui.documentation.sdk.view.App",
+        "metadata": "sap.m.Button",
+        "text": [{
+          "path": "i18n>COOKIE_SETTINGS_DIALOG_FUNCTIONAL_COOKIES_ACCEPT_ALL"
+        }]
+      }
+    };
+    try {
+      await ui5.userInteraction.click(acceptCookiesButton);
+    } catch (e) {
+      // ignore, no cookie dialog
+    }
+    await nonUi5.element.switchToIframe("iframe[id='sampleFrame']");
+
+    const userData = browser.params.import.myUserPrefix;
+    await common.assertion.expectDefined(userData);
+
+    await common.assertion.expectDefined(userData.email);
+    await common.assertion.expectDefined(userData.telephone);
+    await common.assertion.expectDefined(userData.amount);
+    await common.assertion.expectDefined(userData.website);
+
+    await formUtils.fillForm("Data from myUserPrefix", userData);
+
+    await formUtils.clearForm();
+
+  });
+
+  it("step 2: use data loaded from file in subfolder moreDataFolder - anotherUser.json", async function () {
+
+    // file anotherUser.json is in subfolder "moreDataFolder" within directory pointed to by userDataFolder
+    //   userDataFolder: "./data/ui",
+    const userDataFolder = browser.params.import.userDataFolder;
+    await common.assertion.expectDefined(userDataFolder);
+    const moreDataFolder = browser.params.import.userDataFolder.moreDataFolder;
+    await common.assertion.expectDefined(moreDataFolder);
+    const anotherUser = browser.params.import.userDataFolder.moreDataFolder.anotherUser;
+    await common.assertion.expectDefined(anotherUser);
+
+    await common.assertion.expectDefined(anotherUser.email);
+    await common.assertion.expectDefined(anotherUser.telephone);
+    await common.assertion.expectDefined(anotherUser.amount);
+    await common.assertion.expectDefined(anotherUser.website);
+
+    await formUtils.fillForm("Data from anotherUser.json in moreDataFolder", anotherUser);
+
+    await formUtils.clearForm();
+
+  });
+  it("step 3: use data loaded into uiUser", async function () {
+
+    // uses data from file pointed to by reference
+    //   uiUser: "./data/ui/webUser.json"
+    const userData = browser.params.import.uiUser;
+    await common.assertion.expectDefined(userData);
+
+    await common.assertion.expectDefined(userData.email);
+    await common.assertion.expectDefined(userData.telephone);
+    await common.assertion.expectDefined(userData.amount);
+    await common.assertion.expectDefined(userData.website);
+
+    await formUtils.fillForm("Data from uiUser", userData);
+
+    await formUtils.clearForm();
+
+  });
+
+  it("step 4: export data into file pointed to by exportData param", async function () {
+
+    const dateAdded = (new Date()).toISOString();
+    const userData = {
+      "exportedOn": dateAdded,
+      "description": "Should be in file export/exportedUser.json",
+      "email": "joe.exported@example.com",
+      "telephone": "11-2233445566",
+      "amount": 458,
+      "website": "http://www.exportedUser.test"
+
+    };
+
+    // assign the data to export param so that it gets written to file pointed to by "exportData"
+    //   exportData: "./data/ui/export/exportedUser.json",
+    browser.params.export.exportData = userData;
+
+    await common.assertion.expectDefined(browser.params.export.exportData.description);
+    await common.assertion.expectDefined(browser.params.export.exportData.email);
+    await common.assertion.expectDefined(browser.params.export.exportData.telephone);
+    await common.assertion.expectDefined(browser.params.export.exportData.amount);
+    await common.assertion.expectDefined(browser.params.export.exportData.website);
+
+  });
+
+  it("step 5: export data into file pointed to by webUser param", async function () {
+
+
+    const dateAdded = (new Date()).toISOString();
+    const userData = {
+      "exportedOn": dateAdded,
+      "description": "Should be in file export/exportedWebUser.json",
+      "email": "joe.webuser@example.com",
+      "telephone": "333-000-111-222",
+      "amount": 4.79,
+      "website": "http://www.webuser.test"
+
+    };
+    // assign the data to export param so that it gets written to file pointed to by "refUser"
+    //   webUser : "./data/ui/export/exportedWebUser.json"
+    browser.params.export.webUser = userData;
+
+    await common.assertion.expectDefined(browser.params.export.webUser.description);
+    await common.assertion.expectDefined(browser.params.export.webUser.email);
+    await common.assertion.expectDefined(browser.params.export.webUser.telephone);
+    await common.assertion.expectDefined(browser.params.export.webUser.amount);
+    await common.assertion.expectDefined(browser.params.export.webUser.website);
+
+  });
+
+});

package/test/core/dataExchange/utils.js

@@ -0,0 +1,160 @@
+/* eslint-disable no-console */
+const fs = require("fs-extra");
+const path = require("path");
+const dataExchangeUtil = require("../../../lib/scripts/dataExchange/dataExchangeUtil");
+
+/** 
+ * Utility functions for regression testing of import and export of data.
+ * These read data from folders and files, and check against imported data.
+ * Or make data from file available for export.
+ * 
+ */
+const utilsMethods = {
+
+  /**
+   * @function checkImportFolder - check if json files and subfolders in specified folderPath
+   *    have been imported under the specified key.
+   * @param {string} folderPath - the folder to read
+   * @param {string} paramName - the key to check against
+   * @example const myFolder1 = "./data/my/folder/data/qs9";
+   * await utils.checkImportFolder(myFolder1, "myFolder1");
+   *  
+   */
+  checkImportFolder: async function (folderPath, paramName) {
+    folderPath = dataExchangeUtil.getFileAbsPath(folderPath);
+    let files = [];
+    try {
+      files = await fs.readdir(folderPath, { withFileTypes: true });
+    } catch (err) {
+      console.error(err);
+      await common.assertion.expectEqual(true, false);
+    }
+    // filter out json files
+    const jsonFiles = files.filter((file) => !file.isDirectory() && file.name.match(/\.json$/) !== null);
+    const jsonFilePrefixes = jsonFiles.map(file => file.name.replace(/^(.*)\.json$/, "$1"));
+    const nonJsonFiles = files.filter((file) => !file.isDirectory() && file.name.match(/\.json$/) === null);
+    const nonJsonFilePrefixes = nonJsonFiles.map(file => file.name.replace(/^(.*)\.*$/, "$1"));
+
+    // get the subfolders
+    let subfolders = files.filter((file) => file.isDirectory());
+    subfolders = subfolders.map(file => file.name);
+
+    // check if the json files have been loaded into browser.params.import
+    const browserParamKeys = Object.keys(browser.params.import[paramName]);
+
+    for (let i = 0; i < jsonFilePrefixes.length; i++) {
+      const prefix = jsonFilePrefixes[i];
+      await common.assertion.expectUnequal(browserParamKeys.indexOf(prefix), -1);
+    }
+
+    // check if non json files are absent in browser.params.import
+    for (let i = 0; i < nonJsonFilePrefixes.length; i++) {
+      const prefix = nonJsonFilePrefixes[i];
+      await common.assertion.expectEqual(browserParamKeys.indexOf(prefix), -1);
+    }
+
+    //check if subfolders are present
+    for (let i = 0; i < subfolders.length; i++) {
+      const folder = subfolders[i];
+      await common.assertion.expectUnequal(browserParamKeys.indexOf(folder), -1);
+    }
+  },
+
+  /**
+   * @function checkImportedData - check if data from json file specified by jsonFilePrefix under
+   * folderPath has been added using the params key. In the example below data from 
+   * "./data/my/folder/data/qs9/subfolder/LimitPurchaseOrder.json" is checked if present in
+   * browser.params.import.myFolder1.subfolder.LimitPurchaseOrder
+   * @param {string} folderPath - the folder path
+   * @param {string[]} params - array of keys
+   * @param {string} jsonFilePrefix - the prefix of json file.
+   * @example const myFolder1 = "./data/my/folder/data/qs9";
+   * await utils.checkImportedData(myFolder1, ["myFolder1","subfolder"], "LimitPurchaseOrder");
+   */
+  checkImportedData: async function (folderPath, params, jsonFilePrefix) {
+    folderPath = dataExchangeUtil.getFileAbsPath(folderPath);
+
+    //include subfolders
+    params.forEach((param, idx) => {
+      if (idx > 0) folderPath = path.resolve(folderPath, param);
+    });
+    const fileWithPath = path.resolve(folderPath, jsonFilePrefix + ".json");
+    let data;
+    try {
+      data = await dataExchangeUtil.readJson(fileWithPath);
+    } catch (err) {
+      console.error(err);
+      await common.assertion.expectEqual(true, false);
+    }
+
+    let importedData = browser.params.import;
+    params.forEach(param => {
+      importedData = importedData[param] || {};
+    });
+    //check if the json files have been loaded into browser.params.import
+    importedData = importedData[jsonFilePrefix];
+    //can't find a method in ui5.assertion to check if two JSON objects match
+    // await common.assertion.expectEqual(importedData, data);
+    await expect(importedData).toEqual(data);
+
+  },
+  /**
+   * @function checkImportedDataFromFile - check if data from specified file is available under
+   * the specified key
+   * @param {string} fileWithPath - file with path
+   * @param {string} paramName - the key to use
+   * @example const yourPrefixSpecName = "./data/my/folder/data/qs9/data.json";
+   * await await utils.checkImportedDataFromFile(yourPrefixSpecName, "yourPrefixSpecName");
+   */
+  checkImportedDataFromFile: async function (fileWithPath, paramName) {
+    fileWithPath = dataExchangeUtil.getFileAbsPath(fileWithPath);
+
+    let data;
+    try {
+      data = await dataExchangeUtil.readJson(fileWithPath);
+    } catch (err) {
+      console.error(err);
+      await common.assertion.expectEqual(true, false);
+    }
+
+    //check if the json files have been loaded into browser.params.import
+    const importedData = browser.params.import[paramName];
+    // await common.assertion.expectEqual(importedData, data);
+    await expect(importedData).toEqual(data);
+
+  },
+
+  /**
+   * @function exportData - copy data in json file specified by jsonFilePrefix, in specifed folderPath
+   * to browser.params.export under key specified by exportParamName
+   * @param {string} folderPath - the folder path
+   * @param {string} jsonFilePrefix - the json file prefix
+   * @param {string} exportParamName - the key to use. In the example below, browser.params.export.exportMoreData
+   * will have data from "./data/my/folder/data/anotherFolder/subfolder/ServicePurchaseOrder.json", which
+   * at the end of the test run will be written to "./data/my/folder/path/in/moreDataFile.json"
+   * @example const exportMoreData = "./data/my/folder/path/in/moreDataFile.json";
+   * const subfolder = "./data/my/folder/data/anotherFolder/subfolder";
+   * await utils.exportData(subfolder, "ServicePurchaseOrder", "exportMoreData");
+   */
+  exportData: async function (folderPath, jsonFilePrefix, exportParamName) {
+    folderPath = dataExchangeUtil.getFileAbsPath(folderPath);
+
+    const fileWithPath = path.resolve(folderPath, jsonFilePrefix + ".json");
+    let data;
+    try {
+      data = await dataExchangeUtil.readJson(fileWithPath);
+    } catch (err) {
+      console.error(err);
+      await common.assertion.expectEqual(true, false);
+    }
+
+    // assign data to browser.params.export, so that it gets written to export file
+    // at end of test. 
+    // make sure any other data previously in browser.params.export 
+    // against the specified key are not lost,
+    // unless you really don't  want them
+    browser.params.export[exportParamName] = { ...browser.params.export[exportParamName], ...data };
+
+  }
+};
+module.exports = utilsMethods;

package/test/core/functional/README.md

@@ -0,0 +1,30 @@
+# Functional tests
+
+### Main goals of *tests/qmate/functional* test folder is to cover [Qmate WDIO API](../../documentation/topics/locators.md) with tests:
+
+- Test locators and how we can access locators via `browser.uiControl()` and `browser.uiControls()`.
+- Test all methods (custom commands) from [scripts/hooks/utils/addLocatorCommands.js](../../scripts/hooks/utils/locatorCommands.js) (`getUi5Aggregation()`, `getProperties()` etc.)
+- Test corner cases (provide wrong 'elementProperties', try to enter a value to a label, try to click non-clickable element etc.) to check error handling inside custom commands
+
+#### /locators:
+
+- Test only selectors (locators) - `uiControl()` method
+- Try all combinations of `elementProperties`, `ancestorProperties`, `descendantProperties` etc.
+
+#### /ui5Properties:
+
+- Test custom commands: `getUi5Aggregation()`, `getUi5Properties()` etc. on both element and browser levels
+
+#### /chaining:
+
+- Test chaining (work on both browser and element levels):
+```js
+    const list = await browser.uiControl(ui5ControlProperties);
+    const firstIitem = await list.uiControl(ui5ControlProperties2, 0);
+``` 
+
+#### /nonUi5:
+- access UI elements via DOM properties (id, class, li etc.)
+
+#### /nativeBrowser:
+- test method `controlActionInBrowser`

package/test/core/functional/chaining/chaining.test.js

@@ -0,0 +1,137 @@
+"use strict";
+describe("webdriver.io page", function () {
+
+  this.beforeAll(async () => {
+    await browser.url("#/categories");
+  });
+
+  it("step 0:click on item Accessories - Use array controls", async function () {
+    const ui5ControlProperties = {
+      "elementProperties": { "metadata": "sap.m.List", "items": [{ "path": "/ProductCategories" }] },
+      "parentProperties": { "metadata": "sap.m.Page", "title": [{ "path": "i18n>homeTitle" }] }
+    };
+    const ui5ControlProperties2 = {
+      "elementProperties": {
+        "metadata": "sap.m.StandardListItem",
+        "title": [{ "path": "CategoryName" }],
+        "bindingContextPath": "/ProductCategories*"
+      }
+    };
+
+    const list = await browser.uiControl(ui5ControlProperties);
+    const allItems = await list.uiControls(ui5ControlProperties2);
+
+    expect(allItems).toBeInstanceOf(Array);
+    await expect(allItems[0]).toBeDisplayed();
+    await allItems[0].click();
+  });
+
+  it("step 1:navigate back to main page", async function () {
+    const ui5ControlProperties = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Category",
+        "metadata": "sap.ui.core.Icon",
+        "id": "*page-navButton-iconBtn"
+      }
+    };
+    const backToListBtn = await browser.uiControl(ui5ControlProperties);
+    await expect(backToListBtn).toBeClickable();
+    await backToListBtn.click();
+  });
+
+  it("step 2:click on item Accessories - Use control and index", async function () {
+    const ui5ControlProperties = {
+      "elementProperties": { "metadata": "sap.m.List", "items": [{ "path": "/ProductCategories" }] },
+      "parentProperties": { "metadata": "sap.m.Page", "title": [{ "path": "i18n>homeTitle" }] }
+    };
+    const ui5ControlProperties2 = {
+      "elementProperties": {
+        "metadata": "sap.m.StandardListItem",
+        "title": [{ "path": "CategoryName" }],
+        "bindingContextPath": "/ProductCategories*"
+      }
+    };
+    const list = await browser.uiControl(ui5ControlProperties);
+    const item1 = await list.uiControl(ui5ControlProperties2, 0);
+    const item2 = await list.uiControl(ui5ControlProperties2, 1);
+    // expect(ui5ControlProperties2).toBeInstanceOf(Object); use check for  item1?
+    await expect(await item1.getAttribute("id")).not.toBeNull();
+    await expect(await item2.getAttribute("id")).not.toBeNull();
+    await item2.click();
+  });
+
+  it("step 3:click on item Accessories - Use control and index", async function () {
+    const ui5ControlProperties = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Category",
+        "metadata": "sap.m.Page",
+        "id": "*page"
+      }
+    };
+    const ui5ControlProperties2 = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Category",
+        "metadata": "sap.m.ObjectListItem",
+        "bindingContextPath": "/Products*'HT-1114')"
+      }
+    };
+    const ui5ControlProperties3 = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Category",
+        "metadata": "sap.m.Button",
+        "id": "*page-navButton"
+      }
+    };
+    const productList = await browser.uiControl(ui5ControlProperties);
+    const item = await productList.uiControl(ui5ControlProperties2);
+    const backButton = await productList.uiControl(ui5ControlProperties3);
+    await expect(await item.getAttribute("id")).not.toBeNull();
+    await item.click();
+    await expect(backButton).toBeDisplayedInViewport();
+    await expect(await backButton.getAttribute("id")).not.toBeNull();
+    await backButton.click();
+
+  });
+
+  it("step 4:fill search field in Categories - Use control and index", async function () {
+    const ui5ControlProperties = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Home",
+        "metadata": "sap.m.Toolbar",
+        "id": "*searchBar33343"
+      }
+    };
+    const ui5ControlProperties2 = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Home",
+        "metadata": "sap.m.SearchField",
+        "id": "*searchField"
+      }
+    };
+    const list = await browser.uiControl(ui5ControlProperties);
+    const item1 = await list.uiControl(ui5ControlProperties2, 0);
+    await expect(await item1.getAttribute("id")).not.toBeNull();
+    // item1.setValue("ABCDEF"); async code without await
+    // await common.userInteraction.pressEnter(); // we cannot use reuse
+  });
+
+  it("step 5:fill wrong element and catch error - Use control and index", async function () {
+    const ui5ControlProperties = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Home",
+        "metadata": "sap.m.Toolbar",
+        "id": "*searchBar33343"
+      }
+    };
+    const ui5ControlWrongProperties = {
+      "elementProperties": {
+        "viewName": "sap.ui.demo.cart.view.Home",
+        "metadata": ".m.SearchField",
+        "id": "*"
+      }
+    };
+    const list = await browser.uiControl(ui5ControlProperties);
+    await expect(list.uiControl(ui5ControlWrongProperties, 0))
+      .rejects.toThrowError(/uiControlExecuteLocator\(\): No visible elements found/);
+  });
+});