python selenium automation package

# coding = utf-8
from selenium.webdriver.common.action_chains import ActionChains
from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
import time
import os
from selenium.webdriver.support.select import Select
from read_init import ReadIni
from selenium.webdriver.common.keys import Keys
from handle_json import handle_json


#类使用
class SelenimuDriver():
    def __init__(self):
        self.driver = self.open_browser()

    def open_browser(self,browser='chrome'):
        try:
            if browser == 'chrome':
                driver = webdriver.Chrome()
            elif browser == 'firefox':
                driver = webdriver.Firefox()
            elif browser == 'ie':
                driver = webdriver.Ie()
            else:
                driver = webdriver.Edge()    
            time.sleep(1)
            return driver
        except:
            print("open browser fail!")
            return None

    def get_url(self,url):
        if self.driver !=None:
            self.driver.maximize_window()
            if 'http://' in url:
                self.driver.get(url)
            else:
                print("Your url have a problem!")
        else:
            print('can\'t get browser')
        self.driver.quit()

    def handle_windows(self,*args):
        value = len(args)
        if value == 1:
            if args[0] == 'max':
                self.driver.maximize_window()
            elif args[0] == 'min':
                self.driver.minimize_window()
            elif args[0] == 'back':
                self.driver.back()
            elif args[0] == 'go':
                self.driver.forward()
            elif args[0] == 'refresh':
                self.driver.refresh()
            else:
                print('don\'t have this operating')
        elif value == 2:
           self. driver.set_window_size(args[0],args[1])
        else:
            print('You Parameters is error!')
        time.sleep(4)
        self.driver.quit()

    def assert_title(self,title_name = None):
        '''
        判断title是否正确
        :param title_name:
        :return: get_title()
        '''
        if title_name != None:
            get_title = EC.title_contains(title_name)
            return get_title(self.driver)

    def open_url_is_true(self,url,title_name = None):
        self.get_url(url)
        return self.assert_title(title_name)

    def close_driver(self):
        self.driver.close()

    def switch_windows(self,title_name=None):
        '''
        切换windows
        :param title_name:
        :return:
        '''
        handle_list = self.driver.window_handles
        current_handle = self.driver.current_window_handle
        for i in handle_list:
            if i != current_handle:
                time.sleep(2)
                self.driver.switch_to.window(i)
                if self.assert_title(title_name):
                    break
        time.sleep(2)
        self.driver.find_element_by_id('userId').send_keys('test')
        time.sleep(2)

    def element_isdisplay(self,element):
        flag = element.is_displayed()
        if flag == True:
            return element
        else:
            return False

    def get_element(self,info):
        '''
        获取元素element
        :param by:
        :param value:
        :return:
        '''
        try:
            by,value = self.get_local_element('username')
            element = None
            if by == 'id':
                element = self.driver.find_element_by_id(value)
            elif by == 'name':
                element = self.driver.find_element_by_name(value)
            elif by == 'css' :
                Element == self.driver.find_element_by_css_selector (value)
             elif by == ' class ' : 
                Element == self.driver.fing_element_by_class_name (value)
             the else : 
                Element == self.driver.find_element_by_xpath (value)
         the except :
             Print ( " Location way: " , by, " targeting value " , value, " the positioning error, there is no successful positioning " ) 

        return self.element_isdisplay (Element)

     DEF elements_isdisplay(self,elements):
        flag_list = []
        flags = elements.is_displayed()
        for flag in flags:
            if flag == False:
                continue
            else:
                flag_list.append(flag)
        return flag_list


    def get_elements(self,info):
        '''
        获取元素element
        :param by:
        :param value:
        :return:
        '''
        try:
            elements = None
            elements = []
            by,value = self.get_local_element(info)
            if by == 'id':
                elements = self.driver.find_elements_by_id(value)
            elif by == 'name':
                elements = self.driver.find_elements_by_name(value)
            elif by == 'css':
                elements == self.driver.find_elements_by_css_selector(value)
            elif by == 'class ' : 
                Elements == self.driver.fing_elements_by_class_name (value)
             the else : 
                Elements == self.driver.find_elements_by_xpath (value)
         the except :
             Print ( " targeting: " , by, " targeting value " , value, " positioning error no location success " )
         return self.elements_isdisplay (Elements) 

    DEF get_list_element (Self, info, index): 
        Elements = self.get_elements (info)
         IF index> len(elements):
            return  None
        return elements[index]

    def get_level_element(self,info_level,node_info):
        '''

        :param by:
        :param value:
        :param node_by:
        :param node_value:
        :return:
        '''
        element = self.get_element(info_level)
        node_by,node_value = node_info
        if element == False:
            return False

        if node_by == 'id':
            node_element = element.find_element_by_id(node_value)
        elif node_by =='name':
            node_element = element.find_element_by_name(node_value)
        elif node_by =='css':
            node_element = element.find_element_by_css_selector(node_value)
        elif node_by =='class':
            node_element = element.find_element_by_class_name(node_value)
        else:
            node_element =element.find_element_by_xpath (node_value)
         return self.element_isdisplay (node_element) 


    DEF assert_element (Self, Element):
         Pass 

    DEF send_value (Self, by, value, Key):
         '' ' 
        input value 
        ' '' 
        Element = self.get_element (by, value)
         IF element == False:
             Print ( " input fails, the positioning elements can not edit " )
         the else :
             IF ! element = None: 
                element.send_keys (Key) 
            the else :
                 Print (" Input fails, the positioning element not looking to play " ) 

    DEF click_element (Self, info):
         '' ' 
        Click elements 
        : param by: 
        : param value: 
        : return: 
        ' '' 
        Element = self.get_element (info)
         IF Element =! False:
             IF element =! None: 
                element.click () 
            the else :
                 Print ( " click failure, the positioning element is not found " )
         the else :
             Print ( " click failure, invisible elements " )

    def check_box_isselected(self,info,check = None):

        element = self.get_element(info)
        if element != False:
            flag = element.is_selected()
            if flag == True:
                if check != 'check':
                    self.click_element(info)
            else:
                if check == 'check':
                    self.click_element(info)
        else:
            print("Element is not visible, can not select " ) 


    DEF get_local_element (Self, info): 
        Data = ReadIni.get_value (info) 
        data_info = data.split ( ' > ' )
         # Print (data_info) 
        # by data_info = [0] 
        # local = data_info [. 1] 
        # [name, In Email] 
        return data_info 

    DEF get_selected (Self, info, value_index, index = None):
         '' ' 
        acquired by the index we seleced, then choose our selected 
        : param info: 
        : param value_index: 
        : param index : 
        : return: 
        '' '
        selected_element = None
        if index != None:
            selected_element = self.get_list_element(info,index)
        else:
            selected_element = self.get_element(info)
        Select(selected_element).select_by_index(value_index)

    def upload_file(self,file_name):
        '''
        上传文件
        :param file_name:
        :return:
        '''
        pykey = PyKeyboard()
        # pykey.tap_key(pykey.shift_key)
        pykey.type_string("D: \\ \\ download test.png " ) 
        the time.sleep ( 2 ) 
        pykey.tap_key (pykey.enter_key) 

    DEF upload_file_function (Self, file_name):
         Pass 
        # first get to upload files element tag type (input file) send_keys Upload file 

    DEF calendar (Self, info, value):
         '' ' 
        edit calendar 
        : param info: 
        : param value: 
        : return: 
        ' '' 
        Element = self.get_element (info)
         the try : 
            element.get_attribute ( ' Readonly ' ) 
            Self .js_excute_calendar (info)
        the except :
             Print ( " this is not a read-only familiar calendar " ) 
        element.clear () 
        self.send_value (info.value) 

    DEF moveto_element_mouse (Self, info):
         '' ' 
        Move the mouse 
        : param info: 
        : return: 
        ' '' 
        Element = self.get_element (info) 
        ActionChains (self.driver) .move_to_element (Element) .perform () 


    DEF refresh_f5 (Self):
         '' ' 
        mandatory refresh 
        ' '' 
        ActionChains (self.driver) .key_down (Keys.CONTROL) .send_keys (Keys.F5) .key_up (Keys.CONTROL) .perform () 

    DEFswitch_iframe (Self, info, Tag = None):
         '' ' 
        switching iframes 
        : param info: 
        : param Tag: 
        : return: 
        ' '' 
        IF info =! None: 
            iframe_element = self.get_element (info) 
            self.driver.switch_to. Frame (iframe_element) 
        the else : 
            self.driver.switch_to.default_content () 

    DEF switch_alert (Self, info, value = None):
         '' ' 
        system-level pop 
        : param info: confirm or cancel 
        : param value: whether input values 
        : return: 
        '' ' 
        windows_alert = self.driver.switch_to.alert
        if info == 'accept':
            if value == None:
                windows_alert.accept()
            else:
                windows_alert.send_keys(value)
                windows_alert.accept()
            windows_alert.accept()
        else:
            windows_alert.dismiss()

    def scroll_get_element(self,list_info,str_info):
        t = True
        list_element = self.get_elements(list_info)
        js = 'document.documentElement.scrollTop = 100000;'
        while t:
            for element in list_element:
                title_name = element.find_element_by_tag_name('p').text
                if title_name in str_info:
                    element.click()
                    t = False
            self.driver.execute_script(js)
            time.sleep(3)

    def scroll_element(self,info):
        js = 'document.documentElement.scrollTop = 1000;'
        t = True
        while t:
            try:
                self.get_element(info)
                t = False
            except:
                self.driver.execute_script(js)

    def get_cookie(self):
        cookie = self.driver.get_cookies()
        handle_json.write_data(cookie)

    def set_cookie(self):

        cookie = handle_json.get_data()
        self.driver.delete_all_cookies()
        time.sleep(1)

        self.driver.add_cookie(cookie)
        time.sleep(2)

    def save_png(self):
        now_time = time.strftime('%Y%m%d.%H.%M.%S')
        self.driver.get_screenshot_as_file('%s.png' %now_time)




if __name__ == '__main__':
    os.system("taskkill /f /im chromedriver.exe")
    selfnium_driver = SelenimuDriver()
#*************************测试方法


# selfnium_driver.open_browser()
#print (selfnium_driver.open_url_is_true ( 'http://www.imooc.com', ' programmer'))
# The time.sleep (30) 
# selfnium_driver.switch_windows ( 'Web site connections')

 

Guess you like

Origin www.cnblogs.com/zsjlovewm/p/11305547.html