token-wizard-test-automation/pages/ManagePage.js

517 lines
16 KiB
JavaScript

const logger = require('../entity/Logger.js').logger;
const key = require('selenium-webdriver').Key;
const By = require('selenium-webdriver/lib/by').By;
const Page = require('./Page.js').Page;
const buttonOk = By.xpath("/html/body/div[2]/div/div[3]/button[1]");
const modal = By.className("modal");
const Utils = require('../utils/Utils.js').Utils;
const adj = "";
const buttonFinalize = By.xpath("//*[contains(text(),'Finalize Crowdsale')]");
const buttonYesFinalize = By.className("swal2-confirm swal2-styled");
const buttonSave = By.className("no_arrow button button_fill");
const warningEndTimeTier1 = By.xpath("//*[@id=\"root\"]/div/" + adj + "section/div[3]/div/div[2]/div[2]/div[2]/p[2]");
const warningEndTimeTier2 = By.xpath("//*[@id=\"root\"]/div/" + adj + "section/div[4]/div/div[1]/div[2]/div[2]/p[2]");
const warningStartTimeTier2 = By.xpath("//*[@id=\"root\"]/div/" + adj + "section/div[4]/div/div[1]/div[2]/div[1]/p[2]");
const warningStartTimeTier1 = By.xpath("//*[@id=\"root\"]/div/" + adj + "section/div[4]/div/div[2]/div[2]/div[1]/p[2]");
const fieldsReservedTokensAddress = By.className("reserved-tokens-item reserved-tokens-item-left");
const whitelistContainer = By.className("white-list-container");
const fieldMinCap = By.id("minCap");
const contentContainer = By.className("steps-content container");
class ManagePage extends Page {
constructor(driver, crowdsale) {
super(driver);
this.URL;
this.name = "Manage page: ";
this.crowdsale = crowdsale;
this.fieldNameTier = [];
this.fieldWalletAddressTier = [];
this.fieldStartTimeTier = [];
this.fieldEndTimeTier = [];
this.fieldRateTier = [];
this.fieldSupplyTier = [];
this.fieldWhAddressTier = [];
this.fieldMinTier = [];
this.fieldMaxTier = [];
this.buttonAddWh = [];
this.buttonFinalize;
this.buttonSave;
this.fieldWhAddress = [];
this.fieldWhMin = [];
this.fieldWhMax = [];
}
async initWhitelistFields() {
logger.info(this.name + "initWhitelistFields ");
try {
let arrayWh = await this.findWithWait(whitelistContainer);
if (arrayWh === null) return null;
let array;
for (let i = 0; i < arrayWh.length; i++) {
array = await this.getChildFromElementByClassName("input", arrayWh[i]);
if (array !== null) {
this.fieldWhAddress[i] = array[0];
this.fieldWhMin[i] = array[1];
this.fieldWhMax[i] = array[2];
}
}
return arrayWh;
}
catch (err) {
logger.info("Error: " + err);
return null;
}
}
async initButtonSave() {
logger.info(this.name + "initButtonSave ");
try {
let locator = By.className("no_arrow");
let array = await super.findWithWait(locator);
this.buttonSave = array [0];
return array;
}
catch (err) {
logger.info("Error: " + err);
return null;
}
}
async initButtonFinalize() {
logger.info(this.name + "initButtonFinalize ");
try {
let locator = By.className("button");
let array = await super.findWithWait(locator);
this.buttonFinalize = array [0];
return array;
}
catch (err) {
logger.info("Error: " + err);
return null;
}
}
async initButtons() {
logger.info(this.name + "initButtons ");
try {
let locator = By.className("button button_fill button_fill_plus");
let array = await super.findWithWait(locator);
for (let i = 0; i < array.length; i++)
this.buttonAddWh[i] = array[i];
return array;
}
catch (err) {
logger.info("Error: " + err);
return null;
}
}
async initInputs() {
logger.info(this.name + "initInputs ");
try {
let locator = By.className("input");
let array = await super.findWithWait(locator);
let amountTiers = 1;
let tierLength = 6;
if (array.length > 9) {
amountTiers = 2;
}
if ((array.length > 15) || (array.length == 9)) tierLength = 9;
for (let i = 0; i < amountTiers; i++) {
this.fieldNameTier[i] = array[i * tierLength + 0];
this.fieldWalletAddressTier[i] = array[i * tierLength + 1];
this.fieldStartTimeTier[i] = array[i * tierLength + 2];
this.fieldEndTimeTier[i] = array[i * tierLength + 3];
this.fieldRateTier[i] = array[i * tierLength + 4];
this.fieldSupplyTier[i] = array[i * tierLength + 5];
this.fieldWhAddressTier[i] = undefined;
this.fieldMinTier[i] = undefined;
this.fieldMaxTier[i] = undefined;
if ((tierLength == 9) || (tierLength == 18)) {
this.fieldWhAddressTier[i] = array[i * tierLength + 6];
this.fieldMinTier[i] = array[i * tierLength + 7];
this.fieldMaxTier[i] = array[i * tierLength + 8];
}
}
if (array.length == 15) {
this.fieldWhAddressTier[1] = array[12];
this.fieldMinTier[1] = array[13];
this.fieldMaxTier[1] = array[14];
}
return array;
}
catch (err) {
logger.info("Error: " + err);
return null;
}
}
async getNameTier(tier) {
logger.info(this.name + "getNameTier ");
if (await this.initInputs() === null) return "";
else
return await super.getAttribute(this.fieldNameTier[tier - 1], "value");
}
async isDisabledNameTier(tier) {
logger.info(this.name + "isDisabledNameTier ");
return (await this.initInputs() !== null)
&& await this.isElementDisabled(this.fieldNameTier[tier - 1]);
}
async getWalletAddressTier(tier) {
logger.info(this.name + "getWalletAddressTier ");
if (await this.initInputs() === null) return null;
else
return await super.getAttribute(this.fieldWalletAddressTier[tier - 1], "value");
}
async isDisabledWalletAddressTier(tier) {
logger.info(this.name + "isDisabledWalletAddressTier ");
if (await this.initInputs() === null) return null;
else
return await this.isElementDisabled(this.fieldWalletAddressTier[tier - 1]);
}
async isDisabledEndTime(tier) {
logger.info(this.name + "isDisabledEndTime ");
if (await this.initInputs() === null) return null;
else
return await this.isElementDisabled(this.fieldEndTimeTier[tier - 1]);
}
async getRateTier(tier) {
logger.info(this.name + "getRateTier ");
if (await this.initInputs() === null) return null;
else
return await super.getAttribute(this.fieldRateTier[tier - 1], "value");
}
async getSupplyTier(tier) {
logger.info(this.name + "getSupplyTier ");
if (await this.initInputs() === null) return null;
else
return await super.getAttribute(this.fieldSupplyTier[tier - 1], "value");
}
async getStartTimeTier(tier) {
logger.info(this.name + "getStartTimeTier ");
let field = await this.getFieldStartTime(tier);
return await super.getAttribute(field, "value");
}
async getFieldStartTime(tier) {
logger.info(this.name + "getFieldStartTime ");
const locator = By.id("tiers[" + (tier - 1) + "].startTime");
return await super.getElement(locator);
}
async getEndTimeTier(tier) {
logger.info(this.name + "getEndTimeTier ");
let element = await this.getFieldEndTime(tier);
if (element === null) return null;
else return await super.getAttribute(element, "value");
}
async clickButtonSave() {
logger.info(this.name + "clickButtonSave ");
return (await this.initButtonSave() !== null)
&& await super.clickWithWait(this.buttonSave);
}
async isDisabledButtonSave() {
logger.info(this.name + " isDisabledButtonSave ");
await this.initButtonSave();
if (await super.getAttribute(this.buttonSave, "class") === "no_arrow button button_fill button_no_border") {
//no_arrow button button_fill button_disabled
logger.info("present and disabled");
return true;
}
else {
logger.info("not present ");
return false;
}
}
async waitUntilShowUpButtonSave(Twaiting) {
logger.info(this.name + "waitUntilShowUpButtonSave ");
return (await this.initButtonSave() !== null)
&& super.waitUntilDisplayed(this.buttonSave, Twaiting);
}
async isPresentWarningStartTimeTier1() {
logger.info(this.name + "isPresentWarningStartTimeTier1 ");
try {
logger.info(this.name + "red warning if data wrong :");
let result = await super.getTextForElement(warningStartTimeTier1, 1);
logger.info("Text=" + result);
return (result !== "");
}
catch (err) {
logger.info(err);
return false;
}
}
async isPresentWarningStartTimeTier2() {
logger.info(this.name + "isPresentWarningStartTimeTier2 ");
try {
logger.info(this.name + "red warning if data wrong :");
await this.driver.sleep(1000);
let result = await super.getTextForElement(warningStartTimeTier2, 1);
logger.info("Text=" + result);
return (result !== "");
}
catch (err) {
logger.info(err);
return false;
}
}
async isPresentWarningEndTimeTier2() {
logger.info(this.name + "isPresentWarningEndTimeTier2 ");
return false;
await this.driver.sleep(1000);
let result = await super.getTextForElement(warningEndTimeTier2, 1);
logger.info("Text=" + result);
return (result !== "");
}
async isPresentWarningEndTimeTier1() {
logger.info(this.name + "red warning if data wrong :");
return false;
await this.driver.sleep(500);
let result = await super.getTextForElement(warningEndTimeTier1, 1);
logger.info("Text=" + result);
return (result !== "");
}
async getButtonAddWhitelist(tier) {
logger.info(this.name + "getButtonAddWhitelist ");
let containers = await super.findWithWait(contentContainer);
let element = await this.getChildFromElementByClassName("button button_fill button_fill_plus", containers[tier+1]);
return element[0];
}
async clickButtonAddWhitelist(tier) {
logger.info(this.name + "clickButtonAddWhitelist ");
//if (this.tier.minRate !== undefined) return true;
let element = await this.getButtonAddWhitelist(tier);
return await super.clickWithWait(element);
}
async fillWhitelist(tier, address, min, max) {
logger.info(this.name + "fillWhitelist ");
return (await this.initWhitelistFields() !== null)
&& await super.fillWithWait(this.fieldWhAddress[tier - 1], address)
&& await super.fillWithWait(this.fieldWhMin[tier - 1], min)
&& await super.fillWithWait(this.fieldWhMax[tier - 1], max)
&& (await this.initButtons() !== null)
&& await super.clickWithWait(this.buttonAddWh[tier - 1])
&& await this.clickButtonSave();
}
async getFieldEndTime(tier) {
logger.info(this.name + "getFieldEndTime ");
const locator = By.id("tiers[" + (tier - 1) + "].endTime");
return await super.getElement(locator);
}
async fillEndTimeTier(tier, date, time) {
logger.info(this.name + " fill end time, tier #" + tier + ":");
const action = this.driver.actions();
if (date === "") return true;
let format = await Utils.getDateFormat(this.driver);
if (!date.includes("/")) {
time = Utils.getTimeWithAdjust(parseInt(time), format);
date = Utils.getDateWithAdjust(parseInt(date), format);
}
let element = await this.getFieldEndTime(tier);
return (element !== null)
&& !await this.isElementDisabled(element)
&& await super.fillWithWait(element, date)
&& (await action.sendKeys(key.TAB).perform() !== null)
&& await super.fillWithWait(element, time);
}
async fillStartTimeTier(tier, date, time) {
await this.initInputs();
logger.info(this.name + "fill start time,tier #" + tier + ":");
if (await this.isElementDisabled(this.fieldStartTimeTier[tier - 1]))
return false;
await super.fillWithWait(this.fieldStartTimeTier[tier - 1], date);
const action = this.driver.actions();
await action.sendKeys(key.TAB).perform();
await super.fillWithWait(this.fieldStartTimeTier[tier - 1], time);
return true;
}
async fillRateTier(tier, rate) {
await this.initInputs();
logger.info(this.name + "fill Rate,tier #" + tier + ":");
await super.clearField(this.fieldRateTier[tier - 1]);
await super.fillWithWait(this.fieldRateTier[tier - 1], rate);
}
async fillSupplyTier(tier, rate) {
await this.initInputs();
logger.info(this.name + "fill Supply,tier #" + tier + ":");
await super.clearField(this.fieldSupplyTier[tier - 1]);
await super.fillWithWait(this.fieldSupplyTier[tier - 1], rate);
}
async open() {
logger.info(this.name + ": open " + this.URL);
return await super.open(this.URL);
}
async isEnabledButtonFinalize() {
logger.info(this.name + " isEnabledButtonFinalize ");
await this.initButtonFinalize();
if (await super.getAttribute(this.buttonFinalize, "class") === "button button_fill") {
logger.info("present and enabled");
return true;
}
else {
logger.info("present and disabled");
return false;
}
}
async clickButtonFinalize() {
logger.info(this.name + " clickButtonFinalize ");
return (await this.initButtonFinalize() !== null)
&& super.clickWithWait(this.buttonFinalize);
}
async clickButtonYesFinalize() {
logger.info(this.name + "clickButtonYesFinalize ");
return await super.clickWithWait(buttonYesFinalize);
}
async isPresentPopupYesFinalize() {
logger.info(this.name + "confirm Finalize/Yes :");
return await super.isElementDisplayed(buttonYesFinalize);
}
async waitUntilShowUpPopupFinalize(Twaiting) {
logger.info(this.name + "waitUntilShowUpPopupFinalize ");
return super.waitUntilDisplayed(buttonYesFinalize, Twaiting);
}
async waitUntilShowUpPopupConfirm(Twaiting) {
logger.info(this.name + "waitUntilShowUpPopupConfirm ");
return super.waitUntilDisplayed(buttonOk, Twaiting);
}
async isDisplayedButtonOK() {
logger.info(this.name + "button OK :");
return await super.isElementDisplayed(buttonOk);
}
async clickButtonOk() {
logger.info(this.name + "button OK :");
return await super.clickWithWait(buttonOk);
}
async getReservedTokensAddresses() {
logger.info(this.name + "getReservedTokensAddresses ");
try {
let array = await this.findWithWait(fieldsReservedTokensAddress, 180)
if (array === null) return null;
let addresses = [];
for (let i = 0; i < array.length - 1; i++) {
addresses[i] = await super.getTextForElement(array[i + 1]);
logger.info("address: " + addresses[i]);
}
return addresses;
}
catch (err) {
logger.info("Error: " + err);
return null;
}
}
async getWhitelistAddresses(tierNumber) {
logger.info(this.name + "getWhitelistAddresses ");
try {
await this.refresh();
await this.waitUntilLoaderGone();
let elements = await super.findWithWait(whitelistContainer);
let element = elements[tierNumber - 1];
const locator = "white-list-item-container-inner";
let array = await super.getChildFromElementByClassName(locator, element);
if (array === null) return null;
let addresses = [];
for (let i = 0; i < array.length; i++) {
addresses[i] = (await super.getTextForElement(array[array.length - 1 - i])).split(" ")[0];
logger.info("address: " + addresses[i]);
}
logger.info("addresses.length=" + addresses.length);
return addresses;
}
catch (err) {
logger.info("Error: " + err);
return null;
}
}
async isDisplayedWarningMinCap() {
logger.info(this.name + "isDisplayedWarningMinCap ");
const mincapBlock = By.className("left");
const elements = await super.findWithWait(mincapBlock);
const locator = "error";
let warnings = await super.getChildFromElementByClassName(locator, elements[0]);
if (warnings === null) return null;
return (await super.getTextForElement(warnings[0]) !== "");
}
async uploadWhitelistCSVFile() {
logger.info(this.name + "uploadWhitelistCSVFile ");
try {
let path = await Utils.getPathToFileInPWD("bulkWhitelist.csv");
logger.info(this.name + ": uploadWhitelistCSVFile: from path: " + path);
const locator = By.xpath('//input[@type="file"]');
let element = await this.driver.findElements(locator);
console.log("wefwe " + element.length);
await element[0].sendKeys(path);
return true;
}
catch (err) {
logger.info("Error: " + err);
return false;
}
}
async getFieldMinCap(tier) {
logger.info(this.name + "getFieldMinCap ");
const locator = By.id("tiers[" + (tier - 1) + "].minCap");
return await super.getElement(locator);
}
async isDisabledFieldMinCap(tier) {
logger.info(this.name + "isDisabledFieldMinCap ");
let element = await this.getFieldMinCap(tier)
return await this.isElementDisabled(element);
}
async fillMinCap(tier, value) {
logger.info(this.name + "fillMinCap , tier# " + tier + " ,value = " + value);
let element = await this.getFieldMinCap(tier)
return await super.clearField(element)
&& await super.fillWithWait(element, value);
}
}
module
.exports = {
ManagePage: ManagePage
}