def set_driver_path(self): """ Set a correct PATH to the Selenium Web driver :return: None """ logger.info("Preparing driver path.") self.path = CURRENT_DIR + "\\drivers\\MicrosoftWebDriver" logger.info("Driver path set to - {}".format(self.path))
def set_driver_path(self): """ Setting Opera driver path. :return: None """ logger.info("Preparing driver path.") self.path = CURRENT_DIR + "\\drivers\\operadrivers\\operadriver-" + self.version + "\\operadriver.exe" logger.info("Driver path set.")
def set_driver_path(self): """ Set a correct PATH to the Selenium Web driver :return: None """ logger.info("Preparing driver path.") self.path = CURRENT_DIR + "\\drivers\\firefoxdrivers\\geckodriver-" + self.version + "\\geckodriver.exe" logger.info("Driver path set to - {}".format(self.path))
def open_browser(driver, url): """ Opens given url in the browsers. :param driver: Browser driver :param url: Case URL :return: None """ logger.info("Opening {}".format(url)) driver.get(url)
def make_and_save_screenshot(path): """ Makes and saves the screenshot into correct path. :param path: PATH where screenshots will be saved :return: None """ logger.info("Saving screenshot to - {}".format(path)) snapshot = ImageGrab.grab() snapshot.save(path)
def terminate_thread(thread): """ Terminate the thread. :param thread: Thread to be terminated :return: None """ if thread.is_alive(): logger.info("Terminating the thread") thread.terminate() thread.join()
def create_edge_driver(self): """ Setting Edge driver to be able to open URL. :return: None """ logger.info("Preparing driver.") driver = webdriver.Edge(executable_path=self.capabilities) driver.maximize_window() logger.info("Driver is set.") return driver
def create_firefox_driver(self): """ Setting Firefox driver to be able to open URL. :return: Selenium WebDriver """ logger.info("Preparing driver.") driver = webdriver.Firefox(executable_path=self.path, capabilities=self.capabilities) driver.maximize_window() logger.info("Driver is set.") return driver
def create_chromium_driver(self): """ Setting Chromium driver with special windows size. Otherwise it won"t open maximized in older versions. :return: WebDriver """ driver = webdriver.Chrome(desired_capabilities=self.capabilities, executable_path=self.path) driver.set_window_size(1024, 600) driver.maximize_window() logger.info("Driver is set.") return driver
def set_driver_version(self, browser_version): """ Returns the folder name for chromedrivers of the given version. :param browser_version: :return: Driver version """ logger.info("Getting chromedriver version.") if browser_version >= 78: self.version = "78" if browser_version == 77: self.version = "77" if browser_version == 76: self.version = "76" if browser_version == 75: self.version = "75" if browser_version == 74: self.version = "74" if 72 <= browser_version < 74: self.version = "2.46" if 70 <= browser_version < 72: self.version = "2.45" if 68 <= browser_version < 70: self.version = "2.42" if 66 <= browser_version < 68: self.version = "2.40" if 64 <= browser_version < 66: self.version = "2.37" if 62 <= browser_version < 64: self.version = "2.35" if 60 <= browser_version < 62: self.version = "2.33" if 58 <= browser_version < 60: self.version = "2.30" if 56 <= browser_version < 58: self.version = "2.29" if 54 <= browser_version < 56: self.version = "2.27" if 46 <= browser_version < 54: self.version = "2.20" if 43 <= browser_version < 46: self.version = "2.18" if 40 <= browser_version < 43: self.version = "2.15" if 36 <= browser_version < 40: self.version = "2.12" if 34 <= browser_version < 36: self.version = "2.10" if 32 <= browser_version < 34: self.version = "2.9" if 30 <= browser_version < 32: self.version = "2.8" if browser_version < 30: self.version = "2.6" logger.info("Chromedriver version - {}".format(self.version))
def browsers_summary(conn): """ Creates and executes query to get all browsers :param conn: DB connection :return: None """ cursor = conn.cursor() brwosers_total = "SELECT COUNT(browser) FROM collection" cursor.execute(brwosers_total) record = cursor.fetchone()[0] logger.info("{} browsers processed.".format(record)) cursor.close()
def read_config(): """ Loads data from config.yaml to cfg. :return: Configuration in Python readable format """ with open("config.yaml", "r") as yamlfile: try: conf = yaml.safe_load(yamlfile) except yaml.YAMLError as exc: logger.info( "Some error occurred while reading config.yaml - {}".format( exc)) return conf
def create_opera_driver(self): """ Setting Opera driver to be able to open URL. :return: WebDriver """ logger.info("Preparing driver.") webdriver_service = service.Service(self.path) webdriver_service.start() driver = webdriver.Remote(webdriver_service.service_url, self.capabilities) driver.maximize_window() logger.info("Driver is set.") return driver
def new_directory(item): """ Creates new directory if does not exist. :param item: Directory to be created :return: None """ if os.path.exists(item): logger.info("# Directory exists, not creating: {}".format(item)) else: logger.info("# Creating directory: {}".format(item)) try: os.makedirs(item) except OSError: logger.error("Error occured while creating: {}".format(item))
def remove_item(item): """ Removes the given directory. :param item: Directory to be removed :return: None """ if os.path.exists(item): logger.info("# Removing item: {}".format(item)) try: os.rmdir(item) except OSError: logger.error("Error occured while deleting item: {}".format(item)) else: logger.info("# Item does not exist, not removing: {}".format(item))
def edge(browser): """ Opens Edge browsers and makes a screenshot of the desired website. :param browser: Browser :return: None """ edge_driver = prepare_driver() driver = edge_driver.create_edge_driver() try: open_browser(driver, browser.url) screenshot_website(driver, browser, ie=True) finally: logger.info("Closing the browsers.") driver.quit()
def get_screenshot_case_path(path, browser): """ Gets the path for case directory where the screenshot will be saved. :param path: Screenshots directory path :param browser: Browser :return: Finalized PATH where case screenshots will be saved """ logger.info("Preparing path where screenshot will be saved.") directory = path + "\\cases" + "\\" + browser.case + "\\" + browser.package if not os.path.exists(directory): os.makedirs(directory) screenshot_name = browser.version + ".png" screenshot_path = directory + "\\" + screenshot_name logger.info("Screenshot CASE path set - {}".format(screenshot_path)) return screenshot_path
def set_capabilities(self): """ Setting capabilities for Chromium. :return: Capabilities """ logger.info("Setting chromium capabilities.") opts = Options() opts.binary_location = "C:\\Program Files (x86)\\Chromium\\Application\\chrome.exe" opts.add_experimental_option( "excludeSwitches", ["ignore-certificate-errors", "ignore-ssl-errors"]) capabilities = DesiredCapabilities.CHROME capabilities.update(opts.to_capabilities()) capabilities["acceptInsecureCerts"] = False capabilities["acceptSslCerts"] = False self.capabilities = capabilities
def set_driver_version(self, browser_version): """ Setting Firefox driver version. :param browser_version: Browser version :return: Driver version """ logger.info("Getting geckodriver version.") if browser_version >= 62: self.version = "24" elif 52 <= browser_version < 62: self.version = "17" elif 47 <= browser_version < 52: self.version = "14" elif browser_version < 47: self.version = "11" logger.info("Geckodriver version - {}".format(self.version))
def set_capabilities(self, browser_version): """ Setting Firefox capabilities. :param browser_version: Browser version :return: None """ # Marionette is protocol used to communicate with Gecko Driver in versions 48 and higher. capabilities = DesiredCapabilities.FIREFOX capabilities["marionette"] = True capabilities["acceptInsecureCerts"] = False capabilities["acceptSslCerts"] = False # For Firefox 47 and lower the marionette needs to be set to False because it is not included. if browser_version < 47: capabilities["marionette"] = False logger.info("Capabilities are set to - {}".format(capabilities)) self.capabilities = capabilities
def screenshots_summary(conn): """ Creates and executes query to get all collected screenshots :param conn: DB connection :return: None """ cursor = conn.cursor() total_query = "SELECT * FROM collection" cursor.execute(total_query) total = len(cursor.fetchall()) get_query = "SELECT SUM(screenshots) FROM collection" cursor.execute(get_query) record = cursor.fetchone()[0] logger.info("{} screenshots collected out of {} possible.".format( record, total * get_cases_from_conf())) cursor.close()
def set_id(ie): """ Set the ID of element present on the cert page :param ie: True if IE is the actual browser, False otherwise :return: ID of element that Selenium will look for on current case web site """ # ID for internet explorer page id_ie = "invalidcert_mainTitle" # ID for other browsers page id_other = "content" if ie: logger.info("Setting the ID to - {}".format(id_ie)) final_id = id_ie else: logger.info("Setting the ID to - {}".format(id_other)) final_id = id_other return final_id
def open_opera(driver, browser, old_driver=False): """ Run screenshot in different thread. :param driver: Driver :param browser: Browser :param old_driver: True if opera runs old driver, False otherwise :return: None """ try: if old_driver: logger.info("Starting timeout_and_screenshot.") timeout_and_screenshot(driver, browser) else: open_browser(driver, browser.url) screenshot_website(driver, browser) except Exception as e: logger.error("Error in open_opera: {}".format(e))
def set_opera_driver_oldness(self): """ Checking if Opera driver version is lower than 2.40. If yes, sets the old value to True, False otherwise :return: None """ logger.info("Checking if the Opera version is lower than 2.40") if self.version == "0.2.2": self.version = "0.2" if self.version == "0.2.0": self.version = "0.2" if self.version == "0.1.0": self.version = "0.1" if float(self.version) < 2.40: logger.info("Opera version is using old driver. - True") self.old = True
def set_driver_version(self, browser_version): """ Returns the folder name for operadrivers of the given version. :param browser_version: Browser version :return: Driver version """ logger.info("Getting operadriver version.") if browser_version >= 63: self.version = "76" if browser_version == 62: self.version = "2.41" if 58 < browser_version < 62: self.version = "2.45" if 56 < browser_version <= 58: self.version = "2.36" if browser_version == 56: self.version = "2.40" if browser_version == 55: self.version = "2.38" if browser_version == 54: self.version = "2.37" if browser_version == 53: self.version = "2.36" if 50 < browser_version <= 52: self.version = "2.35" if browser_version == 50: self.version = "2.33" if browser_version == 49: self.version = "2.33" if browser_version == 48: self.version = "2.30" if browser_version == 47: self.version = "2.30" if 42 < browser_version <= 46: self.version = "2.29" if 40 < browser_version <= 42: self.version = "2.27" if 26 < browser_version <= 40: self.version = "0.2.2" if browser_version == 26: self.version = "0.2.0" if browser_version <= 25: self.version = "0.1.0" logger.info("Operadriver version - {}".format(self.version))
def install_browser(browser, version): """ Installs the given browsers version. :param browser: Browser :param version: Browser version :return: True if installation was successful, False otherwise """ cmd = "choco install " + str(cfg.get("browsers")[browser].get("package")) + " --force --version="\ + str(version) + " --yes --nocolor --limit-output --no-progress --ignore-checksums " \ "--log-file=choco-log.log" logger.info("# Installing the browser.") process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) logger.info("# Please wait...") for _ in process.stdout.readlines(): process.wait() return process.returncode
def screenshot_website(driver, browser, opera=False, ie=False): """ Makes a screenshot of the opened website. :param driver: Browser WebDriver :param browser: Browser :param opera: True if older opera version, False otherwise :param ie: True if IE is the actual browser, False otherwise :return: None """ logger.info("Going to make screenshot.") new_directory(SCREENSHOT_PATH_BASE) # If alert window appears, Accept and continue to the website. logger.info("Waiting until the website is loaded.") try: load_website(driver, browser, opera=opera, ie=ie) except Exception as e: logger.error("Error occured in function 'shot()' - {}".format(e)) finally: kill_browser()
def print_progress_bar(progress_percentage): """ Prints the progress bar. :param progress_percentage: Actual progress percentage number :return: None """ length = 40 perc_graph = (length * progress_percentage) / 100 output = "[" counter = 0 for i in range(int(perc_graph)): output += "=" counter += 1 for j in range((length - counter) + 1): output += " " output += "] " output += str(round(progress_percentage, 2)) output += "%" logger.info(output) logger.info("")
def get_ssl_screenshot(browser, version): """ Gets the screenshot of SSL warning in the given browsers version. :param browser: Browser :param version: Browser version :return: None """ logger.info("# Preparing iteration.") all_cases = len(cfg.get("cases")) for index, case in enumerate(cfg.get("cases")): progress = set_progress_percentage(index, all_cases) try: output(browser, str(version), case) open_webpage( cfg.get("browsers")[browser].get("binary"), cfg.get("cases")[case].get("url"), case, str(version), cfg.get("browsers")[browser].get("package")) except Exception as e: logger.error("Something went TERRIBLY wrong. - {}".format(e)) print_progress(progress, cases=True)
def set_capabilities(self, browser): """ Setting capabilities for Opera. :return: Capabilities """ logger.info("Setting capabilities.") opts = Options() if not self.old: # In older version these switches do not work, but alerts are there by default. opts.add_experimental_option( "excludeSwitches", ["ignore-certificate-errors", "ignore-ssl-errors"]) capabilities = DesiredCapabilities.OPERA capabilities.update(opts.to_capabilities()) capabilities["acceptInsecureCerts"] = False capabilities["acceptSslCerts"] = False capabilities["operaOptions"] = { "binary": "C:\\Program Files\\Opera\\" + browser.version + "\\opera.exe" } logger.info("Capabilities are set.") self.capabilities = capabilities