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
