コード例 #1
0
class InterviewModulePage:
    __e_interview_module_xpath = Locators.TITLE['title'].format('Interview Module')
    __e_new_form_xpath = Locators.ACCOUNT['new_form']
    __e_click_radio_css = Locators.BUTTONS['radio']

    def __init__(self, driver):
        self.driver = driver
        self.wait = WebElementWait(self.driver)
        self.scroll = PageScroll(self.driver)
        self.notifier = Notifier(self.driver)

    def interview_module(self):
        try:
            self.scroll.down(0, -100)
            time.sleep(0.5)
            self.wait.web_element_wait_click(By.XPATH, self.__e_interview_module_xpath, 'interview_module')
            time.sleep(1)
            return True
        except Exception as error:
            ui_logger.error(error)

    def new_form_setting(self):
        try:
            self.scroll.down(0, -100)
            self.wait.web_element_wait_click(By.XPATH, self.__e_new_form_xpath, 'new_form_setting')
            return True
        except Exception as error:
            ui_logger.error(error)

    def enable_new_form(self):
        try:
            time.sleep(1)
            self.wait.web_elements_wait_multiple_click(By.CSS_SELECTOR, self.__e_click_radio_css, 'On')
            return True
        except Exception as error:
            ui_logger.error(error)

    def disable_new_form(self):
        try:
            time.sleep(1)
            self.wait.web_elements_wait_multiple_click(By.CSS_SELECTOR, self.__e_click_radio_css, 'Off')
            return True
        except Exception as error:
            ui_logger.error(error)

    def save_notifier(self, message):
        try:
            time.sleep(0.8)
            self.notifier.glowing_messages(message)
            return True
        except Exception as error:
            ui_logger.error(error)

    def notifier_dismiss(self):
        try:
            self.notifier.dismiss_message()
            time.sleep(0.5)
            return True
        except Exception as error:
            ui_logger.error(error)
コード例 #2
0
class EventConfiguration:

    __e_click_radio_css = Locators.BUTTONS['radio']
    __e_user_id_xpath = Locators.TITLE['title'].format('Current Status')
    __e_search_user_xpath = Locators.TITLE['title'].format('Type here to search')
    __e_select_search_item_xpath = Locators.MULTI_SELECTIONS['moveAllItemsRight']
    __e_done_button_xpath = Locators.BUTTONS['done']
    __e_save_button_xpath = Locators.BUTTONS['button'].format('save')

    def __init__(self, driver):
        self.driver = driver
        self.wait = WebElementWait(self.driver)
        self.notifier = Notifier(self.driver)

    def on_off_buttons(self, button_name):
        try:
            time.sleep(1)
            self.wait.web_elements_wait_multiple_click(By.CSS_SELECTOR, self.__e_click_radio_css, button_name)
            return True
        except Exception as error:
            ui_logger.error(error)

    def user_id_chat(self):
        try:
            self.wait.web_element_wait_click(By.XPATH, self.__e_user_id_xpath, 'chat_user_filed_click')
            return True
        except Exception as error:
            ui_logger.error(error)

    def search_user_chat(self, user_name):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH, self.__e_search_user_xpath, user_name, 'search_chat_user')
            self.wait.web_element_wait_click(By.XPATH, self.__e_select_search_item_xpath, 'Move_all_items')
            self.wait.web_element_wait_click(By.XPATH, self.__e_done_button_xpath, 'Done_button')
            return True
        except Exception as error:
            ui_logger.error(error)

    def enable_disable_button(self, button_name):
        try:
            self.wait.web_elements_wait_click(By.CSS_SELECTOR, self.__e_click_radio_css, button_name)
            return True
        except Exception as error:
            ui_logger.error(error)

    def save_buttons(self, button_name, message):
        try:
            self.wait.web_elements_wait_multiple_click(By.XPATH, self.__e_save_button_xpath, button_name)
            self.notifier.glowing_messages(message)
            self.notifier.dismiss_message()
            return True
        except Exception as error:
            ui_logger.error(error)
