def create_local_driver(config):
driver = None
if config["browser"] == "chrome":
driver_manager = ChromeDriverManager()
options = get_chrome_options(config)
driver = webdriver.Chrome(
executable_path=driver_manager.install(),
options=options,
)
elif config["browser"] == "firefox" or "ff":
driver_manager = GeckoDriverManager("82.0")
options = get_firefox_options(config)
driver = webdriver.Firefox(
executable_path="Core/drivers/geckodriver.exe",
options=options,
)
return driver
def driver(config):
url = config['url']
selenoid = config['selenoid']
if not selenoid:
manager = ChromeDriverManager(version='latest')
driver = webdriver.Chrome(executable_path=manager.install())
else:
capabilities = {'browserName': "chrome", 'version': '80'}
options = ChromeOptions()
driver = webdriver.Remote(command_executor=selenoid,
options=options,
desired_capabilities=capabilities)
driver.get(url)
driver.maximize_window()
yield driver
driver.quit()
def test_chrome_manager_cached_driver_with_selenium():
custom_path = os.path.join(os.path.dirname(os.path.dirname(__file__)),
"custom")
manager = ChromeDriverManager(path=custom_path)
driver = webdriver.Chrome(manager.install())
driver.get("http://automation-remarks.com")
metadata_file = os.path.join(custom_path, 'drivers.json')
with open(metadata_file) as json_file:
data = json.load(json_file)
for k in data.keys():
data[k]['timestamp'] = "08/06/2019"
with open(metadata_file, 'w') as outfile:
json.dump(data, outfile)
ChromeDriverManager(path=custom_path).install()
def __init__(self):
chrome_options = Options()
chrome_options.add_argument("--disable-extensions")
# chrome_options.add_argument('--headless')
# chrome_options.add_argument('--disable-gpu')
chrome_options.add_argument('--disable-setuid-sandbox')
chrome_obj = ChromeDriverManager()
self.order_url = "https://sellercentral.amazon.in/orders-v3/order/"
self.driver = webdriver.Chrome(executable_path=chrome_obj.install(),
chrome_options=chrome_options)
self.main_window = self.driver.current_window_handle
self.order_details = {}
self.wait = WebDriverWait(self.driver, 90, poll_frequency=0.1,
ignored_exceptions=[NoSuchElementException, ElementNotVisibleException,
ElementNotSelectableException])
def driver(config):
options = webdriver.ChromeOptions()
options.add_experimental_option('prefs', {'intl.accept_languages': f'en,en-us'})
if not config["selenoid"]:
manager = ChromeDriverManager(version=config['version'])
browser = webdriver.Chrome(executable_path=manager.install(), options=options)
else:
capabilities = {'acceptInsecureCerts': True,
'browserName': 'chrome',
'version': config['version'],
}
browser = webdriver.Remote(command_executor=config['selenoid'],
options=options,
desired_capabilities=capabilities)
browser.maximize_window()
browser.get(config['url'])
yield browser
browser.close()
def driver(config):
browser = config['browser']
version = config['version']
url = config['url']
selenoid = config['selenoid']
if not selenoid:
manager = ChromeDriverManager(version=version)
driver = webdriver.Chrome(executable_path=manager.install())
else:
options = ChromeOptions()
capabilities = {'acceptInsecureCerts': True,
'browserName': 'chrome',
'version': '80.0'}
driver = webdriver.Remote(command_executor=selenoid,
options=options,
desired_capabilities=capabilities)
driver.get(url)
driver.maximize_window()
yield driver
driver.close()
def driver(config):
selenoid_server = config["selenoid"]
if selenoid_server:
capabilities = {
'acceptInsecureCerts': True,
'browserName': "chrome",
'version': '80',
}
driver = webdriver.Remote(
command_executor=f'http://{selenoid_server}/wd/hub/',
desired_capabilities=capabilities)
else:
manager = ChromeDriverManager(version=config["version"])
driver = webdriver.Chrome(
executable_path=manager.install(),
desired_capabilities={'acceptInsecureCerts': True})
driver.get(config['url'])
driver.maximize_window()
yield driver
driver.quit()
def load_chromedriver():
webdriver_manager = None
try:
webdriver_manager = ChromeDriverManager(
chrome_type=ChromeType.CHROMIUM)
except:
pass
if webdriver_manager is None:
try:
webdriver_manager = ChromeDriverManager(
chrome_type=ChromeType.GOOGLE)
except:
pass
if webdriver_manager is None:
logging.error("Failed to find chrome/chromium")
exit(1)
return webdriver_manager.install()
def driver(config):
browser = config['browser']
version = config['version']
url = config['url']
download_dir = config['download_dir']
selenoid = config['selenoid']
print(selenoid)
if browser == 'chrome':
options = ChromeOptions()
if selenoid:
capabilities = {
'acceptInsecureCerts': True,
'browserName': 'chrome'
}
driver = webdriver.Remote(command_executor=selenoid,
options=options,
desired_capabilities=capabilities)
else:
options.add_argument("--window-size=800,600")
prefs = {"download.default_directory": download_dir}
options.add_experimental_option('prefs', prefs)
manager = ChromeDriverManager(version=version)
driver = webdriver.Chrome(
executable_path=manager.install(),
options=options,
desired_capabilities={'acceptInsecureCerts': True})
else:
raise UnsupportedBrowserException(f'Unsupported browser: "{browser}"')
driver.get(url)
driver.maximize_window()
yield driver
# quit = закрыть страницу, остановить browser driver
# close = закрыть страницу, бинарь browser driver останется запущенным
driver.quit()
def driver(config):
browser = config['browser']
version = config['version']
url = config['url']
download_dir = config['download_dir']
selenoid = config['selenoid']
window_size = config['window_size']
if browser == 'chrome':
options = ChromeOptions()
if selenoid:
capabilities = {
'acceptInsecureCerts': True,
'browserName': browser
}
driver = webdriver.Remote(command_executor=selenoid,
options=options,
desired_capabilities=capabilities)
else:
options.add_argument(f"--window-size={window_size}")
prefs = {"download.default_directory": download_dir}
options.add_experimental_option('prefs', prefs)
manager = ChromeDriverManager(version=version)
driver = webdriver.Chrome(
executable_path=manager.install(),
options=options,
desired_capabilities={'acceptInsecureCerts': True})
else:
raise UnsupportedBrowserException(f'Unsupported browser: "{browser}"')
driver.get(url)
driver.maximize_window()
yield driver
driver.quit()
def driver(config):
"""
Need for UI test with Chrome
:param config: config of browser
"""
browser = config["browser"]
version = config['version']
selenoid = config["selenoid"]
url = ''
if browser == "chrome":
if selenoid != 'True':
url = config["url"]
manager = ChromeDriverManager(version=version)
driver = webdriver.Chrome(executable_path=manager.install())
else:
selenoid = 'http://0.0.0.0:4444/wd/hub'
url = config['url_sel']
options = ChromeOptions()
options.add_argument("--window-size=800,600")
prefs = {"download.default_directory": '/tmp'}
options.add_experimental_option('prefs', prefs)
capabilities = {
'acceptInsecureCerts': True,
'browserName': browser,
'version': version,
}
driver = webdriver.Remote(command_executor=selenoid,
options=options,
desired_capabilities=capabilities)
else:
raise NotChrome("Sorry, work only with chrome")
driver.maximize_window()
driver.get(url)
yield driver
driver.quit()
def driver(config):
browser = config['browser']
version = config['version']
url = config['url']
selenoid = config['selenoid']
if browser == 'chrome' and selenoid == 'None':
options = ChromeOptions()
options.add_argument("--window-size=800,600")
manager = ChromeDriverManager(version='latest')
driver = webdriver.Chrome(
executable_path=manager.install(),
options=options,
desired_capabilities={'acceptInsecureCerts': True})
elif selenoid != 'None':
options = ChromeOptions()
options.add_argument("--window-size=800,600")
capabilities = {
'acceptInsecureCerts': True,
'browserName': 'chrome',
'version': version,
}
driver = webdriver.Remote(command_executor='http://' + selenoid +
'/wd/hub/',
options=options,
desired_capabilities=capabilities)
else:
raise UsupportedBrowserException(f'Usupported browser: "{browser}"')
driver.get(url)
driver.maximize_window()
yield driver
driver.close()
def driver(config):
browser = config['browser']
version = config['version']
url = config['url']
selenoid = config['selenoid']
if browser == 'chrome':
if not selenoid:
manager = ChromeDriverManager(version=version)
driver = webdriver.Chrome(executable_path=manager.install())
else:
options = ChromeOptions()
driver = webdriver.Remote(
command_executor=selenoid,
options=options,
desired_capabilities={'acceptInsecureCerts': True})
else:
raise UsupportedBrowserException(f'Usupported browser: "{browser}"')
driver.get(url)
driver.maximize_window()
yield driver
driver.close()
def driver(config):
url = config['url']
browser = config['browser']
version = config['version']
selenoid = config['selenoid']
if browser == 'chrome':
if selenoid == 'False':
manager = ChromeDriverManager(version=version)
driver = webdriver.Chrome(executable_path=manager.install())
else:
capabilities = {
'acceptInsecureCerts': True,
'browserName': 'chrome',
'version': '80.0'
}
driver = webdriver.Remote(command_executor=selenoid,
desired_capabilities=capabilities)
else:
raise UnsupportedBrowserException(f'Браузер {browser} не поддерживается')
driver.get(url)
driver.maximize_window()
yield driver
driver.close()
def driver(config):
browser = config['browser']
version = config['version']
selenoid = config['selenoid']
url = config['url']
download_dir = config['download_dir']
if browser == 'chrome':
options = ChromeOptions()
options.add_argument("--window-size=800,600")
prefs = {"download.default_directory": download_dir}
options.add_experimental_option('prefs', prefs)
driver = None
if selenoid is not None:
options.set_capability("browserVersion", version)
driver = webdriver.Remote(
command_executor='http://' + selenoid + '/wd/hub/',
options=options,
desired_capabilities={'acceptInsecureCerts': True})
else:
manager = ChromeDriverManager(version=version)
driver = webdriver.Chrome(
executable_path=manager.install(),
options=options,
desired_capabilities={'acceptInsecureCerts': True})
else:
raise UsupportedBrowserException(f'Usupported browser: "{browser}"')
driver.get(url)
driver.maximize_window()
yield driver
driver.quit()
def runtest():
global config
global datafile
os.system(clearterminal)
if config["test_type"] == "proxy" and config["proxy"] == "":
input(
"ERR: Cannot run proxy based test, configure proxy settings first")
return 99
if config["test_type"] == "pac" and config["pac"] == "":
input("ERR: Cannot run pac based test, configure pac settings first")
return 99
test_label = input("Input test label: ")
while not re.match("^.+$", test_label):
print("ERR: Invalid input [ " + test_label + " ], try again")
test_label = input("\nInput test label: ")
currentDT = datetime.datetime.now()
test_label = test_label + currentDT.strftime("(%Y-%m-%d %H:%M)")
print("\n## Test Information ##")
print("-----------------------\n")
print("Label: " + test_label)
print("Test Type: " + config["test_type"])
if config["test_type"] == "proxy":
print("Proxy: " + config["proxy"])
chrome_options.add_argument("--proxy-server=" + config["proxy"])
if config["test_type"] == "pac":
print("Proxy: " + config["pac"])
chrome_options.add_argument("--proxy-pac-url=" + config["pac"])
print("Incognito Mode: " + config["incognito"])
if re.match("^y|yes$", config["incognito"], re.IGNORECASE):
chrome_options.add_argument("--incognito")
print("")
choice = input("Is the settings correct, initiate test? (y/n): ")
while not re.match("^y|yes|n|no$", choice, re.IGNORECASE):
print("ERR: Invalid input [ " + choice + " ], try again")
choice = input("\nIs the settings correct, initiate test? (y/n): ")
if str.lower(choice[0]) == "n":
os.system(clearterminal)
return 99
os.system(clearterminal)
if config["clear_storage"] == "y":
print("Clearing Chrome Profile..")
try:
if os.path.exists(profile_path):
shutil.rmtree(profile_path)
print("Successfully removed the Chrome Profile")
else:
print("No existing Chrome profile found")
except Exception as ex:
print("Failed to delete the Chrome Profile")
# driver.execute_script('window.localStorage.clear();')
print("Initiating test. Loading new Chrome session")
print(
"NB: Do not interact with or close the script or chrome browser window until tests have been completed!\n"
)
try:
mychromedriver = ChromeDriverManager(log_level=0, cache_valid_range=7)
mychromedriverexe = mychromedriver.install()
except requests.exceptions.SSLError as err:
#install_cert()
print(
"Test Failed: SSL/TLS Interception detected, install the decryption certificate using "
"Test Settings"
" menu item")
input("Press <ENTER> to continue...")
return
except Exception as e:
print(e.__doc__)
print(e.__context__)
'''
chrome_type = ChromeType.GOOGLE
browser_version = chrome_version(chrome_type)
driver_name = mychromedriver.driver.get_name()
os_type = mychromedriver.driver.get_os_type()
driver_version = mychromedriver.driver.get_version()
mychromedriverexe = mychromedriver.driver_cache.find_driver(browser_version, driver_name, os_type,
driver_version)
'''
print("Test Failed: Could not download the required chrome webdriver")
input("Press <ENTER> to continue...")
return
#print(binary_path)
#print(mychromedriverexe)
try:
test_detail = requests.get('http://ip-api.com/json', verify=False).text
print("Test Detail: " + test_detail)
except Exception as e:
print(e.__doc__)
print(e.__context__)
data = []
# Read urls from .csv file
with open(datafile, 'r') as file:
reader = csv.DictReader(file)
for row in reader:
data.append(row)
# print(data)
file.close()
try:
#driver = webdriver.Chrome(chromedriver, options=chrome_options)
driver = webdriver.Chrome(mychromedriverexe, options=chrome_options)
driver.set_page_load_timeout(20) #Set page load timeout
for row in data:
summ = 0
i = 0
# GET link consecutively for number of passes
while i < config["passes"]:
i = i + 1
try:
driver.get(row['url'])
except TimeoutException as ex:
print("Timeout occurred requesting site, retrying pass")
i = i - 1
continue
except InvalidArgumentException as ex:
print(
"ERR: Test failed, close any open Chrome browsers and re-run the test."
)
#print(ex.__doc__)
except Exception as e:
print(e.__doc__)
navigationStart = driver.execute_script(
"return window.performance.timing.navigationStart")
redirectStart = driver.execute_script(
"return window.performance.timing.redirectStart")
redirectEnd = driver.execute_script(
"return window.performance.timing.redirectEnd")
domainLookupStart = driver.execute_script(
"return window.performance.timing.domainLookupStart")
domainLookupEnd = driver.execute_script(
"return window.performance.timing.domainLookupEnd")
connectStart = driver.execute_script(
"return window.performance.timing.connectStart")
connectEnd = driver.execute_script(
"return window.performance.timing.connectEnd")
requestStart = driver.execute_script(
"return window.performance.timing.requestStart")
responseStart = driver.execute_script(
"return window.performance.timing.responseStart")
responseEnd = driver.execute_script(
"return window.performance.timing.responseEnd")
domLoading = driver.execute_script(
"return window.performance.timing.domLoading")
domComplete = driver.execute_script(
"return window.performance.timing.domComplete")
loadEventStart = driver.execute_script(
"return window.performance.timing.loadEventStart")
loadEventEnd = driver.execute_script(
"return window.performance.timing.loadEventEnd")
redirect_calc = redirectEnd - redirectStart
dns_calc = domainLookupEnd - domainLookupStart
tcp_calc = connectEnd - connectStart
request_calc = responseStart - requestStart
response_calc = responseEnd - responseStart
processing_calc = domComplete - domLoading
onload_calc = loadEventEnd - loadEventStart
frontend_calc = domComplete - responseStart
backend_calc = responseStart - navigationStart
total_calc = frontend_calc + backend_calc
summ += total_calc
# calculate average and store in results dictionary
row[test_label] = (int)(summ /
config["passes"]) # calculate the average
print(row)
except NoSuchWindowException as ex:
print("ERR: Test failed, did you close the browser window?")
input("Press <ENTER> to continue...")
return
except Exception as e:
print(e.__doc__)
print(e.__context__)
print("ERR: Test failed.")
input("Press <ENTER> to continue...")
return
driver.quit()
# print(data)
# writing result metrics in file
fields = list(data[0])
with open(datafile, 'w') as file:
writer = csv.DictWriter(file, fieldnames=fields, lineterminator="\n")
writer.writeheader()
writer.writerows(data)
file.close()
print(
"Test Completed, you can now plot the data using the graph menu option."
)
graph_data()
from selenium import webdriver
from selenium.webdriver.common.by import By
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.firefox import GeckoDriverManager
import time
broswerName = "chrome"
if broswerName == "chrome":
driver= webdriver.Chrome(ChromeDriverManager.install())
elif broswerName == "firefox":
driver = webdriver.firefox(executable_path=GeckoDriverManager.install())
else:
print('Please select required broswer'+broswerName)
followers.append(a)
else:
followers.append(i.split(' ',1))
headers = ['Username', 'Name', 'Follow']
with open('followers.csv','w',encoding="utf-8") as f:
csv_writer = csv.writer(f)
csv_writer.writerow(headers)
csv_writer.writerows(followers)
except FileNotFoundError:
f = open('followers.csv','x')
f.close()
store_followers_details(list_followers)
if __name__ == '__main__':
option = webdriver.ChromeOptions()
# option.add_argument('--headless')
option.add_argument("--log-level=3")
option.add_experimental_option('excludeSwitches', ['enable-logging'])
prefs = {"profile.default_content_setting_values.notifications" : 2}
option.add_experimental_option("prefs",prefs)
CDM = ChromeDriverManager(log_level='0')
driver = webdriver.Chrome(CDM.install(), options=option)
login_choice(driver)
driver.quit()
from bs4 import BeautifulSoup
from selenium import webdriver
import selenium.webdriver.support.ui as ui
from webdriver_manager.chrome import ChromeDriverManager
from database import orm
import datetime
import typing
import requests
driver_manager = ChromeDriverManager()
chrome_drive_path = None
try:
chrome_drive_path = driver_manager.install()
except:
chrome_drive_path = driver_manager._file_manager.get_cache_path()
owner_type_name = 'site'
class Scraper:
def get_page(self, url) -> BeautifulSoup:
source_code = requests.get(url)
plain_text = source_code.text
soup = BeautifulSoup(plain_text, 'html.parser')
return soup
@classmethod
def get_page_by_driver(cls, url: str,
wait_element_selector: str) -> BeautifulSoup:
options = webdriver.ChromeOptions()