@Override
public void resolve() {
    try {
        Optional<Object> testInstance = context.getTestInstance();
        Optional<Capabilities> capabilities = annotationsReader
                .getCapabilities(parameter, testInstance);
        EdgeOptions edgeOptions = (EdgeOptions) getOptions(parameter,
                testInstance);
        if (capabilities.isPresent()) {
            edgeOptions.merge(capabilities.get());
        }
        object = new EdgeDriver(edgeOptions);
    } catch (Exception e) {
        handleException(e);
    }
}
 

private static Capabilities edgeWithCustomCapabilities(Capabilities originalCapabilities) {
  EdgeOptions options = new EdgeOptions();

  options.addArguments("disable-extensions", "disable-infobars", "disable-breakpad");
  Map<String, Object> prefs = new HashMap<>();
  prefs.put("exit_type", "None");
  prefs.put("exited_cleanly", true);
  options.setExperimentalOption("prefs", prefs);
  String edgePath = System.getProperty("webdriver.edge.binary");
  if (edgePath != null) {
    options.setBinary(new File(edgePath));
  }

  if (originalCapabilities != null) {
    options.merge(originalCapabilities);
  }

  return options;
}
 

@Test
@PrepareForTest(fullyQualifiedNames = "org.vividus.selenium.WebDriverType$5")
public void testGetEdgeWebDriver() throws Exception
{
    DesiredCapabilities desiredCapabilities = new DesiredCapabilities();
    EdgeOptions edgeOptions = new EdgeOptions();
    edgeOptions.merge(desiredCapabilities);
    edgeOptions.setCapability("ms:inPrivate", true);
    EdgeDriver expected = mock(EdgeDriver.class);
    whenNew(EdgeDriver.class).withParameterTypes(EdgeOptions.class).withArguments(edgeOptions).thenReturn(expected);
    WebDriver actual = WebDriverType.EDGE.getWebDriver(desiredCapabilities, new WebDriverConfiguration());
    assertEquals(expected, actual);
}
 

@Test
@PrepareForTest(fullyQualifiedNames = "org.vividus.selenium.WebDriverType$7")
public void testGetEdgeChromiumWebDriver() throws Exception
{
    DesiredCapabilities desiredCapabilities = new DesiredCapabilities();
    EdgeOptions edgeOptions = new EdgeOptions();
    edgeOptions.merge(desiredCapabilities);
    EdgeDriver expected = mock(EdgeDriver.class);
    whenNew(EdgeDriver.class).withParameterTypes(EdgeOptions.class).withArguments(edgeOptions).thenReturn(expected);
    WebDriver actual = WebDriverType.EDGE_CHROMIUM.getWebDriver(desiredCapabilities, new WebDriverConfiguration());
    assertEquals(expected, actual);
}
 

@Override
public EdgeOptions getCapabilities() {
    EdgeOptions edgeOptions = new EdgeOptions();
    setCapabilities(edgeOptions);
    edgeOptions.setPageLoadStrategy(getPageLoadStrategy().toString());
    return edgeOptions;
}
 

@Override
public WebDriver getDriver() {
	System.setProperty("webdriver.edge.driver", driverPath);
	// System.setProperty("webdriver.ie.driver.loglevel", "DEBUG");

	org.openqa.selenium.edge.EdgeDriverService service = org.openqa.selenium.edge.EdgeDriverService.createDefaultService();

	EdgeOptions options = new EdgeOptions();
	return new EdgeDriver(service, options);
}
 

public EdgeOptions get() {
    EdgeOptions caps = getEdgeOptions();
    if (!this.customCaps.asMap().isEmpty()) {
        caps.merge(this.customCaps);
    }
    return caps;
}
 

private EdgeOptions getEdgeOptions() {
    EdgeOptions options = new EdgeOptions();
    options.setCapability("platform", Platform.WINDOWS);
    options.setCapability(CapabilityType.UNEXPECTED_ALERT_BEHAVIOUR, this.alertBehaviour);
    setLoggingPrefs(options);
    return options;
}
 

@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;
}
 

@ParameterizedTest
@MethodSource("testClassProvider")
void testEdgeOptions(Class<?> testClass) throws Exception {
    Parameter parameter = testClass.getMethod("edgeTest", EdgeDriver.class)
            .getParameters()[0];
    Optional<Object> testInstance = Optional.of(testClass.newInstance());
    EdgeOptions edgeOptions = (EdgeOptions) annotationsReader
            .getOptions(parameter, testInstance);
    assertThat(edgeOptions.getCapability("pageLoadStrategy"),
            equalTo("eager"));
}
 

