def __init__(self, profile=None, extensions=None, user_agent=None,
profile_preferences=None, fullscreen=False, wait_time=2):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if user_agent is not None:
firefox_profile.set_preference(
'general.useragent.override', user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self.driver = Firefox(firefox_profile)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def __init__(self, profile=None, extensions=None, user_agent=None, profile_preferences=None):
self.old_popen = subprocess.Popen
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override', user_agent)
if profile_preferences:
for key, value in profile_preferences.iteritems():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self._patch_subprocess()
self.driver = Firefox(firefox_profile)
self._unpatch_subprocess()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__()
def __init__(self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None):
self.old_popen = subprocess.Popen
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override',
user_agent)
if profile_preferences:
for key, value in profile_preferences.iteritems():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self._patch_subprocess()
self.driver = Firefox(firefox_profile)
self._unpatch_subprocess()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__()
def create_fast_firefox_profile():
quickjava_url = 'https://addons.mozilla.org/firefox/downloads/latest/1237/addon-1237-latest.xpi'
if not os.path.isfile(get_file_name_from_url(quickjava_url)):
# download the extension
downloadFile(quickjava_url)
## get the Firefox profile object
firefox_profile = FirefoxProfile()
## Disable CSS
firefox_profile.set_preference('permissions.default.stylesheet', 2)
## Disable images
firefox_profile.set_preference('permissions.default.image', 2)
## Disable Flash
firefox_profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so',
'false')
firefox_profile.add_extension(get_file_name_from_url(quickjava_url))
firefox_profile.set_preference(
"thatoneguydotnet.QuickJava.curVersion",
"2.0.6.1") ## Prevents loading the 'thank you for installing screen'
firefox_profile.set_preference(
"thatoneguydotnet.QuickJava.startupStatus.Images",
2) ## Turns images off
firefox_profile.set_preference(
"thatoneguydotnet.QuickJava.startupStatus.AnimatedImage",
2) ## Turns animated images off
def __init__(self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override',
user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self.driver = Firefox(firefox_profile)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def getDriver(httpProxy = '', type='Firefox'):
if type == 'Firefox':
proxy = Proxy({
'proxyType': ProxyType.MANUAL,
'httpProxy': httpProxy,
'ftpProxy': httpProxy,
'sslProxy': httpProxy,
'noProxy': '' # set this value as desired
})
firefox_profile = FirefoxProfile()
#firefox_profile.add_extension("firefox_extensions/adblock_plus-2.5.1-sm+tb+an+fx.xpi")
firefox_profile.add_extension("firefox_extensions/webdriver_element_locator-1.rev312-fx.xpi")
firefox_profile.set_preference("browser.download.folderList",2)
firefox_profile.set_preference("webdriver.load.strategy", "unstable")
#driver = webdriver.Firefox(firefox_profile = firefox_profile, proxy=proxy, firefox_binary=FirefoxBinary('/usr/bin/firefox'))
#driver = webdriver.Firefox(firefox_profile = firefox_profile, proxy=proxy, firefox_binary=FirefoxBinary("/cygdrive/c/Program\ Files\ (x86)/Mozilla\ Firefox/firefox.exe"))
driver = webdriver.Firefox(firefox_profile = firefox_profile, proxy=proxy)
elif type == 'PhantomJS': # PhantomJS
service_args = [
'--proxy='+httpProxy,
'--proxy-type=http',
]
webdriver.DesiredCapabilities.PHANTOMJS['phantomjs.page.customHeaders.Accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8'
webdriver.DesiredCapabilities.PHANTOMJS['phantomjs.page.customHeaders.User-Agent'] = 'Mozilla/5.0 (X11; Windows x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.117 Safari/537.36'
driver = webdriver.PhantomJS(executable_path='windows/phantomjs.exe', service_args=service_args)
else: # Chrome
chrome_options = webdriver.ChromeOptions()
#chrome_options.add_extension('firefox_extensions/adblockplus_1_7_4.crx')
chrome_options.add_argument('--proxy-server=%s' % httpProxy)
driver = webdriver.Chrome(executable_path='windows/chromedriver.exe', chrome_options=chrome_options)
return driver
def __init__(self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2,
timeout=90,
capabilities=None,
headless=False,
incognito=False,
**kwargs):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference("extensions.logging.enabled", False)
firefox_profile.set_preference("network.dns.disableIPv6", False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
firefox_options = Options()
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference("general.useragent.override",
user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
firefox_options.add_argument("--headless")
if incognito:
firefox_options.add_argument("-private")
self.driver = Firefox(firefox_profile,
capabilities=firefox_capabilities,
options=firefox_options,
timeout=timeout,
**kwargs)
if fullscreen:
self.driver.fullscreen_window()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def get_driver():
from selenium import webdriver
from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
profile = FirefoxProfile()
profile.add_extension(
'C:/zz_EFG/GitHub/testscript/executables/firebug-2.0.16-fx.xpi')
d = webdriver.Firefox(firefox_profile=profile)
d.implicitly_wait(7)
return d
def __init__(self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2,
timeout=90,
capabilities=None,
headless=False,
**kwargs):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override',
user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": '1'})
binary = FirefoxBinary()
binary.add_command_line_options('-headless')
kwargs['firefox_binary'] = binary
self.driver = Firefox(firefox_profile,
capabilities=firefox_capabilities,
timeout=timeout,
**kwargs)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def process(appid):
profile = FirefoxProfile()
fireFoxOptions = webdriver.FirefoxOptions()
# 静默模式
fireFoxOptions.add_argument('--headless')
fireFoxOptions.add_argument('--no-sandbox')
fireFoxOptions.add_argument('--disable-gpu')
fireFoxOptions.add_argument('--disable-dev-shm-usage')
# 第二步：开启“手动设置代理”
profile.set_preference('network.proxy.type', 1)
# 第三步：设置代理IP
# profile.set_preference('network.proxy.http', proxy[0])
profile.set_preference('network.proxy.http', 'http-dyn.abuyun.com')
# 第四步：设置代理端口，注意端口是int类型，不是字符串
# profile.set_preference('network.proxy.http_port', int(proxy[1]))
profile.set_preference('network.proxy.http_port', 9020)
# 第五步：设置htpps协议也使用该代理
profile.set_preference('network.proxy.ssl', 'http-dyn.abuyun.com')
profile.set_preference('network.proxy.ssl_port', 9020)
# Proxy auto login
credentials = '{}:{}'.format('H64W55P7KS0C4Q7D', 'D03F3742C01C78A1')
credentials = b64encode(bytes(credentials, encoding='utf-8'))
profile.add_extension('/opt/install/close_proxy_authentication-1.1.xpi')
# profile.add_extension('D:/download/close_proxy_authentication-1.1.xpi')
# profile.set_preference('extensions.closeproxyauth.authtoken', credentials)
profile.set_preference('extensions.closeproxyauth.authtoken', str(credentials, encoding='utf-8'))
profile.set_preference('modifyheaders.config.active', True)
profile.set_preference('modifyheaders.headers.count', 1)
driver = webdriver.Firefox(firefox_profile=profile, firefox_options=fireFoxOptions)
# base_url = 'view-source:https://api.qimai.cn/andapp/appinfo?analysis=%s&appid=%s'
base_url = 'view-source:https://api.qimai.cn/andapp/appinfo?analysis=%s&appid=%s'
analysis = get_analysis(appid, '/andapp/appinfo')
real_url = base_url % (urllib.parse.quote(analysis), appid)
try:
logging.info('get appinfo')
driver.get(real_url)
content = driver.find_element_by_xpath('//pre').text
except Exception:
logging.error("%s : get appinfo error" % appid)
raise Exception(appid)
finally:
driver.quit()
result = json.loads(content, encoding='utf-8')
if result['code'] != 10000:
logging.error('req code is not 10000, result : %s' % content)
raise Exception(appid)
return content
def __init__(self, profile=None, extensions=None, user_agent=None,
profile_preferences=None, fullscreen=False, wait_time=2,
timeout=90, capabilities=None, headless=False, **kwargs):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
if 'accepted_languages' in kwargs:
firefox_profile.set_preference('intl.accept_languages', kwargs['accepted_languages'])
del kwargs['accepted_languages']
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference(
'general.useragent.override', user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": '1'})
binary = FirefoxBinary()
binary.add_command_line_options('-headless')
kwargs['firefox_binary'] = binary
self.driver = Firefox(firefox_profile,
capabilities=firefox_capabilities,
timeout=timeout, **kwargs)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def __init__(self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
firefox_profile.set_preference("browser.download.folderList", 2)
firefox_profile.set_preference(
"browser.download.manager.showWhenStarting", False)
firefox_profile.set_preference("browser.download.dir", _DOWNLOAD_PATH)
firefox_profile.set_preference(
"browser.helperApps.neverAsk.saveToDisk", _ALL_MIME_TYPES)
firefox_profile.set_preference("permissions.default.microphone", 1)
firefox_profile.set_preference("permissions.default.camera", 1)
# firefox_profile.set_preference("browser.helperApps.alwaysAsk.force", False)
# firefox_profile.set_preference("browser.download.manager.showWhenStarting", False)
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override',
user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self.driver = Firefox(firefox_profile)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def __init__(self, profile=None, extensions=None):
self.old_popen = subprocess.Popen
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', 'false')
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self._patch_subprocess()
self.driver = Firefox(firefox_profile)
self._unpatch_subprocess()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__()
def __init__(self, default_wait_time=20, profile=None, extensions=None):
self.old_popen = subprocess.Popen
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self._patch_subprocess()
self.driver = Firefox(firefox_profile)
self._unpatch_subprocess()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time=default_wait_time)
def __init__(self, profile=None, extensions=None):
self.old_popen = subprocess.Popen
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self._patch_subprocess()
self.driver = Firefox(firefox_profile)
self._unpatch_subprocess()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__()
def __init__(self, server, port=4443, profile=None, extensions=None):
self.old_popen = subprocess.Popen
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self._patch_subprocess()
dest = 'http://%s:%s/wd/hub'%(server,port)
self.driver = Remote(dest, {}, firefox_profile)
self._unpatch_subprocess()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__()
def __init__(self, profile=None, extensions=None, user_agent=None,
profile_preferences=None, fullscreen=False, wait_time=2,
timeout=90, capabilities=None, log_path=None):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference(
'general.useragent.override', user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
log_path = log_path if log_path is not None else os.devnull
self.driver = Firefox(firefox_profile,
capabilities=firefox_capabilities,
timeout=timeout,
log_path=log_path)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def _init_webdriver():
# get the Firefox profile object
fp = FirefoxProfile()
# Disable CSS
fp.set_preference('permissions.default.stylesheet', 2)
# Disable images
fp.set_preference('permissions.default.image', 2)
# Disable Flash
fp.set_preference('dom.ipc.plugins.enabled.libflashplayer.so',
'false')
# Block Pop ups
fp.set_preference('browser.popups.showPopupBlocker', 'true')
# Install ad block plus
fp.add_extension("adblockplusfirefox.xpi")
# Set the modified profile while creating the browser object
return webdriver.Firefox(fp)
def __init__(
self, profile=None, extensions=None, user_agent=None, profile_preferences=None, wait_time=2, firefox_path=None
):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference("extensions.logging.enabled", False)
firefox_profile.set_preference("network.dns.disableIPv6", False)
if user_agent is not None:
firefox_profile.set_preference("general.useragent.override", user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if firefox_path:
firefox_binary = FirefoxBinary(firefox_path=firefox_path)
self.driver = Firefox(firefox_profile=firefox_profile, firefox_binary=firefox_binary)
else:
self.driver = Firefox(firefox_profile)
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def __init__(self, profile=None, extensions=None, user_agent=None, profile_preferences=None, wait_time=2):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override', user_agent)
if profile_preferences:
for key, value in profile_preferences.iteritems():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
firefox_profile.profile_dir=firefox_profile.profile_dir.encode('ascii','ignore')
self.driver = Firefox(firefox_profile)
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def __init__(self, profile=None, extensions=None, user_agent=None,
profile_preferences=None, wait_time=2, firefox_path=None):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
if user_agent is not None:
firefox_profile.set_preference('general.useragent.override',
user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if firefox_path:
firefox_binary = FirefoxBinary(firefox_path=firefox_path)
self.driver = Firefox(firefox_profile=firefox_profile,
firefox_binary=firefox_binary)
else:
self.driver = Firefox(firefox_profile)
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def __init__(self, profile=None, extensions=None, user_agent=None,
profile_preferences=None, fullscreen=False, wait_time=2):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference('extensions.logging.enabled', False)
firefox_profile.set_preference('network.dns.disableIPv6', False)
firefox_profile.set_preference("browser.download.folderList", 2)
firefox_profile.set_preference("browser.download.manager.showWhenStarting", False)
firefox_profile.set_preference("browser.download.dir", _DOWNLOAD_PATH)
firefox_profile.set_preference("browser.helperApps.neverAsk.saveToDisk", _ALL_MIME_TYPES)
# firefox_profile.set_preference("browser.helperApps.alwaysAsk.force", False)
# firefox_profile.set_preference("browser.download.manager.showWhenStarting", False)
if user_agent is not None:
firefox_profile.set_preference(
'general.useragent.override', user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
self.driver = Firefox(firefox_profile)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def create_browser(self, account_id):
self.account = ProxifierAccount.objects.get(id=account_id)
account = self.account
final_profile = 'Proxifier\default_profile'
# account.profile_file = final_profile
profile = FirefoxProfile(final_profile)
# For linux
# default_profile = 'Proxifier/profiles/DEFAULT'
# For windows
# default_profile = 'Proxifier\default_profile'
# final_profile = id_generator()
# shutil.copy(os.path.join(default_profile), os.path.join('Proxifier/profiles/', final_profile))
# copy_tree(os.path.join(default_profile), os.path.join('Proxifier/profiles/', final_profile))
# account.profile_file = final_profile
# Create profile if it doesn't exist
# if account.profile_file == "":
# profile = FirefoxProfile()
#
# # For linux
# # default_profile = 'Proxifier/profiles/DEFAULT'
# # For windows
# default_profile = 'C:\Users\Volk\AppData\Roaming\Mozilla\Firefox\Profiles'
#
#
# final_profile = id_generator()
# # shutil.copy(os.path.join(default_profile), os.path.join('Proxifier/profiles/', final_profile))
# copy_tree(os.path.join(default_profile), os.path.join('Proxifier/profiles/', final_profile))
# account.profile_file = final_profile
# account.save()
# else:
# profile_file = os.path.join('Proxifier/profiles/', account.profile_file)
# profile = FirefoxProfile(profile_file)
# Set download dir
profile.set_preference("browser.download.folderList", 2)
profile.set_preference("browser.download.manager.showWhenStarting",
False)
profile.set_preference("browser.download.dir", "/proxifier")
profile.set_preference("browser.helperApps.neverAsk.saveToDisk",
"image/jpeg")
# Set user agent
profile.set_preference("general.useragent.override",
account.user_agent)
print("User agent: %s" % account.user_agent)
# Add plugins:
if account.plugin_list != "":
for p in account.plugin_list.split(','):
profile.add_extension(extension="Proxifier/plugins/%s.xpi" % p)
# --------- #
# Set proxy
# proxyHost = "173.232.14.3"
# proxyPort = "3128"
# profile.set_preference("network.proxy.type", 1)
# profile.set_preference('network.proxy.socks', proxyHost)
# profile.set_preference('network.proxy.socks_port', proxyPort)
# profile.set_preference('signon.autologin.proxy', True)
# profile.set_preference('network.websocket.enabled', False)
# profile.update_preferences()
# Setting up profile, now raise browser
# firefox_capabilities = DesiredCapabilities.FIREFOX
# firefox_capabilities['marionette'] = True
# firefox_capabilities['binary'] = 'C:' + os.path.sep + 'Program Files' + os.path.sep + 'Mozilla Firefox' + \
# os.path.sep + 'firefox.exe'
# self.driver = webdriver.Firefox(firefox_profile=profile, capabilities=firefox_capabilities)
self.driver = webdriver.Firefox(firefox_profile=profile)
pickle.dump(self.driver.get_cookies(), open("cookies.pkl", "wb"))
# Set screen size
self.driver.set_window_position(0, 0)
self.driver.set_window_size(account.screen_width,
account.screen_height)
print "%s x %s" % (account.screen_width, account.screen_height)
# load cookies
cookies = pickle.load(open("cookies.pkl", "rb"))
for cookie in cookies:
self.driver.add_cookie(cookie)
print cookie
return self.driver
print("~ CTRL+C to stop ")
print("~ ")
printEnviroment()
chrome_options = Options()
#chrome_options.add_argument("--headless")
#chrome_options.add_argument("--window-size=1024x1400")
chrome_options.add_argument('--user-data-dir=' + os.path.join(origin_path, 'FireFox_User_Data'))
# download Chrome Webdriver
# https://sites.google.com/a/chromium.org/chromedriver/download
# put driver executable file in the script directory
chrome_driver = os.path.join(path_to_modules, 'geckodriver')
firefox_profile = FirefoxProfile()
firefox_profile.add_extension(os.path.join(path_to_modules, 'Ignore-x.zip'))
driver = webdriver.Firefox(firefox_options=chrome_options, firefox_profile=firefox_profile, executable_path=chrome_driver)
driver.get("http://web.whatsapp.com")
input('Press <ENTER> to stop server')
driver.close()
sys.exit(0)
except KeyboardInterrupt:
print('\nProgram stoped...')
sys.exit(0)
def run_tests(firefox_path=None):
basedir = os.path.dirname(__file__)
driver = None
profile = FirefoxProfile()
if firefox_path:
if sys.platform == "darwin" and os.path.isdir(firefox_path):
firefox_path = os.path.join(firefox_path, "Contents", "MacOS",
"firefox")
binary = FirefoxBinary(firefox_path)
else:
binary = None
try:
build1 = tempfile.NamedTemporaryFile(mode="wb",
suffix=".xpi",
delete=False)
build2 = tempfile.NamedTemporaryFile(mode="wb",
suffix=".xpi",
delete=False)
try:
createBuild(basedir, type="gecko", outFile=build1)
createBuild(os.path.join(basedir, "testhelper"),
type="gecko",
outFile=build2)
profile.add_extension(build1.name)
profile.add_extension(build2.name)
finally:
os.unlink(build1.name)
os.unlink(build2.name)
driver = WebDriver(profile, firefox_binary=binary)
driver.wait_until = lambda method: WebDriverWait(
driver, default_timeout).until(lambda d: method())
driver.accept_alert = Alert(driver).accept
driver.keys = Keys
def chain(*actions):
for action in actions:
c = ActionChains(driver)
action(c)
c.perform()
driver.chain = chain
max_timestamp = {"value": 0}
def get_urls():
result = []
prefix = "[testhelper] Loading: "
new_timestamp = max_timestamp["value"]
for item in driver.get_log("browser"):
timestamp = item["timestamp"]
if timestamp <= max_timestamp["value"] or not item[
"message"].startswith(prefix):
continue
if timestamp > new_timestamp:
new_timestamp = timestamp
result.append(item["message"][len(prefix):])
max_timestamp["value"] = new_timestamp
return result
driver.get_urls = get_urls
def close_background_tabs():
driver.execute_script('''
var event = document.createEvent("Events");
event.initEvent("testhelper_closeBackgroundTabs", true, false);
document.dispatchEvent(event);
''')
driver.close_background_tabs = close_background_tabs
def middle_click(self):
driver.execute_script(
'''
var event = document.createEvent("Events");
event.initEvent("testhelper_middleclick", true, false);
arguments[0].dispatchEvent(event);
''', self)
WebElement.middle_click = middle_click
environment = {
"__builtins__": __builtins__,
"driver": driver,
}
testdir = os.path.join(basedir, "tests")
for filename in os.listdir(testdir):
if filename.startswith(".") or not filename.endswith(".py"):
continue
filepath = os.path.join(testdir, filename)
environment["__file__"] = filepath
with open(filepath, "rb") as handle:
exec handle in environment
finally:
if driver:
driver.quit()
shutil.rmtree(profile.path, ignore_errors=True)
def getWebDriver(browser_name, proxy=False, implicit_wait_seconds=0, verbose=False):
logger.info('getWebDriver -> "getWebDriver" procedure started...')
logger.debug('getWebDriver -> Parameters: ')
logger.debug('getWebDriver -> \t"browser_name": ' + browser_name)
logger.debug('getWebDriver -> \t"proxy": ' + str(proxy))
logger.debug('getWebDriver -> \t"inplicit_wait_second": ' + str(implicit_wait_seconds))
proxy_host = 'localhost:9100'
if proxy:
logger.debug('getWebDriver -> \t"proxy_host": ' + proxy_host)
os_name = platform.system()
logger.debug('getWebDriver -> \t"Platform": ' + os_name)
try:
if proxy:
if browser_name == "Chrome":
caps = DesiredCapabilities.CHROME
elif browser_name == "IE":
caps = DesiredCapabilities.INTERNETEXPLORER
caps['ignoreProtectedModeSettings'] = True
else:
caps = DesiredCapabilities.FIREFOX
caps['proxy'] = {"httpProxy": proxy_host,
"ftpProxy": proxy_host,
"sslProxy": proxy_host,
"noProxy": None,
"proxyType": "MANUAL",
"class": "org.openqa.selenium.Proxy",
"autodetect": False}
if browser_name == 'Chrome':
driver = webdriver.Chrome(config_browsers[browser_name][os_name], capabilities=caps)
elif browser_name == 'IE':
if os_name != "Darwin":
# driver = webdriver.Remote(command_executor='http://10.211.55.4:4444/wd/hub', desired_capabilities=caps)
# else:
driver = webdriver.Ie(config_browsers[browser_name][os_name], capabilities=caps)
else:
driver = webdriver.Firefox(capabilities=caps)
else:
if browser_name == 'Chrome':
print(os_name)
driver = webdriver.Chrome(config_browsers[browser_name][os_name])
elif browser_name == 'IE' and os_name != "Darwin":
caps = DesiredCapabilities.INTERNETEXPLORER
caps['ignoreProtectedModeSettings'] = True
#if os_name != "Darwin":
# driver = webdriver.Remote(command_executor='http://10.211.55.4:4444/wd/hub', desired_capabilities=caps)
# else:
driver = webdriver.Ie(config_browsers[browser_name][os_name], capabilities=caps)
else:
browser_name = 'Firefox'
profile = FirefoxProfile()
profile.add_extension(config_browsers[browser_name]['extension_path'][os_name] + 'firebug-2.0.16-fx.xpi')
driver = webdriver.Firefox(firefox_profile=profile)
#driver.maximize_window()
driver.implicitly_wait(implicit_wait_seconds)
logger.info('getWebDriver -> Driver was created successfully')
return driver
except Exception as e:
logger.error('getWebDriver -> Unknown exception. More details: ' + repr(e))
raise BrowserException(repr(e))
def launch_browser(self, request=None):
request = request or self.request
if isinstance(request, str):
request = {'browser': request}
try:
self.request.update(request)
request = self.request
except AttributeError:
self.request = request
if 'browser' in request:
capabilities_map = {
"Firefox": DesiredCapabilities.FIREFOX,
"IExplorer": DesiredCapabilities.INTERNETEXPLORER,
"Chrome": DesiredCapabilities.CHROME,
"PhantomJS": DesiredCapabilities.PHANTOMJS,
"Safari": DesiredCapabilities.SAFARI,
}
caps = capabilities_map[request['browser']]
############################################
### Firefox
############################################
if request['browser'] == 'Firefox':
firefox_profile = FirefoxProfile()
if 'firefox' in request:
if 'preferences' in request['firefox']:
for preference in request['firefox']['preferences']:
firefox_profile.set_preference(*preference)
if 'extensions' in request['firefox']:
for extension in request['firefox']['extensions']:
extension = PurePath(
request['firefox']['extensions_path'],
extension)
firefox_profile.add_extension(str(extension))
if 'mime' in request['firefox']:
import shutil
shutil.copy2(request['firefox']['mime'],
firefox_profile.profile_dir)
if 'capabilities' in request['firefox']:
caps.update(request['firefox']['capabilities'])
selenium_proxy = self.setup_proxy()
class Mixin(Firefox, browser.BrowsingActions):
pass
self.browser = Mixin(firefox_profile,
proxy=selenium_proxy,
capabilities=caps)
############################################
### Internet Explorer
############################################
elif request['browser'] == 'IExplorer':
# Not a good idea => caps['nativeEvents'] = False
iedriver_server = os.path.join(
request['iexplorer']['server_path'],
request['iexplorer']['server_file'])
class Mixin(Ie, browser.BrowsingActions):
pass
self.browser = Mixin(iedriver_server, capabilities=caps)
############################################
### GhostDriver, PhantomJS
############################################
elif request['browser'] == 'PhantomJS':
service_args = ["--ignore-ssl-errors=yes"]
caps['phantomjs.page.settings.userAgent'] = (
'Mozilla/5.0 (Windows NT'
' 6.1; Win64; x64; rv:16.0) Gecko/20121026 Firefox/16.0')
class Mixin(PhantomJS, browser.BrowsingActions):
pass
self.browser = Mixin(service_args=service_args,
desired_capabilities=caps)
# If you don't do this, you'll get the pain:
# https://github.com/angular/protractor/issues/585
self.browser.set_window_size(1024, 768)
############################################
### Chrome
############################################
elif request['browser'] == 'Chrome':
chromedriver_server = os.path.join(
request['chrome']['server_path'],
request['chrome']['server_file'])
os.environ["webdriver.chrome.driver"] = chromedriver_server
class Mixin(Chrome, browser.BrowsingActions):
pass
self.browser = Mixin(chromedriver_server)
############################################
### Safari
############################################
elif request['browser'] == 'Safari':
selenium_server = os.path.join(
request['safari']['server_path'],
request['safari']['server_file'])
class Mixin(Safari, browser.BrowsingActions):
pass
self.browser = Mixin(selenium_server)
return self.browser
print("Please specify which browser to launch.")
assert 'browser' in request
from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
# Define some colors
BLACK = (0, 0, 0)
GREY = (127, 127, 127)
WHITE = (255, 255, 255)
GREEN = (0, 100, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
questions = []
f = codecs.open(sys.argv[1], 'r', 'utf-8')
chop = FirefoxProfile()
chop.add_extension('ublock.xpi')
dr = webdriver.Firefox(firefox_profile=chop)
for line in f:
q = []
b = []
both = line.split(" //")
for i, w in enumerate(both[0].split()):
if w[-1] == '!':
b.append(i)
q.append(w[0:-1])
else:
q.append(w)
questions.append((q, b, both[1]))
def __init__(
self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2,
timeout=90,
capabilities=None,
headless=False,
incognito=False,
**kwargs
):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference("extensions.logging.enabled", False)
firefox_profile.set_preference("network.dns.disableIPv6", False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
firefox_options = Options()
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference("general.useragent.override", user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": "1"})
binary = FirefoxBinary()
binary.add_command_line_options("-headless")
kwargs["firefox_binary"] = binary
if incognito:
firefox_options.add_argument("-private")
self.driver = Firefox(
firefox_profile,
capabilities=firefox_capabilities,
options=firefox_options,
timeout=timeout,
**kwargs
)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
def launch_browser(self, request=None):
request = request or self.request
if isinstance(request, str):
request = {
'browser': request
}
try:
self.request.update(request)
request = self.request
except AttributeError:
self.request = request
if 'browser' in request:
capabilities_map = {
"Firefox": DesiredCapabilities.FIREFOX,
"IExplorer": DesiredCapabilities.INTERNETEXPLORER,
"Chrome": DesiredCapabilities.CHROME,
"PhantomJS": DesiredCapabilities.PHANTOMJS,
"Safari": DesiredCapabilities.SAFARI,
}
caps = capabilities_map[request['browser']]
############################################
### Firefox
############################################
if request['browser'] == 'Firefox':
firefox_profile = FirefoxProfile()
if 'firefox' in request:
if 'preferences' in request['firefox']:
for preference in request['firefox']['preferences']:
firefox_profile.set_preference(*preference)
if 'extensions' in request['firefox']:
for extension in request['firefox']['extensions']:
extension = PurePath(request['firefox']['extensions_path'], extension)
firefox_profile.add_extension(str(extension))
if 'mime' in request['firefox']:
import shutil
shutil.copy2(request['firefox']['mime'], firefox_profile.profile_dir)
if 'capabilities' in request['firefox']:
caps.update(request['firefox']['capabilities'])
selenium_proxy = self.setup_proxy()
class Mixin(Firefox, browser.BrowsingActions): pass
self.browser = Mixin(firefox_profile, proxy=selenium_proxy, capabilities=caps)
############################################
### Internet Explorer
############################################
elif request['browser'] == 'IExplorer':
# Not a good idea => caps['nativeEvents'] = False
iedriver_server = os.path.join(request['iexplorer']['server_path'],
request['iexplorer']['server_file'])
class Mixin(Ie, browser.BrowsingActions): pass
self.browser = Mixin(iedriver_server, capabilities=caps)
############################################
### GhostDriver, PhantomJS
############################################
elif request['browser'] == 'PhantomJS':
service_args = ["--ignore-ssl-errors=yes"]
caps['phantomjs.page.settings.userAgent'] = (
'Mozilla/5.0 (Windows NT'
' 6.1; Win64; x64; rv:16.0) Gecko/20121026 Firefox/16.0'
)
class Mixin(PhantomJS, browser.BrowsingActions): pass
self.browser = Mixin(service_args=service_args,
desired_capabilities=caps)
# If you don't do this, you'll get the pain:
# https://github.com/angular/protractor/issues/585
self.browser.set_window_size(1024, 768)
############################################
### Chrome
############################################
elif request['browser'] == 'Chrome':
chromedriver_server = os.path.join(request['chrome']['server_path'],
request['chrome']['server_file'])
os.environ["webdriver.chrome.driver"] = chromedriver_server
class Mixin(Chrome, browser.BrowsingActions): pass
self.browser = Mixin(chromedriver_server)
############################################
### Safari
############################################
elif request['browser'] == 'Safari':
selenium_server = os.path.join(request['safari']['server_path'],
request['safari']['server_file'])
class Mixin(Safari, browser.BrowsingActions): pass
self.browser = Mixin(selenium_server)
return self.browser
print("Please specify which browser to launch.")
assert 'browser' in request
def __init__(
self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
options=None,
headless=False,
wait_time=2,
desired_capabilities=None,
):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference("extensions.logging.enabled", False)
firefox_profile.set_preference("network.dns.disableIPv6", False)
firefox_profile.set_preference("browser.download.folderList", 2)
firefox_profile.set_preference(
"browser.download.manager.showWhenStarting", False)
firefox_profile.set_preference("browser.download.dir", _DOWNLOAD_PATH)
firefox_profile.set_preference(
"browser.helperApps.neverAsk.saveToDisk", _ALL_MIME_TYPES)
firefox_profile.set_preference("permissions.default.microphone", 1)
firefox_profile.set_preference("permissions.default.camera", 1)
# firefox_profile.set_preference("browser.helperApps.alwaysAsk.force", False)
# firefox_profile.set_preference("browser.download.manager.showWhenStarting", False)
if user_agent is not None:
firefox_profile.set_preference("general.useragent.override",
user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
options = Options() if options is None else options
if headless:
# noinspection PyDeprecation
options.set_headless()
firefox_capabilities = DesiredCapabilities().FIREFOX.copy()
firefox_capabilities["marionette"] = True
if desired_capabilities:
firefox_capabilities.update(desired_capabilities)
self.driver = Firefox(firefox_profile,
capabilities=firefox_capabilities,
firefox_options=options)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
class TorBrowser:
'''
Refactoring for 2020 12 version of Tor Browser Bundle
'''
def __init__(self,
browser_path,
binary_path=None,
profile_path=None,
executable_path=None,
socks_port=9050,
control_port=9051,
extensions=None,
capabilities=None,
headless=False,
capture_screen=False,
url=None):
assert browser_path is not None
self.browser_path = browser_path
self.binary_path = binary_path
self.profile_path = profile_path
self.executable_path = executable_path
self.socks_port = socks_port
self.control_port = control_port
self.extensions = extensions
self.capabilities = capabilities
self.headless = headless
self.capture_screen = capture_screen
self.url = url
self.profile = None
self.binary = None # firefox
self.options = None
self.webdriver = None
self.tor_controller = TorController() # Start tor process..
self._initialize()
def _initialize(self):
self._init_browser()
self.profile = FirefoxProfile(self.profile_path)
self._init_profile()
self._init_extensions()
self._init_capabilities()
self._init_binary()
self._init_options()
self._init_webdriver()
def _init_browser(self):
if self.binary_path is None:
# tor-browser_en-US/Browser/firefox
self.binary_path = os.path.join(self.browser_path,
os.path.join('Browser', 'firefox'))
if self.profile_path is None:
# tor-browser_en-US/Browser/TorBrowser/Data/Browser/profile.default
self.profile_path = os.path.join(
self.browser_path,
os.path.join(
'Browser',
os.path.join(
'TorBrowser',
os.path.join(
'Data', os.path.join('Browser',
'profile.default')))))
def _init_profile(self):
self.profile.set_preference('browser.cache.disk.enable', False)
self.profile.set_preference('browser.cache.memory.enable', False)
self.profile.set_preference('browser.cache.offline.enable', False)
self.profile.set_preference('browser.startup.page', '0')
self.profile.set_preference('browser.startup.homepage', 'about:newtab')
self.profile.set_preference('network.http.use-cache', False)
self.profile.set_preference('network.proxy.type', 1)
self.profile.set_preference('network.proxy.socks', '127.0.0.1')
self.profile.set_preference('network.proxy.socks_port',
self.socks_port)
self.profile.set_preference('extensions.torlauncher.promp_at_startup',
0)
self.profile.set_preference('network.http.use-cache', False)
self.profile.set_preference('webdriver.load.strategy', 'conservative')
self.profile.set_preference('extensions.torlauncher.start_tor', False)
self.profile.set_preference(
'extensions.torbutton.versioncheck_enabled', False)
self.profile.set_preference('permissions.memory_only', False)
# update_preference('webdriver.load.strategy', 'normal')
# update_preference('app.update.enabled', False)
# update_preference('extensions.torbutton.versioncheck_enabled', False)
# update_preference('extensions.torbutton.prompted_language', True)
# update_preference('extensions.torbutton.socks_port', self.socks_port)
# update_preference('extensions.torlauncher.control_port', self.control_port)
# update_preference('extensions.torlauncher.start_tor', True)
# update_preference('extensions.torbutton.block_dis', False)
# update_preference('extensions.torbutton.custom.socks_host', '127.0.0.1')
# update_preference('extensions.torbutton.custom.socks_port', self.socks_port)
# update_preference('extensions.torbutton.inserted_button', True)
# update_preference('extensions.torbutton.launch_warning', False)
# update_preference('privacy.spoof_english', 2)
# update_preference('extensions.torbutton.loglevel', 2)
# update_preference('extensions.torbutton.logmethod', 0)
# update_preference('extensions.torbutton.settings_method', 'custom')
# update_preference('extensions.torbutton.use_privoxy', False)
# update_preference('extensions.torlauncher.control_port', self.control_port)
# update_preference('extensions.torlauncher.loglevel', 2)
# update_preference('extensions.torlauncher.logmethod', 0)
# update_preference('extensions.torlauncher.prompt_at_startup', False)
self.profile.update_preferences()
def _init_extensions(self):
if self.extensions is not None:
for extension in self.extensions:
self.profile.add_extension(extension)
def _init_capabilities(self):
if self.capabilities is None:
self.capabilities = DesiredCapabilities.FIREFOX
self.capabilities.update({
'handlesAlerts': True,
'databaseEnabled': True,
'javascriptEnabled': True,
'browserConnectionEnabled': True
})
def _init_binary(self):
self.binary = FirefoxBinary(firefox_path=self.binary_path)
self.binary.add_command_line_options('--class', '"Tor Browser"')
def _init_options(self):
if self.headless is True:
self.options = Options()
self.options.headless = self.headless
def _init_webdriver(self):
self.webdriver = webdriver.Firefox(
firefox_profile=self.profile,
firefox_binary=self.binary,
timeout=60,
capabilities=self.capabilities,
executable_path=self.executable_path,
options=self.options)
def connect_url(self, url):
self.webdriver.get(url)
WebDriverWait(self.webdriver, timeout=30).until(
expected_conditions.presence_of_element_located(
(By.TAG_NAME, 'body')))
def close(self):
try:
self.tor_controller.stop()
self.webdriver.quit()
except CannotSendRequest:
logger.error('CannotSendRequest while quitting TorBrowserDriver')
self.binary.kill()
except Exception as e:
logger.error('Exception while quitting TorBrowserDriver', e)
def init_canvas_permission(self, url):
'''
Create a permission DB and add exception for the canvas image extraction.
Otherwise screenshots taken by Selenium will be just blank images due to
canvas fingerprinting defense in Tor Browser Bundle.
'''
import sqlite3
from tld import get_tld
connection = sqlite3.connect
permission_db = connection(
os.path.join(self.profile_path, 'permissions.sqlite'))
cursor = permission_db.cursor()
# http://mxr.mozilla.org/mozilla-esr31/source/build/automation.py.in
cursor.execute("PRAGMA user_version=3")
cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts (
id INTEGER PRIMARY KEY,
host TEXT,
type TEXT,
permission INTEGER,
expireType INTEGER,
expireTime INTEGER,
appId INTEGER,
isInBrowserElement INTEGER)""")
domain = get_tld(url)
logger.debug('Adding canvas/extractData permission for %s' % domain)
query = """INSERT INTO 'moz_hosts' VALUES (NULL, '%s', 'canvas/extractData', 1, 0, 0, 0, 0);""" % domain
cursor.execute(query)
permission_db.commit()
cursor.close()
def take_screenshot(self, save_path):
if save_path is not None:
save_path = os.path.join(save_path, 'screenshot.png')
else:
save_path = 'screenshot.png'
self.webdriver.get_screenshot_as_file(save_path)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
def run_tests(firefox_path=None):
basedir = os.path.dirname(__file__)
driver = None
profile = FirefoxProfile()
if firefox_path:
if sys.platform == "darwin" and os.path.isdir(firefox_path):
firefox_path = os.path.join(firefox_path, "Contents", "MacOS", "firefox")
binary = FirefoxBinary(firefox_path)
else:
binary = None
try:
build1 = tempfile.NamedTemporaryFile(mode="wb", suffix=".xpi", delete=False)
build2 = tempfile.NamedTemporaryFile(mode="wb", suffix=".xpi", delete=False)
try:
createBuild(basedir, type="gecko", outFile=build1)
createBuild(os.path.join(basedir, "testhelper"), type="gecko", outFile=build2)
profile.add_extension(build1.name)
profile.add_extension(build2.name)
finally:
os.unlink(build1.name)
os.unlink(build2.name)
driver = WebDriver(profile, firefox_binary=binary)
driver.wait_until = lambda method: WebDriverWait(driver, default_timeout).until(lambda d: method())
driver.accept_alert = Alert(driver).accept
driver.keys = Keys
def chain(*actions):
for action in actions:
c = ActionChains(driver)
action(c)
c.perform()
driver.chain = chain
max_timestamp = {"value": 0}
def get_urls():
result = []
prefix = "[testhelper] Loading: "
new_timestamp = max_timestamp["value"]
for item in driver.get_log("browser"):
timestamp = item["timestamp"]
if timestamp <= max_timestamp["value"] or not item["message"].startswith(prefix):
continue
if timestamp > new_timestamp:
new_timestamp = timestamp
result.append(item["message"][len(prefix):])
max_timestamp["value"] = new_timestamp
return result
driver.get_urls = get_urls
def close_background_tabs():
driver.execute_script('''
var event = document.createEvent("Events");
event.initEvent("testhelper_closeBackgroundTabs", true, false);
document.dispatchEvent(event);
''')
driver.close_background_tabs = close_background_tabs
def middle_click(self):
driver.execute_script('''
var event = document.createEvent("Events");
event.initEvent("testhelper_middleclick", true, false);
arguments[0].dispatchEvent(event);
''', self)
WebElement.middle_click = middle_click
environment = {
"__builtins__": __builtins__,
"driver": driver,
}
testdir = os.path.join(basedir, "tests")
for filename in os.listdir(testdir):
if filename.startswith(".") or not filename.endswith(".py"):
continue
filepath = os.path.join(testdir, filename)
environment["__file__"] = filepath
with open(filepath, "rb") as handle:
exec handle in environment
finally:
if driver:
driver.quit()
shutil.rmtree(profile.path, ignore_errors=True)
def __init__(
self,
profile=None,
extensions=None,
user_agent=None,
profile_preferences=None,
fullscreen=False,
wait_time=2,
timeout=90,
capabilities=None,
headless=False,
incognito=False,
**kwargs
):
firefox_profile = FirefoxProfile(profile)
firefox_profile.set_preference("extensions.logging.enabled", False)
firefox_profile.set_preference("network.dns.disableIPv6", False)
firefox_capabilities = DesiredCapabilities().FIREFOX
firefox_capabilities["marionette"] = True
firefox_options = Options()
if capabilities:
for key, value in capabilities.items():
firefox_capabilities[key] = value
if user_agent is not None:
firefox_profile.set_preference("general.useragent.override", user_agent)
if profile_preferences:
for key, value in profile_preferences.items():
firefox_profile.set_preference(key, value)
if extensions:
for extension in extensions:
firefox_profile.add_extension(extension)
if headless:
os.environ.update({"MOZ_HEADLESS": "1"})
if 'firefox_binary' in kwargs:
if isinstance(kwargs['firefox_binary'], six.string_types):
binary = FirefoxBinary(kwargs['firefox_binary'])
else:
binary = kwargs['firefox_binary']
else:
binary = FirefoxBinary()
binary.add_command_line_options("-headless")
kwargs["firefox_binary"] = binary
if incognito:
firefox_options.add_argument("-private")
self.driver = Firefox(
firefox_profile,
capabilities=firefox_capabilities,
options=firefox_options,
timeout=timeout,
**kwargs
)
if fullscreen:
ActionChains(self.driver).send_keys(Keys.F11).perform()
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
