下面列出了怎么用org.openqa.selenium.MutableCapabilities的API类实例代码及写法，或者点击链接到github查看源代码。
public void setUp() throws MalformedURLException {
String username = System.getenv("SAUCE_USERNAME");
String accessKey = System.getenv("SAUCE_ACCESS_KEY");
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);
MutableCapabilities sauceOpts = new MutableCapabilities();
sauceOpts.setCapability("username", username);
sauceOpts.setCapability("accessKey", accessKey);
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(ChromeOptions.CAPABILITY, chromeOpts);
caps.setCapability("sauce:options", sauceOpts);
caps.setCapability("browserName", "googlechrome");
caps.setCapability("browserVersion", "latest");
caps.setCapability("platformName", "windows 10");
String sauceUrl = "https://ondemand.saucelabs.com:443/wd/hub";
URL url = new URL(sauceUrl);
driver = new RemoteWebDriver(url, caps);
}
/**
* {@inheritDoc}
*/
@Override
public Path createNodeConfig(String capabilities, URL hubUrl) throws IOException {
String nodeConfigPath = getNodeConfigPath().toString();
String configPathBase = nodeConfigPath.substring(0, nodeConfigPath.length() - 5);
String hashCode = String.format("%08X", Objects.hash(capabilities, hubUrl));
Path filePath = Paths.get(configPathBase + "-" + hashCode + ".json");
if (filePath.toFile().createNewFile()) {
JsonInput input = new Json().newInput(new StringReader(JSON_HEAD + capabilities + JSON_TAIL));
List<MutableCapabilities> capabilitiesList = GridNodeConfiguration.loadFromJSON(input).capabilities;
GridNodeConfiguration nodeConfig = GridNodeConfiguration.loadFromJSON(nodeConfigPath);
nodeConfig.capabilities = capabilitiesList;
nodeConfig.hub = hubUrl.toString();
try (OutputStream out = new BufferedOutputStream(new FileOutputStream(filePath.toFile()))) {
out.write(new Json().toJson(nodeConfig).getBytes(StandardCharsets.UTF_8));
}
}
return filePath;
}
private void checkTestEnvironment(BrowserConfiguration config)
{
Assert.assertNotNull(config);
Assert.assertEquals("testEnvironmentFlags", config.getConfigTag());
Assert.assertEquals("Test Environment Browser", config.getName());
MutableCapabilities testCapabilities = config.getCapabilities();
Assert.assertEquals("chrome", testCapabilities.getBrowserName());
Assert.assertEquals(1234, testCapabilities.getCapability("idleTimeout"));
Assert.assertEquals(1234, testCapabilities.getCapability("idletimeout"));
Assert.assertEquals(5678, testCapabilities.getCapability("maxDuration"));
Assert.assertEquals(5678, testCapabilities.getCapability("maxduration"));
Assert.assertEquals("3.1234", testCapabilities.getCapability("seleniumVersion"));
Assert.assertEquals("3.1234", testCapabilities.getCapability("selenium-version"));
Assert.assertEquals("800x600", testCapabilities.getCapability("screenResolution"));
Assert.assertEquals("800x600", testCapabilities.getCapability("screen-resolution"));
Assert.assertEquals(Platform.VISTA, testCapabilities.getCapability("platform"));
Assert.assertEquals("Windows 10", testCapabilities.getCapability("platformName"));
Assert.assertEquals("MyDevice", testCapabilities.getCapability("deviceName"));
Assert.assertEquals("portrait", testCapabilities.getCapability("deviceOrientation"));
Assert.assertEquals("landscape", testCapabilities.getCapability("orientation"));
}
private DesiredCapabilities getCapabilitiesForAndroid(
BrowserInstance browserInstance, String deviceNameCapability)
throws IllegalAccessException, IOException {
DesiredCapabilities capabilities = browserInstance.getCapabilities();
capabilities.setCapability("browserName", browserName);
capabilities.setCapability("deviceName", deviceNameCapability);
Optional<Capabilities> optionalCapabilities = annotationsReader != null
? annotationsReader.getCapabilities(parameter, testInstance)
: Optional.of(new DesiredCapabilities());
MutableCapabilities options = browserInstance.getDriverHandler()
.getOptions(parameter, testInstance);
if (optionalCapabilities.isPresent()) {
options.merge(optionalCapabilities.get());
}
capabilities.setCapability(CAPABILITY, options);
log.trace("Using {}", capabilities);
return capabilities;
}
/**
* Задает capabilities для запуска Remote драйвера для Selenoid
*
* @param capabilities - capabilities для установленного браузера
* @param remoteUrl - url для запуска тестов, например http://remoteIP:4444/wd/hub
* @return WebDriver
*/
private WebDriver getRemoteDriver(MutableCapabilities capabilities, String remoteUrl) {
log.info("---------------run Remote Driver---------------------");
Boolean isSelenoidRun = loadSystemPropertyOrDefault(SELENOID, true);
if (isSelenoidRun) {
capabilities.setCapability("enableVNC", true);
capabilities.setCapability("screenResolution", String.format("%sx%s", loadSystemPropertyOrDefault(WINDOW_WIDTH, DEFAULT_WIDTH),
loadSystemPropertyOrDefault(WINDOW_HEIGHT, DEFAULT_HEIGHT)));
String sessionName = loadSystemPropertyOrDefault(SELENOID_SESSION_NAME, "");
if (!sessionName.isEmpty()) {
capabilities.setCapability("name", String.format("%s %s", sessionName, AkitaScenario.getInstance().getScenario().getName()));
}
}
try {
RemoteWebDriver remoteWebDriver = new RemoteWebDriver(
URI.create(remoteUrl).toURL(),
capabilities
);
remoteWebDriver.setFileDetector(new LocalFileDetector());
return remoteWebDriver;
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
}
public static MutableCapabilities getDeviceProperties(MutableCapabilities desiredCapabilities) {
if (!ConfigurationUtils.isDevice(desiredCapabilities))
return desiredCapabilities;
DeviceResult device = null;
try {
device = getHttpClient().deviceInfo(desiredCapabilities.getCapability("deviceName").toString(), false);
} catch (HttpClientException e) {
e.printStackTrace();
}
for (DeviceParameter parameter : DeviceParameter.values()) {
String paramValue = device.getResponseValue(parameter);
String capName = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, parameter.toString().toLowerCase());
if (!StringUtils.isEmpty(paramValue))
desiredCapabilities.setCapability(capName, paramValue);
}
return desiredCapabilities;
}
@Test
public void canConvertOptionsWithPrefsToCapabilitiesAndRestoreBack() {
FirefoxOptions options = new FirefoxOptions(
new MutableCapabilities(new FirefoxOptions()
.addPreference("string.pref", "some value")
.addPreference("int.pref", 42)
.addPreference("boolean.pref", true)));
Object options2 = options.asMap().get(FirefoxOptions.FIREFOX_OPTIONS);
assertThat(options2)
.asInstanceOf(InstanceOfAssertFactories.MAP)
.extractingByKey("prefs")
.asInstanceOf(InstanceOfAssertFactories.MAP)
.containsEntry("string.pref", "some value")
.containsEntry("int.pref", 42)
.containsEntry("boolean.pref", true);
}
@Test
public void shouldConvertAProxyCorrectly() {
Proxy proxy = new Proxy();
proxy.setHttpProxy("localhost:4444");
MutableCapabilities caps = new DesiredCapabilities("foo", "1", Platform.LINUX);
caps.setCapability(CapabilityType.PROXY, proxy);
Map<String, ?> asMap = ImmutableMap.of("desiredCapabilities", caps);
Command command = new Command(new SessionId("empty"), DriverCommand.NEW_SESSION, asMap);
String json = convert(command.getParameters());
JsonObject converted = new JsonParser().parse(json).getAsJsonObject();
JsonObject capsAsMap = converted.get("desiredCapabilities").getAsJsonObject();
assertThat(capsAsMap.get(CapabilityType.PROXY).getAsJsonObject().get("httpProxy").getAsString())
.isEqualTo(proxy.getHttpProxy());
}
@Test
public void shouldIncludeRemoteInfoForWrappedDriverTimeout() throws IOException {
Capabilities caps = new MutableCapabilities();
Response response = new Response(new SessionId("foo"));
response.setValue(caps.asMap());
CommandExecutor executor = mock(CommandExecutor.class);
when(executor.execute(any(Command.class))).thenReturn(response);
RemoteWebDriver driver = new RemoteWebDriver(executor, caps);
WebDriver testDriver = mock(WebDriver.class, withSettings().extraInterfaces(WrapsDriver.class));
when(((WrapsDriver) testDriver).getWrappedDriver()).thenReturn(driver);
TickingClock clock = new TickingClock();
WebDriverWait wait =
new WebDriverWait(testDriver, Duration.ofSeconds(1), Duration.ofMillis(200), clock, clock);
assertThatExceptionOfType(TimeoutException.class)
.isThrownBy(() -> wait.until(d -> false))
.withMessageContaining("Capabilities {javascriptEnabled: true, platform: ANY, platformName: ANY}")
.withMessageContaining("Session ID: foo");
}
@Override
protected void before() {
selenium = INSTANCE;
if (selenium != null) {
return;
}
MutableCapabilities caps = new MutableCapabilities(createCapabilities());
caps.setCapability(UNEXPECTED_ALERT_BEHAVIOUR, IGNORE);
String baseUrl = whereIs("/common/rc/tests/html/");
WebDriver driver = new WebDriverBuilder().get(caps);
selenium = new WebDriverBackedSelenium(driver, baseUrl);
selenium.setBrowserLogLevel("debug");
INSTANCE = selenium;
}
private static WebDriver createRemoteSession(final RemoteSetting remoteSetting, final MutableCapabilities caps) {
LOG.i("Creating remote session...");
final StringBuilder urlBuilder = new StringBuilder(remoteSetting.getProtocol()
.getPrefix());
final String url = remoteSetting.getUrl();
if (remoteSetting.getSource() != RemoteSource.GRID) {
final String user = remoteSetting.getUserId();
final String pass = remoteSetting.getPassword();
if (isNotEmpty(user)) {
urlBuilder.append(user)
.append(":")
.append(requireNonNull(pass, "Cloud Password cannot be empty."))
.append("@");
}
}
urlBuilder.append(url);
final int port = remoteSetting.getPort();
if (port > 0) {
urlBuilder.append(":")
.append(port);
}
urlBuilder.append("/wd/hub");
try {
final URL remoteUrl = new URL(urlBuilder.toString());
return new RemoteWebDriver(remoteUrl, caps);
} catch (final MalformedURLException e) {
LOG.e("Error occurred while creating remote session: ", e);
}
return null;
}
private void createSauceDriver(MutableCapabilities capabilities, String methodName) {
String username = System.getenv("SAUCE_USERNAME");
String accesskey = System.getenv("SAUCE_ACCESS_KEY");
//Create a map of capabilities called "sauce:options", which contain the info necessary to run on Sauce
// Labs, using the credentials stored in the environment variables. Also runs using the new W3C standard.
MutableCapabilities sauceOptions = new MutableCapabilities();
sauceOptions.setCapability("username", username);
sauceOptions.setCapability("accessKey", accesskey);
sauceOptions.setCapability("seleniumVersion", "3.141.59");
sauceOptions.setCapability("name", methodName);
sauceOptions.setCapability("build", "parallel-TestNG-single-browser-demo");
//Assign the Sauce Options to the base capabilities
capabilities.setCapability("sauce:options", sauceOptions);
//Create a new RemoteWebDriver, which will initialize the test execution on Sauce Labs servers
String SAUCE_REMOTE_URL = "https://ondemand.saucelabs.com/wd/hub";
try {
webDriver.set(new RemoteWebDriver(new URL(SAUCE_REMOTE_URL), capabilities));
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
sessionId.set(((RemoteWebDriver)webDriver.get()).getSessionId().toString());
// set current sessionId
String id = ((RemoteWebDriver) getWebDriver()).getSessionId().toString();
sessionId.set(id);
}
private void createSauceDriver(MutableCapabilities capabilities, String methodName) {
String username = System.getenv("SAUCE_USERNAME");
String accesskey = System.getenv("SAUCE_ACCESS_KEY");
//Create a map of capabilities called "sauce:options", which contain the info necessary to run on Sauce
// Labs, using the credentials stored in the environment variables. Also runs using the new W3C standard.
MutableCapabilities sauceOptions = new MutableCapabilities();
sauceOptions.setCapability("username", username);
sauceOptions.setCapability("accessKey", accesskey);
sauceOptions.setCapability("seleniumVersion", "3.141.59");
sauceOptions.setCapability("name", methodName);
sauceOptions.setCapability("build", "parallel-TestNG-cross-browser-and-platform-demo");
//Assign the Sauce Options to the base capabilities
capabilities.setCapability("sauce:options", sauceOptions);
//Create a new RemoteWebDriver, which will initialize the test execution on Sauce Labs servers
String SAUCE_REMOTE_URL = "https://ondemand.saucelabs.com/wd/hub";
try {
webDriver.set(new RemoteWebDriver(new URL(SAUCE_REMOTE_URL), capabilities));
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
sessionId.set(((RemoteWebDriver)webDriver.get()).getSessionId().toString());
// set current sessionId
String id = ((RemoteWebDriver) getWebDriver()).getSessionId().toString();
sessionId.set(id);
}
/**
* Constructs a new {@link AndroidDriver} instance which is configured to use the capabilities defined by the browser,
* version and os parameters, and which is configured to run against ondemand.saucelabs.com, using
* the username and access key populated by the {@link #authentication} instance.
*
* @param platformName name of the platformName. (Android, iOS, etc.)
* @param deviceName name of the device
* @param platformVersion Os version of the device
* @param appiumVersion appium version
* @param deviceOrientation device orientation
* @return
* @throws MalformedURLException if an error occurs parsing the url
*/
protected void createDriver(
String platformName,
String deviceName,
String platformVersion,
String appiumVersion,
String deviceOrientation,
String methodName)
throws MalformedURLException, UnexpectedException {
MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability("platformName", platformName);
capabilities.setCapability("platformVersion", platformVersion);
capabilities.setCapability("deviceName", deviceName);
capabilities.setCapability("browserName", "");
capabilities.setCapability("deviceOrientation", deviceOrientation);
capabilities.setCapability("appiumVersion", appiumVersion);
capabilities.setCapability("name", methodName);
capabilities.setCapability("app", app);
capabilities.setCapability("build", "Java-TestNG-Appium-Android");
if (buildTag != null) {
capabilities.setCapability("build", buildTag);
}
// Launch remote browser and set it as the current thread
androidDriver.set(new AndroidDriver(
new URL("https://" + authentication.getUsername() + ":" + authentication.getAccessKey() + seleniumURI + "/wd/hub"),
capabilities));
String id = ((RemoteWebDriver) getAndroidDriver()).getSessionId().toString();
sessionId.set(id);
}
/**
* Constructs a new {@link IOSDriver} instance which is configured to use the capabilities defined by the browser,
* version and os parameters, and which is configured to run against ondemand.saucelabs.com, using
* the username and access key populated by the {@link #authentication} instance.
*
* @param platformName name of the platformName. (Android, iOS, etc.)
* @param deviceName name of the device
* @param platformVersion Os version of the device
* @param appiumVersion appium version
* @param deviceOrientation device orientation
* @return
* @throws MalformedURLException if an error occurs parsing the url
*/
protected void createDriver(
String platformName,
String deviceName,
String platformVersion,
String appiumVersion,
String deviceOrientation,
String methodName)
throws MalformedURLException, UnexpectedException {
MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability("platformName", platformName);
capabilities.setCapability("platformVersion", platformVersion);
capabilities.setCapability("deviceName", deviceName);
capabilities.setCapability("browserName", "");
capabilities.setCapability("deviceOrientation", deviceOrientation);
capabilities.setCapability("appiumVersion", appiumVersion);
capabilities.setCapability("name", methodName);
capabilities.setCapability("build","Java-TestNG-Appium-iOS");
capabilities.setCapability("app", app);
if (buildTag != null) {
capabilities.setCapability("build", buildTag);
}
// Launch remote browser and set it as the current thread
iosDriver.set(new IOSDriver(
new URL("https://" + authentication.getUsername() + ":" + authentication.getAccessKey() + seleniumURI +"/wd/hub"),
capabilities));
String id = ((RemoteWebDriver) getiosDriver()).getSessionId().toString();
sessionId.set(id);
}
@Test
public void main() throws MalformedURLException {
String sauceUserName = System.getenv("SAUCE_USERNAME");
String sauceAccessKey = System.getenv("SAUCE_ACCESS_KEY");
String URL = "https://ondemand.us-east-1.saucelabs.com/wd/hub";
ChromeOptions chromeOpts = new ChromeOptions();
chromeOpts.setExperimentalOption("w3c", true);
MutableCapabilities sauceOptions = new MutableCapabilities();
sauceOptions.setCapability("username", sauceUserName);
sauceOptions.setCapability("accessKey", sauceAccessKey);
sauceOptions.setCapability("seleniumVersion", "3.141.59");
sauceOptions.setCapability("name", "headless-chrome-test-java");
sauceOptions.setCapability("build", "Sample Headless Tests");
MutableCapabilities caps = new MutableCapabilities();
caps.setCapability("goog:chromeOptions", chromeOpts);
caps.setCapability("browserName", "chrome");
caps.setCapability("browserVersion", "latest");
caps.setCapability("platformName", "Linux");
caps.setCapability("sauce:options", sauceOptions);
driver = new RemoteWebDriver(new URL(URL), caps);
/* Goes to Sauce Lab's demo page and prints title */
driver.get("https://www.saucedemo.com");
System.out.println("title of page is: " + driver.getTitle());
Assert.assertEquals(driver.getTitle(), "Swag Labs" );
}
private void createSauceDriver(MutableCapabilities capabilities, String methodName) {
String username = System.getenv("SAUCE_USERNAME");
String accesskey = System.getenv("SAUCE_ACCESS_KEY");
//Create a map of capabilities called "sauce:options", which contain the info necessary to run on Sauce
// Labs, using the credentials stored in the environment variables. Also runs using the new W3C standard.
MutableCapabilities sauceOptions = new MutableCapabilities();
sauceOptions.setCapability("username", username);
sauceOptions.setCapability("accessKey", accesskey);
sauceOptions.setCapability("seleniumVersion", "3.141.59");
sauceOptions.setCapability("name", methodName);
sauceOptions.setCapability("build", "Sample Headless Tests");
//Assign the Sauce Options to the base capabilities
capabilities.setCapability("sauce:options", sauceOptions);
//Create a new RemoteWebDriver, which will initialize the test execution on Sauce Labs servers
String SAUCE_REMOTE_URL = "https://ondemand.us-east-1.saucelabs.com/wd/hub";
try {
webDriver.set(new RemoteWebDriver(new URL(SAUCE_REMOTE_URL), capabilities));
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
sessionId.set(((RemoteWebDriver)webDriver.get()).getSessionId().toString());
// set current sessionId
String id = ((RemoteWebDriver) getWebDriver()).getSessionId().toString();
sessionId.set(id);
}
public MutableCapabilities get() {
DesiredCapabilities safariCaps = DesiredCapabilities.safari();
SafariOptions options = new SafariOptions();
options.setUseTechnologyPreview(true);
safariCaps.setCapability(SafariOptions.CAPABILITY, options);
setLoggingPrefs(safariCaps);
if (!this.customCaps.asMap().isEmpty()) {
safariCaps.merge(this.customCaps);
}
return safariCaps;
}
/**
* Sets the logging level of the generated web driver.
*
* @param caps
* The web driver's MutableCapabilities (FirefoxOptions)
* @param level
* The logging level
*/
private void setLoggingLevel(MutableCapabilities caps) {
final LoggingPreferences logPrefs = new LoggingPreferences();
logPrefs.enable(LogType.BROWSER, Level.ALL);
logPrefs.enable(LogType.CLIENT, Level.OFF);
logPrefs.enable(LogType.DRIVER, Level.OFF);
logPrefs.enable(LogType.PERFORMANCE, Level.OFF);
logPrefs.enable(LogType.PROFILER, Level.OFF);
logPrefs.enable(LogType.SERVER, Level.OFF);
caps.setCapability(CapabilityType.LOGGING_PREFS, logPrefs);
}
private void checkChrome(BrowserConfiguration config)
{
Assert.assertNotNull(config);
Assert.assertEquals("chrome", config.getConfigTag());
Assert.assertEquals("Google Chrome", config.getName());
Assert.assertEquals("local", config.getTestEnvironment());
MutableCapabilities testCapabilities = config.getCapabilities();
Assert.assertEquals("chrome", testCapabilities.getBrowserName());
Assert.assertEquals(true, testCapabilities.getCapability(CapabilityType.ACCEPT_INSECURE_CERTS));
LinkedList<String> list = new LinkedList<>();
list.add("headless");
Assert.assertEquals(list, config.getArguments());
}
private void checkMultiChrome(BrowserConfiguration config)
{
Assert.assertNotNull(config);
Assert.assertEquals("multiChrome", config.getConfigTag());
Assert.assertEquals("Multi Argument Chrome", config.getName());
MutableCapabilities testCapabilities = config.getCapabilities();
Assert.assertEquals("chrome", testCapabilities.getBrowserName());
LinkedList<String> list = new LinkedList<>();
list.add("-crash-test");
list.add("-window-position=0,0");
list.add("-window-size=1024,768");
Assert.assertEquals(list, config.getArguments());
}
private void checkFirefox(BrowserConfiguration config)
{
Assert.assertNotNull(config);
Assert.assertEquals("firefox", config.getConfigTag());
Assert.assertEquals("Mozilla Firefox", config.getName());
Assert.assertEquals(null, config.getTestEnvironment());
MutableCapabilities testCapabilities = config.getCapabilities();
Assert.assertEquals("firefox", testCapabilities.getBrowserName());
LinkedList<String> list = new LinkedList<>();
list.add("headless");
Assert.assertEquals(list, config.getArguments());
}
private void checkMultiFirefox(BrowserConfiguration config)
{
Assert.assertNotNull(config);
Assert.assertEquals("multiFirefox", config.getConfigTag());
Assert.assertEquals("Multi Argument Firefox", config.getName());
MutableCapabilities testCapabilities = config.getCapabilities();
Assert.assertEquals("firefox", testCapabilities.getBrowserName());
LinkedList<String> list = new LinkedList<>();
list.add("-headless");
list.add("-width=1024");
list.add("-height=768");
Assert.assertEquals(list, config.getArguments());
}
@Override
public MutableCapabilities getOptions(Parameter parameter,
Optional<Object> testInstance)
throws IOException, IllegalAccessException {
ChromeOptions chromeOptions = new ChromeOptions();
if (parameter != null) {
// @Arguments
Arguments arguments = parameter.getAnnotation(Arguments.class);
if (arguments != null) {
stream(arguments.value()).forEach(chromeOptions::addArguments);
}
// @Extensions
Extensions extensions = parameter.getAnnotation(Extensions.class);
if (extensions != null) {
for (String extension : extensions.value()) {
chromeOptions.addExtensions(getExtension(extension));
}
}
// @Binary
Binary binary = parameter.getAnnotation(Binary.class);
if (binary != null) {
chromeOptions.setBinary(binary.value());
}
// @Options
ChromeOptions optionsFromAnnotatedField = annotationsReader
.getFromAnnotatedField(testInstance, Options.class,
ChromeOptions.class);
if (optionsFromAnnotatedField != null) {
chromeOptions = optionsFromAnnotatedField.merge(chromeOptions);
}
}
return chromeOptions;
}
@Override
public MutableCapabilities getOptions(Parameter parameter,
Optional<Object> testInstance)
throws IOException, IllegalAccessException {
EdgeOptions edgeOptions = new EdgeOptions();
EdgeOptions optionsFromAnnotatedField = annotationsReader
.getFromAnnotatedField(testInstance, Options.class,
EdgeOptions.class);
if (optionsFromAnnotatedField != null) {
edgeOptions = optionsFromAnnotatedField;
}
return edgeOptions;
}
@Override
public MutableCapabilities getOptions(Parameter parameter,
Optional<Object> testInstance) throws IllegalAccessException {
SafariOptions safariOptions = new SafariOptions();
SafariOptions optionsFromAnnotatedField = annotationsReader
.getFromAnnotatedField(testInstance, Options.class,
SafariOptions.class);
if (optionsFromAnnotatedField != null) {
safariOptions = optionsFromAnnotatedField;
}
return safariOptions;
}
@Override
public MutableCapabilities getOptions(Parameter parameter,
Optional<Object> testInstance)
throws IOException, IllegalAccessException {
InternetExplorerOptions internetExplorerOptions = new InternetExplorerOptions();
InternetExplorerOptions optionsFromAnnotatedField = annotationsReader
.getFromAnnotatedField(testInstance, Options.class,
InternetExplorerOptions.class);
if (optionsFromAnnotatedField != null) {
internetExplorerOptions = optionsFromAnnotatedField;
}
return internetExplorerOptions;
}
@Override
public MutableCapabilities getOptions(Parameter parameter,
Optional<Object> testInstance)
throws IOException, IllegalAccessException {
OperaOptions operaOptions = new OperaOptions();
if (parameter != null) {
// @Arguments
Arguments arguments = parameter.getAnnotation(Arguments.class);
if (arguments != null) {
stream(arguments.value()).forEach(operaOptions::addArguments);
}
// @Extensions
Extensions extensions = parameter.getAnnotation(Extensions.class);
if (extensions != null) {
for (String extension : extensions.value()) {
operaOptions.addExtensions(getExtension(extension));
}
}
// @Binary
Binary binary = parameter.getAnnotation(Binary.class);
if (binary != null) {
operaOptions.setBinary(binary.value());
}
// @Options
OperaOptions optionsFromAnnotatedField = annotationsReader
.getFromAnnotatedField(testInstance, Options.class,
OperaOptions.class);
if (optionsFromAnnotatedField != null) {
operaOptions = optionsFromAnnotatedField.merge(operaOptions);
}
}
return operaOptions;
}
private WebDriver prepareRemoteDriver(){
if(System.getenv("SAUCE_USERNAME") == null){
throw new RuntimeException("To use remote driver a Sauce lab account is required. Please assign your Sauce labs account name to the environmental variable 'sauce_username'");
}
if(System.getenv("SAUCE_ACCESS_KEY") == null){
throw new RuntimeException("To use remote driver a Sauce lab account is required. Please assign your Sauce labs access key to the environmental variable 'sauce_access_key'");
}
String URL = "http://" + System.getenv("SAUCE_USERNAME") + ":" + System.getenv("SAUCE_ACCESS_KEY") + "@ondemand.saucelabs.com:80/wd/hub";
FirefoxOptions firefoxOptions = new FirefoxOptions();
firefoxOptions.setCapability("platformName", "Windows 10");
firefoxOptions.setCapability("browserVersion", "65.0");
MutableCapabilities sauceCaps = new MutableCapabilities();
sauceCaps.setCapability("username", System.getenv("SAUCE_USERNAME"));
sauceCaps.setCapability("accessKey", System.getenv("SAUCE_ACCESS_KEY"));
sauceCaps.setCapability("seleniumVersion", "3.141.59");
sauceCaps.setCapability("name", "Restful-booker-platform");
firefoxOptions.setCapability("sauce:options", sauceCaps);
try {
return new RemoteWebDriver(new URL(URL), firefoxOptions);
} catch (MalformedURLException e) {
throw new RuntimeException("WARN: An error occurred attempting to create a remote driver connection. See the following error: " + e);
}
}
private static void setCommonOptions(
MutableCapabilities capabilities, String proxyAddress, int proxyPort) {
capabilities.setCapability(CapabilityType.ACCEPT_SSL_CERTS, true);
// W3C capability
capabilities.setCapability(CapabilityType.ACCEPT_INSECURE_CERTS, true);
if (proxyAddress != null) {
String httpProxy = proxyAddress + ":" + proxyPort;
Proxy proxy = new Proxy();
proxy.setHttpProxy(httpProxy);
proxy.setSslProxy(httpProxy);
capabilities.setCapability(CapabilityType.PROXY, proxy);
}
}