Software-testing Forum_1

import argparse
import unittest
import tkinter
from tkinter.filedialog import askopenfilename
from tkinter.messagebox import askyesno
import time
import os
import sys

from openpyxl.comments.comments import Comment
from openpyxl.styles import Style
from openpyxl.styles.colors import Color

from openpyxl.styles.fills import PatternFill
import openpyxl
from selenium.common.exceptions import TimeoutException
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By

from webfeatures import click
from webfeatures import send_keys
from webfeatures import wait_for_loading
from webfeatures import set_up
from webfeatures import login
from webfeatures import design_creation
from webfeatures import select_by_part_number
from webfeatures import selecting_by_visible_text
from webfeatures import wait_for_staleness
from webfeatures import resistor_changing
from webfeatures import field_param_setting
from webfeatures import unlock_with_change
from webfeatures_locator_generators import field_by_p_name_locator_generator, design_dialog_locator, table_cell_locator
from webfeatures_locator_generators import component_field_locator_generator
from webfeatures_locator_generators import simple_component_field_locator_generator


# Possible CL arguments for parser

default_config = r'D:\Python\PIXlsScript\PIXlsDialogs_Config_TinySwitch4.xlsx'


default_log = '{cur_dir}{path_to_log}'.format(
    cur_dir=os.path.dirname(os.path.realpath(__file__)),
    path_to_log='\\error_log\\')

dateTimeStamp = time.strftime('%Y.%m.%d %H.%M.%S')

parser = argparse.ArgumentParser(add_help=True,
                                 description='Arguments for script',
                                 formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-i', '--input-config',
                    default=default_config,
                    type=str,
                    help='Input config file')
parser.add_argument('-o', '--output-report',
                    type=str,
                    help='Output report file')
parser.add_argument('--output-log',
                    type=str,
                    default=default_log,
                    help='Output log file')
parser.add_argument('--user-dialog',
                    action='store_true',
                    help='Offer the user dialog to choose ')
args = parser.parse_args()

test_count = passed_count = failed_count = errors_count = 0

if args.user_dialog:
    root = tkinter.Tk()
    root.geometry('0x0+0+7300')
    root.update_idletasks()
    answer = askyesno('Config file choose',
                      'Do you want to use default config? '
                      'Default config is: {config}'
                      .format(config=default_config), parent=root)
    if answer:
        config_path = args.input_config
    else:
        config_path = askopenfilename()
    root.destroy()
else:
    config_path = args.input_config

input_config = openpyxl.load_workbook(config_path, data_only=True)

report = input_config.get_sheet_by_name('Dialogs')

link_test = report.cell('B2').value
path_report = args.output_report if args.output_report else report.cell('B3').value
path_report += '\\'
if not os.path.exists(path_report):
    os.makedirs(path_report)
if not os.path.exists(args.output_log):
    os.makedirs(args.output_log)
log_file = open(args.output_log + '{name}_{time}.txt'.format(name=os.path.basename(config_path), time=dateTimeStamp),
                'w')
username = report.cell('B4').value
password = '@' + report.cell('B5').value
family = report.cell('B6').value


max_rows = report.get_highest_row() + 1
test_config = []


def set_test(name, i):
    test_config.append([name, {'parameter to change': report.cell(row=i, column=3).value,
                               'changed value': report.cell(row=i, column=4).value,
                               'parameter to check': report.cell(row=i, column=5).value,
                               'reference value': report.cell(row=i, column=6).value,
                               'row': i, 'col': 8}, True if report.cell(row=i, column=7).value == 'Yes' else False])


dialog_family = ''
for i in range(15, max_rows):
    dialog_family = report.cell('A' + str(i)).value if report.cell('A' + str(i)).value else dialog_family
    cell = report.cell('B' + str(i))

    possible_values = ['Input', 'Outputs', 'Key Parameters', 'Selection', 'UV/OV',
                       'UV/OV/Feedback', 'Programmable pin (PD)', 'Rectifier, Fuse, Surge', 'Capacitors',
                       'EMI Filter', 'ILIM/PLIM', 'Output OVP', 'Core Selection',
                       'Primary and Bias', 'Secondaries', 'Pin Allocation', 'Diodes',
                       'Heatsinks', 'Heatsink', 'Bias Snubber', 'Snubbers',
                       'Post Filters', 'Bias', 'Components', 'Dimming Components',
                       'Peak Detector']
    if cell.value in possible_values:
        set_test((dialog_family, cell.value), i)


class PIXlsDialogs(unittest.TestCase):
    global report
    currentResult = None

    def error_appear_check(self, message):
        """
        Answer if error with specified message is appeared and close it

        :param message: str
        :return: boolean
        """

        try:
            driver.find_element(By.XPATH, '//span[contains(text(), "{message}")]'.format(message=message))
            click(driver, (By.XPATH, '//button[@id="dlgCancelPIEEE"]'))
            return 'Error'
        except (TimeoutException, NoSuchElementException) as e:
            return False

    def compare_value(self, fst_value, scnd_value, param=None):
        """
        Compares two values and add result to report

        :arg fst_value: value from web page
        :arg scnd_value: value from configuration file
        """

        global passed_count, failed_count
        try:
            real_value = float(fst_value)
            value = float(scnd_value)
        except ValueError:
            real_value = str(fst_value)
            value = str(scnd_value)

        report.cell(row=param.get('row'), column=param.get('col')).value = fst_value
        if real_value == value:
            passed_count += 1
            report.cell(row=param.get('row'), column=(param.get('col') + 1)).value = 'PASS'
            report.cell(row=param.get('row'), column=(param.get('col') + 1)).style = Style(
                fill=PatternFill(patternType='solid', fgColor=Color('ff60ff60')))
        else:
            self.fail('Values are not eq')

    def dialog_init(self, param):
        """
        Main initialization of every dialog

        :param param:
        :return: tuple, changed_value -- should be set up to changed_param;
                        changed_param -- field, that should be changed ([0] -- component, [1] -- field);
                        refer_value -- expected result of check_param;
                        check_param -- parameter for compliance test.
        """
        changed_value = param[1].get('changed value')
        refer_value = param[1].get('reference value')


        # Open Dialog
        click(driver, design_dialog_locator(param[0][0], param[0][1]))

        # Parsing block and parameter to change
        changed_param = param[1].get('parameter to change').split(': ')
        check_param = param[1].get('parameter to check').split(': ')

        return changed_value, refer_value, changed_param, check_param

    def designTabs(self, param):
        changed_value, refer_value, changed_param, check_param = self.dialog_init(param)

        legend = changed_param[0]
        field = changed_param[1]

        designTabs = self.driver.find_element(By.XPATH, "//div[@id='designTabs']")
        field_to_check = driver.find_element(*field_by_p_name_locator_generator(field))
        # Send new value to it
        field_param_setting(driver, changed_param[0], changed_value)


@classmethod
    def setUpClass(cls):
        global report, driver
        super(PIXlsDialogs, cls).setUpClass()

        driver = set_up()
        login(driver, link_test, username, password)

        # dimming check for PH and PL
        dimming = 'PH' in family or 'PL' in family
        design_creation(driver, family, 'pixls')