let test = require('selenium-webdriver/testing');
let assert = require('assert');
const fs = require('fs-extra');
///////////////////////////////////////////////////////
const WizardWelcome = require('../pages/WizardWelcome.js').WizardWelcome;
const WizardStep1 = require('../pages/WizardStep1.js').WizardStep1;
const WizardStep2 = require('../pages/WizardStep2.js').WizardStep2;
const WizardStep3 = require('../pages/WizardStep3.js').WizardStep3;
const WizardStep4 = require('../pages/WizardStep4.js').WizardStep4;
const TierPage = require('../pages/TierPage.js').TierPage;
const ReservedTokensPage = require('../pages/ReservedTokensPage.js').ReservedTokensPage;
const CrowdsalePage = require('../pages/CrowdsalePage.js').CrowdsalePage;
const ContributionPage = require('../pages/ContributionPage.js').InvestPage;
const InvestPage = require('../pages/ContributionPage.js').InvestPage;
const ManagePage = require('../pages/ManagePage.js').ManagePage;
const logger = require('../entity/Logger.js').logger;
const tempOutputPath = require('../entity/Logger.js').tempOutputPath;
const Utils = require('../utils/Utils.js').Utils;
const User = require("../entity/User.js").User;
const PublishPage = require('../pages/PublishPage.js').PublishPage;

