@Override
public void resize(WebDriver webDriver, BrowserWindowSize browserWindowSize)
{
    if (isElectronApp() || isMobile(WebDriverUtil.unwrap(webDriver, HasCapabilities.class).getCapabilities()))
    {
        return;
    }
    Window window = webDriver.manage().window();
    if (browserWindowSize == null)
    {
        window.maximize();
    }
    else
    {
        window.setSize(browserWindowSize.toDimension());
    }
}
 

@Test
void testGetWebDriverWithWebDriverType() throws Exception
{
    mockCapabilities((HasCapabilities) driver);
    WebDriverType webDriverType = mock(WebDriverType.class);
    webDriverFactory.setWebDriverType(webDriverType);
    WebDriverConfiguration configuration = mock(WebDriverConfiguration.class);
    Map<String, Object> capablities = Map.of(KEY1, TRUE, KEY2, FALSE);
    when(propertyParser.getPropertyValuesTreeByPrefix(SELENIUM_CAPABILITIES)).thenReturn(capablities);
    configuration.setBinaryPath(Optional.of(PATH));
    injectConfigurations(webDriverType, configuration);
    DesiredCapabilities desiredCapabilities = new DesiredCapabilities(Map.of(KEY2, true));
    when(webDriverType.getWebDriver(new DesiredCapabilities(Map.of(KEY1, Boolean.TRUE, KEY2,  Boolean.TRUE)),
            configuration)).thenReturn(driver);
    mockTimeouts(driver);
    WebDriver actualDriver = webDriverFactory.getWebDriver(desiredCapabilities);
    assertThat(actualDriver, instanceOf(TextFormattingWebDriver.class));
    assertEquals(driver, ((WrapsDriver) actualDriver).getWrappedDriver());
    assertLogger();
    verify(propertyParser, never()).getPropertyValuesTreeByPrefix(SELENIUM_GRID_CAPABILITIES);
}
 

@Test
void testGetWebDriverWithWebDriverTypeAndBinaryPathConfiguration()
{
    mockCapabilities((HasCapabilities) driver);
    WebDriverType webDriverType = mock(WebDriverType.class);
    when(webDriverType.isBinaryPathSupported()).thenReturn(Boolean.TRUE);
    webDriverFactory.setWebDriverType(webDriverType);
    lenient().when(propertyParser.getPropertyValue("web.driver." + webDriverType + ".driver-executable-path"))
            .thenReturn(PATH);
    lenient().when(propertyParser.getPropertyValue(String.format(BINARY_PATH_PROPERTY_FORMAT, webDriverType)))
            .thenReturn(PATH);
    DesiredCapabilities desiredCapabilities = mock(DesiredCapabilities.class);
    when(webDriverType.getWebDriver(eq(new DesiredCapabilities()),
            argThat(config -> Optional.of(PATH).equals(config.getBinaryPath())
                    && Optional.of(PATH).equals(config.getDriverExecutablePath())))).thenReturn(driver);
    Timeouts timeouts = mockTimeouts(driver);
    assertEquals(driver,
            ((WrapsDriver) webDriverFactory.getWebDriver(desiredCapabilities)).getWrappedDriver());
    verify(timeoutConfigurer).configure(timeouts);
    assertLogger();
}
 

@Test
void testGetWebDriverWithWebDriverTypeAndCommandLineArgumentsConfiguration()
{
    mockCapabilities((HasCapabilities) driver);
    WebDriverType webDriverType = mock(WebDriverType.class);
    when(webDriverType.isCommandLineArgumentsSupported()).thenReturn(Boolean.TRUE);
    webDriverFactory.setWebDriverType(webDriverType);
    lenient().when(propertyParser.getPropertyValue(String.format(BINARY_PATH_PROPERTY_FORMAT, webDriverType)))
            .thenReturn(null);
    lenient().when(
            propertyParser.getPropertyValue(String.format(COMMAND_LINE_ARGUMENTS_PROPERTY_FORMAT, webDriverType)))
            .thenReturn(ARGS);
    DesiredCapabilities desiredCapabilities = mock(DesiredCapabilities.class);
    when(webDriverType.getWebDriver(eq(new DesiredCapabilities()),
            argThat(config -> Arrays.equals(new String[] { ARG_1, ARG_2 }, config.getCommandLineArguments()))))
            .thenReturn(driver);
    Timeouts timeouts = mockTimeouts(driver);
    assertEquals(driver,
            ((WrapsDriver) webDriverFactory.getWebDriver(desiredCapabilities)).getWrappedDriver());
    verify(timeoutConfigurer).configure(timeouts);
    assertLogger();
}
 

