def __initWebDriver(self):
from selenium import webdriver
self.TE_LOG.info('init web driver')
if self.web_driver:
self.web_driver.quit()
self.web_driver = None
test_app = test_ext = ''
driver_env = {}
try:
exec 'from testkitlite.capability.%s import initCapability' % self.target_platform
if self.target_platform.upper().find('TIZEN') >= 0:
test_app = self.appid
test_ext = self.debugip
capa = {
'xwalkOptions': {
'tizenAppId': test_app[1:-1],
'tizenDebuggerAddress': test_ext
}
}
driver_env = initCapability(test_app, test_ext)
self.test_prefix = driver_env['test_prefix']
self.web_driver = WebDriver(self.wd_url, capa)
url_compon = urlparse(self.web_driver.current_url)
self.__updateTestPrefix()
elif self.target_platform.upper().find(
'ANDROID') >= 0 and self.launcher != "CordovaLauncher":
test_app, test_ext = self.appid.split('/')
test_ext = test_ext.strip('.').replace('Activity', '')
tmps = test_ext.split('_')
actv_name = ''.join([it.capitalize() for it in tmps if it])
test_ext = '.%sActivity' % actv_name
driver_env = initCapability(test_app, test_ext)
capa = driver_env['desired_capabilities']
self.test_prefix = driver_env['test_prefix']
self.web_driver = WebDriver(self.wd_url, capa)
url_compon = urlparse(self.web_driver.current_url)
self.__updateTestPrefix()
elif self.target_platform.upper().find(
'ANDROID') >= 0 and self.launcher == "CordovaLauncher":
test_app, test_ext = self.appid.split('/')
test_ext = test_ext.replace('Activity', '')
self.TE_LOG.info('activity : %s' % test_ext)
driver_env = initCapability(test_app, test_ext)
self.test_prefix = driver_env['test_prefix']
self.web_driver = WebDriver(self.wd_url,
driver_env['desired_capabilities'])
time.sleep(1)
self.__updateTestPrefix()
except Exception, e:
self.TE_LOG.error('Init Web Driver failed: %s' % e)
return False
def launch_app(self):
try:
desired_capabilities = self.app_config["desired-capabilities"]
if self.app_config["platform"]["name"] == "android":
self.driver = WebDriver(
str(self.app_config["driver-url"]), desired_capabilities)
elif self.app_config["platform"]["name"] == "deepin":
self.driver = WebDriver(
str(self.app_config["driver-url"]), desired_capabilities, keep_alive=True)
except Exception as e:
print "Failed to launch %s: %s" % (self.app_name, e)
return False
return True
def _Run(self):
"""Run the tests."""
# TODO(kkania): Remove this hack.
self._FakePytestHack()
test_names = self._GetTestNames(self._args)
# The tests expect to run with preset 'driver' and 'webserver' class
# properties.
server = ChromeDriverLauncher(
self._options.driver_exe or test_paths.CHROMEDRIVER_EXE,
test_paths.WEBDRIVER_TEST_DATA).Launch()
driver = WebDriver(server.GetUrl(), {})
# The tests expect a webserver. Since ChromeDriver also operates as one,
# just pass this dummy class with the right info.
class DummyWebserver:
pass
webserver = DummyWebserver()
webserver.port = server.GetPort()
for test in test_names:
Main._SetTestClassAttributes(test, 'driver', driver)
Main._SetTestClassAttributes(test, 'webserver', webserver)
# Load and run the tests.
logging.debug('Loading tests from %s', test_names)
loaded_tests = unittest.defaultTestLoader.loadTestsFromNames(test_names)
test_suite = unittest.TestSuite()
test_suite.addTests(loaded_tests)
verbosity = 1
if self._options.verbose:
verbosity = 2
result = GTestTextTestRunner(verbosity=verbosity).run(test_suite)
server.Kill()
sys.exit(not result.wasSuccessful())
def __init__(self, *args, **kwargs):
super(BaseCase, self).__init__(*args, **kwargs)
try:
self.driver = WebDriver()
except Exception:
pass
self.environment = None
def test_converts_oss_capabilities_to_w3c(mocker):
mock = mocker.patch('selenium.webdriver.remote.webdriver.WebDriver.execute')
oss_caps = {'platform': 'WINDOWS', 'version': '11', 'acceptSslCerts': True}
w3c_caps = {'platformName': 'windows', 'browserVersion': '11', 'acceptInsecureCerts': True}
WebDriver(desired_capabilities=deepcopy(oss_caps))
expected_params = {'capabilities': {'firstMatch': [{}], 'alwaysMatch': w3c_caps}}
mock.assert_called_with(Command.NEW_SESSION, expected_params)
def test_converts_proxy_type_value_to_lowercase_for_w3c(mocker):
mock = mocker.patch('selenium.webdriver.remote.webdriver.WebDriver.execute')
oss_caps = {'proxy': {'proxyType': 'MANUAL', 'httpProxy': 'foo'}}
w3c_caps = {'proxy': {'proxyType': 'manual', 'httpProxy': 'foo'}}
WebDriver(desired_capabilities=deepcopy(oss_caps))
expected_params = {'capabilities': {'firstMatch': [{}], 'alwaysMatch': w3c_caps}}
mock.assert_called_with(Command.NEW_SESSION, expected_params)
def ff_driver(request):
timeout = 10000
capabilities = webdriver.DesiredCapabilities.FIREFOX.copy()
capabilities['timeouts'] = {
'implicit': timeout,
'pageLoad': timeout,
'script': timeout
}
capabilities['loggingPrefs'] = {
'browser': 'ALL',
'client': 'ALL',
'driver': 'ALL',
'performance': 'ALL',
'server': 'ALL'
}
profile = webdriver.FirefoxProfile()
profile.set_preference('app.update.auto', False)
profile.set_preference('app.update.enabled', False)
profile.accept_untrusted_certs = True
wd = WebDriver(browser_profile=profile, desired_capabilities=capabilities)
wd.maximize_window()
yield wd
wd.quit()
def get_driver():
global _driver
if '_driver' not in globals():
FILE_PATH = os.path.join(os.getcwd(), 'chromedriver')
_driver = WebDriver("http://5.68.222.13:4444/wd/hub",
DesiredCapabilities.HTMLUNITWITHJS)
return _driver
def test_get_url():
sleep(10)
TEST_URL = "http://httpbin/html"
driver = WebDriver("http://%s:%s/wd/hub" % (SELENIUM_HOST, SELENIUM_PORT),
desired_capabilities={"browserName": "phantomjs"})
driver.get(TEST_URL)
elem = driver.find_element_by_tag_name("h1")
assert "Moby-Dick" in elem.text
def test_works_as_context_manager(mocker):
mocker.patch('selenium.webdriver.remote.webdriver.WebDriver.execute')
quit_ = mocker.patch('selenium.webdriver.remote.webdriver.WebDriver.quit')
with WebDriver() as driver:
assert isinstance(driver, WebDriver)
assert quit_.call_count == 1
def get_remote_driver(cls, config):
"""
:type config: radish_ext.sdk.ui.selenium_driver_config.SeleniumDriverConfig
:rtype: selenium.webdriver.remote.webdriver.WebDriver
"""
driver = WebDriver(config.url,
desired_capabilities=config.capabilities)
return driver
def setUp(self):
firefox_capabilities = DesiredCapabilities.FIREFOX
if self.host == 'localhost':
firefox_capabilities['marionette'] = False
self.selenium = Firefox(capabilities=firefox_capabilities)
else:
self.selenium = WebDriver(command_executor='http://selenium-hub:4444/wd/hub',
desired_capabilities=firefox_capabilities)
super().setUp()
def driver(context):
chrome_options = Options()
desired_capabilities = chrome_options.to_capabilities()
context.driver = WebDriver(command_executor=SELENIUM_NODE,
desired_capabilities=desired_capabilities)
# context.driver = webdriver.Chrome("/usr/local/bin/chromedriver")
yield context.driver
context.driver.quit()
def __init__(self, *args, **kwargs):
super(BaseCase, self).__init__(*args, **kwargs)
try:
self.driver = WebDriver()
except Exception:
pass
self.environment = None
self.page_check_count = 0
self.page_check_failures = []
def launch_app(self):
try:
desired_capabilities = self.app_config["desired-capabilities"]
self.driver = WebDriver(str(self.app_config["driver-url"]),
desired_capabilities)
except Exception as e:
print "Failed to launch %s: %s" % (self.app_name, e)
return False
return True
def setup_method(self):
config = LoadConfig()
selenium_hub = config.get_value(SELENIUM_HUB)
browser = config.get_value(BROWSER).upper()
self.driver = WebDriver(
command_executor=f'http://{selenium_hub}/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy())
self.driver.get('http://store.demoqa.com')
self.navigate_to_page(SAMPLE_PAGE)
self.sample_page = SamplePage(self.driver)
def setUp(self):
browser = os.environ.get("BROWSER")
capability = {}
if browser == "CHROME":
capability = DesiredCapabilities.CHROME
else:
capability = DesiredCapabilities.FIREFOX
self.browser = WebDriver(command_executor='http://127.0.0.1:4444/wd/hub', desired_capabilities=capability)
self.browser.implicitly_wait(3)
self.schedule_page = page.SchedulePage(self.browser)
self.schedule_page.signInAndNavigate()
def setUp(self):
if self.remote:
# self.driver = WebDriver("http://localhost:4444/wd/hub", "chrome", "ANY")
self.driver = WebDriver("http://localhost:4444",
DesiredCapabilities.CHROME)
else:
chrome_driver_path = get_driver_path() + '\\chromedriver.exe'
self.driver = webdriver.Chrome(chrome_driver_path)
self.driver.get(server)
self.calculator = CalculatorElements(self.driver)
self.driver.maximize_window()
self.driver.implicitly_wait(10)
def test_accepts_firefox_options_to_remote_driver(mocker, browser_name):
options = import_module(f'selenium.webdriver.{browser_name}.options')
caps_name = browser_name.upper() if browser_name != 'ie' else 'INTERNETEXPLORER'
mock = mocker.patch('selenium.webdriver.remote.webdriver.WebDriver.start_session')
opts = options.Options()
opts.add_argument('foo')
expected_caps = getattr(DesiredCapabilities, caps_name)
caps = expected_caps.copy()
expected_caps.update(opts.to_capabilities())
WebDriver(desired_capabilities=caps, options=opts)
mock.assert_called_with(expected_caps, None)
def setUp(self):
# 第一步：初始化相关参数
print("开始进行初始化~~~~~~~~~~~~~")
# self.driver = webdriver.Firefox()
self.driver = WebDriver(
command_executor='http://172.31.17.82:4444/wd/hub',
desired_capabilities=DesiredCapabilities.CHROME)
self.base_url = "http://172.31.31.100:8200/"
# 设置元素识别超时时间
self.driver.implicitly_wait(20)
# 设置页面加载超时时间
self.driver.set_page_load_timeout(20)
# 设置异步脚本加载超时时间
self.driver.set_script_timeout(20)
def get_driver(self):
if self.error:
return None
if not self.driver:
checked = check_selenium_service(self.command_executor,
self.capability)
if checked:
self.driver = WebDriver(command_executor=self.command_executor,
desired_capabilities=self.capability)
dispatcher.connect(self.spider_closed, signals.spider_closed)
else:
self.error = True
return self.driver
def before_scenario(context, scenario):
context.cleanup_tasks = []
options = Options()
browser = os.getenv("BROWSER")
context.browser = WebDriver("http://{}:4444/wd/hub".format(
get_config().get(browser, "host")),
desired_capabilities={"browserName": browser},
options=options)
context.browser.set_page_load_timeout(15)
context.browser.implicitly_wait(15)
os.makedirs(join(context.screenshots_dir, scenario.name.replace(" ", "_")),
exist_ok=True)
context.screenshots_dir = join(context.screenshots_dir,
scenario.name.replace(" ", "_"))
def setUp(self):
# 第一步：初始化相关参数
# self.driver = webdriver.Firefox()
self.driver = WebDriver(
command_executor='http://192.168.1.104:4444/wd/hub',
desired_capabilities=DesiredCapabilities.FIREFOX)
print("初始化驱动完成~~~~~~~~~~~~~~~~")
self.base_url = "http://172.31.31.100:8200/"
# 设置元素识别超时时间
self.driver.implicitly_wait(20)
# 设置页面加载超时时间
self.driver.set_page_load_timeout(20)
# 设置异步脚本加载超时时间
self.driver.set_script_timeout(20)
print("初始化相关参数全部完成~~~~~~~~~~~~~~~~")
def setUp(self):
print("开始初始化~~")
# 第一步：初始化相关参数
self.driver = WebDriver(
command_executor='http://172.31.20.124:4444/wd/hub',
desired_capabilities=DesiredCapabilities.CHROME)
self.base_url = "http://172.31.31.100:8200/"
# 设置元素识别超时时间
self.driver.implicitly_wait(15)
# 设置页面加载超时时间
self.driver.set_page_load_timeout(30)
# 设置异步脚本加载超时时间
self.driver.set_script_timeout(30)
# 设置将谷歌浏览器最大化
self.driver.maximize_window()
def __initWebDriver(self):
if self.web_driver:
self.web_driver.quit()
self.web_driver = None
test_app = test_ext = ''
driver_env = {}
try:
exec 'from testkitlite.capability.%s import initCapability' % self.target_platform
if self.target_platform.upper().find('TIZEN') >= 0:
test_app = self.appid
test_ext = self.debugip
elif self.target_platform.upper().find('ANDROID') >= 0:
test_app, test_ext = self.appid.split('/')
driver_env = initCapability(test_app, test_ext)
self.test_prefix = driver_env['test_prefix']
self.web_driver = WebDriver(self.wd_url,
driver_env['desired_capabilities'])
self.__updateTestPrefix()
return True
except Exception, e:
if self.target_platform.upper().find('ANDROID') >= 0:
try:
test_ext = test_ext.strip('.').replace('Activity', '')
tmps = test_ext.split('_')
actv_name = ''.join([it.capitalize() for it in tmps if it])
test_ext = '.%sActivity' % actv_name
driver_env = initCapability(test_app, test_ext)
self.web_driver = WebDriver(
self.wd_url, driver_env['desired_capabilities'])
self.__updateTestPrefix()
return True
except Exception, e:
self.TE_LOG.error(
'Retry to init Web Driver get failed: %s' % e)
return False
def check_selenium_service(command_executor):
browser = WebDriver(command_executor=command_executor,
desired_capabilities=DesiredCapabilities.FIREFOX)
try:
browser.get('https://www.youtube.com/watch?v=dfTWTC7UtcQ')
browser.execute_script(
"window.scrollTo(0, document.body.offsetHeight);")
WebDriverWait(browser, 5).until(
EC.presence_of_element_located(
(By.CLASS_NAME, "comment-renderer-text-content")))
assert u'comment-renderer-text-content' in browser.page_source
logging.warning("check remote web driver (%s) successful." %
command_executor)
finally:
browser.close()
browser.quit()
def set_up_webdriver_in_spider(self, spider):
if not (hasattr(spider, _SELENIUM_DRIVER)
and isinstance(getattr(spider, _SELENIUM_DRIVER), WebDriver)):
# set the selenium driver for this spider
driver = WebDriver(
command_executor=self.command_executor,
desired_capabilities=DesiredCapabilities.FIREFOX)
setattr(spider, _SELENIUM_DRIVER, driver)
def spider_closed(to_be_closed_spider):
getattr(to_be_closed_spider, _SELENIUM_DRIVER).quit()
logging.warning("selenium driver quit.")
dispatcher.connect(spider_closed, signals.spider_closed)
else: # the spider has already been set up
pass
def ch_driver(request):
timeout = 10000
capabilities = webdriver.DesiredCapabilities.CHROME.copy()
capabilities['timeouts'] = {
'implicit': timeout,
'pageLoad': timeout,
'script': timeout
}
capabilities['acceptSslCerts'] = True
capabilities['acceptInsecureCerts'] = True
wd = WebDriver(desired_capabilities=capabilities)
wd.maximize_window()
yield wd
wd.quit()
def login():
global driver
global wait
print('Money lover: Starting selenium session')
driver = WebDriver(
command_executor='http://localhost:4444/wd/hub',
desired_capabilities={'browserName': 'firefox'})
wait = WebDriverWait(driver, 10)
print('Money lover: Starting login process')
driver.get(URL)
wait.until(lambda d: d.find_element_by_id('input-26'))
driver.find_element_by_id('input-26').send_keys(ML_USER)
driver.find_element_by_id('input-28').send_keys(ML_PASS)
driver.find_element_by_class_name('btn-submit-ml').click()
time.sleep(10)
print('Money lover: login process finished')
wait.until(lambda d: d.find_element_by_id('master-container'))
def check_selenium_service(command_executor, capability):
browser = WebDriver(command_executor=command_executor,
desired_capabilities=capability)
try:
browser.get('http://www.baidu.com')
if len(browser.page_source) > 0:
logger.info(
'check remote webdriver (%s) capability (%s) successfully' %
(command_executor, capability['browserName']))
return True
else:
logger.warning(
'check remote webdriver (%s) capability (%s) failed' %
(command_executor, capability['browserName']))
return False
finally:
browser.quit()
