def setup(self, base_url: str, console_ip: str, pages: PageObjectContainer, selenium: webdriver.Remote):
self.base_url = base_url
self.console_ip = console_ip
self.ConnectPage = pages.connect_page
self.OverviewPage = pages.overview_page
self.selenium = selenium
self.test_name = None
return self
python类Remote()的实例源码
def setup(self, base_url: str, console_ip: str, pages: PageObjectContainer, selenium: webdriver.Remote):
self.base_url = base_url
self.console_ip = console_ip
self.console_port = 5673
self.ConnectPage = pages.connect_page
self.OverviewPage = pages.overview_page
self.selenium = selenium
self.test_name = None
return self
def initialize_remote_selenium():
selenium_url = 'http://192.168.33.10:4444/wd/hub'
capabilities = {'browserName': 'chrome'}
# selenium_url = 'http://127.0.0.1:4444/wd/hub'
# capabilities = {
# 'browserName': 'jbrowserdriver',
# 'version': '1',
# 'platform': 'ANY',
# }
driver = webdriver.Remote(selenium_url, desired_capabilities=capabilities)
driver.implicitly_wait(10)
return driver
def deinitialize_selenium(driver: webdriver.Remote):
driver.close()
def start(self):
try:
if self.browser == "Firefox":
driver = webdriver.Firefox()
driver.get(self.url)
return driver
elif self.browser == "IE":
driver = webdriver.Ie()
driver.get(self.url)
return driver
elif self.browser == "HtmlUnit":
# ????? selenium-server
driver = webdriver.Remote("http://127.0.0.1:4444/wd/hub/",
desired_capabilities=webdriver.DesiredCapabilities.HTMLUNITWITHJS)
return driver
elif self.browser =="Chrome":
driver = webdriver.Chrome()
driver.get(self.url)
return driver
else: # ??
#
driver = webdriver.Remote(command_executor='http://192.168.50.162:1111/wd/hub',
desired_capabilities=webdriver.DesiredCapabilities.CHROME)
driver.get(self.url)
return driver
except:
print(str(sys.exc_info()))
def start_headless(self):
"""Headless Chrome initiator."""
print('Start headless browser')
option_set = options.Options()
option_set.add_arguments("test-type")
option_set.add_arguments("start-maximized")
option_set.add_arguments("--js-flags=--expose-gc")
option_set.add_arguments("--enable-precise-memory-info")
option_set.add_argument('headless')
option_set.add_argument('disable-notifications')
option_set.add_argument('disable-gpu')
option_set.add_argument('disable-infobars')
option_set.add_arguments("--disable-default-apps")
option_set.add_arguments("test-type=browser")
option_set.add_experimental_option(
'prefs', {
'credentials_enable_service': False,
'profile': {
'password_manager_enabled': False
}
}
)
option_set.binary_location = os.getenv(
'CHROME_CANARY',
'/Applications/Google Chrome Canary.app' +
'/Contents/MacOS/Google Chrome Canary'
)
webdriver_service = service.Service(
os.getenv(
'CHROMEDRIVER',
'/Applications/chromedriver'
)
)
webdriver_service.start()
print('Service started; returning Remote webdriver')
return webdriver.Remote(
webdriver_service.service_url,
option_set.to_capabilities()
)
def start_opera(self, location):
"""Opera initiator."""
webdriver_service = service.Service(location)
webdriver_service.start()
return webdriver.Remote(
webdriver_service.service_url,
DesiredCapabilities.OPERA.copy()
)
def start_htmlunit(self, implicity_wait_timeout=60):
browser = webdriver.Remote(desired_capabilities=DesiredCapabilities.HTMLUNIT)
browser.implicitly_wait(implicity_wait_timeout)
browser.get(self.url)
def init_driver_chrome():
'''
Initialize chrome browser. it needs a webdriver service
'''
import selenium.webdriver.chrome.service as service
global service # global variable because its needed in quit_driver()
service = service.Service('chromedriver')
service.start()
print "service initialized for chrome browser"
capabilities = {'chrome.loadAsync': 'true'}
driver = webdriver.Remote(service.service_url, capabilities)
driver.wait = WebDriverWait(driver, 5)
driver.implicitly_wait(10)
return driver
def start(self):
if self.is_started is False:
self.service.start()
capabilities = {
'chrome.binary':
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
}
self.browser = (
webdriver.Remote(self.service.service_url, capabilities))
self.is_started = True
return
def connect_to_selenium(port, t=30, c=1):
global Browser
if c >= t:
return False
try:
if verbose:
print ('Connecting to docker selenium server '
'http://127.0.0.1:%s/wd/hub [%s/%s]...') % (str(port), str(c), str(t))
if driver == 'chrome':
desired_caps = DesiredCapabilities.CHROME
elif driver == 'firefox':
desired_caps = DesiredCapabilities.FIREFOX
Browser = webdriver.Remote(
command_executor='http://127.0.0.1:%s/wd/hub' % str(port),
desired_capabilities=desired_caps
)
except:
c += 1
sleep(1)
connect_to_selenium(port, t, c)
return True
def selenium_setup(self):
capabilities = {'browserName': 'chrome'}
try:
self.pydriver = webdriver.Remote(self.config_dict[TABLEAU_SELENIUM_URL], capabilities)
except (WebDriverException, Exception), we:
ACLogger().get_logger().error('unable to start webdriver.Remote: %s ' % we)
return False
return True
def driver(base_url, osinfo, browserinfo):
ostype, os_version = osinfo
browser, browser_version = browserinfo
buildid = '{0}_{1}_{2}_{3}'.format(ostype.lower().replace(' ', '_'),
os_version.lower().replace(' ', '_'), browser, browser_version)
# skip some combinations
if os_version == 'Sierra' and browser == 'safari' and browser_version == '9.1':
pytest.skip('cannot have Sierra running safari 9.1')
elif os_version == 'El Capitan' and browser == 'safari' and browser_version == '10':
pytest.skip('cannot have El Capitan running safari 10')
# set driver
if browserstack:
username = os.environ.get('BROWSERSTACK_USER', None)
access = os.environ.get('BROWSERSTACK_ACCESS_KEY', None)
desired_cap = {'os': ostype, 'os_version': os_version, 'browser': browser, 'build': buildid,
'browser_version': browser_version, 'project': 'marvin', 'resolution': '1920x1080'}
desired_cap['browserstack.local'] = True
desired_cap['browserstack.debug'] = True
desired_cap['browserstack.localIdentifier'] = os.environ['BROWSERSTACK_LOCAL_IDENTIFIER']
driver = webdriver.Remote(
command_executor='http://{0}:{1}@hub.browserstack.com:80/wd/hub'.format(username, access),
desired_capabilities=desired_cap)
else:
if browser == 'chrome':
driver = webdriver.Chrome()
elif browser == 'firefox':
driver = webdriver.Firefox()
elif browser == 'safari':
driver = webdriver.Safari()
driver.get(base_url)
yield driver
# teardown
driver.quit()
def start_driver_session(context: Context, session_name: str):
desired_capabilities = context.desired_capabilities
desired_capabilities["name"] = session_name
if CONFIG["hub_url"]:
context.driver = webdriver.Remote(
desired_capabilities=desired_capabilities,
command_executor=CONFIG["hub_url"])
else:
browser_name = CONFIG["environments"][0]["browser"]
drivers = {
"chrome": webdriver.Chrome,
"edge": webdriver.Edge,
"firefox": webdriver.Firefox,
"ie": webdriver.Ie,
"phantomjs": webdriver.PhantomJS,
"safari": webdriver.Safari,
}
# start the browser
context.driver = drivers[browser_name.lower()]()
context.driver.set_page_load_timeout(time_to_wait=27)
try:
context.driver.maximize_window()
logging.debug("Maximized the window.")
except WebDriverException:
logging.debug("Failed to maximize the window.")
try:
context.driver.set_window_size(1600, 1200)
logging.warning("Set window size to 1600x1200")
except WebDriverException:
logging.warning("Failed to set window size, will continue as is")
logging.debug("Browser Capabilities: %s", context.driver.capabilities)
def get_appium_driver(url, desired_capabilities) -> Remote:
"""
Return the same instance to the Appium driver.
:param url: the URL (address and port) where the service runs.
:param desired_capabilities: session configuration data.
:return: returns the SAME instance of the driver
"""
return SingletonFactory.build(Remote,
command_executor=url,
desired_capabilities=desired_capabilities)
