Java Code Examples for org.openqa.selenium.chrome.ChromeOptions#setExperimentalOption()

The following examples show how to use org.openqa.selenium.chrome.ChromeOptions#setExperimentalOption() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may want to check out the right sidebar which shows the related API usage.
Example 1
/**
 * Start the Selenium chrome driver instance with lean options
 */
public void startDriver(){
    if (serviceManager != null){
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--headless");
        options.addArguments("--no-sandbox");
        options.addArguments("--disable-dev-shm-usage");
        HashMap<String, Object> prefs = new HashMap<String, Object>(); 
        prefs.put("profile.managed_default_content_settings.images", 2);
        options.setExperimentalOption("prefs", prefs); 

        driver = new RemoteWebDriver(serviceManager.getService().getUrl(), options);
        driver.manage().timeouts().implicitlyWait(PAGE_WAIT_TIMEOUT, TimeUnit.SECONDS); // Wait for the page to be completely loaded. Or reasonably loaded.
    }
    else {
        System.err.println("[JS-SRI][-] You must set a driver service manager before you can start a driver.");
    }
}
 
Example 2
Source Project: demo-java   File: UpdateSauceStatusTest.java    License: MIT License 6 votes vote down vote up
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);
}
 
Example 3
Source Project: testng-cucumber   File: CucumberRunner.java    License: MIT License 6 votes vote down vote up
public void openBrowser() throws Exception {
	// loads the config options
	LoadConfigProperty();
	// configures the driver path
	configureDriverPath();
	if (config.getProperty("browserType").equals("firefox")) {
		driver = new FirefoxDriver();
	} else if (config.getProperty("browserType").equals("chrome")) {
		ChromeOptions options = new ChromeOptions();
		options.addArguments("--headless");
		options.addArguments("--disable-gpu");
		options.addArguments("--no-sandbox");
		options.addArguments("--disable-dev-shm-usage");
		options.setExperimentalOption("useAutomationExtension", false);
		driver = new ChromeDriver(options);
	}
}
 
Example 4
Source Project: AndroidRobot   File: ChromeDriverClient.java    License: Apache License 2.0 6 votes vote down vote up
public void createDriver(String pkg_name, String sn) {
    	if(this.driver == null) {
	        ChromeOptions chromeOptions = new ChromeOptions();
	        chromeOptions.setExperimentalOption("androidPackage", pkg_name);
	//        chromeOptions.setExperimentalOption("androidActivity", "com.eg.android.AlipayGphone.AlipayLogin");
	//        chromeOptions.setExperimentalOption("debuggerAddress", "127.0.0.1:9222");
	        chromeOptions.setExperimentalOption("androidUseRunningApp", true);
	        chromeOptions.setExperimentalOption("androidDeviceSerial", sn);
	//        Map<String, Object> chromeOptions = new HashMap<String, Object>();
	//        chromeOptions.put("androidPackage", "com.eg.android.AlipayGphoneRC");
	//        chromeOptions.put("androidActivity", "com.eg.android.AlipayGphone.AlipayLogin");
	        DesiredCapabilities capabilities = DesiredCapabilities.chrome();
	        LoggingPreferences logPrefs = new LoggingPreferences();
	        logPrefs.enable(LogType.PERFORMANCE, Level.ALL);
	        capabilities.setCapability(CapabilityType.LOGGING_PREFS, logPrefs);
	        capabilities.setCapability(ChromeOptions.CAPABILITY, chromeOptions);
//	        capabilities.setCapability(CapabilityType., value);
	        if(ChromeService.getService() != null)
	        	driver = new RobotRemoteWebDriver(ChromeService.getService().getUrl(), capabilities);
    	}
    }
 
Example 5
private ChromeOptions buildChromeOptions() {
	final ChromeOptions options = new ChromeOptions();
	final Map<String, Object> prefs = new HashMap<String, Object>();
	prefs.put("credentials_enable_service", false);
	prefs.put("password_manager_enabled", false);
	options.setExperimentalOption("prefs", prefs);
	SYSTEM_PROPERTY_UTILS.getPropertyAsOptional(Constants.CHROME_EXECUTABLE_LOCATION_SYSTEM_PROPERTY)
               .ifPresent(options::setBinary);
	return options;
}
 