@Test
void testGetWebDriverWithWebDriverTypeAndExperimentalOptionsConfiguration()
{
    mockCapabilities((HasCapabilities) driver);
    WebDriverType webDriverType = mock(WebDriverType.class);
    webDriverFactory.setWebDriverType(webDriverType);
    lenient().when(propertyParser.getPropertyValue(String.format(BINARY_PATH_PROPERTY_FORMAT, webDriverType)))
            .thenReturn(null);
    lenient().when(
            propertyParser.getPropertyValue(String.format(EXPERIMENTAL_OPTIONS_PROPERTY_FORMAT, webDriverType)))
            .thenReturn("{\"mobileEmulation\": {\"deviceName\": \"iPhone 8\"}}");
    DesiredCapabilities desiredCapabilities = mock(DesiredCapabilities.class);
    when(webDriverType.getWebDriver(eq(new DesiredCapabilities()),
            argThat(config ->  Map.of("mobileEmulation", Map.of("deviceName", "iPhone 8"))
                    .equals(config.getExperimentalOptions())))).thenReturn(driver);
    Timeouts timeouts = mockTimeouts(driver);
    assertEquals(driver,
            ((WrapsDriver) webDriverFactory.getWebDriver(desiredCapabilities)).getWrappedDriver());
    verify(timeoutConfigurer).configure(timeouts);
    assertLogger();
}
 

@Test
void testGetSize()
{
    MobileDriver<?> mobileDriver = mock(MobileDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    Set<String> contexts = new HashSet<>();
    contexts.add(WEBVIEW_CONTEXT);
    contexts.add(NATIVE_APP_CONTEXT);
    mockMobileDriverContext(mobileDriver, WEBVIEW_CONTEXT, contexts);
    lenient().when(webDriverManagerContext.getParameter(WebDriverManagerParameter.SCREEN_SIZE)).thenReturn(null);
    lenient().when(webDriverManagerContext.getParameter(WebDriverManagerParameter.ORIENTATION))
            .thenReturn(ScreenOrientation.PORTRAIT);
    WebDriverManager spy = spyIsMobile(true);
    Window window = mock(Window.class);
    when(mockOptions(mobileDriver).window()).thenReturn(window);
    when(window.getSize()).thenReturn(mock(Dimension.class));
    assertNotNull(spy.getSize());
}
 

@TestFactory
Stream<DynamicTest> testCleanBeforeNavigate()
{
    WebDriver driver = mock(WebDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    Consumer<Runnable> test = methodUnderTest ->
    {
        Options options = mock(Options.class);
        when(driver.manage()).thenReturn(options);
        Logs logs = mock(Logs.class);
        when(options.logs()).thenReturn(logs);
        when(logs.get(LogType.BROWSER)).thenReturn(mock(LogEntries.class));
        methodUnderTest.run();
    };
    return Stream.of(
            dynamicTest("beforeNavigateBack", () -> test.accept(() -> listener.beforeNavigateBack(driver))),
            dynamicTest("beforeNavigateForward", () -> test.accept(() -> listener.beforeNavigateForward(driver))),
            dynamicTest("beforeNavigateRefresh", () -> test.accept(() -> listener.beforeNavigateRefresh(driver))),
            dynamicTest("beforeNavigateTo", () -> test.accept(() -> listener.beforeNavigateTo("url", driver))));
}
 

/**
 * Determine if the specified driver is capable of producing page source.
 * 
 * @param optDriver optional web driver object
 * @param logger SLF4J logger object; may be 'null'
 * @return 'true' if driver can produce page source; otherwise 'false
 */
public static boolean canGetArtifact(final Optional<WebDriver> optDriver, final Logger logger) {
    if (optDriver.isPresent()) {
        WebDriver driver = optDriver.get();
        if (driver instanceof HasCapabilities) {
            Capabilities caps = ((HasCapabilities) driver).getCapabilities();
            // if driver explicitly reports that it cannot produce page source
            if (Boolean.FALSE.equals(caps.getCapability(TAKES_ELEMENT_SCREENSHOT))) {
                if (logger != null) {
                    logger.warn("This driver is not capable of producing page source."); //NOSONAR
                }
            } else {
                return true;
            }
        } else {
            if (logger != null) {
                logger.warn("Unable to determine if this driver can capture page source."); //NOSONAR
            }
        }
    }
    return false;
}
 

@Test
public void testDocumentPreview(){
    assumeThat(((HasCapabilities) getDriver()).getCapabilities().getBrowserName(), is("firefox"));

    final ListView results = findService.search("The Season");
    final FindResult searchResult = results.searchResult(1);

    deleteCookies();

    final DocumentViewer docViewer = searchResult.openDocumentPreview();
    final Frame frame = new Frame(getDriver(), docViewer.frame());
    frame.operateOnContent(content -> {
        verifyThat("Authentication Fail frame displayed correctly", content, allOf(
                containsText("403"),
                containsText("Authentication Failed"),
                containsText("You do not have permission to view this page")
        ));
        return null;
    });
}
 

private InMemorySession(WebDriver driver, Capabilities capabilities, Dialect downstream) {
  this.driver = Require.nonNull("Driver", driver);

  Capabilities caps;
  if (driver instanceof HasCapabilities) {
    caps = ((HasCapabilities) driver).getCapabilities();
  } else {
    caps = capabilities;
  }

  this.capabilities = caps.asMap().entrySet().stream()
      .filter(e -> e.getValue() != null)
      .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));

  this.id = new SessionId(UUID.randomUUID().toString());
  this.downstream = Require.nonNull("Downstream dialect", downstream);

  File tempRoot = new File(StandardSystemProperty.JAVA_IO_TMPDIR.value(), id.toString());
  Require.stateCondition(tempRoot.mkdirs(), "Could not create directory %s", tempRoot);
  this.filesystem = TemporaryFilesystem.getTmpFsBasedOn(tempRoot);

  this.handler = new JsonHttpCommandHandler(
      new PretendDriverSessions(),
      LOG);
}
 