@Test
void testAnnotatedEdgeOptionsIsSelectedOverOtherAnnotatedOptions()
        throws Exception {
    Optional<Object> testInstance = Optional
            .of(new ClassWithMultipleOptions());
    EdgeOptions edgeOptions = (EdgeOptions) annotationsReader
            .getOptions(null, testInstance);
    assertThat(edgeOptions, notNullValue());
}
 

/**
 * Задает options для запуска Edge драйвера
 * options можно передавать, как системную переменную, например -Doptions=--load-extension=my-custom-extension
 *
 * @return edgeOptions
 */
private EdgeOptions getEdgeDriverOptions(DesiredCapabilities capabilities) {
    log.info("---------------Edge Driver---------------------");
    EdgeOptions edgeOptions = new EdgeOptions();
    edgeOptions.setCapability(CapabilityType.BROWSER_VERSION, loadSystemPropertyOrDefault(CapabilityType.BROWSER_VERSION, VERSION_LATEST));
    edgeOptions.merge(capabilities);
    return edgeOptions;
}
 

@Before
public void setupTest() {
    ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setBinary(
            "C:\\Program Files (x86)\\Microsoft\\Edge Dev\\Application\\msedge.exe");
    EdgeOptions edgeOptions = new EdgeOptions().merge(chromeOptions);
    driver = new EdgeDriver(edgeOptions);
}
 

@Test
@EnabledOnOs(OS.WINDOWS)
@DisabledIfEnvironmentVariable(named = "CI", matches = "true")
void canInstantiateEdgeDriverWithEdgeOptions() {
  driver = provider.createDriver(new EdgeOptions());
  assertTrue(driver instanceof EdgeDriver);
}
 

private Capabilities createCapabilities() {
  String property = System.getProperty("selenium.browser", "ff");

  Browser browser = Browser.detect();
  switch (browser) {
    case CHROME:
      return new ChromeOptions();

    case EDGE:
      return new EdgeHtmlOptions();

    case CHROMIUMEDGE:
      return new EdgeOptions();

    case IE:
      return new InternetExplorerOptions();

    case FIREFOX:
    case MARIONETTE:
      return new FirefoxOptions();

    case OPERA:
    case OPERABLINK:
      return new OperaOptions();

    case SAFARI:
      return new SafariOptions();

    default:
      fail("Attempt to use an unsupported browser: " + property);
      // we never get here, but keep null checks happy anyway
      return new DesiredCapabilities();
  }
}
 

private static WebDriver setupEdgeDriver() throws MalformedURLException {
    LOG.i("Setting up Edge driver...");
    setupDriver(edgedriver());
    final EdgeOptions options = new EdgeOptions();
    return new EdgeDriver(options);
}
 

private void setupEdge() {
    EdgeOptions edgeOptions = new EdgeOptions();

    capabilities.merge(edgeOptions);
}
 

/**
 * Pass options which will be applied when starting a Edge browser through Selenium
 * @param options Internet Explorer options
 */
@PublicAtsApi
public void setEdgeDriverOptions( EdgeOptions options ) {

    edgeOptions = options;
}
 

/**
 * @return the Edge options
 */
public EdgeOptions getEdgeDriverOptions() {

    return edgeOptions;
}
 