Example 6
Source Project: vividus   File: WebDriverTypeTests.java    License: Apache License 2.0 5 votes vote down vote up
@Test
@PrepareForTest(fullyQualifiedNames = "org.vividus.selenium.WebDriverType$3")
public void testGetChromeWebDriverWithAdditionalOptions() throws Exception
{
    Map<String, String> experimentalOptionValue = singletonMap(OPTION_KEY, OPTION_VALUE);
    WebDriverConfiguration configuration = new WebDriverConfiguration();
    configuration.setBinaryPath(Optional.of(PATH));
    configuration.setCommandLineArguments(new String[] { ARGUMENT });
    configuration.setExperimentalOptions(singletonMap(MOBILE_EMULATION, experimentalOptionValue));
    ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setBinary(PATH);
    chromeOptions.addArguments(ARGUMENT);
    chromeOptions.setExperimentalOption(MOBILE_EMULATION, experimentalOptionValue);
    testGetChromeWebDriver(configuration, chromeOptions);
}
 
Example 7
private void setChromePrefs(ChromeOptions options){
    HashMap<String, Object> chromePrefs = new HashMap<>();
    Map<String, Object> configOptions = getBrowserOptions();
    configOptions.forEach((key, value) -> {
        if (key.equals(getDownloadDirCapabilityKey())) {
            chromePrefs.put(key, getDownloadDir());
        } else {
            chromePrefs.put(key, value);
        }
    });
    options.setExperimentalOption("prefs", chromePrefs);
}
 
Example 8
Source Project: dropwizard-experiment   File: WebDriverFactory.java    License: MIT License 5 votes vote down vote up
/**
 * Create a Chrome WebDriver instance.
 * @return The WebDriver
 */
public static EventFiringWebDriver createChrome() {
    String chromeDriverBinary = WebDriverBinaryFinder.findChromeDriver();
    System.setProperty("webdriver.chrome.driver", chromeDriverBinary);
    log.info("Using ChromeDriver binary from {}", chromeDriverBinary);

    // Prevent annoying yellow warning bar from being displayed.
    ChromeOptions options = new ChromeOptions();
    options.setExperimentalOption("excludeSwitches", ImmutableList.of("ignore-certificate-errors"));
    DesiredCapabilities caps = getCapabilities();
    caps.setCapability(ChromeOptions.CAPABILITY, options);

    return withReports(new ChromeDriver(caps));
}
 
Example 9
@BeforeMethod
@Parameters({ "remoteURL", "baseURL", "OS", "browser",
		"version", "internal" })
public void beforeTest(String remoteURL, String baseURL,
		String OS, String browser, String version, String internal)
		throws IOException {
	this.testCase = new TestCase();
	this.testCase.setExecutionEnvironment("{browser:"+browser+",browserVersion:"+version+",OperatingSystem:"+OS+"}");
	this.testCase.setParentURL(baseURL);
	this.testCase.setTestCaseId("KT"+testCaseCount++);
	this.testCase.setScreenshotDirectory(log.getReportDirectory()+ File.separator + "images");
	config = new WebDriverConfig();
	config.setRemoteURL(remoteURL);
	this.baseURL = baseURL;
	config.setOS(OS);
	config.setBrowserName(browser);
	config.setBrowserVersion(version);
	config.setIntenal(Boolean.parseBoolean(internal));
	ChromeOptions options = new ChromeOptions();
	options.addArguments("--start-maximized");
	options.addArguments("--enable-strict-powerful-feature-restrictions");
	JsonObject jsonObject = new JsonObject();
	jsonObject.addProperty("profile.default_content_settings.geolocation", 2);
	jsonObject.addProperty("profile.default_content_setting_values.notifications",2);
	options.setExperimentalOption("prefs", jsonObject);
	options.addArguments("--disable-notifications");
	config.setChromeOptions(options);
	driver = xRemoteWebDriver.getInstance(config, log);
	driver.manage().window().maximize();
	driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
	driver.get(this.baseURL);
}
 