@Override
public Capabilities getCapabilities()
{
    if (wrappedDriver instanceof HasCapabilities)
    {
        return ((HasCapabilities) wrappedDriver).getCapabilities();
    }
    throw new IllegalStateException(DRIVER_NOT_IMPLEMENT_HAS_CAPABILITIES);
}
 

private WebDriver createWebDriver(WebDriver webDriver)
{
    WebDriver driver = new TextFormattingWebDriver(webDriver);
    timeoutConfigurer.configure(driver.manage().timeouts());

    LOGGER.atInfo()
          .addArgument(() -> jsonUtils
                  .toPrettyJson(WebDriverUtil.unwrap(driver, HasCapabilities.class).getCapabilities().asMap()))
          .log("Session capabilities:\n{}");
    return driver;
}
 

@Test
void testGetWebDriverWithWebDriverTypeWOBinary() throws Exception
{
    mockCapabilities((HasCapabilities) driver);
    WebDriverConfiguration configuration = new WebDriverConfiguration();
    WebDriverType webDriverType = mock(WebDriverType.class);
    webDriverFactory.setWebDriverType(webDriverType);
    injectConfigurations(webDriverType, configuration);
    DesiredCapabilities desiredCapabilities = mock(DesiredCapabilities.class);
    when(webDriverType.getWebDriver(new DesiredCapabilities(), configuration)).thenReturn(driver);
    Timeouts timeouts = mockTimeouts(driver);
    assertEquals(driver, ((WrapsDriver) webDriverFactory.getWebDriver(desiredCapabilities)).getWrappedDriver());
    verify(timeoutConfigurer).configure(timeouts);
    assertLogger();
}
 

private WebDriver mockWebDriverHavingCapabilities(Map<String, Object> capabilities)
{
    Capabilities capabilitiesMock = mock(Capabilities.class);
    capabilities.forEach((capabilityType, capabilityValue) ->
            setCapabilities(capabilitiesMock, capabilityType, capabilityValue));

    WebDriver webDriver = mockWebDriverHavingCapabilities();
    when(((HasCapabilities) webDriver).getCapabilities()).thenReturn(capabilitiesMock);
    return webDriver;
}
 