/**
   * Build capabilities for client web driver
   *
   * @param client the Client object
   * @return capabilities appium driver
   */
  private static MutableCapabilities buildBrowserCapabilities(Client client) {
    MutableCapabilities capabilities = new MutableCapabilities();
    BrowserSpecs specs = client.getBrowserSpecs();
    if (specs.getVersion() != null) {
      capabilities.setCapability(CapabilityType.VERSION, specs.getVersion());
    }
    if (specs.getPlatform() != null) {
      capabilities.setCapability(CapabilityType.PLATFORM_NAME, specs.getPlatform());
    }

//    if (client.getCapability().getGateway().toString() != null && !"none".equalsIgnoreCase(client.getCapability().getGateway().toString())) {
//      capabilities.setCapability("gateway", client.getCapability().getGateway().toString());
//    }

    // Only consider next code block if this is a client.
    switch (specs.getBrowserName()) {
      case "chrome":
        capabilities.setCapability(ChromeOptions.CAPABILITY, setCommonChromeOptions(client.getCapability(), specs));
        break;
      case "firefox":
        capabilities.merge(setCommonFirefoxOptions(client.getCapability(), specs));
        break;
      case "MicrosoftEdge":
        EdgeOptions MicrosoftEdgeOptions = new EdgeOptions();
        capabilities.setCapability("edgeOptions", MicrosoftEdgeOptions);
        capabilities.setCapability("avoidProxy", true);
        break;
      case "safari":
        SafariOptions options = new SafariOptions();
        options.setUseTechnologyPreview(client.getCapability().isTechnologyPreview());
        capabilities.setCapability(SafariOptions.CAPABILITY, options);
        break;
      default:
        capabilities.setCapability(CapabilityType.BROWSER_NAME, specs.getBrowserName());
        break;
    }
    // Add log preference to webdriver
    // TODO put log preference into config file
    LoggingPreferences logPrefs = new LoggingPreferences();
    logPrefs.enable(LogType.BROWSER, Level.ALL);
    capabilities.setCapability(CapabilityType.LOGGING_PREFS, logPrefs);
//    capabilities.setCapability("goog:loggingPrefs", logPrefs);
    // Capabilities for mobile client/app
    if (specs.getPlatform().toString().equalsIgnoreCase("android")
      ||specs.getPlatform().toString().equalsIgnoreCase("ios")) {
      // deviceName:
      // On iOS, this should be one of the valid devices returned by instruments with instruments -s devices.
      // On Android this capability is currently ignored, though it remains required.
      capabilities.setCapability("deviceName", specs.getDeviceName());
      capabilities.setCapability("platformName", specs.getPlatform());
      capabilities.setCapability("platformVersion", specs.getPlatformVersion());
      if (specs.getPlatform().name().equalsIgnoreCase("ios")) {
        capabilities.setCapability("automationName", "XCUITest");
        capabilities.setCapability("autoAcceptAlerts", true);
      } else {
        capabilities.setCapability("autoGrantPermissions", true);
        capabilities.setCapability(MobileCapabilityType.NEW_COMMAND_TIMEOUT, 300);
      }
      capabilities.setCapability("noReset", true);
    }
    return capabilities;
  }
 

@Override
public WebDriver create(Capabilities capabilities) {
  LOG.info("Starting the initialization of '{}' WebDriver instance", ID);
  LOG.debug("Initializing WebDriver with following capabilities: {}", capabilities);
  return new EdgeDriver(new EdgeOptions().merge(capabilities));
}
 

public EdgeFactory() {
    super((capabilities) -> {
        EdgeOptions edgeOptions = new EdgeOptions().merge(capabilities);
        return new EdgeDriver(edgeOptions);
    });
}
 

public WebDriver createDriver(EdgeOptions options) {
  return new EdgeDriver(options);
}
 

@Override
public EdgeOptions getCapabilities() {
    return new EdgeOptions();
}
 

public EdgeDriver(EdgeOptions options) {
  this(new EdgeDriverService.Builder().build(), options);
}
 

public EdgeDriver(EdgeDriverService service) {
  this(service, new EdgeOptions());
}
 

public EdgeDriver(EdgeDriverService service, EdgeOptions options) {
  super(new ChromiumDriverCommandExecutor("ms", service), Require.nonNull("Driver options", options), EdgeOptions.CAPABILITY);
}
 

@Deprecated
public EdgeDriver(Capabilities capabilities) {
  this(new EdgeDriverService.Builder().build(), new EdgeOptions().merge(capabilities));
}
 

@Test
public void testScoring() {
  EdgeHtmlDriverService.Builder builder = new EdgeHtmlDriverService.Builder();
  assertThat(builder.score(new EdgeHtmlOptions())).isGreaterThan(0);
  assertThat(builder.score(new EdgeOptions())).isEqualTo(0);
}
 

@BeforeMethod
public void setup() {

    System.setProperty("webdriver.edge.driver",
            "./src/test/resources/drivers/MicrosoftWebDriver.exe");

    EdgeOptions options = new EdgeOptions();
    options.setPageLoadStrategy("eager");

    driver = new EdgeDriver(options);

    driver.get("http://demo-store.seleniumacademy.com/");
}