コード例 #3
0
class JobAutomations:

    __e_registration_stage_xpath = Locators.JOB['registration_hop']
    __e_eligibility_stage_xpath = Locators.JOB['eligibility_hop']
    __e_offer_stage_xpath = Locators.JOB['offer_stage']
    __e_hopping_stage_xpath = Locators.JOB['hop_stage_field']
    __e_hopping_status_xpath = Locators.JOB['hop_status_field']
    __e_toggle_buttons_css = Locators.JOB['toggle_buttons']
    __e_save_xpath = Locators.BUTTONS['button'].format('Save')

    def __init__(self, driver):
        self.driver = driver
        self.wait = WebElementWait(self.driver)
        self.scroll = PageScroll(self.driver)
        self.notifier = Notifier(self.driver)

    def registration_stage(self):
        try:
            time.sleep(0.6)
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_registration_stage_xpath,
                                             'registration_stage')
            print('Clicked - On registration stage')
            return True
        except Exception as error:
            ui_logger.error(error)

    def eligibility_stage(self):
        try:
            time.sleep(0.6)
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_eligibility_stage_xpath,
                                             'eligibility_stage')
            print('Clicked - On eligibility stage')
            return True
        except Exception as error:
            ui_logger.error(error)

    def offer_stage(self):
        try:
            time.sleep(0.6)
            self.scroll.down(0, -300)
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_offer_stage_xpath,
                                             'offer_stage')
            print('Clicked - On offer stage')
            return True
        except Exception as error:
            ui_logger.error(error)

    def hop_stage(self, stage):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_hopping_stage_xpath,
                                                 stage, 'hop_stage')
            print('Select - Hopping stage')
            return True
        except Exception as error:
            ui_logger.error(error)

    def hop_status(self, status):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_hopping_status_xpath,
                                                 status, 'hop_status')
            print('Select - Hopping status')
            return True
        except Exception as error:
            ui_logger.error(error)

    def all_round_button_on(self):
        try:
            time.sleep(0.5)
            self.scroll.up(0, 100)
            self.wait.web_elements_wait_multiple_click(
                By.CSS_SELECTOR, self.__e_toggle_buttons_css, '')
            print('Auto Tag to test - ON')
            print('Eligibility Criteria - ON')
            print('Self Schedule - ON')
            return True
        except Exception as error:
            ui_logger.error(error)

    def automation_save(self):
        try:
            time.sleep(0.5)
            self.scroll.down(0, -300)
            self.wait.web_element_wait_click(By.XPATH, self.__e_save_xpath,
                                             'automation_save')
            print('Job Automation Configuration - Save')
            return True
        except Exception as error:
            ui_logger.error(error)

    def job_automation_save_notifier(self, message):
        try:
            time.sleep(0.7)
            self.notifier.glowing_messages(message)
            return True
        except Exception as error:
            ui_logger.error(error)

    def job_automations_notifier_dismiss(self):
        try:
            self.notifier.dismiss_message()
            return True
        except Exception as error:
            ui_logger.error(error)