Example 10
Source Project: openvidu   File: ChromeUser.java    License: Apache License 2.0 5 votes vote down vote up
private ChromeUser(String userName, int timeOfWaitInSeconds, ChromeOptions options) {
	super(userName, timeOfWaitInSeconds);
	options.setAcceptInsecureCerts(true);
	options.setUnhandledPromptBehaviour(UnexpectedAlertBehaviour.IGNORE);

	options.addArguments("--disable-infobars");
	options.setExperimentalOption("excludeSwitches", new String[]{"enable-automation"}); 

	Map<String, Object> prefs = new HashMap<String, Object>();
	prefs.put("profile.default_content_setting_values.media_stream_mic", 1);
	prefs.put("profile.default_content_setting_values.media_stream_camera", 1);
	options.setExperimentalOption("prefs", prefs);

	String REMOTE_URL = System.getProperty("REMOTE_URL_CHROME");
	if (REMOTE_URL != null) {
		log.info("Using URL {} to connect to remote web driver", REMOTE_URL);
		try {
			this.driver = new RemoteWebDriver(new URL(REMOTE_URL), options);
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
	} else {
		log.info("Using local web driver");
		this.driver = new ChromeDriver(options);
	}

	this.driver.manage().timeouts().setScriptTimeout(this.timeOfWaitInSeconds, TimeUnit.SECONDS);
	this.configureDriver();
}
 
Example 11
Capabilities createCapabilities() {
      DesiredCapabilities capabilities = new DesiredCapabilities();
      capabilities.setCapability(CapabilityType.PROXY, createProxy());
      LoggingPreferences logPrefs = new LoggingPreferences();
logPrefs.enable(LogType.BROWSER, Level.ALL);
capabilities.setCapability(CapabilityType.LOGGING_PREFS, logPrefs);
      

      if(isAndroidEnabled() || isHeadlessEnabled() || isIncognitoEnabled()) {
          //Map<String, String> chromeOptions = new HashMap<String, String>();
          //chromeOptions.put("androidPackage", "com.android.chrome");
          ChromeOptions chromeOptions = new ChromeOptions();
          if (isAndroidEnabled()) {
              chromeOptions.setExperimentalOption("androidPackage", "com.android.chrome");
          }
          if (isHeadlessEnabled()) {
              chromeOptions.addArguments("--headless");

          }
          if (isIncognitoEnabled()) {
              chromeOptions.addArguments("--incognito");

          }
          capabilities.setCapability(ChromeOptions.CAPABILITY, chromeOptions);
      }

      if(isInsecureCertsEnabled()) {
            capabilities.setCapability("acceptInsecureCerts", true);
      }

      return capabilities;
  }
 
Example 12
Source Project: teasy   File: ChromeCaps.java    License: MIT License 5 votes vote down vote up
private ChromeOptions getChromeOptions() {
    ChromeOptions options = new ChromeOptions();
    options.setCapability(CapabilityType.UNEXPECTED_ALERT_BEHAVIOUR, this.alertBehaviour);
    //To view pdf in chrome
    options.setExperimentalOption("excludeSwitches", Arrays.asList("test-type", "--ignore-certificate-errors"));
    if (this.isHeadless) {
        options.addArguments("headless");
    }
    options.setCapability(ChromeOptions.CAPABILITY, options);
    options.setCapability(CapabilityType.ACCEPT_SSL_CERTS, true);
    options.setCapability("platform", platform);
    setLoggingPrefs(options);
    return options;
}
 
Example 13
private static synchronized BrowserWebDriverContainer initializeSeleniumContainer() {

        if (SELENIUMCONTAINER == null) {
            java.util.logging.Logger.getLogger("org.openqa.selenium").setLevel(Level.OFF);

            final ChromeOptions theOptions = new ChromeOptions().setHeadless(true);
            theOptions.addArguments("--js-flags=experimental-wasm-eh");
            theOptions.addArguments("--enable-experimental-wasm-eh");
            theOptions.addArguments("disable-infobars"); // disabling infobars
            theOptions.addArguments("--disable-dev-shm-usage"); // overcome limited resource problems
            theOptions.addArguments("--no-sandbox"); // Bypass OS security model
            theOptions.setExperimentalOption("useAutomationExtension", false);
            final LoggingPreferences theLoggingPreferences = new LoggingPreferences();
            theLoggingPreferences.enable(LogType.BROWSER, Level.ALL);
            theOptions.setCapability(CapabilityType.LOGGING_PREFS, theLoggingPreferences);
            theOptions.setCapability("goog:loggingPrefs", theLoggingPreferences);

            Testcontainers.exposeHostPorts(getTestWebServerPort());

            SELENIUMCONTAINER = new BrowserWebDriverContainer()
                    .withCapabilities(theOptions)
                    .withRecordingMode(BrowserWebDriverContainer.VncRecordingMode.SKIP, new File("."));
            SELENIUMCONTAINER.start();

            Runtime.getRuntime().addShutdownHook(new Thread(() -> SELENIUMCONTAINER.stop()));
        }
        return SELENIUMCONTAINER;
    }
 
Example 14
private static ChromeOptions getChromeEmulatorCaps(DesiredCapabilities caps, String deviceName) {
      Map<String, String> mobileEmulation = new HashMap<>();
      mobileEmulation.put("deviceName", deviceName);
      ChromeOptions chromeOptions = new ChromeOptions();
      chromeOptions.setExperimentalOption("mobileEmulation", mobileEmulation);
chromeOptions.merge(caps);
      //caps.setCapability(ChromeOptions.CAPABILITY, chromeOptions);
      return chromeOptions;
  }
 
Example 15
Source Project: akita   File: CustomDriverProvider.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Устанавливает ChromeOptions для запуска google chrome эмулирующего работу мобильного устройства (по умолчанию nexus 5)
 * Название мобильного устройства (device) может быть задано через системные переменные
 *
 * @return ChromeOptions
 */
private ChromeOptions getMobileChromeOptions(DesiredCapabilities capabilities) {
    log.info("---------------run CustomMobileDriver---------------------");
    String mobileDeviceName = loadSystemPropertyOrDefault("device", "Nexus 5");
    ChromeOptions chromeOptions = new ChromeOptions().addArguments("disable-extensions",
        "test-type", "no-default-browser-check", "ignore-certificate-errors");

    Map<String, String> mobileEmulation = new HashMap<>();
    chromeOptions.setHeadless(getHeadless());
    mobileEmulation.put("deviceName", mobileDeviceName);
    chromeOptions.setExperimentalOption("mobileEmulation", mobileEmulation);
    chromeOptions.merge(capabilities);
    return chromeOptions;
}
 
Example 16
/**
 * setDriver method to create driver instance
 *
 * @param browser
 * @param environment
 * @param platform
 * @param optPreferences
 * @throws Exception
 */
@SafeVarargs
public final void setDriver(String browser,
                            String platform,
                            String environment,
                            Map<String, Object>... optPreferences)
                            throws Exception {

    DesiredCapabilities caps = null;
    String getPlatform = null;
    props.load(new FileInputStream(Global_VARS.SE_PROPS));

    switch (browser) {
        case "firefox":
            caps = DesiredCapabilities.firefox();

            FirefoxOptions ffOpts = new FirefoxOptions();
            FirefoxProfile ffProfile = new FirefoxProfile();

            ffProfile.setPreference("browser.autofocus", true);
            ffProfile.setPreference("browser.tabs.remote.autostart.2", false);

            caps.setCapability(FirefoxDriver.PROFILE, ffProfile);
            caps.setCapability("marionette", true);

            // then pass them to the local WebDriver
            if ( environment.equalsIgnoreCase("local") ) {
                System.setProperty("webdriver.gecko.driver", props.getProperty("gecko.driver.windows.path"));
                webDriver.set(new FirefoxDriver(ffOpts.merge(caps)));
            }

            break;
        case "chrome":
            caps = DesiredCapabilities.chrome();

            ChromeOptions chOptions = new ChromeOptions();
            Map<String, Object> chromePrefs = new HashMap<String, Object>();

            chromePrefs.put("credentials_enable_service", false);

            chOptions.setExperimentalOption("prefs", chromePrefs);
            chOptions.addArguments("--disable-plugins", "--disable-extensions", "--disable-popup-blocking");

            caps.setCapability(ChromeOptions.CAPABILITY, chOptions);
            caps.setCapability("applicationCacheEnabled", false);

            if ( environment.equalsIgnoreCase("local") ) {
                System.setProperty("webdriver.chrome.driver", props.getProperty("chrome.driver.windows.path"));
                webDriver.set(new ChromeDriver(chOptions.merge(caps)));
            }

            break;
        case "internet explorer":
            caps = DesiredCapabilities.internetExplorer();

            InternetExplorerOptions ieOpts = new InternetExplorerOptions();

            ieOpts.requireWindowFocus();
            ieOpts.merge(caps);

            caps.setCapability("requireWindowFocus", true);

            if ( environment.equalsIgnoreCase("local") ) {
                System.setProperty("webdriver.ie.driver", props.getProperty("ie.driver.windows.path"));
                webDriver.set(new InternetExplorerDriver(ieOpts.merge(caps)));
            }

            break;
    }

    getEnv = environment;
    getPlatform = platform;
    sessionId.set(((RemoteWebDriver) webDriver.get()).getSessionId().toString());
    sessionBrowser.set(caps.getBrowserName());
    sessionVersion.set(caps.getVersion());
    sessionPlatform.set(getPlatform);

    System.out.println("\n*** TEST ENVIRONMENT = "
            + getSessionBrowser().toUpperCase()
            + "/" + getSessionPlatform().toUpperCase()
            + "/" + getEnv.toUpperCase()
            + "/Selenium Version=" + props.getProperty("selenium.revision")
            + "/Session ID=" + getSessionId() + "\n");

    getDriver().manage().timeouts().implicitlyWait(IMPLICIT_TIMEOUT, TimeUnit.SECONDS);
    getDriver().manage().window().maximize();
}
 
Example 17
Source Project: demo-java   File: Module4JunitTest.java    License: MIT License 4 votes vote down vote up
@Test
public void shouldOpenChrome() throws MalformedURLException {
    /** Here we set environment variables from your local machine, or IntelliJ run configuration,
     *  and store these values in the variables below. Doing this is a best practice in terms of test execution
     *  and security. If you're not sure how to use env variables, refer to this guide -
     * https://wiki.saucelabs.com/display/DOCS/Best+Practice%3A+Use+Environment+Variables+for+Authentication+Credentials
     * or check junit5-README.md */
    String sauceUserName = System.getenv("SAUCE_USERNAME");
    String sauceAccessKey = System.getenv("SAUCE_ACCESS_KEY");
    String sauceURL = "https://ondemand.saucelabs.com/wd/hub";
    /**
     * * Here we set the MutableCapabilities for "sauce:options", which is required for newer versions of Selenium
     * and the w3c protocol, for more info read the documentation:
     * https://wiki.saucelabs.com/display/DOCS/Selenium+W3C+Capabilities+Support+-+Beta */
    MutableCapabilities sauceOpts = new MutableCapabilities();
    sauceOpts.setCapability("username", sauceUserName);
    sauceOpts.setCapability("accessKey", sauceAccessKey);
    /** In order to use w3c you must set the seleniumVersion **/
    sauceOpts.setCapability("seleniumVersion", "3.141.59");
    sauceOpts.setCapability("name", "4-best-practices");

    /**
     * in this exercise we set additional capabilities below that align with
     * testing best practices such as tags, timeouts, and build name/numbers.
     *
     * Tags are an excellent way to control and filter your test automation
     * in Sauce Analytics. Get a better view into your test automation.
     */
    List<String> tags = Arrays.asList("sauceDemo", "demoTest", "module4", "javaTest");
    sauceOpts.setCapability("tags", tags);
    /** Another of the most important things that you can do to get started
     * is to set timeout capabilities for Sauce based on your organizations needs. For example:
     * How long is the whole test allowed to run?*/
    sauceOpts.setCapability("maxDuration", 3600);
    /** A Selenium crash might cause a session to hang indefinitely.
     * Below is the max time allowed to wait for a Selenium command*/
    sauceOpts.setCapability("commandTimeout", 600);
    /** How long can the browser wait for a new command */
    sauceOpts.setCapability("idleTimeout", 1000);

    /** Setting a build name is one of the most fundamental pieces of running
     * successful test automation. Builds will gather all of your tests into a single
     * 'test suite' that you can analyze for results.
     * It's a best practice to always group your tests into builds. */
    sauceOpts.setCapability("build", "Onboarding Sample App - Java-Junit5");

    /** Required to set w3c protoccol **/
    ChromeOptions chromeOpts = new ChromeOptions();
    chromeOpts.setExperimentalOption("w3c", true);

    /** Set a second MutableCapabilities object to pass Sauce Options and Chrome Options **/
    MutableCapabilities capabilities = new MutableCapabilities();
    capabilities.setCapability("sauce:options", sauceOpts);
    capabilities.setCapability("goog:chromeOptions", chromeOpts);
    capabilities.setCapability("browserName", "chrome");
    capabilities.setCapability("platformVersion", "Windows 10");
    capabilities.setCapability("browserVersion", "latest");


    /** If you're accessing the EU data center, use the following endpoint:.
     * https://ondemand.eu-central-1.saucelabs.com/wd/hub
     * */
    driver = new RemoteWebDriver(new URL(sauceURL), capabilities);
    /** Don't forget to enter in your application's URL in place of 'https://www.saucedemo.com'. */
    driver.navigate().to("https://www.saucedemo.com");
    assertTrue(true);
}
 
Example 18
Source Project: demo-java   File: JUnit5W3CChromeTest.java    License: MIT License 4 votes vote down vote up
/**
 * @BeforeEach is a JUnit 5 annotation that defines specific prerequisite test method behaviors.
In the example below we:
- Define Environment Variables for Sauce Credentials ("SAUCE_USERNAME" and "SAUCE_ACCESS_KEY")
- Define Chrome Options such as W3C protocol
- Define the "sauce:options" capabilities, indicated by the "sauceOpts" MutableCapability object
- Define the WebDriver capabilities, indicated by the "caps" DesiredCapabilities object
- Define the service URL for communicating with SauceLabs.com indicated by "sauceURL" string
- Set the URL to sauceURl
- Set the driver instance to a RemoteWebDriver
- Pass "url" and "caps" as parameters of the RemoteWebDriver
For more information visit the docs: https://junit.org/junit5/docs/5.0.2/api/org/junit/jupiter/api/BeforeEach.html
 */

@BeforeEach
public void setup(TestInfo testInfo) throws MalformedURLException {
    String username = System.getenv("SAUCE_USERNAME");
    String accessKey = System.getenv("SAUCE_ACCESS_KEY");
    String methodName = testInfo.getDisplayName();

    /** ChomeOptions allows us to set browser-specific behavior such as profile settings, headless capabilities, insecure tls certs,
     and in this example--the W3C protocol
     For more information see: https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/chrome/ChromeOptions.html */

    ChromeOptions chromeOpts = new ChromeOptions();
    chromeOpts.setExperimentalOption("w3c", true);

    /** The MutableCapabilities class  came into existence with Selenium 3.6.0 and acts as the parent class for
     all browser implementations--including the ChromeOptions class extension.
     Fore more information see: https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/MutableCapabilities.html */

    MutableCapabilities sauceOpts = new MutableCapabilities();
    sauceOpts.setCapability("name", methodName);
    sauceOpts.setCapability("build", "Java-W3C-Examples");
    sauceOpts.setCapability("seleniumVersion", "3.141.59");
    sauceOpts.setCapability("username", username);
    sauceOpts.setCapability("accessKey", accessKey);
    sauceOpts.setCapability("tags", testInfo.getTags());


    /** Below we see the use of our other capability objects, 'chromeOpts' and 'sauceOpts',
     defined in ChromeOptions.CAPABILITY and sauce:options respectively.
     */
    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");

    /** Finally, we pass our DesiredCapabilities object 'caps' as a parameter of our RemoteWebDriver instance */
    String sauceUrl = "https://ondemand.saucelabs.com:443/wd/hub";
    URL url = new URL(sauceUrl);
    driver = new RemoteWebDriver(url, caps);
}
 
Example 19
Source Project: QVisual   File: WebDriverCapabilities.java    License: Apache License 2.0 4 votes vote down vote up
/**
 * List of Chromium Command Line Switches
 * http://peter.sh/experiments/chromium-command-line-switches/#disable-popup-blocking
 */
private void setupChrome() {
    HashMap<String, Object> prefs = new HashMap<>();
    prefs.put("profile.default_content_setting_values.notifications", 2);
    prefs.put("profile.default_content_settings.popups", 0);
    prefs.put("download.default_directory", DOWNLOAD_DIRECTORY);
    prefs.put("download.prompt_for_download", false);
    prefs.put("profile.content_settings.pattern_pairs.*.multiple-automatic-downloads", 1);
    prefs.put("safebrowsing.enabled", true);
    prefs.put("plugins.always_open_pdf_externally", true);

    ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setExperimentalOption("useAutomationExtension", false);
    chromeOptions.setExperimentalOption("prefs", prefs);
    chromeOptions.addArguments("allow-file-access");
    chromeOptions.addArguments("allow-file-access-from-files");
    chromeOptions.addArguments("disable-background-networking");
    chromeOptions.addArguments("disable-background-timer-throttling");
    chromeOptions.addArguments("disable-breakpad");
    chromeOptions.addArguments("disable-child-account-detection");
    chromeOptions.addArguments("disable-clear-browsing-data-counters");
    chromeOptions.addArguments("disable-client-side-phishing-detection");
    chromeOptions.addArguments("disable-cloud-import");
    chromeOptions.addArguments("disable-component-cloud-policy");
    chromeOptions.addArguments("disable-component-update");
    chromeOptions.addArguments("disable-default-apps");
    chromeOptions.addArguments("disable-download-notification");
    chromeOptions.addArguments("disable-extensions");
    chromeOptions.addArguments("disable-extensions-file-access-check");
    chromeOptions.addArguments("disable-extensions-http-throttling");
    chromeOptions.addArguments("disable-hang-monitor");
    chromeOptions.addArguments("disable-infobars");
    chromeOptions.addArguments("disable-popup-blocking");
    chromeOptions.addArguments("disable-print-preview");
    chromeOptions.addArguments("disable-prompt-on-repost");
    chromeOptions.addArguments("disable-sync");
    chromeOptions.addArguments("disable-translate");
    chromeOptions.addArguments("disable-web-resources");
    chromeOptions.addArguments("disable-web-security");
    chromeOptions.addArguments("dns-prefetch-disable");
    chromeOptions.addArguments("download-whole-document");
    chromeOptions.addArguments("enable-logging");
    chromeOptions.addArguments("enable-screenshot-testing-with-mode");
    chromeOptions.addArguments("ignore-certificate-errors");
    chromeOptions.addArguments("log-level=0");
    chromeOptions.addArguments("metrics-recording-only");
    chromeOptions.addArguments("mute-audio");
    chromeOptions.addArguments("no-default-browser-check");
    chromeOptions.addArguments("no-displaying-insecure-content");
    chromeOptions.addArguments("no-experiments");
    chromeOptions.addArguments("no-first-run");
    chromeOptions.addArguments("no-sandbox");
    chromeOptions.addArguments("no-service-autorun");
    chromeOptions.addArguments("noerrdialogs");
    chromeOptions.addArguments("password-store=basic");
    chromeOptions.addArguments("reduce-security-for-testing");
    chromeOptions.addArguments("safebrowsing-disable-auto-update");
    chromeOptions.addArguments("safebrowsing-disable-download-protection");
    chromeOptions.addArguments("safebrowsing-disable-extension-blacklist");
    chromeOptions.addArguments("start-maximized");
    chromeOptions.addArguments("test-type=webdriver");
    chromeOptions.addArguments("use-mock-keychain");
    chromeOptions.setHeadless(BROWSER_HEADLESS);

    capabilities.merge(chromeOptions);
}
 
Example 20
/**
 * Generates a chrome webdriver.
 *
 * @return
 *         A chrome webdriver
 * @throws TechnicalException
 *             if an error occured when Webdriver setExecutable to true.
 */
private WebDriver generateGoogleChromeDriver() throws TechnicalException {
    final String pathWebdriver = DriverFactory.getPath(Driver.CHROME);
    if (!new File(pathWebdriver).setExecutable(true)) {
        throw new TechnicalException(Messages.getMessage(TechnicalException.TECHNICAL_ERROR_MESSAGE_WEBDRIVER_SET_EXECUTABLE));
    }
    log.info("Generating Chrome driver ({}) ...", pathWebdriver);

    System.setProperty(Driver.CHROME.getDriverName(), pathWebdriver);

    final ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setCapability(CapabilityType.ForSeleniumServer.ENSURING_CLEAN_SESSION, true);
    chromeOptions.setCapability(CapabilityType.UNEXPECTED_ALERT_BEHAVIOUR, UnexpectedAlertBehaviour.ACCEPT);
    chromeOptions.setCapability(CapabilityType.ACCEPT_SSL_CERTS, true);
    chromeOptions.setCapability(CapabilityType.ACCEPT_INSECURE_CERTS, true);

    setLoggingLevel(chromeOptions);
    chromeOptions.addArguments("--ignore-certificate-errors");

    if (Context.isHeadless()) {
        chromeOptions.addArguments("--headless");
    }

    // Proxy configuration
    if (Context.getProxy().getProxyType() != ProxyType.UNSPECIFIED && Context.getProxy().getProxyType() != ProxyType.AUTODETECT) {
        chromeOptions.setCapability(CapabilityType.PROXY, Context.getProxy());
    }

    // add Modifyheader Extensions to Chrome
    if (Context.getWebdriversProperties(MODIFYHEADER_PATH) != null && !"".equals(Context.getWebdriversProperties(MODIFYHEADER_PATH))) {
        chromeOptions.addExtensions(new File(Context.getWebdriversProperties(MODIFYHEADER_PATH)));
    }

    // Set custom downloaded file path. When you check content of downloaded file by robot.
    final HashMap<String, Object> chromePrefs = new HashMap<>();
    chromePrefs.put("download.default_directory", System.getProperty(USER_DIR) + File.separator + DOWNLOADED_FILES_FOLDER);
    chromeOptions.setExperimentalOption("prefs", chromePrefs);

    // Set custom chromium (if you not use default chromium on your target device)
    final String targetBrowserBinaryPath = Context.getWebdriversProperties(TARGET_BROWSER_BINARY_PATH);
    if (targetBrowserBinaryPath != null && !"".equals(targetBrowserBinaryPath)) {
        chromeOptions.setBinary(targetBrowserBinaryPath);
    }

    log.info("addArguments [{}] to webdriver.", Context.getWebdriversProperties(WEBDRIVER_OPTIONS_ADDITIONAL_ARGS));
    for (String additionalArgument : Context.getWebdriversProperties(WEBDRIVER_OPTIONS_ADDITIONAL_ARGS).split(",")) {
        log.info("addArgument [{}] to webdriver.", additionalArgument);
        chromeOptions.addArguments(additionalArgument);
    }

    if (Context.getWebdriversProperties(REMOTE_WEBDRIVER_URL) != null && !"".equals(Context.getWebdriversProperties(REMOTE_WEBDRIVER_URL))
            && Context.getWebdriversProperties(REMOTE_WEBDRIVER_BROWSER_VERSION) != null && !"".equals(Context.getWebdriversProperties(REMOTE_WEBDRIVER_BROWSER_VERSION))
            && Context.getWebdriversProperties(REMOTE_WEBDRIVER_PLATFORM_NAME) != null && !"".equals(Context.getWebdriversProperties(REMOTE_WEBDRIVER_PLATFORM_NAME))) {
        chromeOptions.setCapability("browserVersion", Context.getWebdriversProperties(REMOTE_WEBDRIVER_BROWSER_VERSION));
        chromeOptions.setCapability("platformName", Context.getWebdriversProperties(REMOTE_WEBDRIVER_PLATFORM_NAME));
        try {
            return new RemoteWebDriver(new URL(Context.getWebdriversProperties(REMOTE_WEBDRIVER_URL)), chromeOptions);
        } catch (MalformedURLException e) {
            throw new TechnicalException(Messages.getMessage(TechnicalException.TECHNICAL_ERROR_MESSAGE_REMOTE_WEBDRIVER_URL));
        }
    } else {
        final String withWhitelistedIps = Context.getWebdriversProperties(WITH_WHITE_LISTED_IPS);
        if (withWhitelistedIps != null && !"".equals(withWhitelistedIps)) {
            final ChromeDriverService service = new ChromeDriverService.Builder().withWhitelistedIps(withWhitelistedIps).withVerbose(false).build();
            return new ChromeDriver(service, chromeOptions);
        } else {
            return new ChromeDriver(chromeOptions);
        }
    }
}