@Test
void shouldNotResizeElectronApps()
{
    webDriverManager.setElectronApp(true);
    WebDriver webDriver = mock(WebDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    BrowserWindowSize browserWindowSize = mock(BrowserWindowSize.class);
    webDriverManager.resize(browserWindowSize);
    verify(webDriver, never()).manage();
    verifyNoInteractions(webDriverProvider);
}
 

@Test
void testPerformActionInNativeContext()
{
    MobileDriver<?> mobileDriver = mock(MobileDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    Set<String> contexts = new HashSet<>();
    contexts.add(WEBVIEW_CONTEXT);
    contexts.add(NATIVE_APP_CONTEXT);
    mockMobileDriverContext(mobileDriver, WEBVIEW_CONTEXT, contexts);
    WebDriverManager spy = spyIsMobile(true);
    spy.performActionInNativeContext(webDriver -> assertEquals(mobileDriver, webDriver));
    verify(mobileDriver).context(NATIVE_APP_CONTEXT);
    verify(mobileDriver).context(WEBVIEW_CONTEXT);
}
 

@Test
void testPerformActionInNativeContextException()
{
    MobileDriver<?> mobileDriver = mock(MobileDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    mockMobileDriverContext(mobileDriver, WEBVIEW_CONTEXT, new HashSet<>());
    WebDriverManager spy = spyIsMobile(true);
    IllegalStateException exception = assertThrows(IllegalStateException.class,
        () -> spy.performActionInNativeContext(webDriver -> assertEquals(mobileDriver, webDriver)));
    assertEquals("MobileDriver doesn't have context: " + NATIVE_APP_CONTEXT, exception.getMessage());
}
 

private static WebDriver mockBrowserName(String browserName)
{
    WebDriver webDriver = mock(WebDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    Capabilities capabilities = mock(Capabilities.class);
    when(((HasCapabilities) webDriver).getCapabilities()).thenReturn(capabilities);
    when(capabilities.getBrowserName()).thenReturn(browserName);
    return webDriver;
}
 

@Test
void testGetCapabilities()
{
    WebDriver driverWithCapabilities = Mockito.mock(WebDriver.class,
            withSettings().extraInterfaces(HasCapabilities.class));
    Capabilities capabilities = Mockito.mock(Capabilities.class);
    when(((HasCapabilities) driverWithCapabilities).getCapabilities()).thenReturn(capabilities);
    assertEquals(capabilities, new DelegatingWebDriver(driverWithCapabilities).getCapabilities());
}
 

private LogEntry mockGetLogEntry(String logErrorMessage)
{
    WebDriver webDriver = mock(WebDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
    when(webDriverProvider.get()).thenReturn(webDriver);
    when(webDriver.getCurrentUrl()).thenReturn(URL);
    Options options = mock(Options.class);
    when(webDriver.manage()).thenReturn(options);
    Logs logs = mock(Logs.class);
    when(options.logs()).thenReturn(logs);
    LogEntry severeEntry = new LogEntry(Level.SEVERE, 1L, logErrorMessage);
    LogEntry infoEntry = new LogEntry(Level.INFO, 1L, logErrorMessage);
    LogEntries logEntries = new LogEntries(Arrays.asList(severeEntry, infoEntry));
    when(logs.get(LogType.BROWSER)).thenReturn(logEntries);
    return severeEntry;
}
 

/**
 * Determine if the specified driver is capable of taking screenshots.
 * 
 * @param optDriver optional web driver object
 * @param logger SLF4J logger object; may be 'null'
 * @return 'true' if driver can take screenshots; otherwise 'false'
 */
public static boolean canGetArtifact(final Optional<WebDriver> optDriver, final Logger logger) {
    if (optDriver.isPresent()) {
        WebDriver driver = optDriver.get();
        if (driver instanceof HasCapabilities) {
            if (((HasCapabilities) driver).getCapabilities().is(CapabilityType.TAKES_SCREENSHOT)) {
                return true;
            }
        }
        if (driver instanceof TakesScreenshot) {
            return true; // for remote drivers, this may be bogus
        }
        if (logger != null) {
            logger.warn("This driver is not able to take screenshots."); //NOSONAR
        }
    }
    return false;
}
 

/**
 * Get the capabilities of the specified search context
 * 
 * @param context search context
 * @return context capabilities
 */
public static Capabilities getCapabilities(final SearchContext context) {
    WebDriver driver = getDriver(context);
    
    if (driver instanceof HasCapabilities) {
        return ((HasCapabilities) driver).getCapabilities();
    } else {
        throw new UnsupportedOperationException("The specified context is unable to describe its capabilities");
    }
}
 

@Override
public Capabilities getCapabilities()
{
    if ( webDriver instanceof HasCapabilities )
        return ((HasCapabilities) webDriver).getCapabilities();
    else
        return null;
}
 

public static Optional<Connection> create(WebDriver driver) {
  if (!(driver instanceof HasCapabilities)) {
    throw new IllegalStateException("Given webdriver instance must have capabilities");
  }

  return create(((HasCapabilities) driver).getCapabilities());
}
 

@Override
public Capabilities getCapabilities() {
  if (driver instanceof HasCapabilities) {
    return ((HasCapabilities) driver).getCapabilities();
  }
  throw new UnsupportedOperationException(
      "Underlying driver does not implement getting capabilities yet.");
}
 

@Override
public Capabilities getCapabilities() {
  WebDriver driver = getWrappedDriver();
  if (driver instanceof HasCapabilities) {
    return ((HasCapabilities) driver).getCapabilities();
  }

  return null;
}
 

@VisibleForTesting
protected void assertDriverSupportsJavascript(WebDriver driver) {
  if (!(driver instanceof JavascriptExecutor)) {
    throw new IllegalStateException("Driver instance must support JS.");
  }

  if (!(driver instanceof HasCapabilities)) {
    // Might be proxy. Bail.
    return;
  }

  if (!((HasCapabilities) driver).getCapabilities().is(SUPPORTS_JAVASCRIPT)) {
    throw new IllegalStateException("JS support must be enabled.");
  }
}
 

private void configureCapability(String capability, boolean isEnabled) {
  Capabilities desiredCaps = new ImmutableCapabilities(capability, isEnabled);
  localDriver = new WebDriverBuilder().get(desiredCaps);
  Capabilities caps = ((HasCapabilities) localDriver).getCapabilities();
  assertThat(caps.getCapability(capability)).isNotNull();
  assertThat(caps.is(capability)).isEqualTo(isEnabled);
}
 

@Test
public void shouldReturnCapabilitiesWhenUnderlyingDriverImplementsInterfac() {
  WebDriver mockedDriver = mock(WebDriver.class, withSettings().extraInterfaces(HasCapabilities.class));
  EventFiringWebDriver testedDriver = new EventFiringWebDriver(mockedDriver);

  final Capabilities caps = new ImmutableCapabilities();
  when(((HasCapabilities) mockedDriver).getCapabilities()).thenReturn(caps);

  assertThat(testedDriver.getCapabilities()).isSameAs(caps);
}
 

@Test
public void shouldBeAbleToAugmentMultipleTimes() {
  Capabilities caps = new ImmutableCapabilities("canRotate", true, "magic.numbers", true);

  StubExecutor stubExecutor = new StubExecutor(caps);
  stubExecutor.expect(DriverCommand.GET_SCREEN_ORIENTATION,
    Collections.emptyMap(),
    ScreenOrientation.PORTRAIT.name());
  RemoteWebDriver driver = new RemoteWebDriver(stubExecutor, caps);

  WebDriver augmented = getAugmenter()
    .addDriverAugmentation(
      "canRotate",
      Rotatable.class,
      (c, exe) -> new RemoteRotatable(exe))
    .augment(driver);

  assertThat(driver).isNotSameAs(augmented);
  assertThat(augmented).isInstanceOf(Rotatable.class);
  assertThat(augmented).isNotInstanceOf(HasMagicNumbers.class);

  WebDriver augmentedAgain = getAugmenter()
    .addDriverAugmentation(
      "magic.numbers",
      HasMagicNumbers.class,
      (c, exe) -> () -> 42)
    .augment(augmented);

  assertThat(augmented).isNotSameAs(augmentedAgain);
  assertThat(augmentedAgain).isInstanceOf(Rotatable.class);
  assertThat(augmentedAgain).isInstanceOf(HasMagicNumbers.class);

  ((Rotatable) augmentedAgain).getOrientation();  // Should not throw.

  assertThat(((HasCapabilities) augmentedAgain).getCapabilities())
    .isSameAs(driver.getCapabilities());
}