コード例 #4
0
class EventCreation:

    __e_new_event_xpath = Locators.BUTTONS['create']
    __e_event_name_xpath = Locators.PLACEHOLDER['text_ph'].format('Name')
    __e_event_req_name_xpath = Locators.PLACEHOLDER['text_ph'].format(
        'Requirement')
    __e_event_job_xpath = Locators.TITLE['title'].format('Job Roles')
    __e_event_slot_xpath = Locators.PLACEHOLDER['text_ph'].format('Slot')
    __e_event_from_date_xpath = Locators.PLACEHOLDER['place_holder'].format(
        'From')
    __e_event_to_date_xpath = Locators.PLACEHOLDER['place_holder'].format('To')
    __e_event_report_date_xpath = Locators.PLACEHOLDER['place_holder'].format(
        'Reporting Date')
    __e_event_manager_xpath = Locators.PLACEHOLDER['place_holder'].format(
        'Event Manager')
    __e_event_college_xpath = Locators.PLACEHOLDER['place_holder'].format(
        'College')
    __e_event_ec_css = Locators.BUTTONS['radio']
    __e_event_create_xpath = Locators.BUTTONS['actionClicked'].format(
        "'", 'create', "'")

    def __init__(self, driver):
        self.driver = driver
        self.wait = WebElementWait(self.driver)
        self.notifier = Notifier(self.driver)
        self.scroll = PageScroll(self.driver)

    def new_event_button(self):
        try:
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_new_event_xpath,
                                             'new_event_button')
            print('New event creation button - Clicked')
            self.wait.loading()
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_name_field(self, event_name):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_event_name_xpath,
                                                 event_name,
                                                 'event_name_field')
            print(f'New event name - {event_name} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_req_field(self, req_name):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_event_req_name_xpath,
                                                 req_name, 'event_req_field')
            time.sleep(1)
            self.wait.drop_down_selection()
            self.wait.loading()
            print(f'New event req name - {req_name} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_job_field(self):
        try:
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_event_job_xpath,
                                             'event_job_field')
            print('Event job field - Clicked')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_slot_field(self, slot):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_event_slot_xpath,
                                                 slot, 'event_slot_field')
            self.wait.drop_down_selection()
            print(f'New event slot - {slot} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_from_date(self, from_date):
        try:
            self.wait.web_element_wait_send_keys(
                By.XPATH, self.__e_event_from_date_xpath, from_date,
                'event_from_date')
            print(f'New Event from date - {from_date} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_to_date(self, to_date):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_event_to_date_xpath,
                                                 to_date, 'event_to_date')
            print(f'New Event to date - {to_date} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_report_date(self, report_date):
        try:
            self.wait.web_element_wait_send_keys(
                By.XPATH, self.__e_event_report_date_xpath, report_date,
                'event_to_date')
            print(f'New Event reporting date - {report_date} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_manager_field(self, event_manager):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_event_manager_xpath,
                                                 event_manager,
                                                 'event_manager_field')
            self.wait.drop_down_selection()
            print(f'Event manager name - {event_manager} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_college_field(self, college):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_event_college_xpath,
                                                 college,
                                                 'event_college_field')
            self.wait.drop_down_selection()
            print(f'Event college name - {college} - Entered')
            self.wait.loading()
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_ec_enable(self):
        try:
            self.scroll.down(0, -50)
            time.sleep(0.6)
            button = ' Enable'
            self.wait.web_elements_wait_multiple_click(By.CSS_SELECTOR,
                                                       self.__e_event_ec_css,
                                                       button)
            print(f'Event Ec - {button} - Selected')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_create_button(self):
        try:
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_event_create_xpath,
                                             'event_create_button')
            self.wait.drop_down_selection()
            print('Event Create button - Clicked')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_create_notifier(self, message):
        try:
            time.sleep(0.7)
            self.notifier.glowing_messages(message)
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_create_notifier_dismiss(self):
        try:
            self.notifier.dismiss_message()
            time.sleep(0.9)
            self.wait.loading()
            return True
        except Exception as error:
            ui_logger.error(error)
コード例 #5
0
class EventTestConfigPage:
    __e_event_test_config_btn_xpath = Locators.BUTTONS[
        'btnActionClicked'].format("'", 'configure', "'")
    __e_job_name_xpath = Locators.PLACEHOLDER['text_ph'].format('Job Role')
    __e_stage_xpath = Locators.PLACEHOLDER['text_ph'].format('Stage')
    __e_test_xpath = Locators.PLACEHOLDER['text_ph'].format('Test')
    __e_test_active_css = Locators.BUTTONS['radio']
    __e_test_save_xpath = Locators.BUTTONS['button'].format('Save')
    __e_test_config_cancel_xpath = Locators.BUTTONS['all_buttons'].format(
        'CANCEL')

    def __init__(self, driver):
        self.driver = driver
        self.wait = WebElementWait(self.driver)
        self.notifier = Notifier(self.driver)

    def event_test_configure_button(self):
        try:
            self.wait.web_element_wait_click(
                By.XPATH, self.__e_event_test_config_btn_xpath,
                'event_test_configure_button')
            print('Event Test Configuration button - Clicked')
            self.wait.loading()
            return True
        except Exception as error:
            ui_logger.error(error)

    def test_job_name_field(self, job_name):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_job_name_xpath,
                                                 job_name,
                                                 'test_job_name_field')
            self.wait.drop_down_selection()
            print(f'Test Configuration Job Name - {job_name} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def test_stage_name_field(self, stage_name):
        try:
            time.sleep(0.8)
            self.wait.web_element_wait_send_keys(By.XPATH,
                                                 self.__e_stage_xpath,
                                                 stage_name,
                                                 'test_job_name_field')
            self.wait.drop_down_selection()
            print(f'Test Configuration stage Name - {stage_name} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def test_test_name_field(self, test_name):
        try:
            self.wait.web_element_wait_send_keys(By.XPATH, self.__e_test_xpath,
                                                 test_name,
                                                 'test_job_name_field')
            self.wait.drop_down_selection()
            print(
                f'Test Configuration Assessment Name - {test_name} - Entered')
            return True
        except Exception as error:
            ui_logger.error(error)

    def test_active_enable(self):
        try:
            time.sleep(0.6)
            button = ' On'
            self.wait.web_elements_wait_multiple_click(
                By.CSS_SELECTOR, self.__e_test_active_css, button)
            print(f'Event Ec - {button} - Selected')
            return True
        except Exception as error:
            ui_logger.error(error)

    def event_test_configure_save(self):
        try:
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_test_save_xpath,
                                             'event_test_configure_save')
            print('Event Test Configuration Save - Clicked')
            self.wait.loading()
            return True
        except Exception as error:
            ui_logger.error(error)

    def test_tag_notifier(self, message):
        try:
            time.sleep(0.7)
            self.notifier.glowing_messages(message)
            return True
        except Exception as error:
            ui_logger.error(error)

    def test_tag_notifier_dismiss(self):
        try:
            self.notifier.dismiss_message()
            time.sleep(0.7)
            return True
        except Exception as error:
            ui_logger.error(error)

    def cancel_test_extra_config(self):
        try:
            self.wait.loading()
            self.wait.web_element_wait_click(By.XPATH,
                                             self.__e_test_config_cancel_xpath,
                                             'cancel_test_extra_config')
            return True
        except Exception as error:
            ui_logger.error(error)