test.describe(`e2e test for TokenWizard2.0/MintedCappedCrowdsale. v ${testVersion}`, async function () {
    this.timeout(2400000);//40 min
    this.slow(1800000);

    const user8545_56B2File = './users/user8545_56B2.json';//Owner
    const user77_F16AFile = './users/user77_F16A.json';//Investor1
    let driver;
    let Owner;
    let Investor1;

    let wallet;
    let welcomePage;
    let wizardStep1;
    let wizardStep2;
    let wizardStep3;
    let wizardStep4;
    let tierPage;
    let reservedTokensPage;
    let investPage;
    let contributionPage;
    let crowdsalePage;

    let startURL;
    let crowdsaleForUItests;
    let mngPage;
    let balanceEthOwnerBefore;
    let crowdsaleMintedSimple;
    let publishPage;
    let scenarioSimple

    const placeholder = {
        gasCustom: '0.1',
        setupNameTier1: 'Tier 1',
        decimals: '18',
        mincap: '0'
    }

    const newValue = {
        setupNameTier1: 'tier#1',
        name: 'Name',
        decimals: '13',
        customGas: '100',
        ticker: 'Tick',
        rateTier1: '456',
        supplyTier1: '1e18',
        mincapTier2: '423'
    }


/////////////////////////////////////////////////////////////////////////

    test.before(async function () {

        await Utils.copyEnvFromWizard();

        const scenarioForUItests = './scenarios/scenarioUItests.json';
        crowdsaleForUItests = await Utils.getMintedCrowdsaleInstance(scenarioForUItests);
        scenarioSimple = './scenarios/scenarioMintedSimple.json'
        crowdsaleMintedSimple = await Utils.getMintedCrowdsaleInstance(scenarioSimple);

        startURL = await Utils.getStartURL();
        driver = await Utils.startBrowserWithWallet();

        Owner = new User(driver, user8545_56B2File);
        await Utils.receiveEth(Owner, 20);
        Investor1 = new User(driver, user77_F16AFile);

        logger.info("Roles:");
        logger.info("Owner = " + Owner.account);
        balanceEthOwnerBefore = await Utils.getBalance(Owner);
        logger.info("Owner's balance = :" + balanceEthOwnerBefore / 1e18);

        wallet = await Utils.getWalletInstance(driver);
        //await wallet.activate();//return activated Wallet and empty page
       // await Owner.setWalletAccount();

        welcomePage = new WizardWelcome(driver, startURL);
        wizardStep1 = new WizardStep1(driver);
        wizardStep2 = new WizardStep2(driver);
        wizardStep3 = new WizardStep3(driver);
        wizardStep4 = new WizardStep4(driver);
        investPage = new InvestPage(driver);
        reservedTokensPage = new ReservedTokensPage(driver);
        mngPage = new ManagePage(driver);
        tierPage = new TierPage(driver, crowdsaleForUItests.tiers[0]);
        contributionPage = new ContributionPage(driver);
        crowdsalePage = new CrowdsalePage(driver);
        publishPage = new PublishPage(driver)
    });

    test.after(async function () {
        // Utils.killProcess(ganache);
        //await Utils.sendEmail(tempOutputFile);
        let outputPath = Utils.getOutputPath();
        outputPath = outputPath + "/result" + Utils.getDate();
        await fs.ensureDirSync(outputPath);
        await fs.copySync(tempOutputPath, outputPath);
        //await fs.remove(tempOutputPath);
        // await driver.quit();
    });
///////////////////////// UI TESTS /////////////////////////////////////

    describe('Welcome page', async function () {
        test.it('User is able to open wizard welcome page',
            async function () {
                await welcomePage.open();
                let result = await welcomePage.waitUntilDisplayedButtonNewCrowdsale(180);
                return await assert.equal(result, true, "Test FAILED. Wizard's page is not available ");
            });

        test.it('Warning present if user logged out from wallet',
            async function () {
                let result = await welcomePage.waitUntilShowUpWarning(180)
                return await assert.equal(result, true, "Test FAILED. No warning present if user logged out from wallet ");
            });

        test.it('User can confirm warning',
            async function () {
                let result = await welcomePage.clickButtonOK()
                return await assert.equal(result, true, "Test FAILED. Button Ok doesn\'t present");
            });

        test.it('No warning present if user logged into wallet',
            async function () {
                await wallet.activate();//return activated Wallet and empty page
                await Owner.setWalletAccount();
                let result = await welcomePage.waitUntilShowUpWarning(10)
                return await assert.equal(result, false, "Test FAILED. No warning present if user logged out from wallet ");
            });

        test.it('Button NewCrowdsale present ',
            async function () {
                let result = await welcomePage.isDisplayedButtonNewCrowdsale();
                return await assert.equal(result, true, "Test FAILED. Button NewCrowdsale not present ");
            });

        test.it('Button \'ChooseContract\' present ',
            async function () {
                let result = await welcomePage.isDisplayedButtonChooseContract();
                return await assert.equal(result, true, "Test FAILED. button ChooseContract not present ");
            });

        test.it('User is able to open Step1 by clicking button NewCrowdsale ',
            async function () {
                let result = await welcomePage.clickButtonNewCrowdsale()
                    && await wizardStep1.waitUntilDisplayedCheckboxWhitelistWithCap();
                return await assert.equal(result, true, "Test FAILED. User is not able to activate Step1 by clicking button NewCrowdsale");
            });
    })
    describe('Step#1: ', async function () {
        test.it('Go back - page keep state of checkbox \'Whitelist with mincap\' ',
            async function () {
                const result = await wizardStep1.clickCheckboxWhitelistWithCap()
                    && await wizardStep1.goBack()
                    && await welcomePage.isDisplayedButtonChooseContract()
                    && await wizardStep1.goForward()
                    && await wizardStep1.waitUntilLoaderGone()
                    && await wizardStep1.waitUntilDisplayedCheckboxWhitelistWithCap()
                    && await wizardStep1.isSelectedCheckboxWhitelistWithCap()
                return await assert.equal(result, true, "Test FAILED. Checkbox changed");
            });

        test.it('Refresh - page keep state of checkbox \'Whitelist with mincap\' ',
            async function () {
                const result = await wizardStep1.clickCheckboxWhitelistWithCap()
                    && await wizardStep1.refresh()
                    && await wizardStep1.isSelectedCheckboxWhitelistWithCap()
                return await assert.equal(result, true, "Test FAILED. Checkbox changed");
            });

        test.it('Change network - page keep state of checkbox \'Whitelist with mincap\' ',
            async function () {
                const result = await wizardStep1.clickCheckboxWhitelistWithCap()
                    && await Investor1.setWalletAccount()
                    && await wizardStep1.waitUntilLoaderGone()
                    && await wizardStep1.waitUntilDisplayedCheckboxWhitelistWithCap()
                    && await wizardStep1.isSelectedCheckboxWhitelistWithCap()
                    && await Owner.setWalletAccount()
                    && await wizardStep1.waitUntilLoaderGone()
                return await assert.equal(result, true, "Test FAILED. Checkbox changed");
            });

        test.it('User is able to open Step2 by clicking button Continue ',
            async function () {
                let count = 10;
                do {
                    await driver.sleep(1000);
                    if ( (await wizardStep1.isDisplayedButtonContinue()) &&
                        !(await wizardStep2.isDisplayedFieldName()) ) {
                        await wizardStep1.clickButtonContinue();
                    }
                    else break;
                }
                while ( count-- > 0 );
                let result = await wizardStep2.isDisplayedFieldName();
                return await assert.equal(result, true, "Test FAILED. User is not able to open Step2 by clicking button Continue");
            });
    })
    describe('Step#2: ', async function () {
        test.it('Field \'Decimals\' has placeholder 18',
            async function () {
                return await assert.equal(await wizardStep2.getValueFieldDecimals(), placeholder.decimals, "Test FAILED. Step#2:incorrect placeholder for field 'Decimals'");
            });

        test.it('User able to fill out field \'Name\' with valid data',
            async function () {
                let result = await wizardStep2.fillName(newValue.name)
                    && await wizardStep2.isDisplayedWarningName();
                return await assert.equal(result, false, "Test FAILED. Wizard step#2: field name changed");
            });

        test.it('Go back - page keep state of field \'Name\' ',
            async function () {
                const result = await wizardStep2.goBack()
                    && await wizardStep1.waitUntilDisplayedCheckboxWhitelistWithCap()
                    && await wizardStep1.goForward()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilDisplayedFieldName()
                    && await wizardStep2.waitUntilHasValueFieldName();
                await assert.equal(result, true, "Test FAILED. Wizard step#2: field name changed");
                return await assert.equal(await wizardStep2.getValueFieldName(), newValue.name, "Test FAILED.Field name changed");
            });

        test.it('Refresh - page keep state of  field \'Name\'',
            async function () {
                const result = await wizardStep2.refresh()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilDisplayedFieldName()
                    && await wizardStep2.waitUntilHasValueFieldName();
                await assert.equal(result, true, "Test FAILED. Wizard step#2: field name changed");
                return await assert.equal(await wizardStep2.getValueFieldName(), newValue.name, "Test FAILED.Wizard step#2: field name changed");
            });

        test.it('Change network - page keep state of  field \'Name\'',
            async function () {
                const result = await Investor1.setWalletAccount()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilHasValueFieldName()
                    && (await wizardStep2.getValueFieldName() === newValue.name)
                    && await Owner.setWalletAccount()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilHasValueFieldName()
                    && (await wizardStep2.getValueFieldName() === newValue.name)
                return await assert.equal(result, true, "Test FAILED. Wizard step#2: field name changed");
            });

        test.it('User able to fill out field Ticker with valid data',
            async function () {
                await wizardStep2.fillTicker(newValue.ticker);
                let result = await wizardStep2.isDisplayedWarningTicker();
                return await assert.equal(result, false, "Test FAILED. Wizard step#2: user is not  able to fill out field Ticker with valid data ");
            });

        test.it('User able to fill out  Decimals field with valid data',
            async function () {
                await wizardStep2.fillDecimals(newValue.decimals);
                let result = await wizardStep2.isDisplayedWarningDecimals();
                return await assert.equal(result, false, "Test FAILED. Wizard step#2: user is not able to fill Decimals  field with valid data ");
            });


        test.it('User is able to download CSV file with reserved tokens',
            async function () {
                let fileName = './public/reservedAddresses21.csv';
                let result = await reservedTokensPage.uploadReservedCSVFile(fileName);
                return await assert.equal(result, true, 'Test FAILED. Wizard step#3: User is NOT able to download CVS file with whitelisted addresses');
            });

        test.it('Alert present if number of reserved addresses greater 20 ',
            async function () {
                let result = await reservedTokensPage.waitUntilShowUpPopupConfirm(100)
                    && await reservedTokensPage.clickButtonOk();
                return await assert.equal(result, true, "Test FAILED.ClearAll button is NOT present");
            });
        test.it('Added only 20 reserved addresses from CSV file',
            async function () {
                let correctNumberReservedTokens = 20;
                let result = await reservedTokensPage.amountAddedReservedTokens();
                return await assert.equal(result, correctNumberReservedTokens, "Test FAILED. Wizard step#2: number of added reserved tokens is correct");
            });

        test.it('Check validator for reserved addresses',
            async function () {
                let fileName = './public/reservedAddressesTestValidation.csv';
                let result = await reservedTokensPage.uploadReservedCSVFile(fileName);
                await reservedTokensPage.clickButtonOk();
                return await assert.equal(result, true, 'Test FAILED. Wizard step#3: User is NOT able to download CVS file with whitelisted addresses');
            });

        test.it('Added only valid data from CSV file',
            async function () {
                let correctNumberReservedTokens = 20;
                let result = await reservedTokensPage.amountAddedReservedTokens();
                return await assert.equal(result, correctNumberReservedTokens, "Test FAILED. Wizard step#2: number of added reserved tokens is correct");
            });

        test.it('Button ClearAll is displayed ',
            async function () {

                let result = await reservedTokensPage.isLocatedButtonClearAll();
                return await assert.equal(result, true, "Test FAILED.ClearAll button is NOT present");
            });

        test.it('Alert present after clicking ClearAll',
            async function () {
                await reservedTokensPage.clickButtonClearAll();
                let result = await reservedTokensPage.isDisplayedButtonNoAlert();
                return await assert.equal(result, true, "Test FAILED.Alert does NOT present after select ClearAll or button No does NOT present");
            });

        test.it('User is able to bulk delete of reserved tokens ',
            async function () {
                let result = await reservedTokensPage.waitUntilShowUpPopupConfirm(20)
                    && await reservedTokensPage.clickButtonYesAlert()
                    && await reservedTokensPage.amountAddedReservedTokens();
                return await assert.equal(result, 0, "Wizard step#2: user is NOT able bulk delete of reserved tokens");
            });

        test.it('User is able to add reserved tokens one by one ',
            async function () {
                await reservedTokensPage.fillReservedTokens(crowdsaleForUItests);
                let result = await reservedTokensPage.amountAddedReservedTokens();
                return await assert.equal(result, crowdsaleForUItests.reservedTokens.length, "Test FAILED. Wizard step#2: user is NOT able to add reserved tokens");
            });

        test.it('Field Decimals is disabled if reserved tokens are added ',
            async function () {
                let result = await wizardStep2.isDisabledDecimals();
                return await assert.equal(result, true, "Wizard step#2: field Decimals enabled if reserved tokens added ");
            });

        test.it('User is able to remove one of reserved tokens ',
            async function () {
                let amountBefore = await reservedTokensPage.amountAddedReservedTokens();
                await reservedTokensPage.removeReservedTokens(1);
                let amountAfter = await reservedTokensPage.amountAddedReservedTokens();
                return await assert.equal(amountBefore, amountAfter + 1, "Test FAILED. Wizard step#2: user is NOT able to add reserved tokens");
            });

        test.it('Go back - page keep state of each field',
            async function () {
                const result = await wizardStep2.goBack()
                    && await wizardStep1.waitUntilDisplayedCheckboxWhitelistWithCap()
                    && await wizardStep1.goForward()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilHasValueFieldName();
                await assert.equal(result, true, "Test FAILED. Wizard step#2: page isn\'t loaded");
                await assert.equal(await wizardStep2.getValueFieldName(), newValue.name, "Test FAILED.Field name changed");
                await assert.equal(await wizardStep2.getValueFieldDecimals(), newValue.decimals, "Test FAILED.Field decimals changed");
                await assert.equal(await wizardStep2.getValueFieldTicker(), newValue.ticker, "Test FAILED.Field ticker changed");
                await assert.equal(await reservedTokensPage.amountAddedReservedTokens(), crowdsaleForUItests.reservedTokens.length - 1, "Test FAILED. Wizard step#2: user is NOT able to add reserved tokens");
            });

        test.it('Refresh - page keep state of each field',
            async function () {
                const result = await wizardStep2.refresh()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilDisplayedFieldName()
                    && await wizardStep2.waitUntilHasValueFieldName();
                await assert.equal(result, true, "Test FAILED. Wizard step#2: page isn\'t loaded");
                await assert.equal(await wizardStep2.getValueFieldName(), newValue.name, "Test FAILED.Field name changed");
                await assert.equal(await wizardStep2.getValueFieldDecimals(), newValue.decimals, "Test FAILED.Field decimals changed");
                await assert.equal(await wizardStep2.getValueFieldTicker(), newValue.ticker, "Test FAILED.Field ticker changed");
                await assert.equal(await reservedTokensPage.amountAddedReservedTokens(), crowdsaleForUItests.reservedTokens.length - 1, "Test FAILED. Wizard step#2: user is NOT able to add reserved tokens");
            });

        test.it('Change network - page keep state of each field',
            async function () {
                let result = await Investor1.setWalletAccount()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilHasValueFieldName()
                await assert.equal(result, true, "Test FAILED. Wizard step#2: page isn\'t loaded");
                await assert.equal(await wizardStep2.getValueFieldName(), newValue.name, "Test FAILED.Field name changed");
                await assert.equal(await wizardStep2.getValueFieldDecimals(), newValue.decimals, "Test FAILED.Field decimals changed");
                await assert.equal(await wizardStep2.getValueFieldTicker(), newValue.ticker, "Test FAILED.Field ticker changed");
                await assert.equal(await reservedTokensPage.amountAddedReservedTokens(), crowdsaleForUItests.reservedTokens.length - 1, "Test FAILED. Wizard step#2: user is NOT able to add reserved tokens");

                result = await Owner.setWalletAccount()
                    && await wizardStep2.waitUntilLoaderGone()
                    && await wizardStep2.waitUntilHasValueFieldName()
                await assert.equal(result, true, "Test FAILED. Wizard step#2: page isn\'t loaded");
                await assert.equal(await wizardStep2.getValueFieldName(), newValue.name, "Test FAILED.Field name changed");
                await assert.equal(await wizardStep2.getValueFieldDecimals(), newValue.decimals, "Test FAILED.Field decimals changed");
                await assert.equal(await wizardStep2.getValueFieldTicker(), newValue.ticker, "Test FAILED.Field ticker changed");
                await assert.equal(await reservedTokensPage.amountAddedReservedTokens(), crowdsaleForUItests.reservedTokens.length - 1, "Test FAILED. Wizard step#2: user is NOT able to add reserved tokens");

            });

        test.it('Button Continue is displayed ',
            async function () {
                let result = await wizardStep2.isDisplayedButtonContinue();
                return await assert.equal(result, true, "Test FAILED. Wizard step#2: button Continue  not present ");

            });

        test.it('User is able to open Step3 by clicking button Continue ',
            async function () {
                await wizardStep2.clickButtonContinue();
                await wizardStep3.waitUntilDisplayedTitle(180);
                let result = await wizardStep3.getTitleText();
                result = (result === wizardStep3.title);
                return await assert.equal(result, true, "Test FAILED. User is not able to activate Step2 by clicking button Continue");
            });
    })
    describe('Step#3: ', async function () {

        test.it('Field Wallet address contains current metamask account address  ',
            async function () {
                let result = await wizardStep3.getValueFieldWalletAddress();
                result = (result === Owner.account.toString());
                return await assert.equal(result, true, "Test FAILED. Wallet address does not match the metamask account address ");
            });

        test.it('Checkbox gasprice \'Safe\'  by default ',
            async function () {
                const result = await wizardStep3.isSelectedCheckboxGasSafe()
                    && !await wizardStep3.isSelectedCheckboxGasNormal()
                    && !await wizardStep3.isSelectedCheckboxGasFast()
                    && !await wizardStep3.isSelectedCheckboxGasCustom()
                    && !await wizardStep3.isDisplayedFieldGasCustom()
                return await assert.equal(result, true, "Wizard step#3: checkbox gasprice 'Safe'  by default ");
            });

        test.it('User is able to set checkbox gasprice \'Normal\'',
            async function () {
                const result = await wizardStep3.clickCheckboxGasNormal()
                    && await wizardStep3.isSelectedCheckboxGasNormal()
                return await assert.equal(result, true, "Wizard step#3: checkbox gasprice 'Normal' isn\'t selected ");
            });

        test.it('User is able to set checkbox gasprice \'Safe\'',
            async function () {
                const result = await wizardStep3.clickCheckboxGasSafe()
                    && await wizardStep3.isSelectedCheckboxGasSafe()
                return await assert.equal(result, true, "Wizard step#3: checkbox gasprice 'Safe' isn\'t selected ");
            });

        test.it('Field \'Gas price custom\' isn\'t displayed if checkbox gasprice \'Custom\' isn\'t selected ',
            async function () {
                const result = await wizardStep3.isDisplayedFieldGasCustom()
                return await assert.equal(result, false, "Wizard step#3: checkbox gasprice 'Custom' isn\'t selected ");
            });

        test.it('User is able to set checkbox gasprice \'Fast\'',
            async function () {
                const result = await wizardStep3.clickCheckboxGasFast()
                    && await wizardStep3.isSelectedCheckboxGasFast()
                return await assert.equal(result, true, "Wizard step#3: checkbox gasprice 'Fast' isn\'t selected ");
            });

        test.it('User is able to set "Custom Gasprice" checkbox',
            async function () {
                const result = await wizardStep3.clickCheckboxGasCustom()
                    && await wizardStep3.isSelectedCheckboxGasCustom()
                return await assert.equal(result, true, "Wizard step#3: checkbox gasprice 'Custom' isn\'t selected ");
            });

        test.it('Field \'Gas price custom\' displayed if checkbox gasprice \'Custom\'is selected ',
            async function () {
                const result = await wizardStep3.isDisplayedFieldGasCustom()
                return await assert.equal(result, true, "Wizard step#3: checkbox gasprice 'Custom' isn\'t selected ");
            });

        test.it('Field \'Gas price custom\' has correct placeholder ',
            async function () {
                const result = await wizardStep3.getValueFieldGasCustom()
                return await assert.equal(result, placeholder.gasCustom, "Wizard step#3: checkbox gasprice 'Custom' isn\'t selected ");
            });

        test.it('User is able to fill out the  CustomGasprice field with valid value',
            async function () {
                const result = await wizardStep3.fillGasPriceCustom(newValue.customGas);
                return await assert.equal(result, true, 'Test FAILED. Wizard step#3: User is NOT able to fill "Custom Gasprice" with valid value');
            });
    })
    describe('Tier#1: ', async function () {
        test.it('Field \'Mincap\' has value 0 by default ',
            async function () {
                const result = await tierPage.getValueFieldMinCap();
                return await assert.equal(result, placeholder.mincap, "Tier#1: field 'Mincap' has incorrect value by default ");
            });
        test.it('Field \'Setup name\' has value 0 by default ',
            async function () {
                const result = await tierPage.getValueFieldSetupName();
                return await assert.equal(result, placeholder.setupNameTier1, "Tier#1: field 'Setup name' has incorrect value by default ");
            });

        test.it('Checkbox \'Allow Modify\' is off by default ',
            async function () {
                const result = await tierPage.isSelectedCheckboxAllowModifyOff()
                    && !await tierPage.isSelectedCheckboxAllowModifyOn();
                return await assert.equal(result, true, "Tier#1: checkbox 'Allow Modify' isn\'t OFF by default ");
            });
        test.it('Checkbox \'Enable Whitelist\' is no by default ',
            async function () {
                const result = await tierPage.isSelectedCheckboxWhitelistNo()
                    && !await tierPage.isSelectedCheckboxWhitelistYes();
                return await assert.equal(result, true, "Tier#1: checkbox 'Enable Whitelist' isn\'t NO by default ");
            });

        test.it('User is able to set checkbox  \'Allow Modify on\'',
            async function () {
                const result = await tierPage.clickCheckboxAllowModifyOn()
                    && await tierPage.isSelectedCheckboxAllowModifyOn()
                    && !await tierPage.isSelectedCheckboxAllowModifyOff()
                return await assert.equal(result, true, "Wizard step#3: checkbox gasprice 'Allow Modify on' isn\'t selected ");
            });

        test.it('Whitelist container isn\'t present if checkbox "Whitelist enabled" is no',
            async function () {
                const result = await tierPage.isDisplayedWhitelistContainer();
                return await assert.equal(result, false, 'Test FAILED. Wizard step#3: User is NOT able to set checkbox  "Whitelist enabled"');
            });
        test.it('Whitelist container present if checkbox "Whitelist enabled" is selected',
            async function () {
                const result = await tierPage.clickCheckboxWhitelistYes()
                    && await tierPage.isDisplayedWhitelistContainer();
                return await assert.equal(result, true, 'Test FAILED. Wizard step#3: User is NOT able to set checkbox  "Whitelist enabled"');
            });

        test.it('Field minCap disabled if whitelist enabled ',
            async function () {
                const tierNumber = 1;
                const result = await tierPage.isDisabledFieldMinCap(tierNumber);
                return await assert.equal(result, true, "Test FAILED. Field minCap disabled if whitelist enabled");
            });
        test.it('User is able to fill out field "Setup name" with valid data',
            async function () {
                tierPage.tier.name = newValue.setupNameTier1;
                let result = await tierPage.fillSetupName();

                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is able to fill out field 'Supply' with valid data");
            });
        test.it('User is able to fill out field "Supply" with valid data',
            async function () {
                tierPage.tier.supply = 69;
                let result = await tierPage.fillSupply();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is able to fill out field 'Supply' with valid data");
            });

        test.it('User is able to download CSV file with whitelisted addresses',
            async function () {
                const fileName = "./public/whitelistAddressesTestValidation.csv";
                const result = await tierPage.uploadWhitelistCSVFile(fileName)
                    && await tierPage.waitUntilShowUpPopupConfirm(180)
                    && await wizardStep3.clickButtonOk();
                return await assert.equal(result, true, 'Test FAILED. Wizard step#3: User is NOT able to download CVS file with whitelisted addresses');
            });

        test.it('Field Supply disabled if whitelist added ',
            async function () {
                const result = await tierPage.isDisabledFieldSupply();
                return await assert.equal(result, true, "Test FAILED. Field minCap disabled if whitelist enabled");
            });

        test.it('Number of added whitelisted addresses is correct, data is valid',
            async function () {
                const shouldBe = 5;
                const inReality = await tierPage.amountAddedWhitelist();
                return await assert.equal(shouldBe, inReality, "Test FAILED. Wizard step#3: Number of added whitelisted addresses is NOT correct");
            });

        test.it('User is able to bulk delete all whitelisted addresses ',
            async function () {
                const result = await tierPage.clickButtonClearAll()
                    && await tierPage.waitUntilShowUpPopupConfirm(180)
                    && await tierPage.clickButtonYesAlert();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is NOT able to bulk delete all whitelisted addresses");
            });

        test.it('All whitelisted addresses are removed after deletion ',
            async function () {
                const result = await tierPage.amountAddedWhitelist(10);
                return await assert.equal(result, 0, "Test FAILED. Wizard step#3: User is NOT able to bulk delete all whitelisted addresses");
            });

        test.it('Field Supply enabled if whitelist was deleted ',
            async function () {
                const result = await tierPage.isDisabledFieldSupply();
                return await assert.equal(result, false, "Test FAILED. Field minCap disabled if whitelist enabled");
            });

        test.it('User is able to fill out field "Supply" with valid data',
            async function () {
                tierPage.tier.supply = newValue.supplyTier1;
                const result = await tierPage.fillSupply();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is able to fill out field 'Supply' with valid data");
            });

        test.it('User is able to download CSV file with more than 50 whitelisted addresses',
            async function () {
                const fileName = "./public/whitelistedAddresses61.csv";
                const result = await tierPage.uploadWhitelistCSVFile(fileName);
                return await assert.equal(result, true, 'Test FAILED. Wizard step#3: User is NOT able to download CVS file with whitelisted addresses');
            });

        test.it('Alert present if number of whitelisted addresses greater 50 ',
            async function () {
                const result = await tierPage.waitUntilShowUpPopupConfirm(100)
                    && await wizardStep3.clickButtonOk();
                return await assert.equal(result, true, "Test FAILED.ClearAll button is NOT present");
            });

        test.it('Number of added whitelisted addresses is correct, data is valid',
            async function () {
                const shouldBe = 50;
                const inReality = await tierPage.amountAddedWhitelist();
                return await assert.equal(shouldBe, inReality, "Test FAILED. Wizard step#3: Number of added whitelisted addresses is NOT correct");

            });

        test.it('User is able to bulk delete all whitelisted addresses ',
            async function () {
                const result = await tierPage.clickButtonClearAll()
                    && await tierPage.waitUntilShowUpPopupConfirm(180)
                    && await tierPage.clickButtonYesAlert();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is NOT able to bulk delete all whitelisted addresses");
            });

        test.it('User is able to add several whitelisted addresses one by one ',
            async function () {
                const result = await tierPage.fillWhitelist();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is able to add several whitelisted addresses");
            });

        test.it('User is able to remove one whitelisted address',
            async function () {
                const beforeRemoving = await tierPage.amountAddedWhitelist();
                const numberAddressForRemove = 1;
                await tierPage.removeWhiteList(numberAddressForRemove - 1);
                const afterRemoving = await tierPage.amountAddedWhitelist();
                return await assert.equal(beforeRemoving, afterRemoving + 1, "Test FAILED. Wizard step#3: User is NOT able to remove one whitelisted address");
            });


        test.it('User is able to fill out field "Rate" with valid data',
            async function () {
                tierPage.number = 0;
                tierPage.tier.rate = newValue.rateTier1;
                const result = await tierPage.fillRate();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is NOT able to fill out field 'Rate' with valid data");
            });
    })
    describe('Tier#2:', async function () {
        test.it('User is able to add tier',
            async function () {
                const result = await wizardStep3.clickButtonAddTier();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: Wizard step#3: User is able to add tier");
            });

        test.it('User is able to fill out field "Rate" with valid data',
            async function () {
                tierPage.number = 1;
                tierPage.tier.rate = newValue.rateTier1;
                let result = await tierPage.fillRate();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is NOT able to fill out field 'Rate' with valid data");
            });

        test.it('User is able to fill out field "Supply" with valid data',
            async function () {
                tierPage.tier.supply = newValue.supplyTier1;
                let result = await tierPage.fillSupply();
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is able to fill out field 'Supply' with valid data");
            });
        test.it('User is able to fill out field "minCap" with valid data',
            async function () {
                tierPage.tier.minCap = newValue.mincapTier2;
                let tierNumber = 2;
                let result = await tierPage.fillMinCap(tierNumber,);
                return await assert.equal(result, true, "Test FAILED. Wizard step#3: User is able to fill out field 'Supply' with valid data");
            });

        test.it('Go back - page keep state  ',
            async function () {
                const result = await wizardStep3.goBack()
                    && await wizardStep2.waitUntilDisplayedFieldName()
                    && await Utils.delay(5000)
                    && await wizardStep3.goForward()
                    && await wizardStep1.waitUntilLoaderGone()
                    && await wizardStep3.waitUntilDisplayedFieldWalletAddress()
                await assert.equal(result, true, "Test FAILED.Page crashed after go back/forward");
                await assert.equal(await wizardStep3.isSelectedCheckboxGasCustom(), true, "Checkbox \'Custom\' lost state after refresh");
                await assert.equal(await wizardStep3.getValueFieldGasCustom(), newValue.customGas, "field \'Gas Custom\' lost value after refresh");
                await assert.equal(await wizardStep3.getValueFieldWalletAddress(), Owner.account, "field \'Gas Custom\' lost value after refresh");
                tierPage.number = 0
                await assert.equal(await tierPage.isSelectedCheckboxAllowModifyOff(), false, "Checkbox \'Allow modify off\' lost state after refresh");
                await assert.equal(await tierPage.isSelectedCheckboxAllowModifyOn(), true, "Checkbox \'Allow modify on\' lost state after refresh");

                await assert.equal(await tierPage.isSelectedCheckboxWhitelistYes(), true, "Checkbox \'Enable whitelist\' lost state after refresh");
                await assert.equal(await tierPage.isSelectedCheckboxWhitelistNo(), false, "Checkbox \'Enable whitelist\' lost state after refresh");

                await assert.equal(await tierPage.getValueFieldSetupName(), newValue.setupNameTier1, "field \'Setup name\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldRate(), newValue.rateTier1, "field \'Rate\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldSupply(), newValue.supplyTier1, "field \'Supply\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldMinCap(), 0, "field \'Mincap\' lost value after refresh");
                await assert.equal(await tierPage.isDisabledFieldMinCap(), true, "field 'Mincap' became enabled after refresh");
                tierPage.number = 1;
                await assert.equal(await tierPage.getValueFieldMinCap(), newValue.mincapTier2, "field \'Mincap\' lost value after refresh");

            });

        test.it('Refresh - page keep state of checkbox \'Whitelist with mincap\' ',
            async function () {
                const result = await wizardStep3.refresh()
                    && await wizardStep1.waitUntilLoaderGone()
                    && await wizardStep3.waitUntilDisplayedFieldWalletAddress()
                await assert.equal(result, true, "Test FAILED.Page crashed after refreshing");
                await assert.equal(await wizardStep3.isSelectedCheckboxGasCustom(), true, "Checkbox \'Custom\' lost state after refresh");
                await assert.equal(await wizardStep3.getValueFieldGasCustom(), newValue.customGas, "field \'Gas Custom\' lost value after refresh");
                await assert.equal(await wizardStep3.getValueFieldWalletAddress(), Owner.account, "field \'Gas Custom\' lost value after refresh");
                tierPage.number = 0
                await assert.equal(await tierPage.isSelectedCheckboxAllowModifyOff(), false, "Checkbox \'Allow modify off\' lost state after refresh");
                await assert.equal(await tierPage.isSelectedCheckboxAllowModifyOn(), true, "Checkbox \'Allow modify on\' lost state after refresh");

                await assert.equal(await tierPage.isSelectedCheckboxWhitelistYes(), true, "Checkbox \'Enable whitelist\' lost state after refresh");
                await assert.equal(await tierPage.isSelectedCheckboxWhitelistNo(), false, "Checkbox \'Enable whitelist\' lost state after refresh");

                await assert.equal(await tierPage.getValueFieldSetupName(), newValue.setupNameTier1, "field \'Setup name\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldRate(), newValue.rateTier1, "field \'Rate\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldSupply(), newValue.supplyTier1, "field \'Supply\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldMinCap(), 0, "field \'Mincap\' lost value after refresh");
                await assert.equal(await tierPage.isDisabledFieldMinCap(), true, "field 'Mincap' became enabled after refresh");
                tierPage.number = 1;
                await assert.equal(await tierPage.getValueFieldMinCap(), newValue.mincapTier2, "field \'Mincap\' lost value after refresh");

            });

        test.it('Change network - page keep state of checkbox \'Whitelist with mincap\' ',
            async function () {
                const result = await Investor1.setWalletAccount()
                    && await wizardStep1.waitUntilLoaderGone()
                    && await Owner.setWalletAccount()
                    && await wizardStep3.waitUntilDisplayedFieldWalletAddress()
                await assert.equal(result, true, "Test FAILED.Page crashed after switch account");
                await assert.equal(await wizardStep3.isSelectedCheckboxGasCustom(), true, "Checkbox \'Custom\' lost state after refresh");
                await assert.equal(await wizardStep3.getValueFieldGasCustom(), newValue.customGas, "field \'Gas Custom\' lost value after refresh");
                await assert.equal(await wizardStep3.getValueFieldWalletAddress(), Owner.account, "field \'Gas Custom\' lost value after refresh");
                tierPage.number = 0
                await assert.equal(await tierPage.isSelectedCheckboxAllowModifyOff(), false, "Checkbox \'Allow modify off\' lost state after refresh");
                await assert.equal(await tierPage.isSelectedCheckboxAllowModifyOn(), true, "Checkbox \'Allow modify on\' lost state after refresh");

                await assert.equal(await tierPage.isSelectedCheckboxWhitelistYes(), true, "Checkbox \'Enable whitelist\' lost state after refresh");
                await assert.equal(await tierPage.isSelectedCheckboxWhitelistNo(), false, "Checkbox \'Enable whitelist\' lost state after refresh");

                await assert.equal(await tierPage.getValueFieldSetupName(), newValue.setupNameTier1, "field \'Setup name\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldRate(), newValue.rateTier1, "field \'Rate\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldSupply(), newValue.supplyTier1, "field \'Supply\' lost value after refresh");
                await assert.equal(await tierPage.getValueFieldMinCap(), 0, "field \'Mincap\' lost value after refresh");
                await assert.equal(await tierPage.isDisabledFieldMinCap(), true, "field 'Mincap' became enabled after refresh");
                tierPage.number = 1;
                await assert.equal(await tierPage.getValueFieldMinCap(), newValue.mincapTier2, "field \'Mincap\' lost value after refresh");
            });


        test.it('User is able to proceed to Step4 by clicking button Continue ',
            async function () {
                await wizardStep3.clickButtonContinue();
                let result = await wizardStep4.waitUntilDisplayedModal(60);
                return await assert.equal(result, true, "Test FAILED. User is not able to activate Step2 by clicking button Continue");
            });
    })
    describe('Step#4:', async function () {
        test.it('Modal is displayed ',
            async function () {

                let result = await wizardStep4.waitUntilDisplayedModal()
                    && await wizardStep4.isDisplayedModal();
                return await assert.equal(result, true, "Test FAILED. Modal is not displayed");
            });

        test.it('Alert present if user reload the page ',
            async function () {
                await wizardStep4.refresh();
                await driver.sleep(2000);
                let result = await wizardStep4.isPresentAlert();
                return await assert.equal(result, true, "Test FAILED.  Alert does not present if user refresh the page");
            });

        test.it('User is able to accept alert after reloading the page ',
            async function () {

                let result = await wizardStep4.acceptAlert()
                    && await wizardStep4.waitUntilDisplayedModal(80);
                return await assert.equal(result, true, "Test FAILED. Modal does not present after user has accepted alert");
            });

        test.it('Button SkipTransaction is  presented if user reject a transaction ',
            async function () {
                let result = await wallet.rejectTransaction(20)
                    && await wallet.rejectTransaction(20)
                    && await wizardStep4.isDisplayedButtonSkipTransaction();
                return await assert.equal(result, true, "Test FAILED. button'Skip transaction' does not present if user reject the transaction");
            });

        test.it('User is able to skip transaction ',
            async function () {

                let result = await wizardStep4.clickButtonSkipTransaction()
                    && await wizardStep4.waitUntilShowUpPopupConfirm(80)
                    && await wizardStep4.clickButtonYes();
                return await assert.equal(result, true, "Test FAILED. user is not able to skip transaction");
            });

        test.it('Alert is presented if user wants to leave the wizard ',
            async function () {

                let result = await welcomePage.openWithAlertConfirmation();
                return await assert.equal(result, false, "Test FAILED. Alert does not present if user wants to leave the site");
            });

        test.it('User is able to stop deployment ',
            async function () {

                let result = await wizardStep4.waitUntilShowUpButtonCancelDeployment(80)
                    && await wizardStep4.clickButtonCancelDeployment()
                    && await wizardStep4.waitUntilShowUpPopupConfirm(80)
                    && await wizardStep4.clickButtonYes();

                return await assert.equal(result, true, "Test FAILED. Button 'Cancel' does not present");
            });
    })

    describe('Create crowdsale', async function () {
        test.it('User is able to create crowdsale(scenarioMintedSimple.json),minCap,1 tier',
            async function () {
                let owner = Owner;
                assert.equal(await owner.setWalletAccount(), true, "Can not set Metamask account");
                let result = await owner.createMintedCappedCrowdsale({
                    crowdsale: crowdsaleMintedSimple,
                    stop: { publish: true }
                });
                return await assert.equal(result, true, 'Test FAILED. Crowdsale has not created ');
            });
    })
    describe('Publish page', async function () {
        describe('Common data', async function () {
            test.it('Name is correct',
                async function () {
                    await driver.sleep(10000)
                    const result = await publishPage.getName()
                    return await assert.equal(crowdsaleMintedSimple.name, result, 'Publish page: name is incorrect ');
                });

            test.it('Ticker is correct',
                async function () {
                    const result = await publishPage.getTicker()
                    return await assert.equal(crowdsaleMintedSimple.ticker, result, 'Publish page: ticker is incorrect ');
                });

            test.it('Decimals is correct',
                async function () {
                    const result = await publishPage.getDecimals()
                    return await assert.equal(crowdsaleMintedSimple.decimals, result, 'Publish page: decimals is incorrect ');
                });

            test.it('Supply is correct',
                async function () {
                    const result = await publishPage.getSupply()
                    return await assert.equal(result, '0', 'Publish page: wallet address is incorrect ');
                });

            test.it('Wallet address is correct',
                async function () {
                    const result = await publishPage.getWalletAddress()
                    return await assert.equal(crowdsaleMintedSimple.walletAddress, result, 'Publish page: wallet address is incorrect ');
                });

            test.it('Crowdsale start time/date is correct',
                async function () {
                    const startTime = await publishPage.getCrowdsaleStartTime()
                    const date = startTime.split(' ')
                    const arr1 = date[0].split('-')
                    const startDateShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].startDate;
                    const arr2 = startDateShouldBe.split('/')
                    const result = (arr1[0].trim() === arr2[2].trim()) && (arr1[1].trim() === arr2[1].trim()) && (arr1[2].trim() === arr2[0].trim())
                    await assert.equal(result, true, 'Publish page: start date is incorrect ');
                    const startTimeShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].startTime;
                    await assert.equal(startTimeShouldBe, date[1], 'Publish page: start time is incorrect ');
                });

            test.it('Crowdsale end time/date is correct',
                async function () {
                    const endTime = await publishPage.getCrowdsaleEndTime()
                    const date = endTime.split(' ')
                    const arr1 = date[0].split('-')
                    const endDateShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[1].endDate;
                    const arr2 = endDateShouldBe.split('/')
                    const result = (arr1[0].trim() === arr2[2].trim()) && (arr1[1].trim() === arr2[1].trim()) && (arr1[2].trim() === arr2[0].trim())
                    await assert.equal(result, true, 'Publish page: end date is incorrect ');
                    const startTimeShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[1].endTime;
                    await assert.equal(startTimeShouldBe, date[1], 'Publish page: end time is incorrect ');
                });

            test.it('Wallet address is correct',
                async function () {
                    const result = await publishPage.getWalletAddress()
                    return await assert.equal(crowdsaleMintedSimple.walletAddress, result, 'Publish page: wallet address is incorrect ');
                });


            test.it('Publish page : compiler version is correct',
                async function () {
                    const result = await publishPage.getCompilerVersion()
                    return await assert.equal(result.includes('0.4.'), true, 'Publish page: compiler version is incorrect ');
                });

            test.it('Publish page : contract name is correct',
                async function () {
                    const result = await publishPage.getContractName()
                    return await assert.equal(result, 'MintedCappedProxy', 'Publish page: contract name is incorrect ');
                });

            test.it('Publish page : optimized flag is correct',
                async function () {
                    const result = await publishPage.getOptimized()
                    return await assert.equal(result, 'Yes', 'Publish page: optimized flag name is incorrect ');
                });

            test.it('Publish page: contract source code is displayed and correct ',
                async function () {
                    const contract = await publishPage.getTextContract()
                    crowdsaleMintedSimple.sort = 'minted'
                    const shouldBe = await Utils.getContractSourceCode(crowdsaleMintedSimple)
                    return await assert.equal(contract, shouldBe, 'Publish page:contract source code isn\'t correct ');
                });

            test.it('Publish page: encoded ABI is displayed and correct ',
                async function () {
                    const abi = await publishPage.getEncodedABI()
                    return await assert.equal(abi.length, 256, 'Publish page:encoded ABI isn\'t correct ');
                });
        })
        describe('Tier#1', async function () {
            test.it('Tier start time/date is correct',
                async function () {
                    const startTime = await publishPage.getTierStartTime(1)
                    const date = startTime.split(' ')
                    const arr1 = date[0].split('-')
                    const startDateShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].startDate;
                    const arr2 = startDateShouldBe.split('/')
                    const result = (arr1[0].trim() === arr2[2].trim()) && (arr1[1].trim() === arr2[1].trim()) && (arr1[2].trim() === arr2[0].trim())
                    await assert.equal(result, true, 'Publish page: start date is incorrect ');
                    const startTimeShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].startTime;
                    await assert.equal(startTimeShouldBe, date[1], 'Publish page: start time is incorrect ');
                });

            test.it('Tier end time/date is correct',
                async function () {
                    const endTime = await publishPage.getTierEndTime(1)
                    const date = endTime.split(' ')
                    const arr1 = date[0].split('-')
                    const endDateShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].endDate;
                    const arr2 = endDateShouldBe.split('/')
                    const result = (arr1[0].trim() === arr2[2].trim()) && (arr1[1].trim() === arr2[1].trim()) && (arr1[2].trim() === arr2[0].trim())
                    await assert.equal(result, true, 'Publish page: end date is incorrect ');
                    const startTimeShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].endTime;
                    await assert.equal(startTimeShouldBe, date[1], 'Publish page: end time is incorrect ');
                });

            test.it('Rate is correct',
                async function () {
                    const result = await publishPage.getRate(1)
                    return await assert.equal(crowdsaleMintedSimple.tiers[0].rate, result, 'Publish page: rate is incorrect ');
                });
            test.it('Allow modifying is correct',
                async function () {
                    const result = (await publishPage.getAllowModifying(1)) === 'on'
                    return await assert.equal(crowdsaleMintedSimple.tiers[0].allowModify, result, 'Publish page: allow modify is incorrect ');
                });
            test.it('Maxcap is correct',
                async function () {
                    const result = await publishPage.getMaxcap(1)
                    return await assert.equal(crowdsaleMintedSimple.tiers[0].supply, result, 'Publish page: maxcap is incorrect ');
                });
            test.it('Whitelisting is correct',
                async function () {
                    const result = (await publishPage.getWhitelisting(1)) === 'yes'
                    return await assert.equal(crowdsaleMintedSimple.tiers[0].isWhitelisted, result, 'Publish page: whitelisting is incorrect ');
                });
            test.it('Mincap is correct',
                async function () {
                    const result = await publishPage.getMincap(1)
                    return await assert.equal('0', result, 'Publish page: mincap is incorrect ');
                });
        })
        describe('Tier#2', async function () {
            test.it('Tier start time/date is correct',
                async function () {
                    const startTime = await publishPage.getTierStartTime(2)
                    const date = startTime.split(' ')
                    const arr1 = date[0].split('-')
                    const startDateShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].endDate;
                    const arr2 = startDateShouldBe.split('/')
                    const result = (arr1[0].trim() === arr2[2].trim()) && (arr1[1].trim() === arr2[1].trim()) && (arr1[2].trim() === arr2[0].trim())
                    await assert.equal(result, true, 'Publish page: start date is incorrect ');
                    const startTimeShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[0].endTime;
                    await assert.equal(startTimeShouldBe, date[1], 'Publish page: start time is incorrect ');
                });

            test.it('Tier end time/date is correct',
                async function () {
                    const endTime = await publishPage.getTierEndTime(2)
                    const date = endTime.split(' ')
                    const arr1 = date[0].split('-')
                    const endDateShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[1].endDate;
                    const arr2 = endDateShouldBe.split('/')
                    const result = (arr1[0].trim() === arr2[2].trim()) && (arr1[1].trim() === arr2[1].trim()) && (arr1[2].trim() === arr2[0].trim())
                    await assert.equal(result, true, 'Publish page: end date is incorrect ');
                    const startTimeShouldBe = JSON.parse(fs.readFileSync(scenarioSimple, "utf8")).tiers[1].endTime;
                    await assert.equal(startTimeShouldBe, date[1], 'Publish page: end time is incorrect ');
                });

            test.it('Rate is correct',
                async function () {
                    const result = await publishPage.getRate(2)
                    return await assert.equal(crowdsaleMintedSimple.tiers[1].rate, result, 'Publish page: rate is incorrect ');
                });
            test.it('Allow modifying is correct',
                async function () {
                    const result = (await publishPage.getAllowModifying(2)) === 'off'
                    return await assert.equal(result, true, 'Publish page: allow modify is incorrect ');
                });
            test.it('Maxcap is correct',
                async function () {
                    const result = await publishPage.getMaxcap(2)
                    return await assert.equal(crowdsaleMintedSimple.tiers[1].supply, result, 'Publish page: maxcap is incorrect ');
                });
            test.it('Whitelisting is correct',
                async function () {
                    const result = (await publishPage.getWhitelisting(2)) === 'no'
                    return await assert.equal(result, true, 'Publish page: whitelisting is incorrect ');
                });
            test.it('Mincap is correct',
                async function () {
                    const result = await publishPage.getMincap(2)
                    return await assert.equal(crowdsaleMintedSimple.tiers[1].minCap, result, 'Publish page: mincap is incorrect ');
                });
        })
        describe('Check alert, buttons', async function () {
            test.it('Alert displayed after refresh ',
                async function () {
                    await publishPage.refresh()
                    await driver.sleep(2000);
                    let result = await publishPage.isPresentAlert();
                    return await assert.equal(result, true, "Test FAILED.  Alert does not present if user refresh the page");
                });
            test.it('Warning displayed after accepting alert ',
                async function () {
                    await publishPage.acceptAlert()
                    const result = await publishPage.waitUntilShowUpWarning()
                        && await publishPage.clickButtonOK()
                    return await assert.equal(result, true, "Test FAILED.  Warning does not present");
                });

            test.it('Button \'Download file\' is presented and clickable, notice appears ',
                async function () {
                    const result = !await publishPage.waitUntilShowUpWarning(15)
                    await publishPage.clickButtonDownload()
                    && await publishPage.waitUntilShowUpErrorNotice()
                    return await assert.equal(result, true, ' button \'Download file\' isn\'t present ');
                });
            test.it('Clicking button \'Continue\' opens Crowdsale page ',
                async function () {
                    const result = await publishPage.clickButtonContinue()
                        && await publishPage.waitUntilLoaderGone()
                        && await crowdsalePage.waitUntilShowUpTitle()
                    return await assert.equal(result, true, 'Crowdsale page hasn\'t opened ');
                });
        })

        describe('Crowdsale page:', async function () {

            test.it('Proxy address is correct ',
                async function () {
                    const result = await crowdsalePage.getProxyAddress()
                    return await assert.equal(result.length, 42, 'Proxy address is incorrect');
                });
            test.it('Raised funds is correct ',
                async function () {
                    const result = await crowdsalePage.getRaisedFunds()
                    return await assert.equal(result, '0 ETH', 'Raised funds is incorrect');
                });
            test.it('Goal funds is correct ',
                async function () {
                    const result = await crowdsalePage.getGoalFunds()
                    const goal = crowdsaleMintedSimple.tiers[0].supply / crowdsaleMintedSimple.tiers[0].rate + crowdsaleMintedSimple.tiers[1].supply / crowdsaleMintedSimple.tiers[1].rate
                    return await assert.equal(result.includes(goal.toString().slice(0, 15)), true, 'Goal funds is incorrect');
                });
            test.it('Tokens claimed is correct ',
                async function () {
                    const result = await crowdsalePage.getTokensClaimed()
                    return await assert.equal(result, '0', 'Tokens claimed is incorrect')
                });
            test.it('Contributors number is correct ',
                async function () {
                    const result = await crowdsalePage.getContributors()
                    return await assert.equal(result, '0', 'Contributors number is incorrect')
                });

            test.it('Rate is correct ',
                async function () {
                    const result = await crowdsalePage.getRate()
                    return await assert.equal(result, crowdsaleMintedSimple.tiers[1].rate, 'Rate is incorrect')
                });

            test.it('Total supply is correct ',
                async function () {
                    const result = await crowdsalePage.getTotalSupply()
                    const goal = crowdsaleMintedSimple.tiers[0].supply + crowdsaleMintedSimple.tiers[1].supply
                    return await assert.equal(result, goal, 'Total supply is incorrect')
                });

            test.it('Clicking button \'Continue\' opens Contribution page ',
                async function () {
                    const result = await crowdsalePage.clickButtonContribute()
                        && await crowdsalePage.waitUntilLoaderGone()
                        && await contributionPage.waitUntilShowUpCountdownTimer()
                    return await assert.equal(result, true, 'Contribution page hasn\'t opened ');
                });
        })

        describe('Contribution page:', async function () {
            test.it('Should be alert if invalid proxyID in address bar',
                async function () {
                    crowdsaleMintedSimple.url = await contributionPage.getURL()
                    let wrongUrl = crowdsaleMintedSimple.url.substring(0, 50) + crowdsaleMintedSimple.url.substring(52, crowdsaleMintedSimple.length)
                    let result = await contributionPage.open(wrongUrl)
                        && await contributionPage.waitUntilShowUpButtonOk()
                        && await contributionPage.clickButtonOK()
                    return await assert.equal(result, true, 'Test FAILED. Contribution page: no alert if invalid proxyID in address bar');
                });
            test.it('Should be alert if invalid proxyID in address bar',
                async function () {
                    let owner = Owner;
                    crowdsaleMintedSimple.proxyAddress = await contributionPage.getProxyAddress()
                    let wrongCrowdsale = crowdsaleMintedSimple;
                    wrongCrowdsale.proxyAddress = crowdsaleMintedSimple.proxyAddress.substring(0, crowdsaleMintedSimple.proxyAddress.length - 5)
                    let result = await owner.openCrowdsalePage(wrongCrowdsale)
                        && await contributionPage.waitUntilShowUpButtonOk()
                        && await contributionPage.clickButtonOK()
                    return await assert.equal(result, true, 'Test FAILED. Crowdsale page: no alert if invalid proxyID in address bar');
                });
        })
    })
})